mirror of
https://github.com/fmtlib/fmt.git
synced 2024-09-02 21:19:26 +00:00
Replace a fused version of gtest with a stripped down one.
This commit is contained in:
parent
9cf43ccdad
commit
7bde2b3c25
@ -64,7 +64,8 @@ add_test(compile-test ${CMAKE_CTEST_COMMAND}
|
||||
# pre-compiled copy of Google Test (for example, into /usr/local)?"
|
||||
# at http://code.google.com/p/googletest/wiki/FAQ for more details.
|
||||
|
||||
include_directories(.)
|
||||
include_directories(gtest/include)
|
||||
add_subdirectory(gtest)
|
||||
|
||||
if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
|
||||
add_definitions(-DGTEST_USE_OWN_TR1_TUPLE=1)
|
||||
@ -80,11 +81,7 @@ if (HAVE_DUP)
|
||||
add_definitions(-DFMT_USE_DUP=1)
|
||||
endif ()
|
||||
|
||||
add_library(gtest gtest/gtest-all.cc)
|
||||
|
||||
find_package(Threads)
|
||||
target_link_libraries(gtest ${CMAKE_THREAD_LIBS_INIT})
|
||||
|
||||
include_directories(.)
|
||||
add_executable(format-test test/format-test.cc)
|
||||
target_link_libraries(format-test format gtest)
|
||||
if (CMAKE_COMPILER_IS_GNUCXX)
|
||||
|
246
gtest/CMakeLists.txt
Normal file
246
gtest/CMakeLists.txt
Normal file
@ -0,0 +1,246 @@
|
||||
########################################################################
|
||||
# CMake build script for Google Test.
|
||||
#
|
||||
# To run the tests for Google Test itself on Linux, use 'make test' or
|
||||
# ctest. You can select which tests to run using 'ctest -R regex'.
|
||||
# For more options, run 'ctest --help'.
|
||||
|
||||
# BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to
|
||||
# make it prominent in the GUI.
|
||||
option(BUILD_SHARED_LIBS "Build shared libraries (DLLs)." OFF)
|
||||
|
||||
# When other libraries are using a shared version of runtime libraries,
|
||||
# Google Test also has to use one.
|
||||
option(
|
||||
gtest_force_shared_crt
|
||||
"Use shared (DLL) run-time lib even when Google Test is built as static lib."
|
||||
OFF)
|
||||
|
||||
option(gtest_build_tests "Build all of gtest's own tests." OFF)
|
||||
|
||||
option(gtest_build_samples "Build gtest's sample programs." OFF)
|
||||
|
||||
option(gtest_disable_pthreads "Disable uses of pthreads in gtest." OFF)
|
||||
|
||||
# Defines pre_project_set_up_hermetic_build() and set_up_hermetic_build().
|
||||
include(cmake/hermetic_build.cmake OPTIONAL)
|
||||
|
||||
if (COMMAND pre_project_set_up_hermetic_build)
|
||||
pre_project_set_up_hermetic_build()
|
||||
endif()
|
||||
|
||||
########################################################################
|
||||
#
|
||||
# Project-wide settings
|
||||
|
||||
# Name of the project.
|
||||
#
|
||||
# CMake files in this project can refer to the root source directory
|
||||
# as ${gtest_SOURCE_DIR} and to the root binary directory as
|
||||
# ${gtest_BINARY_DIR}.
|
||||
# Language "C" is required for find_package(Threads).
|
||||
project(gtest CXX C)
|
||||
cmake_minimum_required(VERSION 2.6.2)
|
||||
|
||||
if (COMMAND set_up_hermetic_build)
|
||||
set_up_hermetic_build()
|
||||
endif()
|
||||
|
||||
# Define helper functions and macros used by Google Test.
|
||||
include(cmake/internal_utils.cmake)
|
||||
|
||||
config_compiler_and_linker() # Defined in internal_utils.cmake.
|
||||
|
||||
# Where Google Test's .h files can be found.
|
||||
include_directories(
|
||||
${gtest_SOURCE_DIR}/include
|
||||
${gtest_SOURCE_DIR})
|
||||
|
||||
# Where Google Test's libraries can be found.
|
||||
link_directories(${gtest_BINARY_DIR}/src)
|
||||
|
||||
########################################################################
|
||||
#
|
||||
# Defines the gtest & gtest_main libraries. User tests should link
|
||||
# with one of them.
|
||||
|
||||
# Google Test libraries. We build them using more strict warnings than what
|
||||
# are used for other targets, to ensure that gtest can be compiled by a user
|
||||
# aggressive about warnings.
|
||||
cxx_library(gtest "${cxx_strict}" src/gtest-all.cc)
|
||||
cxx_library(gtest_main "${cxx_strict}" src/gtest_main.cc)
|
||||
target_link_libraries(gtest_main gtest)
|
||||
|
||||
########################################################################
|
||||
#
|
||||
# Samples on how to link user tests with gtest or gtest_main.
|
||||
#
|
||||
# They are not built by default. To build them, set the
|
||||
# gtest_build_samples option to ON. You can do it by running ccmake
|
||||
# or specifying the -Dbuild_gtest_samples=ON flag when running cmake.
|
||||
|
||||
if (gtest_build_samples)
|
||||
cxx_executable(sample1_unittest samples gtest_main samples/sample1.cc)
|
||||
cxx_executable(sample2_unittest samples gtest_main samples/sample2.cc)
|
||||
cxx_executable(sample3_unittest samples gtest_main)
|
||||
cxx_executable(sample4_unittest samples gtest_main samples/sample4.cc)
|
||||
cxx_executable(sample5_unittest samples gtest_main samples/sample1.cc)
|
||||
cxx_executable(sample6_unittest samples gtest_main)
|
||||
cxx_executable(sample7_unittest samples gtest_main)
|
||||
cxx_executable(sample8_unittest samples gtest_main)
|
||||
cxx_executable(sample9_unittest samples gtest)
|
||||
cxx_executable(sample10_unittest samples gtest)
|
||||
endif()
|
||||
|
||||
########################################################################
|
||||
#
|
||||
# Google Test's own tests.
|
||||
#
|
||||
# You can skip this section if you aren't interested in testing
|
||||
# Google Test itself.
|
||||
#
|
||||
# The tests are not built by default. To build them, set the
|
||||
# gtest_build_tests option to ON. You can do it by running ccmake
|
||||
# or specifying the -Dgtest_build_tests=ON flag when running cmake.
|
||||
|
||||
if (gtest_build_tests)
|
||||
# This must be set in the root directory for the tests to be run by
|
||||
# 'make test' or ctest.
|
||||
enable_testing()
|
||||
|
||||
############################################################
|
||||
# C++ tests built with standard compiler flags.
|
||||
|
||||
cxx_test(gtest-death-test_test gtest_main)
|
||||
cxx_test(gtest_environment_test gtest)
|
||||
cxx_test(gtest-filepath_test gtest_main)
|
||||
cxx_test(gtest-linked_ptr_test gtest_main)
|
||||
cxx_test(gtest-listener_test gtest_main)
|
||||
cxx_test(gtest_main_unittest gtest_main)
|
||||
cxx_test(gtest-message_test gtest_main)
|
||||
cxx_test(gtest_no_test_unittest gtest)
|
||||
cxx_test(gtest-options_test gtest_main)
|
||||
cxx_test(gtest-param-test_test gtest
|
||||
test/gtest-param-test2_test.cc)
|
||||
cxx_test(gtest-port_test gtest_main)
|
||||
cxx_test(gtest_pred_impl_unittest gtest_main)
|
||||
cxx_test(gtest-printers_test gtest_main)
|
||||
cxx_test(gtest_prod_test gtest_main
|
||||
test/production.cc)
|
||||
cxx_test(gtest_repeat_test gtest)
|
||||
cxx_test(gtest_sole_header_test gtest_main)
|
||||
cxx_test(gtest_stress_test gtest)
|
||||
cxx_test(gtest-test-part_test gtest_main)
|
||||
cxx_test(gtest_throw_on_failure_ex_test gtest)
|
||||
cxx_test(gtest-typed-test_test gtest_main
|
||||
test/gtest-typed-test2_test.cc)
|
||||
cxx_test(gtest_unittest gtest_main)
|
||||
cxx_test(gtest-unittest-api_test gtest)
|
||||
|
||||
############################################################
|
||||
# C++ tests built with non-standard compiler flags.
|
||||
|
||||
cxx_library(gtest_no_exception "${cxx_no_exception}"
|
||||
src/gtest-all.cc)
|
||||
cxx_library(gtest_main_no_exception "${cxx_no_exception}"
|
||||
src/gtest-all.cc src/gtest_main.cc)
|
||||
cxx_library(gtest_main_no_rtti "${cxx_no_rtti}"
|
||||
src/gtest-all.cc src/gtest_main.cc)
|
||||
|
||||
cxx_test_with_flags(gtest-death-test_ex_nocatch_test
|
||||
"${cxx_exception} -DGTEST_ENABLE_CATCH_EXCEPTIONS_=0"
|
||||
gtest test/gtest-death-test_ex_test.cc)
|
||||
cxx_test_with_flags(gtest-death-test_ex_catch_test
|
||||
"${cxx_exception} -DGTEST_ENABLE_CATCH_EXCEPTIONS_=1"
|
||||
gtest test/gtest-death-test_ex_test.cc)
|
||||
|
||||
cxx_test_with_flags(gtest_no_rtti_unittest "${cxx_no_rtti}"
|
||||
gtest_main_no_rtti test/gtest_unittest.cc)
|
||||
|
||||
cxx_shared_library(gtest_dll "${cxx_default}"
|
||||
src/gtest-all.cc src/gtest_main.cc)
|
||||
|
||||
cxx_executable_with_flags(gtest_dll_test_ "${cxx_default}"
|
||||
gtest_dll test/gtest_all_test.cc)
|
||||
set_target_properties(gtest_dll_test_
|
||||
PROPERTIES
|
||||
COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1")
|
||||
|
||||
if (NOT MSVC OR NOT MSVC_VERSION EQUAL 1600)
|
||||
# The C++ Standard specifies tuple_element<int, class>.
|
||||
# Yet MSVC 10's <utility> declares tuple_element<size_t, class>.
|
||||
# That declaration conflicts with our own standard-conforming
|
||||
# tuple implementation. Therefore using our own tuple with
|
||||
# MSVC 10 doesn't compile.
|
||||
cxx_library(gtest_main_use_own_tuple "${cxx_use_own_tuple}"
|
||||
src/gtest-all.cc src/gtest_main.cc)
|
||||
|
||||
cxx_test_with_flags(gtest-tuple_test "${cxx_use_own_tuple}"
|
||||
gtest_main_use_own_tuple test/gtest-tuple_test.cc)
|
||||
|
||||
cxx_test_with_flags(gtest_use_own_tuple_test "${cxx_use_own_tuple}"
|
||||
gtest_main_use_own_tuple
|
||||
test/gtest-param-test_test.cc test/gtest-param-test2_test.cc)
|
||||
endif()
|
||||
|
||||
# VC11 contains std::tuple with variadic templates emulation macro.
|
||||
# _VARIADIC_MAX defaulted to 5 but gtest requires 10.
|
||||
if (MSVC AND MSVC_VERSION EQUAL 1700)
|
||||
add_definitions(-D_VARIADIC_MAX=10)
|
||||
endif()
|
||||
|
||||
############################################################
|
||||
# Python tests.
|
||||
|
||||
cxx_executable(gtest_break_on_failure_unittest_ test gtest)
|
||||
py_test(gtest_break_on_failure_unittest)
|
||||
|
||||
cxx_executable_with_flags(
|
||||
gtest_catch_exceptions_no_ex_test_
|
||||
"${cxx_no_exception}"
|
||||
gtest_main_no_exception
|
||||
test/gtest_catch_exceptions_test_.cc)
|
||||
cxx_executable_with_flags(
|
||||
gtest_catch_exceptions_ex_test_
|
||||
"${cxx_exception}"
|
||||
gtest_main
|
||||
test/gtest_catch_exceptions_test_.cc)
|
||||
py_test(gtest_catch_exceptions_test)
|
||||
|
||||
cxx_executable(gtest_color_test_ test gtest)
|
||||
py_test(gtest_color_test)
|
||||
|
||||
cxx_executable(gtest_env_var_test_ test gtest)
|
||||
py_test(gtest_env_var_test)
|
||||
|
||||
cxx_executable(gtest_filter_unittest_ test gtest)
|
||||
py_test(gtest_filter_unittest)
|
||||
|
||||
cxx_executable(gtest_help_test_ test gtest_main)
|
||||
py_test(gtest_help_test)
|
||||
|
||||
cxx_executable(gtest_list_tests_unittest_ test gtest)
|
||||
py_test(gtest_list_tests_unittest)
|
||||
|
||||
cxx_executable(gtest_output_test_ test gtest)
|
||||
py_test(gtest_output_test)
|
||||
|
||||
cxx_executable(gtest_shuffle_test_ test gtest)
|
||||
py_test(gtest_shuffle_test)
|
||||
|
||||
cxx_executable(gtest_throw_on_failure_test_ test gtest_no_exception)
|
||||
set_target_properties(gtest_throw_on_failure_test_
|
||||
PROPERTIES
|
||||
COMPILE_FLAGS "${cxx_no_exception}")
|
||||
py_test(gtest_throw_on_failure_test)
|
||||
|
||||
cxx_executable(gtest_uninitialized_test_ test gtest)
|
||||
py_test(gtest_uninitialized_test)
|
||||
|
||||
cxx_executable(gtest_xml_outfile1_test_ test gtest_main)
|
||||
cxx_executable(gtest_xml_outfile2_test_ test gtest_main)
|
||||
py_test(gtest_xml_outfiles_test)
|
||||
|
||||
cxx_executable(gtest_xml_output_unittest_ test gtest)
|
||||
py_test(gtest_xml_output_unittest)
|
||||
endif()
|
37
gtest/CONTRIBUTORS
Normal file
37
gtest/CONTRIBUTORS
Normal file
@ -0,0 +1,37 @@
|
||||
# This file contains a list of people who've made non-trivial
|
||||
# contribution to the Google C++ Testing Framework project. People
|
||||
# who commit code to the project are encouraged to add their names
|
||||
# here. Please keep the list sorted by first names.
|
||||
|
||||
Ajay Joshi <jaj@google.com>
|
||||
Balázs Dán <balazs.dan@gmail.com>
|
||||
Bharat Mediratta <bharat@menalto.com>
|
||||
Chandler Carruth <chandlerc@google.com>
|
||||
Chris Prince <cprince@google.com>
|
||||
Chris Taylor <taylorc@google.com>
|
||||
Dan Egnor <egnor@google.com>
|
||||
Eric Roman <eroman@chromium.org>
|
||||
Hady Zalek <hady.zalek@gmail.com>
|
||||
Jeffrey Yasskin <jyasskin@google.com>
|
||||
Jói Sigurðsson <joi@google.com>
|
||||
Keir Mierle <mierle@gmail.com>
|
||||
Keith Ray <keith.ray@gmail.com>
|
||||
Kenton Varda <kenton@google.com>
|
||||
Manuel Klimek <klimek@google.com>
|
||||
Markus Heule <markus.heule@gmail.com>
|
||||
Mika Raento <mikie@iki.fi>
|
||||
Miklós Fazekas <mfazekas@szemafor.com>
|
||||
Pasi Valminen <pasi.valminen@gmail.com>
|
||||
Patrick Hanna <phanna@google.com>
|
||||
Patrick Riley <pfr@google.com>
|
||||
Peter Kaminski <piotrk@google.com>
|
||||
Preston Jackson <preston.a.jackson@gmail.com>
|
||||
Rainer Klaffenboeck <rainer.klaffenboeck@dynatrace.com>
|
||||
Russ Cox <rsc@google.com>
|
||||
Russ Rufer <russ@pentad.com>
|
||||
Sean Mcafee <eefacm@gmail.com>
|
||||
Sigurður Ásgeirsson <siggi@google.com>
|
||||
Tracy Bialik <tracy@pentad.com>
|
||||
Vadim Berman <vadimb@google.com>
|
||||
Vlad Losev <vladl@google.com>
|
||||
Zhanyong Wan <wan@google.com>
|
28
gtest/COPYING
Normal file
28
gtest/COPYING
Normal file
@ -0,0 +1,28 @@
|
||||
Copyright 2008, Google Inc.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are
|
||||
met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above
|
||||
copyright notice, this list of conditions and the following disclaimer
|
||||
in the documentation and/or other materials provided with the
|
||||
distribution.
|
||||
* Neither the name of Google Inc. nor the names of its
|
||||
contributors may be used to endorse or promote products derived from
|
||||
this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
424
gtest/README
Normal file
424
gtest/README
Normal file
@ -0,0 +1,424 @@
|
||||
Google C++ Testing Framework
|
||||
============================
|
||||
|
||||
http://code.google.com/p/googletest/
|
||||
|
||||
Overview
|
||||
--------
|
||||
|
||||
Google's framework for writing C++ tests on a variety of platforms
|
||||
(Linux, Mac OS X, Windows, Windows CE, Symbian, etc). Based on the
|
||||
xUnit architecture. Supports automatic test discovery, a rich set of
|
||||
assertions, user-defined assertions, death tests, fatal and non-fatal
|
||||
failures, various options for running the tests, and XML test report
|
||||
generation.
|
||||
|
||||
Please see the project page above for more information as well as the
|
||||
mailing list for questions, discussions, and development. There is
|
||||
also an IRC channel on OFTC (irc.oftc.net) #gtest available. Please
|
||||
join us!
|
||||
|
||||
Requirements for End Users
|
||||
--------------------------
|
||||
|
||||
Google Test is designed to have fairly minimal requirements to build
|
||||
and use with your projects, but there are some. Currently, we support
|
||||
Linux, Windows, Mac OS X, and Cygwin. We will also make our best
|
||||
effort to support other platforms (e.g. Solaris, AIX, and z/OS).
|
||||
However, since core members of the Google Test project have no access
|
||||
to these platforms, Google Test may have outstanding issues there. If
|
||||
you notice any problems on your platform, please notify
|
||||
googletestframework@googlegroups.com. Patches for fixing them are
|
||||
even more welcome!
|
||||
|
||||
### Linux Requirements ###
|
||||
|
||||
These are the base requirements to build and use Google Test from a source
|
||||
package (as described below):
|
||||
* GNU-compatible Make or gmake
|
||||
* POSIX-standard shell
|
||||
* POSIX(-2) Regular Expressions (regex.h)
|
||||
* A C++98-standard-compliant compiler
|
||||
|
||||
### Windows Requirements ###
|
||||
|
||||
* Microsoft Visual C++ 7.1 or newer
|
||||
|
||||
### Cygwin Requirements ###
|
||||
|
||||
* Cygwin 1.5.25-14 or newer
|
||||
|
||||
### Mac OS X Requirements ###
|
||||
|
||||
* Mac OS X 10.4 Tiger or newer
|
||||
* Developer Tools Installed
|
||||
|
||||
Also, you'll need CMake 2.6.4 or higher if you want to build the
|
||||
samples using the provided CMake script, regardless of the platform.
|
||||
|
||||
Requirements for Contributors
|
||||
-----------------------------
|
||||
|
||||
We welcome patches. If you plan to contribute a patch, you need to
|
||||
build Google Test and its own tests from an SVN checkout (described
|
||||
below), which has further requirements:
|
||||
|
||||
* Python version 2.3 or newer (for running some of the tests and
|
||||
re-generating certain source files from templates)
|
||||
* CMake 2.6.4 or newer
|
||||
|
||||
Getting the Source
|
||||
------------------
|
||||
|
||||
There are two primary ways of getting Google Test's source code: you
|
||||
can download a stable source release in your preferred archive format,
|
||||
or directly check out the source from our Subversion (SVN) repositary.
|
||||
The SVN checkout requires a few extra steps and some extra software
|
||||
packages on your system, but lets you track the latest development and
|
||||
make patches much more easily, so we highly encourage it.
|
||||
|
||||
### Source Package ###
|
||||
|
||||
Google Test is released in versioned source packages which can be
|
||||
downloaded from the download page [1]. Several different archive
|
||||
formats are provided, but the only difference is the tools used to
|
||||
manipulate them, and the size of the resulting file. Download
|
||||
whichever you are most comfortable with.
|
||||
|
||||
[1] http://code.google.com/p/googletest/downloads/list
|
||||
|
||||
Once the package is downloaded, expand it using whichever tools you
|
||||
prefer for that type. This will result in a new directory with the
|
||||
name "gtest-X.Y.Z" which contains all of the source code. Here are
|
||||
some examples on Linux:
|
||||
|
||||
tar -xvzf gtest-X.Y.Z.tar.gz
|
||||
tar -xvjf gtest-X.Y.Z.tar.bz2
|
||||
unzip gtest-X.Y.Z.zip
|
||||
|
||||
### SVN Checkout ###
|
||||
|
||||
To check out the main branch (also known as the "trunk") of Google
|
||||
Test, run the following Subversion command:
|
||||
|
||||
svn checkout http://googletest.googlecode.com/svn/trunk/ gtest-svn
|
||||
|
||||
Setting up the Build
|
||||
--------------------
|
||||
|
||||
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.
|
||||
|
||||
### Generic Build Instructions ###
|
||||
|
||||
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 and ${GTEST_DIR}
|
||||
|
||||
in the header search path. Assuming a Linux-like system and gcc,
|
||||
something like the following will do:
|
||||
|
||||
g++ -I${GTEST_DIR}/include -I${GTEST_DIR} -c ${GTEST_DIR}/src/gtest-all.cc
|
||||
ar -rv libgtest.a gtest-all.o
|
||||
|
||||
Next, you should compile your test source file with
|
||||
${GTEST_DIR}/include in the header search path, and link it with gtest
|
||||
and any other necessary libraries:
|
||||
|
||||
g++ -I${GTEST_DIR}/include 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.
|
||||
|
||||
If the default settings are correct for your environment, the
|
||||
following commands should succeed:
|
||||
|
||||
cd ${GTEST_DIR}/make
|
||||
make
|
||||
./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.
|
||||
|
||||
### Using CMake ###
|
||||
|
||||
Google Test comes with a CMake build script (CMakeLists.txt) that can
|
||||
be used on a wide range of platforms ("C" stands for cross-platofrm.).
|
||||
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. 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
|
||||
|
||||
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 use Windows and have Vistual 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.
|
||||
|
||||
### 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 previous two 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.
|
||||
|
||||
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.
|
||||
|
||||
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.
|
||||
|
||||
We list the most frequently used macros below. For a complete list,
|
||||
see file include/gtest/internal/gtest-port.h.
|
||||
|
||||
### 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.
|
||||
|
||||
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
|
||||
|
||||
-DGTEST_USE_OWN_TR1_TUPLE=1
|
||||
|
||||
to the compiler flags instead.
|
||||
|
||||
If you don't want Google Test to use tuple at all, add
|
||||
|
||||
-DGTEST_HAS_TR1_TUPLE=0
|
||||
|
||||
and all features using tuple will be disabled.
|
||||
|
||||
### 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.).
|
||||
|
||||
If Google Test doesn't correctly detect whether pthread is available
|
||||
in your environment, you can force it with
|
||||
|
||||
-DGTEST_HAS_PTHREAD=1
|
||||
|
||||
or
|
||||
|
||||
-DGTEST_HAS_PTHREAD=0
|
||||
|
||||
When 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) ###
|
||||
|
||||
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 compile your *tests* that use the gtest shared library, add
|
||||
|
||||
-DGTEST_LINKED_AS_SHARED_LIBRARY=1
|
||||
|
||||
to the compiler flags.
|
||||
|
||||
Note: while the above steps aren't technically necessary today when
|
||||
using some compilers (e.g. GCC), they may become necessary in the
|
||||
future, if we decide to improve the speed of loading the library (see
|
||||
http://gcc.gnu.org/wiki/Visibility for details). Therefore you are
|
||||
recommended to always add the above flags when using Google Test as a
|
||||
shared library. Otherwise a future release of Google Test may break
|
||||
your build script.
|
||||
|
||||
### Avoiding Macro Name Clashes ###
|
||||
|
||||
In C++, macros don't obey namespaces. Therefore two libraries that
|
||||
both define a macro of the same name will clash if you #include both
|
||||
definitions. In case a 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
|
||||
|
||||
-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
|
||||
|
||||
GTEST_TEST(SomeTest, DoesThis) { ... }
|
||||
|
||||
instead of
|
||||
|
||||
TEST(SomeTest, DoesThis) { ... }
|
||||
|
||||
in order to define a test.
|
||||
|
||||
Upgrating from an Earlier Version
|
||||
---------------------------------
|
||||
|
||||
We strive to keep Google Test releases backward compatible.
|
||||
Sometimes, though, we have to make some breaking changes for the
|
||||
users' long-term benefits. This section describes what you'll need to
|
||||
do if you are upgrading from an earlier version of Google Test.
|
||||
|
||||
### Upgrading from 1.3.0 or Earlier ###
|
||||
|
||||
You may need to explicitly enable or disable Google Test's own TR1
|
||||
tuple library. See the instructions in section "Choosing a TR1 Tuple
|
||||
Library".
|
||||
|
||||
### Upgrading from 1.4.0 or Earlier ###
|
||||
|
||||
The Autotools build script (configure + make) is no longer officially
|
||||
supportted. You are encouraged to migrate to your own build system or
|
||||
use CMake. If you still need to use Autotools, you can find
|
||||
instructions in the README file from Google Test 1.4.0.
|
||||
|
||||
On platforms where the pthread library is available, Google Test uses
|
||||
it in order to be thread-safe. See the "Multi-threaded Tests" section
|
||||
for what this means to your build script.
|
||||
|
||||
If you use Microsoft Visual C++ 7.1 with exceptions disabled, Google
|
||||
Test will no longer compile. This should affect very few people, as a
|
||||
large portion of STL (including <string>) doesn't compile in this mode
|
||||
anyway. We decided to stop supporting it in order to greatly simplify
|
||||
Google Test's implementation.
|
||||
|
||||
Developing Google Test
|
||||
----------------------
|
||||
|
||||
This section discusses how to make your own changes to Google Test.
|
||||
|
||||
### Testing Google Test Itself ###
|
||||
|
||||
To make sure your changes work as intended and don't break existing
|
||||
functionality, you'll want to compile and run Google Test's own tests.
|
||||
For that you can use CMake:
|
||||
|
||||
mkdir mybuild
|
||||
cd mybuild
|
||||
cmake -Dgtest_build_tests=ON ${GTEST_DIR}
|
||||
|
||||
Make sure you have Python installed, as some of Google Test's tests
|
||||
are written in Python. If the cmake command complains about not being
|
||||
able to find Python ("Could NOT find PythonInterp (missing:
|
||||
PYTHON_EXECUTABLE)"), try telling it explicitly where your Python
|
||||
executable can be found:
|
||||
|
||||
cmake -DPYTHON_EXECUTABLE=path/to/python -Dgtest_build_tests=ON ${GTEST_DIR}
|
||||
|
||||
Next, you can build Google Test and all of its own tests. On *nix,
|
||||
this is usually done by 'make'. To run the tests, do
|
||||
|
||||
make test
|
||||
|
||||
All tests should pass.
|
||||
|
||||
### Regenerating Source Files ###
|
||||
|
||||
Some of Google Test's source files are generated from templates (not
|
||||
in the C++ sense) using a script. A template file is named FOO.pump,
|
||||
where FOO is the name of the file it will generate. For example, the
|
||||
file include/gtest/internal/gtest-type-util.h.pump is used to generate
|
||||
gtest-type-util.h in the same directory.
|
||||
|
||||
Normally you don't need to worry about regenerating the source files,
|
||||
unless you need to modify them. In that case, you should modify the
|
||||
corresponding .pump files instead and run the pump.py Python script to
|
||||
regenerate them. You can find pump.py in the scripts/ directory.
|
||||
Read the Pump manual [2] for how to use it.
|
||||
|
||||
[2] http://code.google.com/p/googletest/wiki/PumpManual
|
||||
|
||||
### Contributing a Patch ###
|
||||
|
||||
We welcome patches. Please read the Google Test developer's guide [3]
|
||||
for how you can contribute. In particular, make sure you have signed
|
||||
the Contributor License Agreement, or we won't be able to accept the
|
||||
patch.
|
||||
|
||||
[3] http://code.google.com/p/googletest/wiki/GoogleTestDevGuide
|
||||
|
||||
Happy testing!
|
216
gtest/cmake/internal_utils.cmake
Normal file
216
gtest/cmake/internal_utils.cmake
Normal file
@ -0,0 +1,216 @@
|
||||
# Defines functions and macros useful for building Google Test and
|
||||
# Google Mock.
|
||||
#
|
||||
# Note:
|
||||
#
|
||||
# - This file will be run twice when building Google Mock (once via
|
||||
# Google Test's CMakeLists.txt, and once via Google Mock's).
|
||||
# Therefore it shouldn't have any side effects other than defining
|
||||
# the functions and macros.
|
||||
#
|
||||
# - The functions/macros defined in this file may depend on Google
|
||||
# Test and Google Mock's option() definitions, and thus must be
|
||||
# called *after* the options have been defined.
|
||||
|
||||
# Tweaks CMake's default compiler/linker settings to suit Google Test's needs.
|
||||
#
|
||||
# This must be a macro(), as inside a function string() can only
|
||||
# update variables in the function scope.
|
||||
macro(fix_default_compiler_settings_)
|
||||
if (MSVC)
|
||||
# For MSVC, CMake sets certain flags to defaults we want to override.
|
||||
# This replacement code is taken from sample in the CMake Wiki at
|
||||
# http://www.cmake.org/Wiki/CMake_FAQ#Dynamic_Replace.
|
||||
foreach (flag_var
|
||||
CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
|
||||
CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
|
||||
if (NOT BUILD_SHARED_LIBS AND NOT gtest_force_shared_crt)
|
||||
# When Google Test is built as a shared library, it should also use
|
||||
# shared runtime libraries. Otherwise, it may end up with multiple
|
||||
# copies of runtime library data in different modules, resulting in
|
||||
# hard-to-find crashes. When it is built as a static library, it is
|
||||
# preferable to use CRT as static libraries, as we don't have to rely
|
||||
# on CRT DLLs being available. CMake always defaults to using shared
|
||||
# CRT libraries, so we override that default here.
|
||||
string(REPLACE "/MD" "-MT" ${flag_var} "${${flag_var}}")
|
||||
endif()
|
||||
|
||||
# We prefer more strict warning checking for building Google Test.
|
||||
# Replaces /W3 with /W4 in defaults.
|
||||
string(REPLACE "/W3" "-W4" ${flag_var} "${${flag_var}}")
|
||||
endforeach()
|
||||
endif()
|
||||
endmacro()
|
||||
|
||||
# Defines the compiler/linker flags used to build Google Test and
|
||||
# Google Mock. You can tweak these definitions to suit your need. A
|
||||
# variable's value is empty before it's explicitly assigned to.
|
||||
macro(config_compiler_and_linker)
|
||||
if (NOT gtest_disable_pthreads)
|
||||
# Defines CMAKE_USE_PTHREADS_INIT and CMAKE_THREAD_LIBS_INIT.
|
||||
find_package(Threads)
|
||||
endif()
|
||||
|
||||
fix_default_compiler_settings_()
|
||||
if (MSVC)
|
||||
# Newlines inside flags variables break CMake's NMake generator.
|
||||
# TODO(vladl@google.com): Add -RTCs and -RTCu to debug builds.
|
||||
set(cxx_base_flags "-GS -W4 -WX -wd4127 -wd4251 -wd4275 -nologo -J -Zi")
|
||||
set(cxx_base_flags "${cxx_base_flags} -D_UNICODE -DUNICODE -DWIN32 -D_WIN32")
|
||||
set(cxx_base_flags "${cxx_base_flags} -DSTRICT -DWIN32_LEAN_AND_MEAN")
|
||||
set(cxx_exception_flags "-EHsc -D_HAS_EXCEPTIONS=1")
|
||||
set(cxx_no_exception_flags "-D_HAS_EXCEPTIONS=0")
|
||||
set(cxx_no_rtti_flags "-GR-")
|
||||
elseif (CMAKE_COMPILER_IS_GNUCXX)
|
||||
set(cxx_base_flags "-Wall -Wshadow")
|
||||
set(cxx_exception_flags "-fexceptions")
|
||||
set(cxx_no_exception_flags "-fno-exceptions")
|
||||
# Until version 4.3.2, GCC doesn't define a macro to indicate
|
||||
# whether RTTI is enabled. Therefore we define GTEST_HAS_RTTI
|
||||
# explicitly.
|
||||
set(cxx_no_rtti_flags "-fno-rtti -DGTEST_HAS_RTTI=0")
|
||||
set(cxx_strict_flags "-Wextra")
|
||||
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "SunPro")
|
||||
set(cxx_exception_flags "-features=except")
|
||||
# Sun Pro doesn't provide macros to indicate whether exceptions and
|
||||
# RTTI are enabled, so we define GTEST_HAS_* explicitly.
|
||||
set(cxx_no_exception_flags "-features=no%except -DGTEST_HAS_EXCEPTIONS=0")
|
||||
set(cxx_no_rtti_flags "-features=no%rtti -DGTEST_HAS_RTTI=0")
|
||||
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "VisualAge" OR
|
||||
CMAKE_CXX_COMPILER_ID STREQUAL "XL")
|
||||
# CMake 2.8 changes Visual Age's compiler ID to "XL".
|
||||
set(cxx_exception_flags "-qeh")
|
||||
set(cxx_no_exception_flags "-qnoeh")
|
||||
# Until version 9.0, Visual Age doesn't define a macro to indicate
|
||||
# whether RTTI is enabled. Therefore we define GTEST_HAS_RTTI
|
||||
# explicitly.
|
||||
set(cxx_no_rtti_flags "-qnortti -DGTEST_HAS_RTTI=0")
|
||||
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "HP")
|
||||
set(cxx_base_flags "-AA -mt")
|
||||
set(cxx_exception_flags "-DGTEST_HAS_EXCEPTIONS=1")
|
||||
set(cxx_no_exception_flags "+noeh -DGTEST_HAS_EXCEPTIONS=0")
|
||||
# RTTI can not be disabled in HP aCC compiler.
|
||||
set(cxx_no_rtti_flags "")
|
||||
endif()
|
||||
|
||||
if (CMAKE_USE_PTHREADS_INIT) # The pthreads library is available and allowed.
|
||||
set(cxx_base_flags "${cxx_base_flags} -DGTEST_HAS_PTHREAD=1")
|
||||
else()
|
||||
set(cxx_base_flags "${cxx_base_flags} -DGTEST_HAS_PTHREAD=0")
|
||||
endif()
|
||||
|
||||
# For building gtest's own tests and samples.
|
||||
set(cxx_exception "${CMAKE_CXX_FLAGS} ${cxx_base_flags} ${cxx_exception_flags}")
|
||||
set(cxx_no_exception
|
||||
"${CMAKE_CXX_FLAGS} ${cxx_base_flags} ${cxx_no_exception_flags}")
|
||||
set(cxx_default "${cxx_exception}")
|
||||
set(cxx_no_rtti "${cxx_default} ${cxx_no_rtti_flags}")
|
||||
set(cxx_use_own_tuple "${cxx_default} -DGTEST_USE_OWN_TR1_TUPLE=1")
|
||||
|
||||
# For building the gtest libraries.
|
||||
set(cxx_strict "${cxx_default} ${cxx_strict_flags}")
|
||||
endmacro()
|
||||
|
||||
# Defines the gtest & gtest_main libraries. User tests should link
|
||||
# with one of them.
|
||||
function(cxx_library_with_type name type cxx_flags)
|
||||
# type can be either STATIC or SHARED to denote a static or shared library.
|
||||
# ARGN refers to additional arguments after 'cxx_flags'.
|
||||
add_library(${name} ${type} ${ARGN})
|
||||
set_target_properties(${name}
|
||||
PROPERTIES
|
||||
COMPILE_FLAGS "${cxx_flags}")
|
||||
if (BUILD_SHARED_LIBS OR type STREQUAL "SHARED")
|
||||
set_target_properties(${name}
|
||||
PROPERTIES
|
||||
COMPILE_DEFINITIONS "GTEST_CREATE_SHARED_LIBRARY=1")
|
||||
endif()
|
||||
if (CMAKE_USE_PTHREADS_INIT)
|
||||
target_link_libraries(${name} ${CMAKE_THREAD_LIBS_INIT})
|
||||
endif()
|
||||
endfunction()
|
||||
|
||||
########################################################################
|
||||
#
|
||||
# Helper functions for creating build targets.
|
||||
|
||||
function(cxx_shared_library name cxx_flags)
|
||||
cxx_library_with_type(${name} SHARED "${cxx_flags}" ${ARGN})
|
||||
endfunction()
|
||||
|
||||
function(cxx_library name cxx_flags)
|
||||
cxx_library_with_type(${name} "" "${cxx_flags}" ${ARGN})
|
||||
endfunction()
|
||||
|
||||
# cxx_executable_with_flags(name cxx_flags libs srcs...)
|
||||
#
|
||||
# creates a named C++ executable that depends on the given libraries and
|
||||
# is built from the given source files with the given compiler flags.
|
||||
function(cxx_executable_with_flags name cxx_flags libs)
|
||||
add_executable(${name} ${ARGN})
|
||||
if (cxx_flags)
|
||||
set_target_properties(${name}
|
||||
PROPERTIES
|
||||
COMPILE_FLAGS "${cxx_flags}")
|
||||
endif()
|
||||
if (BUILD_SHARED_LIBS)
|
||||
set_target_properties(${name}
|
||||
PROPERTIES
|
||||
COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1")
|
||||
endif()
|
||||
# To support mixing linking in static and dynamic libraries, link each
|
||||
# library in with an extra call to target_link_libraries.
|
||||
foreach (lib "${libs}")
|
||||
target_link_libraries(${name} ${lib})
|
||||
endforeach()
|
||||
endfunction()
|
||||
|
||||
# cxx_executable(name dir lib srcs...)
|
||||
#
|
||||
# creates a named target that depends on the given libs and is built
|
||||
# from the given source files. dir/name.cc is implicitly included in
|
||||
# the source file list.
|
||||
function(cxx_executable name dir libs)
|
||||
cxx_executable_with_flags(
|
||||
${name} "${cxx_default}" "${libs}" "${dir}/${name}.cc" ${ARGN})
|
||||
endfunction()
|
||||
|
||||
# Sets PYTHONINTERP_FOUND and PYTHON_EXECUTABLE.
|
||||
find_package(PythonInterp)
|
||||
|
||||
# cxx_test_with_flags(name cxx_flags libs srcs...)
|
||||
#
|
||||
# creates a named C++ test that depends on the given libs and is built
|
||||
# from the given source files with the given compiler flags.
|
||||
function(cxx_test_with_flags name cxx_flags libs)
|
||||
cxx_executable_with_flags(${name} "${cxx_flags}" "${libs}" ${ARGN})
|
||||
add_test(${name} ${name})
|
||||
endfunction()
|
||||
|
||||
# cxx_test(name libs srcs...)
|
||||
#
|
||||
# creates a named test target that depends on the given libs and is
|
||||
# built from the given source files. Unlike cxx_test_with_flags,
|
||||
# test/name.cc is already implicitly included in the source file list.
|
||||
function(cxx_test name libs)
|
||||
cxx_test_with_flags("${name}" "${cxx_default}" "${libs}"
|
||||
"test/${name}.cc" ${ARGN})
|
||||
endfunction()
|
||||
|
||||
# py_test(name)
|
||||
#
|
||||
# creates a Python test with the given name whose main module is in
|
||||
# test/name.py. It does nothing if Python is not installed.
|
||||
function(py_test name)
|
||||
# We are not supporting Python tests on Linux yet as they consider
|
||||
# all Linux environments to be google3 and try to use google3 features.
|
||||
if (PYTHONINTERP_FOUND)
|
||||
# ${CMAKE_BINARY_DIR} is known at configuration time, so we can
|
||||
# directly bind it from cmake. ${CTEST_CONFIGURATION_TYPE} is known
|
||||
# only at ctest runtime (by calling ctest -c <Configuration>), so
|
||||
# we have to escape $ to delay variable substitution here.
|
||||
add_test(${name}
|
||||
${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py
|
||||
--build_dir=${CMAKE_CURRENT_BINARY_DIR}/\${CTEST_CONFIGURATION_TYPE})
|
||||
endif()
|
||||
endfunction()
|
19537
gtest/gtest.h
19537
gtest/gtest.h
File diff suppressed because it is too large
Load Diff
283
gtest/include/gtest/gtest-death-test.h
Normal file
283
gtest/include/gtest/gtest-death-test.h
Normal file
@ -0,0 +1,283 @@
|
||||
// Copyright 2005, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
//
|
||||
// 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.
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
|
||||
#define GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
|
||||
|
||||
#include "gtest/internal/gtest-death-test-internal.h"
|
||||
|
||||
namespace testing {
|
||||
|
||||
// This flag controls the style of death tests. Valid values are "threadsafe",
|
||||
// meaning that the death test child process will re-execute the test binary
|
||||
// from the start, running only a single death test, or "fast",
|
||||
// meaning that the child process will execute the test logic immediately
|
||||
// after forking.
|
||||
GTEST_DECLARE_string_(death_test_style);
|
||||
|
||||
#if GTEST_HAS_DEATH_TEST
|
||||
|
||||
// The following macros are useful for writing death tests.
|
||||
|
||||
// Here's what happens when an ASSERT_DEATH* or EXPECT_DEATH* is
|
||||
// executed:
|
||||
//
|
||||
// 1. It generates a warning if there is more than one active
|
||||
// thread. This is because it's safe to fork() or clone() only
|
||||
// when there is a single thread.
|
||||
//
|
||||
// 2. The parent process clone()s a sub-process and runs the death
|
||||
// test in it; the sub-process exits with code 0 at the end of the
|
||||
// death test, if it hasn't exited already.
|
||||
//
|
||||
// 3. The parent process waits for the sub-process to terminate.
|
||||
//
|
||||
// 4. The parent process checks the exit code and error message of
|
||||
// the sub-process.
|
||||
//
|
||||
// Examples:
|
||||
//
|
||||
// ASSERT_DEATH(server.SendMessage(56, "Hello"), "Invalid port number");
|
||||
// for (int i = 0; i < 5; i++) {
|
||||
// EXPECT_DEATH(server.ProcessRequest(i),
|
||||
// "Invalid request .* in ProcessRequest()")
|
||||
// << "Failed to die on request " << i);
|
||||
// }
|
||||
//
|
||||
// ASSERT_EXIT(server.ExitNow(), ::testing::ExitedWithCode(0), "Exiting");
|
||||
//
|
||||
// bool KilledBySIGHUP(int exit_code) {
|
||||
// return WIFSIGNALED(exit_code) && WTERMSIG(exit_code) == SIGHUP;
|
||||
// }
|
||||
//
|
||||
// ASSERT_EXIT(client.HangUpServer(), KilledBySIGHUP, "Hanging up!");
|
||||
//
|
||||
// On the regular expressions used in death tests:
|
||||
//
|
||||
// On POSIX-compliant systems (*nix), we use the <regex.h> library,
|
||||
// which uses the POSIX extended regex syntax.
|
||||
//
|
||||
// On other platforms (e.g. Windows), we only support a simple regex
|
||||
// syntax implemented as part of Google Test. This limited
|
||||
// implementation should be enough most of the time when writing
|
||||
// death tests; though it lacks many features you can find in PCRE
|
||||
// or POSIX extended regex syntax. For example, we don't support
|
||||
// union ("x|y"), grouping ("(xy)"), brackets ("[xy]"), and
|
||||
// repetition count ("x{5,7}"), among others.
|
||||
//
|
||||
// Below is the syntax that we do support. We chose it to be a
|
||||
// subset of both PCRE and POSIX extended regex, so it's easy to
|
||||
// learn wherever you come from. In the following: 'A' denotes a
|
||||
// literal character, period (.), or a single \\ escape sequence;
|
||||
// 'x' and 'y' denote regular expressions; 'm' and 'n' are for
|
||||
// natural numbers.
|
||||
//
|
||||
// c matches any literal character c
|
||||
// \\d matches any decimal digit
|
||||
// \\D matches any character that's not a decimal digit
|
||||
// \\f matches \f
|
||||
// \\n matches \n
|
||||
// \\r matches \r
|
||||
// \\s matches any ASCII whitespace, including \n
|
||||
// \\S matches any character that's not a whitespace
|
||||
// \\t matches \t
|
||||
// \\v matches \v
|
||||
// \\w matches any letter, _, or decimal digit
|
||||
// \\W matches any character that \\w doesn't match
|
||||
// \\c matches any literal character c, which must be a punctuation
|
||||
// . matches any single character except \n
|
||||
// A? matches 0 or 1 occurrences of A
|
||||
// A* matches 0 or many occurrences of A
|
||||
// A+ matches 1 or many occurrences of A
|
||||
// ^ matches the beginning of a string (not that of each line)
|
||||
// $ matches the end of a string (not that of each line)
|
||||
// xy matches x followed by y
|
||||
//
|
||||
// If you accidentally use PCRE or POSIX extended regex features
|
||||
// not implemented by us, you will get a run-time failure. In that
|
||||
// case, please try to rewrite your regular expression within the
|
||||
// above syntax.
|
||||
//
|
||||
// This implementation is *not* meant to be as highly tuned or robust
|
||||
// as a compiled regex library, but should perform well enough for a
|
||||
// death test, which already incurs significant overhead by launching
|
||||
// a child process.
|
||||
//
|
||||
// Known caveats:
|
||||
//
|
||||
// A "threadsafe" style death test obtains the path to the test
|
||||
// program from argv[0] and re-executes it in the sub-process. For
|
||||
// simplicity, the current implementation doesn't search the PATH
|
||||
// when launching the sub-process. This means that the user must
|
||||
// invoke the test program via a path that contains at least one
|
||||
// path separator (e.g. path/to/foo_test and
|
||||
// /absolute/path/to/bar_test are fine, but foo_test is not). This
|
||||
// is rarely a problem as people usually don't put the test binary
|
||||
// directory in PATH.
|
||||
//
|
||||
// TODO(wan@google.com): 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
|
||||
// that matches regex.
|
||||
# define ASSERT_EXIT(statement, predicate, regex) \
|
||||
GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_FATAL_FAILURE_)
|
||||
|
||||
// Like ASSERT_EXIT, but continues on to successive tests in the
|
||||
// test case, if any:
|
||||
# define EXPECT_EXIT(statement, predicate, regex) \
|
||||
GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_NONFATAL_FAILURE_)
|
||||
|
||||
// Asserts that a given statement causes the program to exit, either by
|
||||
// explicitly exiting with a nonzero exit code or being killed by a
|
||||
// signal, and emitting error output that matches regex.
|
||||
# define ASSERT_DEATH(statement, regex) \
|
||||
ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)
|
||||
|
||||
// Like ASSERT_DEATH, but continues on to successive tests in the
|
||||
// test case, if any:
|
||||
# define EXPECT_DEATH(statement, regex) \
|
||||
EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)
|
||||
|
||||
// Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*:
|
||||
|
||||
// Tests that an exit code describes a normal exit with a given exit code.
|
||||
class GTEST_API_ ExitedWithCode {
|
||||
public:
|
||||
explicit ExitedWithCode(int exit_code);
|
||||
bool operator()(int exit_status) const;
|
||||
private:
|
||||
// No implementation - assignment is unsupported.
|
||||
void operator=(const ExitedWithCode& other);
|
||||
|
||||
const int exit_code_;
|
||||
};
|
||||
|
||||
# if !GTEST_OS_WINDOWS
|
||||
// Tests that an exit code describes an exit due to termination by a
|
||||
// given signal.
|
||||
class GTEST_API_ KilledBySignal {
|
||||
public:
|
||||
explicit KilledBySignal(int signum);
|
||||
bool operator()(int exit_status) const;
|
||||
private:
|
||||
const int signum_;
|
||||
};
|
||||
# endif // !GTEST_OS_WINDOWS
|
||||
|
||||
// EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode.
|
||||
// The death testing framework causes this to have interesting semantics,
|
||||
// since the sideeffects of the call are only visible in opt mode, and not
|
||||
// in debug mode.
|
||||
//
|
||||
// In practice, this can be used to test functions that utilize the
|
||||
// LOG(DFATAL) macro using the following style:
|
||||
//
|
||||
// int DieInDebugOr12(int* sideeffect) {
|
||||
// if (sideeffect) {
|
||||
// *sideeffect = 12;
|
||||
// }
|
||||
// LOG(DFATAL) << "death";
|
||||
// return 12;
|
||||
// }
|
||||
//
|
||||
// TEST(TestCase, TestDieOr12WorksInDgbAndOpt) {
|
||||
// int sideeffect = 0;
|
||||
// // Only asserts in dbg.
|
||||
// EXPECT_DEBUG_DEATH(DieInDebugOr12(&sideeffect), "death");
|
||||
//
|
||||
// #ifdef NDEBUG
|
||||
// // opt-mode has sideeffect visible.
|
||||
// EXPECT_EQ(12, sideeffect);
|
||||
// #else
|
||||
// // dbg-mode no visible sideeffect.
|
||||
// EXPECT_EQ(0, sideeffect);
|
||||
// #endif
|
||||
// }
|
||||
//
|
||||
// This will assert that DieInDebugReturn12InOpt() crashes in debug
|
||||
// mode, usually due to a DCHECK or LOG(DFATAL), but returns the
|
||||
// appropriate fallback value (12 in this case) in opt mode. If you
|
||||
// need to test that a function has appropriate side-effects in opt
|
||||
// mode, include assertions against the side-effects. A general
|
||||
// pattern for this is:
|
||||
//
|
||||
// EXPECT_DEBUG_DEATH({
|
||||
// // Side-effects here will have an effect after this statement in
|
||||
// // opt mode, but none in debug mode.
|
||||
// EXPECT_EQ(12, DieInDebugOr12(&sideeffect));
|
||||
// }, "death");
|
||||
//
|
||||
# ifdef NDEBUG
|
||||
|
||||
# define EXPECT_DEBUG_DEATH(statement, regex) \
|
||||
do { statement; } while (::testing::internal::AlwaysFalse())
|
||||
|
||||
# define ASSERT_DEBUG_DEATH(statement, regex) \
|
||||
do { statement; } while (::testing::internal::AlwaysFalse())
|
||||
|
||||
# else
|
||||
|
||||
# define EXPECT_DEBUG_DEATH(statement, regex) \
|
||||
EXPECT_DEATH(statement, regex)
|
||||
|
||||
# define ASSERT_DEBUG_DEATH(statement, regex) \
|
||||
ASSERT_DEATH(statement, regex)
|
||||
|
||||
# endif // NDEBUG for EXPECT_DEBUG_DEATH
|
||||
#endif // GTEST_HAS_DEATH_TEST
|
||||
|
||||
// EXPECT_DEATH_IF_SUPPORTED(statement, regex) and
|
||||
// ASSERT_DEATH_IF_SUPPORTED(statement, regex) expand to real death tests if
|
||||
// death tests are supported; otherwise they just issue a warning. This is
|
||||
// useful when you are combining death test assertions with normal test
|
||||
// assertions in one test.
|
||||
#if GTEST_HAS_DEATH_TEST
|
||||
# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
|
||||
EXPECT_DEATH(statement, regex)
|
||||
# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
|
||||
ASSERT_DEATH(statement, regex)
|
||||
#else
|
||||
# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
|
||||
GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, )
|
||||
# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
|
||||
GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, return)
|
||||
#endif
|
||||
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
|
230
gtest/include/gtest/gtest-message.h
Normal file
230
gtest/include/gtest/gtest-message.h
Normal file
@ -0,0 +1,230 @@
|
||||
// Copyright 2005, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
//
|
||||
// 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
|
||||
// leave some internal implementation details in this header file.
|
||||
// They are clearly marked by comments like this:
|
||||
//
|
||||
// // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
|
||||
//
|
||||
// Such code is NOT meant to be used by a user directly, and is subject
|
||||
// to CHANGE WITHOUT NOTICE. Therefore DO NOT DEPEND ON IT in a user
|
||||
// program!
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
|
||||
#define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
|
||||
|
||||
#include <limits>
|
||||
|
||||
#include "gtest/internal/gtest-string.h"
|
||||
#include "gtest/internal/gtest-internal.h"
|
||||
|
||||
namespace testing {
|
||||
|
||||
// The Message class works like an ostream repeater.
|
||||
//
|
||||
// Typical usage:
|
||||
//
|
||||
// 1. You stream a bunch of values to a Message object.
|
||||
// It will remember the text in a stringstream.
|
||||
// 2. Then you stream the Message object to an ostream.
|
||||
// This causes the text in the Message to be streamed
|
||||
// to the ostream.
|
||||
//
|
||||
// For example;
|
||||
//
|
||||
// testing::Message foo;
|
||||
// foo << 1 << " != " << 2;
|
||||
// std::cout << foo;
|
||||
//
|
||||
// will print "1 != 2".
|
||||
//
|
||||
// Message is not intended to be inherited from. In particular, its
|
||||
// destructor is not virtual.
|
||||
//
|
||||
// Note that stringstream behaves differently in gcc and in MSVC. You
|
||||
// can stream a NULL char pointer to it in the former, but not in the
|
||||
// latter (it causes an access violation if you do). The Message
|
||||
// class hides this difference by treating a NULL char pointer as
|
||||
// "(null)".
|
||||
class GTEST_API_ Message {
|
||||
private:
|
||||
// The type of basic IO manipulators (endl, ends, and flush) for
|
||||
// narrow streams.
|
||||
typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&);
|
||||
|
||||
public:
|
||||
// Constructs an empty Message.
|
||||
// We allocate the stringstream separately because otherwise each use of
|
||||
// ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's
|
||||
// stack frame leading to huge stack frames in some cases; gcc does not reuse
|
||||
// the stack space.
|
||||
Message() : ss_(new ::std::stringstream) {
|
||||
// By default, we want there to be enough precision when printing
|
||||
// a double to a Message.
|
||||
*ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
|
||||
}
|
||||
|
||||
// Copy constructor.
|
||||
Message(const Message& msg) : ss_(new ::std::stringstream) { // NOLINT
|
||||
*ss_ << msg.GetString();
|
||||
}
|
||||
|
||||
// Constructs a Message from a C-string.
|
||||
explicit Message(const char* str) : ss_(new ::std::stringstream) {
|
||||
*ss_ << str;
|
||||
}
|
||||
|
||||
#if GTEST_OS_SYMBIAN
|
||||
// Streams a value (either a pointer or not) to this object.
|
||||
template <typename T>
|
||||
inline Message& operator <<(const T& value) {
|
||||
StreamHelper(typename internal::is_pointer<T>::type(), value);
|
||||
return *this;
|
||||
}
|
||||
#else
|
||||
// Streams a non-pointer value to this object.
|
||||
template <typename T>
|
||||
inline Message& operator <<(const T& val) {
|
||||
::GTestStreamToHelper(ss_.get(), val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
// Streams a pointer value to this object.
|
||||
//
|
||||
// This function is an overload of the previous one. When you
|
||||
// stream a pointer to a Message, this definition will be used as it
|
||||
// is more specialized. (The C++ Standard, section
|
||||
// [temp.func.order].) If you stream a non-pointer, then the
|
||||
// previous definition will be used.
|
||||
//
|
||||
// The reason for this overload is that streaming a NULL pointer to
|
||||
// ostream is undefined behavior. Depending on the compiler, you
|
||||
// may get "0", "(nil)", "(null)", or an access violation. To
|
||||
// ensure consistent result across compilers, we always treat NULL
|
||||
// as "(null)".
|
||||
template <typename T>
|
||||
inline Message& operator <<(T* const& pointer) { // NOLINT
|
||||
if (pointer == NULL) {
|
||||
*ss_ << "(null)";
|
||||
} else {
|
||||
::GTestStreamToHelper(ss_.get(), pointer);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
#endif // GTEST_OS_SYMBIAN
|
||||
|
||||
// Since the basic IO manipulators are overloaded for both narrow
|
||||
// and wide streams, we have to provide this specialized definition
|
||||
// of operator <<, even though its body is the same as the
|
||||
// templatized version above. Without this definition, streaming
|
||||
// endl or other basic IO manipulators to Message will confuse the
|
||||
// compiler.
|
||||
Message& operator <<(BasicNarrowIoManip val) {
|
||||
*ss_ << val;
|
||||
return *this;
|
||||
}
|
||||
|
||||
// Instead of 1/0, we want to see true/false for bool values.
|
||||
Message& operator <<(bool b) {
|
||||
return *this << (b ? "true" : "false");
|
||||
}
|
||||
|
||||
// These two overloads allow streaming a wide C string to a Message
|
||||
// using the UTF-8 encoding.
|
||||
Message& operator <<(const wchar_t* wide_c_str) {
|
||||
return *this << internal::String::ShowWideCString(wide_c_str);
|
||||
}
|
||||
Message& operator <<(wchar_t* wide_c_str) {
|
||||
return *this << internal::String::ShowWideCString(wide_c_str);
|
||||
}
|
||||
|
||||
#if GTEST_HAS_STD_WSTRING
|
||||
// Converts the given wide string to a narrow string using the UTF-8
|
||||
// encoding, and streams the result to this Message object.
|
||||
Message& operator <<(const ::std::wstring& wstr);
|
||||
#endif // GTEST_HAS_STD_WSTRING
|
||||
|
||||
#if GTEST_HAS_GLOBAL_WSTRING
|
||||
// Converts the given wide string to a narrow string using the UTF-8
|
||||
// encoding, and streams the result to this Message object.
|
||||
Message& operator <<(const ::wstring& wstr);
|
||||
#endif // GTEST_HAS_GLOBAL_WSTRING
|
||||
|
||||
// Gets the text streamed to this object so far as a String.
|
||||
// Each '\0' character in the buffer is replaced with "\\0".
|
||||
//
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
|
||||
internal::String GetString() const {
|
||||
return internal::StringStreamToString(ss_.get());
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
#if GTEST_OS_SYMBIAN
|
||||
// These are needed as the Nokia Symbian Compiler cannot decide between
|
||||
// const T& and const T* in a function template. The Nokia compiler _can_
|
||||
// decide between class template specializations for T and T*, so a
|
||||
// tr1::type_traits-like is_pointer works, and we can overload on that.
|
||||
template <typename T>
|
||||
inline void StreamHelper(internal::true_type /*dummy*/, T* pointer) {
|
||||
if (pointer == NULL) {
|
||||
*ss_ << "(null)";
|
||||
} else {
|
||||
::GTestStreamToHelper(ss_.get(), pointer);
|
||||
}
|
||||
}
|
||||
template <typename T>
|
||||
inline void StreamHelper(internal::false_type /*dummy*/, const T& value) {
|
||||
::GTestStreamToHelper(ss_.get(), value);
|
||||
}
|
||||
#endif // GTEST_OS_SYMBIAN
|
||||
|
||||
// We'll hold the text streamed to this object here.
|
||||
const internal::scoped_ptr< ::std::stringstream> ss_;
|
||||
|
||||
// We declare (but don't implement) this to prevent the compiler
|
||||
// from implementing the assignment operator.
|
||||
void operator=(const Message&);
|
||||
};
|
||||
|
||||
// Streams a Message to an ostream.
|
||||
inline std::ostream& operator <<(std::ostream& os, const Message& sb) {
|
||||
return os << sb.GetString();
|
||||
}
|
||||
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
|
1421
gtest/include/gtest/gtest-param-test.h
Normal file
1421
gtest/include/gtest/gtest-param-test.h
Normal file
File diff suppressed because it is too large
Load Diff
487
gtest/include/gtest/gtest-param-test.h.pump
Normal file
487
gtest/include/gtest/gtest-param-test.h.pump
Normal file
@ -0,0 +1,487 @@
|
||||
$$ -*- mode: c++; -*-
|
||||
$var n = 50 $$ Maximum length of Values arguments we want to support.
|
||||
$var maxtuple = 10 $$ Maximum number of Combine arguments we want to support.
|
||||
// Copyright 2008, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Authors: vladl@google.com (Vlad Losev)
|
||||
//
|
||||
// Macros and functions for implementing parameterized tests
|
||||
// in Google C++ Testing Framework (Google Test)
|
||||
//
|
||||
// This file is generated by a SCRIPT. DO NOT EDIT BY HAND!
|
||||
//
|
||||
#ifndef GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
|
||||
#define GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
|
||||
|
||||
|
||||
// Value-parameterized tests allow you to test your code with different
|
||||
// parameters without writing multiple copies of the same test.
|
||||
//
|
||||
// Here is how you use value-parameterized tests:
|
||||
|
||||
#if 0
|
||||
|
||||
// To write value-parameterized tests, first you should define a fixture
|
||||
// class. It is usually derived from testing::TestWithParam<T> (see below for
|
||||
// another inheritance scheme that's sometimes useful in more complicated
|
||||
// class hierarchies), where the type of your parameter values.
|
||||
// TestWithParam<T> is itself derived from testing::Test. T can be any
|
||||
// copyable type. If it's a raw pointer, you are responsible for managing the
|
||||
// lifespan of the pointed values.
|
||||
|
||||
class FooTest : public ::testing::TestWithParam<const char*> {
|
||||
// You can implement all the usual class fixture members here.
|
||||
};
|
||||
|
||||
// Then, use the TEST_P macro to define as many parameterized tests
|
||||
// for this fixture as you want. The _P suffix is for "parameterized"
|
||||
// or "pattern", whichever you prefer to think.
|
||||
|
||||
TEST_P(FooTest, DoesBlah) {
|
||||
// Inside a test, access the test parameter with the GetParam() method
|
||||
// of the TestWithParam<T> class:
|
||||
EXPECT_TRUE(foo.Blah(GetParam()));
|
||||
...
|
||||
}
|
||||
|
||||
TEST_P(FooTest, HasBlahBlah) {
|
||||
...
|
||||
}
|
||||
|
||||
// Finally, you can use INSTANTIATE_TEST_CASE_P to instantiate the test
|
||||
// case with any set of parameters you want. Google Test defines a number
|
||||
// of functions for generating test parameters. They return what we call
|
||||
// (surprise!) parameter generators. Here is a summary of them, which
|
||||
// are all in the testing namespace:
|
||||
//
|
||||
//
|
||||
// Range(begin, end [, step]) - Yields values {begin, begin+step,
|
||||
// begin+step+step, ...}. The values do not
|
||||
// include end. step defaults to 1.
|
||||
// Values(v1, v2, ..., vN) - Yields values {v1, v2, ..., vN}.
|
||||
// ValuesIn(container) - Yields values from a C-style array, an STL
|
||||
// ValuesIn(begin,end) container, or an iterator range [begin, end).
|
||||
// Bool() - Yields sequence {false, true}.
|
||||
// Combine(g1, g2, ..., gN) - Yields all combinations (the Cartesian product
|
||||
// for the math savvy) of the values generated
|
||||
// by the N generators.
|
||||
//
|
||||
// For more details, see comments at the definitions of these functions below
|
||||
// in this file.
|
||||
//
|
||||
// The following statement will instantiate tests from the FooTest test case
|
||||
// each with parameter values "meeny", "miny", and "moe".
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(InstantiationName,
|
||||
FooTest,
|
||||
Values("meeny", "miny", "moe"));
|
||||
|
||||
// To distinguish different instances of the pattern, (yes, you
|
||||
// can instantiate it more then once) the first argument to the
|
||||
// INSTANTIATE_TEST_CASE_P macro is a prefix that will be added to the
|
||||
// actual test case name. Remember to pick unique prefixes for different
|
||||
// instantiations. The tests from the instantiation above will have
|
||||
// these names:
|
||||
//
|
||||
// * InstantiationName/FooTest.DoesBlah/0 for "meeny"
|
||||
// * InstantiationName/FooTest.DoesBlah/1 for "miny"
|
||||
// * InstantiationName/FooTest.DoesBlah/2 for "moe"
|
||||
// * InstantiationName/FooTest.HasBlahBlah/0 for "meeny"
|
||||
// * InstantiationName/FooTest.HasBlahBlah/1 for "miny"
|
||||
// * InstantiationName/FooTest.HasBlahBlah/2 for "moe"
|
||||
//
|
||||
// You can use these names in --gtest_filter.
|
||||
//
|
||||
// This statement will instantiate all tests from FooTest again, each
|
||||
// with parameter values "cat" and "dog":
|
||||
|
||||
const char* pets[] = {"cat", "dog"};
|
||||
INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets));
|
||||
|
||||
// The tests from the instantiation above will have these names:
|
||||
//
|
||||
// * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat"
|
||||
// * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog"
|
||||
// * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat"
|
||||
// * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog"
|
||||
//
|
||||
// Please note that INSTANTIATE_TEST_CASE_P will instantiate all tests
|
||||
// in the given test case, whether their definitions come before or
|
||||
// AFTER the INSTANTIATE_TEST_CASE_P statement.
|
||||
//
|
||||
// Please also note that generator expressions (including parameters to the
|
||||
// generators) are evaluated in InitGoogleTest(), after main() has started.
|
||||
// This allows the user on one hand, to adjust generator parameters in order
|
||||
// to dynamically determine a set of tests to run and on the other hand,
|
||||
// give the user a chance to inspect the generated tests with Google Test
|
||||
// reflection API before RUN_ALL_TESTS() is executed.
|
||||
//
|
||||
// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc
|
||||
// for more examples.
|
||||
//
|
||||
// In the future, we plan to publish the API for defining new parameter
|
||||
// generators. But for now this interface remains part of the internal
|
||||
// implementation and is subject to change.
|
||||
//
|
||||
//
|
||||
// A parameterized test fixture must be derived from testing::Test and from
|
||||
// testing::WithParamInterface<T>, where T is the type of the parameter
|
||||
// values. Inheriting from TestWithParam<T> satisfies that requirement because
|
||||
// TestWithParam<T> inherits from both Test and WithParamInterface. In more
|
||||
// complicated hierarchies, however, it is occasionally useful to inherit
|
||||
// separately from Test and WithParamInterface. For example:
|
||||
|
||||
class BaseTest : public ::testing::Test {
|
||||
// You can inherit all the usual members for a non-parameterized test
|
||||
// fixture here.
|
||||
};
|
||||
|
||||
class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> {
|
||||
// The usual test fixture members go here too.
|
||||
};
|
||||
|
||||
TEST_F(BaseTest, HasFoo) {
|
||||
// This is an ordinary non-parameterized test.
|
||||
}
|
||||
|
||||
TEST_P(DerivedTest, DoesBlah) {
|
||||
// GetParam works just the same here as if you inherit from TestWithParam.
|
||||
EXPECT_TRUE(foo.Blah(GetParam()));
|
||||
}
|
||||
|
||||
#endif // 0
|
||||
|
||||
#include "gtest/internal/gtest-port.h"
|
||||
|
||||
#if !GTEST_OS_SYMBIAN
|
||||
# include <utility>
|
||||
#endif
|
||||
|
||||
// scripts/fuse_gtest.py depends on gtest's own header being #included
|
||||
// *unconditionally*. Therefore these #includes cannot be moved
|
||||
// inside #if GTEST_HAS_PARAM_TEST.
|
||||
#include "gtest/internal/gtest-internal.h"
|
||||
#include "gtest/internal/gtest-param-util.h"
|
||||
#include "gtest/internal/gtest-param-util-generated.h"
|
||||
|
||||
#if GTEST_HAS_PARAM_TEST
|
||||
|
||||
namespace testing {
|
||||
|
||||
// Functions producing parameter generators.
|
||||
//
|
||||
// Google Test uses these generators to produce parameters for value-
|
||||
// parameterized tests. When a parameterized test case is instantiated
|
||||
// with a particular generator, Google Test creates and runs tests
|
||||
// for each element in the sequence produced by the generator.
|
||||
//
|
||||
// In the following sample, tests from test case FooTest are instantiated
|
||||
// each three times with parameter values 3, 5, and 8:
|
||||
//
|
||||
// class FooTest : public TestWithParam<int> { ... };
|
||||
//
|
||||
// TEST_P(FooTest, TestThis) {
|
||||
// }
|
||||
// TEST_P(FooTest, TestThat) {
|
||||
// }
|
||||
// INSTANTIATE_TEST_CASE_P(TestSequence, FooTest, Values(3, 5, 8));
|
||||
//
|
||||
|
||||
// Range() returns generators providing sequences of values in a range.
|
||||
//
|
||||
// Synopsis:
|
||||
// Range(start, end)
|
||||
// - returns a generator producing a sequence of values {start, start+1,
|
||||
// start+2, ..., }.
|
||||
// Range(start, end, step)
|
||||
// - returns a generator producing a sequence of values {start, start+step,
|
||||
// start+step+step, ..., }.
|
||||
// Notes:
|
||||
// * The generated sequences never include end. For example, Range(1, 5)
|
||||
// returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2)
|
||||
// returns a generator producing {1, 3, 5, 7}.
|
||||
// * start and end must have the same type. That type may be any integral or
|
||||
// floating-point type or a user defined type satisfying these conditions:
|
||||
// * It must be assignable (have operator=() defined).
|
||||
// * It must have operator+() (operator+(int-compatible type) for
|
||||
// two-operand version).
|
||||
// * It must have operator<() defined.
|
||||
// Elements in the resulting sequences will also have that type.
|
||||
// * Condition start < end must be satisfied in order for resulting sequences
|
||||
// to contain any elements.
|
||||
//
|
||||
template <typename T, typename IncrementT>
|
||||
internal::ParamGenerator<T> Range(T start, T end, IncrementT step) {
|
||||
return internal::ParamGenerator<T>(
|
||||
new internal::RangeGenerator<T, IncrementT>(start, end, step));
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
internal::ParamGenerator<T> Range(T start, T end) {
|
||||
return Range(start, end, 1);
|
||||
}
|
||||
|
||||
// ValuesIn() function allows generation of tests with parameters coming from
|
||||
// a container.
|
||||
//
|
||||
// Synopsis:
|
||||
// ValuesIn(const T (&array)[N])
|
||||
// - returns a generator producing sequences with elements from
|
||||
// a C-style array.
|
||||
// ValuesIn(const Container& container)
|
||||
// - returns a generator producing sequences with elements from
|
||||
// an STL-style container.
|
||||
// ValuesIn(Iterator begin, Iterator end)
|
||||
// - returns a generator producing sequences with elements from
|
||||
// a range [begin, end) defined by a pair of STL-style iterators. These
|
||||
// iterators can also be plain C pointers.
|
||||
//
|
||||
// Please note that ValuesIn copies the values from the containers
|
||||
// passed in and keeps them to generate tests in RUN_ALL_TESTS().
|
||||
//
|
||||
// Examples:
|
||||
//
|
||||
// This instantiates tests from test case StringTest
|
||||
// each with C-string values of "foo", "bar", and "baz":
|
||||
//
|
||||
// const char* strings[] = {"foo", "bar", "baz"};
|
||||
// INSTANTIATE_TEST_CASE_P(StringSequence, SrtingTest, ValuesIn(strings));
|
||||
//
|
||||
// This instantiates tests from test case StlStringTest
|
||||
// each with STL strings with values "a" and "b":
|
||||
//
|
||||
// ::std::vector< ::std::string> GetParameterStrings() {
|
||||
// ::std::vector< ::std::string> v;
|
||||
// v.push_back("a");
|
||||
// v.push_back("b");
|
||||
// return v;
|
||||
// }
|
||||
//
|
||||
// INSTANTIATE_TEST_CASE_P(CharSequence,
|
||||
// StlStringTest,
|
||||
// ValuesIn(GetParameterStrings()));
|
||||
//
|
||||
//
|
||||
// This will also instantiate tests from CharTest
|
||||
// each with parameter values 'a' and 'b':
|
||||
//
|
||||
// ::std::list<char> GetParameterChars() {
|
||||
// ::std::list<char> list;
|
||||
// list.push_back('a');
|
||||
// list.push_back('b');
|
||||
// return list;
|
||||
// }
|
||||
// ::std::list<char> l = GetParameterChars();
|
||||
// INSTANTIATE_TEST_CASE_P(CharSequence2,
|
||||
// CharTest,
|
||||
// ValuesIn(l.begin(), l.end()));
|
||||
//
|
||||
template <typename ForwardIterator>
|
||||
internal::ParamGenerator<
|
||||
typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
|
||||
ValuesIn(ForwardIterator begin, ForwardIterator end) {
|
||||
typedef typename ::testing::internal::IteratorTraits<ForwardIterator>
|
||||
::value_type ParamType;
|
||||
return internal::ParamGenerator<ParamType>(
|
||||
new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));
|
||||
}
|
||||
|
||||
template <typename T, size_t N>
|
||||
internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) {
|
||||
return ValuesIn(array, array + N);
|
||||
}
|
||||
|
||||
template <class Container>
|
||||
internal::ParamGenerator<typename Container::value_type> ValuesIn(
|
||||
const Container& container) {
|
||||
return ValuesIn(container.begin(), container.end());
|
||||
}
|
||||
|
||||
// Values() allows generating tests from explicitly specified list of
|
||||
// parameters.
|
||||
//
|
||||
// Synopsis:
|
||||
// Values(T v1, T v2, ..., T vN)
|
||||
// - returns a generator producing sequences with elements v1, v2, ..., vN.
|
||||
//
|
||||
// For example, this instantiates tests from test case BarTest each
|
||||
// with values "one", "two", and "three":
|
||||
//
|
||||
// INSTANTIATE_TEST_CASE_P(NumSequence, BarTest, Values("one", "two", "three"));
|
||||
//
|
||||
// This instantiates tests from test case BazTest each with values 1, 2, 3.5.
|
||||
// The exact type of values will depend on the type of parameter in BazTest.
|
||||
//
|
||||
// INSTANTIATE_TEST_CASE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));
|
||||
//
|
||||
// Currently, Values() supports from 1 to $n parameters.
|
||||
//
|
||||
$range i 1..n
|
||||
$for i [[
|
||||
$range j 1..i
|
||||
|
||||
template <$for j, [[typename T$j]]>
|
||||
internal::ValueArray$i<$for j, [[T$j]]> Values($for j, [[T$j v$j]]) {
|
||||
return internal::ValueArray$i<$for j, [[T$j]]>($for j, [[v$j]]);
|
||||
}
|
||||
|
||||
]]
|
||||
|
||||
// Bool() allows generating tests with parameters in a set of (false, true).
|
||||
//
|
||||
// Synopsis:
|
||||
// Bool()
|
||||
// - returns a generator producing sequences with elements {false, true}.
|
||||
//
|
||||
// It is useful when testing code that depends on Boolean flags. Combinations
|
||||
// of multiple flags can be tested when several Bool()'s are combined using
|
||||
// Combine() function.
|
||||
//
|
||||
// In the following example all tests in the test case FlagDependentTest
|
||||
// will be instantiated twice with parameters false and true.
|
||||
//
|
||||
// class FlagDependentTest : public testing::TestWithParam<bool> {
|
||||
// virtual void SetUp() {
|
||||
// external_flag = GetParam();
|
||||
// }
|
||||
// }
|
||||
// INSTANTIATE_TEST_CASE_P(BoolSequence, FlagDependentTest, Bool());
|
||||
//
|
||||
inline internal::ParamGenerator<bool> Bool() {
|
||||
return Values(false, true);
|
||||
}
|
||||
|
||||
# if GTEST_HAS_COMBINE
|
||||
// Combine() allows the user to combine two or more sequences to produce
|
||||
// values of a Cartesian product of those sequences' elements.
|
||||
//
|
||||
// Synopsis:
|
||||
// Combine(gen1, gen2, ..., genN)
|
||||
// - returns a generator producing sequences with elements coming from
|
||||
// the Cartesian product of elements from the sequences generated by
|
||||
// gen1, gen2, ..., genN. The sequence elements will have a type of
|
||||
// tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types
|
||||
// of elements from sequences produces by gen1, gen2, ..., genN.
|
||||
//
|
||||
// Combine can have up to $maxtuple arguments. This number is currently limited
|
||||
// by the maximum number of elements in the tuple implementation used by Google
|
||||
// Test.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// This will instantiate tests in test case AnimalTest each one with
|
||||
// the parameter values tuple("cat", BLACK), tuple("cat", WHITE),
|
||||
// tuple("dog", BLACK), and tuple("dog", WHITE):
|
||||
//
|
||||
// enum Color { BLACK, GRAY, WHITE };
|
||||
// class AnimalTest
|
||||
// : public testing::TestWithParam<tuple<const char*, Color> > {...};
|
||||
//
|
||||
// TEST_P(AnimalTest, AnimalLooksNice) {...}
|
||||
//
|
||||
// INSTANTIATE_TEST_CASE_P(AnimalVariations, AnimalTest,
|
||||
// Combine(Values("cat", "dog"),
|
||||
// Values(BLACK, WHITE)));
|
||||
//
|
||||
// This will instantiate tests in FlagDependentTest with all variations of two
|
||||
// Boolean flags:
|
||||
//
|
||||
// class FlagDependentTest
|
||||
// : public testing::TestWithParam<tuple(bool, bool)> > {
|
||||
// virtual void SetUp() {
|
||||
// // Assigns external_flag_1 and external_flag_2 values from the tuple.
|
||||
// tie(external_flag_1, external_flag_2) = GetParam();
|
||||
// }
|
||||
// };
|
||||
//
|
||||
// TEST_P(FlagDependentTest, TestFeature1) {
|
||||
// // Test your code using external_flag_1 and external_flag_2 here.
|
||||
// }
|
||||
// INSTANTIATE_TEST_CASE_P(TwoBoolSequence, FlagDependentTest,
|
||||
// Combine(Bool(), Bool()));
|
||||
//
|
||||
$range i 2..maxtuple
|
||||
$for i [[
|
||||
$range j 1..i
|
||||
|
||||
template <$for j, [[typename Generator$j]]>
|
||||
internal::CartesianProductHolder$i<$for j, [[Generator$j]]> Combine(
|
||||
$for j, [[const Generator$j& g$j]]) {
|
||||
return internal::CartesianProductHolder$i<$for j, [[Generator$j]]>(
|
||||
$for j, [[g$j]]);
|
||||
}
|
||||
|
||||
]]
|
||||
# endif // GTEST_HAS_COMBINE
|
||||
|
||||
|
||||
|
||||
# define TEST_P(test_case_name, test_name) \
|
||||
class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
|
||||
: public test_case_name { \
|
||||
public: \
|
||||
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {} \
|
||||
virtual void TestBody(); \
|
||||
private: \
|
||||
static int AddToRegistry() { \
|
||||
::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
|
||||
GetTestCasePatternHolder<test_case_name>(\
|
||||
#test_case_name, __FILE__, __LINE__)->AddTestPattern(\
|
||||
#test_case_name, \
|
||||
#test_name, \
|
||||
new ::testing::internal::TestMetaFactory< \
|
||||
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>()); \
|
||||
return 0; \
|
||||
} \
|
||||
static int gtest_registering_dummy_; \
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(\
|
||||
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \
|
||||
}; \
|
||||
int GTEST_TEST_CLASS_NAME_(test_case_name, \
|
||||
test_name)::gtest_registering_dummy_ = \
|
||||
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \
|
||||
void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
|
||||
|
||||
# define INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator) \
|
||||
::testing::internal::ParamGenerator<test_case_name::ParamType> \
|
||||
gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \
|
||||
int gtest_##prefix##test_case_name##_dummy_ = \
|
||||
::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
|
||||
GetTestCasePatternHolder<test_case_name>(\
|
||||
#test_case_name, __FILE__, __LINE__)->AddTestCaseInstantiation(\
|
||||
#prefix, \
|
||||
>est_##prefix##test_case_name##_EvalGenerator_, \
|
||||
__FILE__, __LINE__)
|
||||
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_HAS_PARAM_TEST
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
|
796
gtest/include/gtest/gtest-printers.h
Normal file
796
gtest/include/gtest/gtest-printers.h
Normal file
@ -0,0 +1,796 @@
|
||||
// Copyright 2007, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
// Google Test - The Google C++ Testing Framework
|
||||
//
|
||||
// This file implements a universal value printer that can print a
|
||||
// value of any type T:
|
||||
//
|
||||
// void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
|
||||
//
|
||||
// A user can teach this function how to print a class type T by
|
||||
// defining either operator<<() or PrintTo() in the namespace that
|
||||
// defines T. More specifically, the FIRST defined function in the
|
||||
// following list will be used (assuming T is defined in namespace
|
||||
// foo):
|
||||
//
|
||||
// 1. foo::PrintTo(const T&, ostream*)
|
||||
// 2. operator<<(ostream&, const T&) defined in either foo or the
|
||||
// global namespace.
|
||||
//
|
||||
// If none of the above is defined, it will print the debug string of
|
||||
// the value if it is a protocol buffer, or print the raw bytes in the
|
||||
// value otherwise.
|
||||
//
|
||||
// To aid debugging: when T is a reference type, the address of the
|
||||
// value is also printed; when T is a (const) char pointer, both the
|
||||
// pointer value and the NUL-terminated string it points to are
|
||||
// printed.
|
||||
//
|
||||
// We also provide some convenient wrappers:
|
||||
//
|
||||
// // Prints a value to a string. For a (const or not) char
|
||||
// // pointer, the NUL-terminated string (but not the pointer) is
|
||||
// // printed.
|
||||
// std::string ::testing::PrintToString(const T& value);
|
||||
//
|
||||
// // Prints a value tersely: for a reference type, the referenced
|
||||
// // value (but not the address) is printed; for a (const or not) char
|
||||
// // pointer, the NUL-terminated string (but not the pointer) is
|
||||
// // printed.
|
||||
// void ::testing::internal::UniversalTersePrint(const T& value, ostream*);
|
||||
//
|
||||
// // Prints value using the type inferred by the compiler. The difference
|
||||
// // from UniversalTersePrint() is that this function prints both the
|
||||
// // pointer and the NUL-terminated string for a (const or not) char pointer.
|
||||
// void ::testing::internal::UniversalPrint(const T& value, ostream*);
|
||||
//
|
||||
// // Prints the fields of a tuple tersely to a string vector, one
|
||||
// // element for each field. Tuple support must be enabled in
|
||||
// // gtest-port.h.
|
||||
// std::vector<string> UniversalTersePrintTupleFieldsToStrings(
|
||||
// const Tuple& value);
|
||||
//
|
||||
// Known limitation:
|
||||
//
|
||||
// The print primitives print the elements of an STL-style container
|
||||
// using the compiler-inferred type of *iter where iter is a
|
||||
// const_iterator of the container. When const_iterator is an input
|
||||
// iterator but not a forward iterator, this inferred type may not
|
||||
// match value_type, and the print output may be incorrect. In
|
||||
// practice, this is rarely a problem as for most containers
|
||||
// const_iterator is a forward iterator. We'll fix this if there's an
|
||||
// actual need for it. Note that this fix cannot rely on value_type
|
||||
// being defined as many user-defined container types don't have
|
||||
// value_type.
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
|
||||
#define GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
|
||||
|
||||
#include <ostream> // NOLINT
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
#include "gtest/internal/gtest-port.h"
|
||||
#include "gtest/internal/gtest-internal.h"
|
||||
|
||||
namespace testing {
|
||||
|
||||
// Definitions in the 'internal' and 'internal2' name spaces are
|
||||
// subject to change without notice. DO NOT USE THEM IN USER CODE!
|
||||
namespace internal2 {
|
||||
|
||||
// Prints the given number of bytes in the given object to the given
|
||||
// ostream.
|
||||
GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes,
|
||||
size_t count,
|
||||
::std::ostream* os);
|
||||
|
||||
// For selecting which printer to use when a given type has neither <<
|
||||
// nor PrintTo().
|
||||
enum TypeKind {
|
||||
kProtobuf, // a protobuf type
|
||||
kConvertibleToInteger, // a type implicitly convertible to BiggestInt
|
||||
// (e.g. a named or unnamed enum type)
|
||||
kOtherType // anything else
|
||||
};
|
||||
|
||||
// TypeWithoutFormatter<T, kTypeKind>::PrintValue(value, os) is called
|
||||
// by the universal printer to print a value of type T when neither
|
||||
// operator<< nor PrintTo() is defined for T, where kTypeKind is the
|
||||
// "kind" of T as defined by enum TypeKind.
|
||||
template <typename T, TypeKind kTypeKind>
|
||||
class TypeWithoutFormatter {
|
||||
public:
|
||||
// This default version is called when kTypeKind is kOtherType.
|
||||
static void PrintValue(const T& value, ::std::ostream* os) {
|
||||
PrintBytesInObjectTo(reinterpret_cast<const unsigned char*>(&value),
|
||||
sizeof(value), os);
|
||||
}
|
||||
};
|
||||
|
||||
// We print a protobuf using its ShortDebugString() when the string
|
||||
// doesn't exceed this many characters; otherwise we print it using
|
||||
// DebugString() for better readability.
|
||||
const size_t kProtobufOneLinerMaxLength = 50;
|
||||
|
||||
template <typename T>
|
||||
class TypeWithoutFormatter<T, kProtobuf> {
|
||||
public:
|
||||
static void PrintValue(const T& value, ::std::ostream* os) {
|
||||
const ::testing::internal::string short_str = value.ShortDebugString();
|
||||
const ::testing::internal::string pretty_str =
|
||||
short_str.length() <= kProtobufOneLinerMaxLength ?
|
||||
short_str : ("\n" + value.DebugString());
|
||||
*os << ("<" + pretty_str + ">");
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
class TypeWithoutFormatter<T, kConvertibleToInteger> {
|
||||
public:
|
||||
// Since T has no << operator or PrintTo() but can be implicitly
|
||||
// converted to BiggestInt, we print it as a BiggestInt.
|
||||
//
|
||||
// Most likely T is an enum type (either named or unnamed), in which
|
||||
// case printing it as an integer is the desired behavior. In case
|
||||
// T is not an enum, printing it as an integer is the best we can do
|
||||
// given that it has no user-defined printer.
|
||||
static void PrintValue(const T& value, ::std::ostream* os) {
|
||||
const internal::BiggestInt kBigInt = value;
|
||||
*os << kBigInt;
|
||||
}
|
||||
};
|
||||
|
||||
// Prints the given value to the given ostream. If the value is a
|
||||
// protocol message, its debug string is printed; if it's an enum or
|
||||
// of a type implicitly convertible to BiggestInt, it's printed as an
|
||||
// integer; otherwise the bytes in the value are printed. This is
|
||||
// what UniversalPrinter<T>::Print() does when it knows nothing about
|
||||
// type T and T has neither << operator nor PrintTo().
|
||||
//
|
||||
// A user can override this behavior for a class type Foo by defining
|
||||
// a << operator in the namespace where Foo is defined.
|
||||
//
|
||||
// We put this operator in namespace 'internal2' instead of 'internal'
|
||||
// to simplify the implementation, as much code in 'internal' needs to
|
||||
// use << in STL, which would conflict with our own << were it defined
|
||||
// in 'internal'.
|
||||
//
|
||||
// Note that this operator<< takes a generic std::basic_ostream<Char,
|
||||
// CharTraits> type instead of the more restricted std::ostream. If
|
||||
// we define it to take an std::ostream instead, we'll get an
|
||||
// "ambiguous overloads" compiler error when trying to print a type
|
||||
// Foo that supports streaming to std::basic_ostream<Char,
|
||||
// CharTraits>, as the compiler cannot tell whether
|
||||
// operator<<(std::ostream&, const T&) or
|
||||
// operator<<(std::basic_stream<Char, CharTraits>, const Foo&) is more
|
||||
// specific.
|
||||
template <typename Char, typename CharTraits, typename T>
|
||||
::std::basic_ostream<Char, CharTraits>& operator<<(
|
||||
::std::basic_ostream<Char, CharTraits>& os, const T& x) {
|
||||
TypeWithoutFormatter<T,
|
||||
(internal::IsAProtocolMessage<T>::value ? kProtobuf :
|
||||
internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
|
||||
kConvertibleToInteger : kOtherType)>::PrintValue(x, &os);
|
||||
return os;
|
||||
}
|
||||
|
||||
} // namespace internal2
|
||||
} // namespace testing
|
||||
|
||||
// This namespace MUST NOT BE NESTED IN ::testing, or the name look-up
|
||||
// magic needed for implementing UniversalPrinter won't work.
|
||||
namespace testing_internal {
|
||||
|
||||
// Used to print a value that is not an STL-style container when the
|
||||
// user doesn't define PrintTo() for it.
|
||||
template <typename T>
|
||||
void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
|
||||
// With the following statement, during unqualified name lookup,
|
||||
// testing::internal2::operator<< appears as if it was declared in
|
||||
// the nearest enclosing namespace that contains both
|
||||
// ::testing_internal and ::testing::internal2, i.e. the global
|
||||
// namespace. For more details, refer to the C++ Standard section
|
||||
// 7.3.4-1 [namespace.udir]. This allows us to fall back onto
|
||||
// testing::internal2::operator<< in case T doesn't come with a <<
|
||||
// operator.
|
||||
//
|
||||
// We cannot write 'using ::testing::internal2::operator<<;', which
|
||||
// gcc 3.3 fails to compile due to a compiler bug.
|
||||
using namespace ::testing::internal2; // NOLINT
|
||||
|
||||
// Assuming T is defined in namespace foo, in the next statement,
|
||||
// the compiler will consider all of:
|
||||
//
|
||||
// 1. foo::operator<< (thanks to Koenig look-up),
|
||||
// 2. ::operator<< (as the current namespace is enclosed in ::),
|
||||
// 3. testing::internal2::operator<< (thanks to the using statement above).
|
||||
//
|
||||
// The operator<< whose type matches T best will be picked.
|
||||
//
|
||||
// We deliberately allow #2 to be a candidate, as sometimes it's
|
||||
// impossible to define #1 (e.g. when foo is ::std, defining
|
||||
// anything in it is undefined behavior unless you are a compiler
|
||||
// vendor.).
|
||||
*os << value;
|
||||
}
|
||||
|
||||
} // namespace testing_internal
|
||||
|
||||
namespace testing {
|
||||
namespace internal {
|
||||
|
||||
// UniversalPrinter<T>::Print(value, ostream_ptr) prints the given
|
||||
// value to the given ostream. The caller must ensure that
|
||||
// 'ostream_ptr' is not NULL, or the behavior is undefined.
|
||||
//
|
||||
// We define UniversalPrinter as a class template (as opposed to a
|
||||
// function template), as we need to partially specialize it for
|
||||
// reference types, which cannot be done with function templates.
|
||||
template <typename T>
|
||||
class UniversalPrinter;
|
||||
|
||||
template <typename T>
|
||||
void UniversalPrint(const T& value, ::std::ostream* os);
|
||||
|
||||
// Used to print an STL-style container when the user doesn't define
|
||||
// a PrintTo() for it.
|
||||
template <typename C>
|
||||
void DefaultPrintTo(IsContainer /* dummy */,
|
||||
false_type /* is not a pointer */,
|
||||
const C& container, ::std::ostream* os) {
|
||||
const size_t kMaxCount = 32; // The maximum number of elements to print.
|
||||
*os << '{';
|
||||
size_t count = 0;
|
||||
for (typename C::const_iterator it = container.begin();
|
||||
it != container.end(); ++it, ++count) {
|
||||
if (count > 0) {
|
||||
*os << ',';
|
||||
if (count == kMaxCount) { // Enough has been printed.
|
||||
*os << " ...";
|
||||
break;
|
||||
}
|
||||
}
|
||||
*os << ' ';
|
||||
// We cannot call PrintTo(*it, os) here as PrintTo() doesn't
|
||||
// handle *it being a native array.
|
||||
internal::UniversalPrint(*it, os);
|
||||
}
|
||||
|
||||
if (count > 0) {
|
||||
*os << ' ';
|
||||
}
|
||||
*os << '}';
|
||||
}
|
||||
|
||||
// Used to print a pointer that is neither a char pointer nor a member
|
||||
// pointer, when the user doesn't define PrintTo() for it. (A member
|
||||
// variable pointer or member function pointer doesn't really point to
|
||||
// a location in the address space. Their representation is
|
||||
// implementation-defined. Therefore they will be printed as raw
|
||||
// bytes.)
|
||||
template <typename T>
|
||||
void DefaultPrintTo(IsNotContainer /* dummy */,
|
||||
true_type /* is a pointer */,
|
||||
T* p, ::std::ostream* os) {
|
||||
if (p == NULL) {
|
||||
*os << "NULL";
|
||||
} else {
|
||||
// C++ doesn't allow casting from a function pointer to any object
|
||||
// pointer.
|
||||
//
|
||||
// IsTrue() silences warnings: "Condition is always true",
|
||||
// "unreachable code".
|
||||
if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {
|
||||
// T is not a function type. We just call << to print p,
|
||||
// relying on ADL to pick up user-defined << for their pointer
|
||||
// types, if any.
|
||||
*os << p;
|
||||
} else {
|
||||
// T is a function type, so '*os << p' doesn't do what we want
|
||||
// (it just prints p as bool). We want to print p as a const
|
||||
// void*. However, we cannot cast it to const void* directly,
|
||||
// even using reinterpret_cast, as earlier versions of gcc
|
||||
// (e.g. 3.4.5) cannot compile the cast when p is a function
|
||||
// pointer. Casting to UInt64 first solves the problem.
|
||||
*os << reinterpret_cast<const void*>(
|
||||
reinterpret_cast<internal::UInt64>(p));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Used to print a non-container, non-pointer value when the user
|
||||
// doesn't define PrintTo() for it.
|
||||
template <typename T>
|
||||
void DefaultPrintTo(IsNotContainer /* dummy */,
|
||||
false_type /* is not a pointer */,
|
||||
const T& value, ::std::ostream* os) {
|
||||
::testing_internal::DefaultPrintNonContainerTo(value, os);
|
||||
}
|
||||
|
||||
// Prints the given value using the << operator if it has one;
|
||||
// otherwise prints the bytes in it. This is what
|
||||
// UniversalPrinter<T>::Print() does when PrintTo() is not specialized
|
||||
// or overloaded for type T.
|
||||
//
|
||||
// A user can override this behavior for a class type Foo by defining
|
||||
// an overload of PrintTo() in the namespace where Foo is defined. We
|
||||
// give the user this option as sometimes defining a << operator for
|
||||
// Foo is not desirable (e.g. the coding style may prevent doing it,
|
||||
// or there is already a << operator but it doesn't do what the user
|
||||
// wants).
|
||||
template <typename T>
|
||||
void PrintTo(const T& value, ::std::ostream* os) {
|
||||
// DefaultPrintTo() is overloaded. The type of its first two
|
||||
// arguments determine which version will be picked. If T is an
|
||||
// STL-style container, the version for container will be called; if
|
||||
// T is a pointer, the pointer version will be called; otherwise the
|
||||
// generic version will be called.
|
||||
//
|
||||
// Note that we check for container types here, prior to we check
|
||||
// for protocol message types in our operator<<. The rationale is:
|
||||
//
|
||||
// For protocol messages, we want to give people a chance to
|
||||
// override Google Mock's format by defining a PrintTo() or
|
||||
// operator<<. For STL containers, other formats can be
|
||||
// incompatible with Google Mock's format for the container
|
||||
// elements; therefore we check for container types here to ensure
|
||||
// that our format is used.
|
||||
//
|
||||
// The second argument of DefaultPrintTo() is needed to bypass a bug
|
||||
// in Symbian's C++ compiler that prevents it from picking the right
|
||||
// overload between:
|
||||
//
|
||||
// PrintTo(const T& x, ...);
|
||||
// PrintTo(T* x, ...);
|
||||
DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
|
||||
}
|
||||
|
||||
// The following list of PrintTo() overloads tells
|
||||
// UniversalPrinter<T>::Print() how to print standard types (built-in
|
||||
// types, strings, plain arrays, and pointers).
|
||||
|
||||
// Overloads for various char types.
|
||||
GTEST_API_ void PrintTo(unsigned char c, ::std::ostream* os);
|
||||
GTEST_API_ void PrintTo(signed char c, ::std::ostream* os);
|
||||
inline void PrintTo(char c, ::std::ostream* os) {
|
||||
// When printing a plain char, we always treat it as unsigned. This
|
||||
// way, the output won't be affected by whether the compiler thinks
|
||||
// char is signed or not.
|
||||
PrintTo(static_cast<unsigned char>(c), os);
|
||||
}
|
||||
|
||||
// Overloads for other simple built-in types.
|
||||
inline void PrintTo(bool x, ::std::ostream* os) {
|
||||
*os << (x ? "true" : "false");
|
||||
}
|
||||
|
||||
// Overload for wchar_t type.
|
||||
// Prints a wchar_t as a symbol if it is printable or as its internal
|
||||
// code otherwise and also as its decimal code (except for L'\0').
|
||||
// The L'\0' char is printed as "L'\\0'". The decimal code is printed
|
||||
// as signed integer when wchar_t is implemented by the compiler
|
||||
// as a signed type and is printed as an unsigned integer when wchar_t
|
||||
// is implemented as an unsigned type.
|
||||
GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os);
|
||||
|
||||
// Overloads for C strings.
|
||||
GTEST_API_ void PrintTo(const char* s, ::std::ostream* os);
|
||||
inline void PrintTo(char* s, ::std::ostream* os) {
|
||||
PrintTo(ImplicitCast_<const char*>(s), os);
|
||||
}
|
||||
|
||||
// signed/unsigned char is often used for representing binary data, so
|
||||
// we print pointers to it as void* to be safe.
|
||||
inline void PrintTo(const signed char* s, ::std::ostream* os) {
|
||||
PrintTo(ImplicitCast_<const void*>(s), os);
|
||||
}
|
||||
inline void PrintTo(signed char* s, ::std::ostream* os) {
|
||||
PrintTo(ImplicitCast_<const void*>(s), os);
|
||||
}
|
||||
inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
|
||||
PrintTo(ImplicitCast_<const void*>(s), os);
|
||||
}
|
||||
inline void PrintTo(unsigned char* s, ::std::ostream* os) {
|
||||
PrintTo(ImplicitCast_<const void*>(s), os);
|
||||
}
|
||||
|
||||
// MSVC can be configured to define wchar_t as a typedef of unsigned
|
||||
// short. It defines _NATIVE_WCHAR_T_DEFINED when wchar_t is a native
|
||||
// type. When wchar_t is a typedef, defining an overload for const
|
||||
// wchar_t* would cause unsigned short* be printed as a wide string,
|
||||
// possibly causing invalid memory accesses.
|
||||
#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
|
||||
// Overloads for wide C strings
|
||||
GTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os);
|
||||
inline void PrintTo(wchar_t* s, ::std::ostream* os) {
|
||||
PrintTo(ImplicitCast_<const wchar_t*>(s), os);
|
||||
}
|
||||
#endif
|
||||
|
||||
// Overload for C arrays. Multi-dimensional arrays are printed
|
||||
// properly.
|
||||
|
||||
// Prints the given number of elements in an array, without printing
|
||||
// the curly braces.
|
||||
template <typename T>
|
||||
void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) {
|
||||
UniversalPrint(a[0], os);
|
||||
for (size_t i = 1; i != count; i++) {
|
||||
*os << ", ";
|
||||
UniversalPrint(a[i], os);
|
||||
}
|
||||
}
|
||||
|
||||
// Overloads for ::string and ::std::string.
|
||||
#if GTEST_HAS_GLOBAL_STRING
|
||||
GTEST_API_ void PrintStringTo(const ::string&s, ::std::ostream* os);
|
||||
inline void PrintTo(const ::string& s, ::std::ostream* os) {
|
||||
PrintStringTo(s, os);
|
||||
}
|
||||
#endif // GTEST_HAS_GLOBAL_STRING
|
||||
|
||||
GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os);
|
||||
inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
|
||||
PrintStringTo(s, os);
|
||||
}
|
||||
|
||||
// Overloads for ::wstring and ::std::wstring.
|
||||
#if GTEST_HAS_GLOBAL_WSTRING
|
||||
GTEST_API_ void PrintWideStringTo(const ::wstring&s, ::std::ostream* os);
|
||||
inline void PrintTo(const ::wstring& s, ::std::ostream* os) {
|
||||
PrintWideStringTo(s, os);
|
||||
}
|
||||
#endif // GTEST_HAS_GLOBAL_WSTRING
|
||||
|
||||
#if GTEST_HAS_STD_WSTRING
|
||||
GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os);
|
||||
inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
|
||||
PrintWideStringTo(s, os);
|
||||
}
|
||||
#endif // GTEST_HAS_STD_WSTRING
|
||||
|
||||
#if GTEST_HAS_TR1_TUPLE
|
||||
// Overload for ::std::tr1::tuple. Needed for printing function arguments,
|
||||
// which are packed as tuples.
|
||||
|
||||
// Helper function for printing a tuple. T must be instantiated with
|
||||
// a tuple type.
|
||||
template <typename T>
|
||||
void PrintTupleTo(const T& t, ::std::ostream* os);
|
||||
|
||||
// Overloaded PrintTo() for tuples of various arities. We support
|
||||
// tuples of up-to 10 fields. The following implementation works
|
||||
// regardless of whether tr1::tuple is implemented using the
|
||||
// non-standard variadic template feature or not.
|
||||
|
||||
inline void PrintTo(const ::std::tr1::tuple<>& t, ::std::ostream* os) {
|
||||
PrintTupleTo(t, os);
|
||||
}
|
||||
|
||||
template <typename T1>
|
||||
void PrintTo(const ::std::tr1::tuple<T1>& t, ::std::ostream* os) {
|
||||
PrintTupleTo(t, os);
|
||||
}
|
||||
|
||||
template <typename T1, typename T2>
|
||||
void PrintTo(const ::std::tr1::tuple<T1, T2>& t, ::std::ostream* os) {
|
||||
PrintTupleTo(t, os);
|
||||
}
|
||||
|
||||
template <typename T1, typename T2, typename T3>
|
||||
void PrintTo(const ::std::tr1::tuple<T1, T2, T3>& t, ::std::ostream* os) {
|
||||
PrintTupleTo(t, os);
|
||||
}
|
||||
|
||||
template <typename T1, typename T2, typename T3, typename T4>
|
||||
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4>& t, ::std::ostream* os) {
|
||||
PrintTupleTo(t, os);
|
||||
}
|
||||
|
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5>
|
||||
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5>& t,
|
||||
::std::ostream* os) {
|
||||
PrintTupleTo(t, os);
|
||||
}
|
||||
|
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5,
|
||||
typename T6>
|
||||
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6>& t,
|
||||
::std::ostream* os) {
|
||||
PrintTupleTo(t, os);
|
||||
}
|
||||
|
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5,
|
||||
typename T6, typename T7>
|
||||
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7>& t,
|
||||
::std::ostream* os) {
|
||||
PrintTupleTo(t, os);
|
||||
}
|
||||
|
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5,
|
||||
typename T6, typename T7, typename T8>
|
||||
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8>& t,
|
||||
::std::ostream* os) {
|
||||
PrintTupleTo(t, os);
|
||||
}
|
||||
|
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5,
|
||||
typename T6, typename T7, typename T8, typename T9>
|
||||
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>& t,
|
||||
::std::ostream* os) {
|
||||
PrintTupleTo(t, os);
|
||||
}
|
||||
|
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5,
|
||||
typename T6, typename T7, typename T8, typename T9, typename T10>
|
||||
void PrintTo(
|
||||
const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& t,
|
||||
::std::ostream* os) {
|
||||
PrintTupleTo(t, os);
|
||||
}
|
||||
#endif // GTEST_HAS_TR1_TUPLE
|
||||
|
||||
// Overload for std::pair.
|
||||
template <typename T1, typename T2>
|
||||
void PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) {
|
||||
*os << '(';
|
||||
// We cannot use UniversalPrint(value.first, os) here, as T1 may be
|
||||
// a reference type. The same for printing value.second.
|
||||
UniversalPrinter<T1>::Print(value.first, os);
|
||||
*os << ", ";
|
||||
UniversalPrinter<T2>::Print(value.second, os);
|
||||
*os << ')';
|
||||
}
|
||||
|
||||
// Implements printing a non-reference type T by letting the compiler
|
||||
// pick the right overload of PrintTo() for T.
|
||||
template <typename T>
|
||||
class UniversalPrinter {
|
||||
public:
|
||||
// MSVC warns about adding const to a function type, so we want to
|
||||
// disable the warning.
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning(push) // Saves the current warning state.
|
||||
# pragma warning(disable:4180) // Temporarily disables warning 4180.
|
||||
#endif // _MSC_VER
|
||||
|
||||
// Note: we deliberately don't call this PrintTo(), as that name
|
||||
// conflicts with ::testing::internal::PrintTo in the body of the
|
||||
// function.
|
||||
static void Print(const T& value, ::std::ostream* os) {
|
||||
// By default, ::testing::internal::PrintTo() is used for printing
|
||||
// the value.
|
||||
//
|
||||
// Thanks to Koenig look-up, if T is a class and has its own
|
||||
// PrintTo() function defined in its namespace, that function will
|
||||
// be visible here. Since it is more specific than the generic ones
|
||||
// in ::testing::internal, it will be picked by the compiler in the
|
||||
// following statement - exactly what we want.
|
||||
PrintTo(value, os);
|
||||
}
|
||||
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning(pop) // Restores the warning state.
|
||||
#endif // _MSC_VER
|
||||
};
|
||||
|
||||
// UniversalPrintArray(begin, len, os) prints an array of 'len'
|
||||
// elements, starting at address 'begin'.
|
||||
template <typename T>
|
||||
void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) {
|
||||
if (len == 0) {
|
||||
*os << "{}";
|
||||
} else {
|
||||
*os << "{ ";
|
||||
const size_t kThreshold = 18;
|
||||
const size_t kChunkSize = 8;
|
||||
// If the array has more than kThreshold elements, we'll have to
|
||||
// omit some details by printing only the first and the last
|
||||
// kChunkSize elements.
|
||||
// TODO(wan@google.com): let the user control the threshold using a flag.
|
||||
if (len <= kThreshold) {
|
||||
PrintRawArrayTo(begin, len, os);
|
||||
} else {
|
||||
PrintRawArrayTo(begin, kChunkSize, os);
|
||||
*os << ", ..., ";
|
||||
PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os);
|
||||
}
|
||||
*os << " }";
|
||||
}
|
||||
}
|
||||
// This overload prints a (const) char array compactly.
|
||||
GTEST_API_ void UniversalPrintArray(const char* begin,
|
||||
size_t len,
|
||||
::std::ostream* os);
|
||||
|
||||
// Implements printing an array type T[N].
|
||||
template <typename T, size_t N>
|
||||
class UniversalPrinter<T[N]> {
|
||||
public:
|
||||
// Prints the given array, omitting some elements when there are too
|
||||
// many.
|
||||
static void Print(const T (&a)[N], ::std::ostream* os) {
|
||||
UniversalPrintArray(a, N, os);
|
||||
}
|
||||
};
|
||||
|
||||
// Implements printing a reference type T&.
|
||||
template <typename T>
|
||||
class UniversalPrinter<T&> {
|
||||
public:
|
||||
// MSVC warns about adding const to a function type, so we want to
|
||||
// disable the warning.
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning(push) // Saves the current warning state.
|
||||
# pragma warning(disable:4180) // Temporarily disables warning 4180.
|
||||
#endif // _MSC_VER
|
||||
|
||||
static void Print(const T& value, ::std::ostream* os) {
|
||||
// Prints the address of the value. We use reinterpret_cast here
|
||||
// as static_cast doesn't compile when T is a function type.
|
||||
*os << "@" << reinterpret_cast<const void*>(&value) << " ";
|
||||
|
||||
// Then prints the value itself.
|
||||
UniversalPrint(value, os);
|
||||
}
|
||||
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning(pop) // Restores the warning state.
|
||||
#endif // _MSC_VER
|
||||
};
|
||||
|
||||
// Prints a value tersely: for a reference type, the referenced value
|
||||
// (but not the address) is printed; for a (const) char pointer, the
|
||||
// NUL-terminated string (but not the pointer) is printed.
|
||||
template <typename T>
|
||||
void UniversalTersePrint(const T& value, ::std::ostream* os) {
|
||||
UniversalPrint(value, os);
|
||||
}
|
||||
inline void UniversalTersePrint(const char* str, ::std::ostream* os) {
|
||||
if (str == NULL) {
|
||||
*os << "NULL";
|
||||
} else {
|
||||
UniversalPrint(string(str), os);
|
||||
}
|
||||
}
|
||||
inline void UniversalTersePrint(char* str, ::std::ostream* os) {
|
||||
UniversalTersePrint(static_cast<const char*>(str), os);
|
||||
}
|
||||
|
||||
// Prints a value using the type inferred by the compiler. The
|
||||
// difference between this and UniversalTersePrint() is that for a
|
||||
// (const) char pointer, this prints both the pointer and the
|
||||
// NUL-terminated string.
|
||||
template <typename T>
|
||||
void UniversalPrint(const T& value, ::std::ostream* os) {
|
||||
UniversalPrinter<T>::Print(value, os);
|
||||
}
|
||||
|
||||
#if GTEST_HAS_TR1_TUPLE
|
||||
typedef ::std::vector<string> Strings;
|
||||
|
||||
// This helper template allows PrintTo() for tuples and
|
||||
// UniversalTersePrintTupleFieldsToStrings() to be defined by
|
||||
// induction on the number of tuple fields. The idea is that
|
||||
// TuplePrefixPrinter<N>::PrintPrefixTo(t, os) prints the first N
|
||||
// fields in tuple t, and can be defined in terms of
|
||||
// TuplePrefixPrinter<N - 1>.
|
||||
|
||||
// The inductive case.
|
||||
template <size_t N>
|
||||
struct TuplePrefixPrinter {
|
||||
// Prints the first N fields of a tuple.
|
||||
template <typename Tuple>
|
||||
static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
|
||||
TuplePrefixPrinter<N - 1>::PrintPrefixTo(t, os);
|
||||
*os << ", ";
|
||||
UniversalPrinter<typename ::std::tr1::tuple_element<N - 1, Tuple>::type>
|
||||
::Print(::std::tr1::get<N - 1>(t), os);
|
||||
}
|
||||
|
||||
// Tersely prints the first N fields of a tuple to a string vector,
|
||||
// one element for each field.
|
||||
template <typename Tuple>
|
||||
static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) {
|
||||
TuplePrefixPrinter<N - 1>::TersePrintPrefixToStrings(t, strings);
|
||||
::std::stringstream ss;
|
||||
UniversalTersePrint(::std::tr1::get<N - 1>(t), &ss);
|
||||
strings->push_back(ss.str());
|
||||
}
|
||||
};
|
||||
|
||||
// Base cases.
|
||||
template <>
|
||||
struct TuplePrefixPrinter<0> {
|
||||
template <typename Tuple>
|
||||
static void PrintPrefixTo(const Tuple&, ::std::ostream*) {}
|
||||
|
||||
template <typename Tuple>
|
||||
static void TersePrintPrefixToStrings(const Tuple&, Strings*) {}
|
||||
};
|
||||
// We have to specialize the entire TuplePrefixPrinter<> class
|
||||
// template here, even though the definition of
|
||||
// TersePrintPrefixToStrings() is the same as the generic version, as
|
||||
// Embarcadero (formerly CodeGear, formerly Borland) C++ doesn't
|
||||
// support specializing a method template of a class template.
|
||||
template <>
|
||||
struct TuplePrefixPrinter<1> {
|
||||
template <typename Tuple>
|
||||
static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
|
||||
UniversalPrinter<typename ::std::tr1::tuple_element<0, Tuple>::type>::
|
||||
Print(::std::tr1::get<0>(t), os);
|
||||
}
|
||||
|
||||
template <typename Tuple>
|
||||
static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) {
|
||||
::std::stringstream ss;
|
||||
UniversalTersePrint(::std::tr1::get<0>(t), &ss);
|
||||
strings->push_back(ss.str());
|
||||
}
|
||||
};
|
||||
|
||||
// Helper function for printing a tuple. T must be instantiated with
|
||||
// a tuple type.
|
||||
template <typename T>
|
||||
void PrintTupleTo(const T& t, ::std::ostream* os) {
|
||||
*os << "(";
|
||||
TuplePrefixPrinter< ::std::tr1::tuple_size<T>::value>::
|
||||
PrintPrefixTo(t, os);
|
||||
*os << ")";
|
||||
}
|
||||
|
||||
// Prints the fields of a tuple tersely to a string vector, one
|
||||
// element for each field. See the comment before
|
||||
// UniversalTersePrint() for how we define "tersely".
|
||||
template <typename Tuple>
|
||||
Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) {
|
||||
Strings result;
|
||||
TuplePrefixPrinter< ::std::tr1::tuple_size<Tuple>::value>::
|
||||
TersePrintPrefixToStrings(value, &result);
|
||||
return result;
|
||||
}
|
||||
#endif // GTEST_HAS_TR1_TUPLE
|
||||
|
||||
} // namespace internal
|
||||
|
||||
template <typename T>
|
||||
::std::string PrintToString(const T& value) {
|
||||
::std::stringstream ss;
|
||||
internal::UniversalTersePrint(value, &ss);
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
|
232
gtest/include/gtest/gtest-spi.h
Normal file
232
gtest/include/gtest/gtest-spi.h
Normal file
@ -0,0 +1,232 @@
|
||||
// Copyright 2007, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
//
|
||||
// Utilities for testing Google Test itself and code that uses Google Test
|
||||
// (e.g. frameworks built on top of Google Test).
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_GTEST_SPI_H_
|
||||
#define GTEST_INCLUDE_GTEST_GTEST_SPI_H_
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
namespace testing {
|
||||
|
||||
// This helper class can be used to mock out Google Test failure reporting
|
||||
// so that we can test Google Test or code that builds on Google Test.
|
||||
//
|
||||
// An object of this class appends a TestPartResult object to the
|
||||
// TestPartResultArray object given in the constructor whenever a Google Test
|
||||
// failure is reported. It can either intercept only failures that are
|
||||
// generated in the same thread that created this object or it can intercept
|
||||
// all generated failures. The scope of this mock object can be controlled with
|
||||
// the second argument to the two arguments constructor.
|
||||
class GTEST_API_ ScopedFakeTestPartResultReporter
|
||||
: public TestPartResultReporterInterface {
|
||||
public:
|
||||
// The two possible mocking modes of this object.
|
||||
enum InterceptMode {
|
||||
INTERCEPT_ONLY_CURRENT_THREAD, // Intercepts only thread local failures.
|
||||
INTERCEPT_ALL_THREADS // Intercepts all failures.
|
||||
};
|
||||
|
||||
// The c'tor sets this object as the test part result reporter used
|
||||
// by Google Test. The 'result' parameter specifies where to report the
|
||||
// results. This reporter will only catch failures generated in the current
|
||||
// thread. DEPRECATED
|
||||
explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result);
|
||||
|
||||
// Same as above, but you can choose the interception scope of this object.
|
||||
ScopedFakeTestPartResultReporter(InterceptMode intercept_mode,
|
||||
TestPartResultArray* result);
|
||||
|
||||
// The d'tor restores the previous test part result reporter.
|
||||
virtual ~ScopedFakeTestPartResultReporter();
|
||||
|
||||
// Appends the TestPartResult object to the TestPartResultArray
|
||||
// received in the constructor.
|
||||
//
|
||||
// This method is from the TestPartResultReporterInterface
|
||||
// interface.
|
||||
virtual void ReportTestPartResult(const TestPartResult& result);
|
||||
private:
|
||||
void Init();
|
||||
|
||||
const InterceptMode intercept_mode_;
|
||||
TestPartResultReporterInterface* old_reporter_;
|
||||
TestPartResultArray* const result_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);
|
||||
};
|
||||
|
||||
namespace internal {
|
||||
|
||||
// A helper class for implementing EXPECT_FATAL_FAILURE() and
|
||||
// EXPECT_NONFATAL_FAILURE(). Its destructor verifies that the given
|
||||
// TestPartResultArray contains exactly one failure that has the given
|
||||
// type and contains the given substring. If that's not the case, a
|
||||
// non-fatal failure will be generated.
|
||||
class GTEST_API_ SingleFailureChecker {
|
||||
public:
|
||||
// The constructor remembers the arguments.
|
||||
SingleFailureChecker(const TestPartResultArray* results,
|
||||
TestPartResult::Type type,
|
||||
const string& substr);
|
||||
~SingleFailureChecker();
|
||||
private:
|
||||
const TestPartResultArray* const results_;
|
||||
const TestPartResult::Type type_;
|
||||
const string substr_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);
|
||||
};
|
||||
|
||||
} // namespace internal
|
||||
|
||||
} // namespace testing
|
||||
|
||||
// A set of macros for testing Google Test assertions or code that's expected
|
||||
// to generate Google Test fatal failures. It verifies that the given
|
||||
// statement will cause exactly one fatal Google Test failure with 'substr'
|
||||
// being part of the failure message.
|
||||
//
|
||||
// There are two different versions of this macro. EXPECT_FATAL_FAILURE only
|
||||
// affects and considers failures generated in the current thread and
|
||||
// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
|
||||
//
|
||||
// The verification of the assertion is done correctly even when the statement
|
||||
// throws an exception or aborts the current function.
|
||||
//
|
||||
// Known restrictions:
|
||||
// - 'statement' cannot reference local non-static variables or
|
||||
// non-static members of the current object.
|
||||
// - 'statement' cannot return a value.
|
||||
// - You cannot stream a failure message to this macro.
|
||||
//
|
||||
// Note that even though the implementations of the following two
|
||||
// macros are much alike, we cannot refactor them to use a common
|
||||
// helper macro, due to some peculiarity in how the preprocessor
|
||||
// works. The AcceptsMacroThatExpandsToUnprotectedComma test in
|
||||
// gtest_unittest.cc will fail to compile if we do that.
|
||||
#define EXPECT_FATAL_FAILURE(statement, substr) \
|
||||
do { \
|
||||
class GTestExpectFatalFailureHelper {\
|
||||
public:\
|
||||
static void Execute() { statement; }\
|
||||
};\
|
||||
::testing::TestPartResultArray gtest_failures;\
|
||||
::testing::internal::SingleFailureChecker gtest_checker(\
|
||||
>est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
|
||||
{\
|
||||
::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
|
||||
::testing::ScopedFakeTestPartResultReporter:: \
|
||||
INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\
|
||||
GTestExpectFatalFailureHelper::Execute();\
|
||||
}\
|
||||
} while (::testing::internal::AlwaysFalse())
|
||||
|
||||
#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
|
||||
do { \
|
||||
class GTestExpectFatalFailureHelper {\
|
||||
public:\
|
||||
static void Execute() { statement; }\
|
||||
};\
|
||||
::testing::TestPartResultArray gtest_failures;\
|
||||
::testing::internal::SingleFailureChecker gtest_checker(\
|
||||
>est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
|
||||
{\
|
||||
::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
|
||||
::testing::ScopedFakeTestPartResultReporter:: \
|
||||
INTERCEPT_ALL_THREADS, >est_failures);\
|
||||
GTestExpectFatalFailureHelper::Execute();\
|
||||
}\
|
||||
} while (::testing::internal::AlwaysFalse())
|
||||
|
||||
// A macro for testing Google Test assertions or code that's expected to
|
||||
// generate Google Test non-fatal failures. It asserts that the given
|
||||
// statement will cause exactly one non-fatal Google Test failure with 'substr'
|
||||
// being part of the failure message.
|
||||
//
|
||||
// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
|
||||
// affects and considers failures generated in the current thread and
|
||||
// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
|
||||
//
|
||||
// 'statement' is allowed to reference local variables and members of
|
||||
// the current object.
|
||||
//
|
||||
// The verification of the assertion is done correctly even when the statement
|
||||
// throws an exception or aborts the current function.
|
||||
//
|
||||
// Known restrictions:
|
||||
// - You cannot stream a failure message to this macro.
|
||||
//
|
||||
// Note that even though the implementations of the following two
|
||||
// macros are much alike, we cannot refactor them to use a common
|
||||
// helper macro, due to some peculiarity in how the preprocessor
|
||||
// works. If we do that, the code won't compile when the user gives
|
||||
// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that
|
||||
// expands to code containing an unprotected comma. The
|
||||
// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc
|
||||
// catches that.
|
||||
//
|
||||
// For the same reason, we have to write
|
||||
// if (::testing::internal::AlwaysTrue()) { statement; }
|
||||
// instead of
|
||||
// GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
|
||||
// to avoid an MSVC warning on unreachable code.
|
||||
#define EXPECT_NONFATAL_FAILURE(statement, substr) \
|
||||
do {\
|
||||
::testing::TestPartResultArray gtest_failures;\
|
||||
::testing::internal::SingleFailureChecker gtest_checker(\
|
||||
>est_failures, ::testing::TestPartResult::kNonFatalFailure, \
|
||||
(substr));\
|
||||
{\
|
||||
::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
|
||||
::testing::ScopedFakeTestPartResultReporter:: \
|
||||
INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\
|
||||
if (::testing::internal::AlwaysTrue()) { statement; }\
|
||||
}\
|
||||
} while (::testing::internal::AlwaysFalse())
|
||||
|
||||
#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
|
||||
do {\
|
||||
::testing::TestPartResultArray gtest_failures;\
|
||||
::testing::internal::SingleFailureChecker gtest_checker(\
|
||||
>est_failures, ::testing::TestPartResult::kNonFatalFailure, \
|
||||
(substr));\
|
||||
{\
|
||||
::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
|
||||
::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS,\
|
||||
>est_failures);\
|
||||
if (::testing::internal::AlwaysTrue()) { statement; }\
|
||||
}\
|
||||
} while (::testing::internal::AlwaysFalse())
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_GTEST_SPI_H_
|
176
gtest/include/gtest/gtest-test-part.h
Normal file
176
gtest/include/gtest/gtest-test-part.h
Normal file
@ -0,0 +1,176 @@
|
||||
// Copyright 2008, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: mheule@google.com (Markus Heule)
|
||||
//
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
|
||||
#define GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
|
||||
|
||||
#include <iosfwd>
|
||||
#include <vector>
|
||||
#include "gtest/internal/gtest-internal.h"
|
||||
#include "gtest/internal/gtest-string.h"
|
||||
|
||||
namespace testing {
|
||||
|
||||
// A copyable object representing the result of a test part (i.e. an
|
||||
// assertion or an explicit FAIL(), ADD_FAILURE(), or SUCCESS()).
|
||||
//
|
||||
// Don't inherit from TestPartResult as its destructor is not virtual.
|
||||
class GTEST_API_ TestPartResult {
|
||||
public:
|
||||
// The possible outcomes of a test part (i.e. an assertion or an
|
||||
// explicit SUCCEED(), FAIL(), or ADD_FAILURE()).
|
||||
enum Type {
|
||||
kSuccess, // Succeeded.
|
||||
kNonFatalFailure, // Failed but the test can continue.
|
||||
kFatalFailure // Failed and the test should be terminated.
|
||||
};
|
||||
|
||||
// C'tor. TestPartResult does NOT have a default constructor.
|
||||
// Always use this constructor (with parameters) to create a
|
||||
// TestPartResult object.
|
||||
TestPartResult(Type a_type,
|
||||
const char* a_file_name,
|
||||
int a_line_number,
|
||||
const char* a_message)
|
||||
: type_(a_type),
|
||||
file_name_(a_file_name),
|
||||
line_number_(a_line_number),
|
||||
summary_(ExtractSummary(a_message)),
|
||||
message_(a_message) {
|
||||
}
|
||||
|
||||
// Gets the outcome of the test part.
|
||||
Type type() const { return type_; }
|
||||
|
||||
// Gets the name of the source file where the test part took place, or
|
||||
// NULL if it's unknown.
|
||||
const char* file_name() const { return file_name_.c_str(); }
|
||||
|
||||
// Gets the line in the source file where the test part took place,
|
||||
// or -1 if it's unknown.
|
||||
int line_number() const { return line_number_; }
|
||||
|
||||
// Gets the summary of the failure message.
|
||||
const char* summary() const { return summary_.c_str(); }
|
||||
|
||||
// Gets the message associated with the test part.
|
||||
const char* message() const { return message_.c_str(); }
|
||||
|
||||
// Returns true iff the test part passed.
|
||||
bool passed() const { return type_ == kSuccess; }
|
||||
|
||||
// Returns true iff the test part failed.
|
||||
bool failed() const { return type_ != kSuccess; }
|
||||
|
||||
// Returns true iff the test part non-fatally failed.
|
||||
bool nonfatally_failed() const { return type_ == kNonFatalFailure; }
|
||||
|
||||
// Returns true iff the test part fatally failed.
|
||||
bool fatally_failed() const { return type_ == kFatalFailure; }
|
||||
private:
|
||||
Type type_;
|
||||
|
||||
// Gets the summary of the failure message by omitting the stack
|
||||
// trace in it.
|
||||
static internal::String ExtractSummary(const char* message);
|
||||
|
||||
// The name of the source file where the test part took place, or
|
||||
// NULL if the source file is unknown.
|
||||
internal::String file_name_;
|
||||
// The line in the source file where the test part took place, or -1
|
||||
// if the line number is unknown.
|
||||
int line_number_;
|
||||
internal::String summary_; // The test failure summary.
|
||||
internal::String message_; // The test failure message.
|
||||
};
|
||||
|
||||
// Prints a TestPartResult object.
|
||||
std::ostream& operator<<(std::ostream& os, const TestPartResult& result);
|
||||
|
||||
// An array of TestPartResult objects.
|
||||
//
|
||||
// Don't inherit from TestPartResultArray as its destructor is not
|
||||
// virtual.
|
||||
class GTEST_API_ TestPartResultArray {
|
||||
public:
|
||||
TestPartResultArray() {}
|
||||
|
||||
// Appends the given TestPartResult to the array.
|
||||
void Append(const TestPartResult& result);
|
||||
|
||||
// Returns the TestPartResult at the given index (0-based).
|
||||
const TestPartResult& GetTestPartResult(int index) const;
|
||||
|
||||
// Returns the number of TestPartResult objects in the array.
|
||||
int size() const;
|
||||
|
||||
private:
|
||||
std::vector<TestPartResult> array_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestPartResultArray);
|
||||
};
|
||||
|
||||
// This interface knows how to report a test part result.
|
||||
class TestPartResultReporterInterface {
|
||||
public:
|
||||
virtual ~TestPartResultReporterInterface() {}
|
||||
|
||||
virtual void ReportTestPartResult(const TestPartResult& result) = 0;
|
||||
};
|
||||
|
||||
namespace internal {
|
||||
|
||||
// This helper class is used by {ASSERT|EXPECT}_NO_FATAL_FAILURE to check if a
|
||||
// statement generates new fatal failures. To do so it registers itself as the
|
||||
// current test part result reporter. Besides checking if fatal failures were
|
||||
// reported, it only delegates the reporting to the former result reporter.
|
||||
// The original result reporter is restored in the destructor.
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
|
||||
class GTEST_API_ HasNewFatalFailureHelper
|
||||
: public TestPartResultReporterInterface {
|
||||
public:
|
||||
HasNewFatalFailureHelper();
|
||||
virtual ~HasNewFatalFailureHelper();
|
||||
virtual void ReportTestPartResult(const TestPartResult& result);
|
||||
bool has_new_fatal_failure() const { return has_new_fatal_failure_; }
|
||||
private:
|
||||
bool has_new_fatal_failure_;
|
||||
TestPartResultReporterInterface* original_reporter_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(HasNewFatalFailureHelper);
|
||||
};
|
||||
|
||||
} // namespace internal
|
||||
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
|
259
gtest/include/gtest/gtest-typed-test.h
Normal file
259
gtest/include/gtest/gtest-typed-test.h
Normal file
@ -0,0 +1,259 @@
|
||||
// Copyright 2008 Google Inc.
|
||||
// All Rights Reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
|
||||
#define GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
|
||||
|
||||
// This header implements typed tests and type-parameterized tests.
|
||||
|
||||
// Typed (aka type-driven) tests repeat the same test for types in a
|
||||
// list. You must know which types you want to test with when writing
|
||||
// typed tests. Here's how you do it:
|
||||
|
||||
#if 0
|
||||
|
||||
// First, define a fixture class template. It should be parameterized
|
||||
// by a type. Remember to derive it from testing::Test.
|
||||
template <typename T>
|
||||
class FooTest : public testing::Test {
|
||||
public:
|
||||
...
|
||||
typedef std::list<T> List;
|
||||
static T shared_;
|
||||
T value_;
|
||||
};
|
||||
|
||||
// Next, associate a list of types with the test case, which will be
|
||||
// repeated for each type in the list. The typedef is necessary for
|
||||
// the macro to parse correctly.
|
||||
typedef testing::Types<char, int, unsigned int> MyTypes;
|
||||
TYPED_TEST_CASE(FooTest, MyTypes);
|
||||
|
||||
// If the type list contains only one type, you can write that type
|
||||
// directly without Types<...>:
|
||||
// TYPED_TEST_CASE(FooTest, int);
|
||||
|
||||
// Then, use TYPED_TEST() instead of TEST_F() to define as many typed
|
||||
// tests for this test case as you want.
|
||||
TYPED_TEST(FooTest, DoesBlah) {
|
||||
// Inside a test, refer to TypeParam to get the type parameter.
|
||||
// Since we are inside a derived class template, C++ requires use to
|
||||
// visit the members of FooTest via 'this'.
|
||||
TypeParam n = this->value_;
|
||||
|
||||
// To visit static members of the fixture, add the TestFixture::
|
||||
// prefix.
|
||||
n += TestFixture::shared_;
|
||||
|
||||
// To refer to typedefs in the fixture, add the "typename
|
||||
// TestFixture::" prefix.
|
||||
typename TestFixture::List values;
|
||||
values.push_back(n);
|
||||
...
|
||||
}
|
||||
|
||||
TYPED_TEST(FooTest, HasPropertyA) { ... }
|
||||
|
||||
#endif // 0
|
||||
|
||||
// Type-parameterized tests are abstract test patterns parameterized
|
||||
// by a type. Compared with typed tests, type-parameterized tests
|
||||
// allow you to define the test pattern without knowing what the type
|
||||
// parameters are. The defined pattern can be instantiated with
|
||||
// different types any number of times, in any number of translation
|
||||
// units.
|
||||
//
|
||||
// If you are designing an interface or concept, you can define a
|
||||
// suite of type-parameterized tests to verify properties that any
|
||||
// valid implementation of the interface/concept should have. Then,
|
||||
// each implementation can easily instantiate the test suite to verify
|
||||
// that it conforms to the requirements, without having to write
|
||||
// similar tests repeatedly. Here's an example:
|
||||
|
||||
#if 0
|
||||
|
||||
// First, define a fixture class template. It should be parameterized
|
||||
// by a type. Remember to derive it from testing::Test.
|
||||
template <typename T>
|
||||
class FooTest : public testing::Test {
|
||||
...
|
||||
};
|
||||
|
||||
// Next, declare that you will define a type-parameterized test case
|
||||
// (the _P suffix is for "parameterized" or "pattern", whichever you
|
||||
// prefer):
|
||||
TYPED_TEST_CASE_P(FooTest);
|
||||
|
||||
// Then, use TYPED_TEST_P() to define as many type-parameterized tests
|
||||
// for this type-parameterized test case as you want.
|
||||
TYPED_TEST_P(FooTest, DoesBlah) {
|
||||
// Inside a test, refer to TypeParam to get the type parameter.
|
||||
TypeParam n = 0;
|
||||
...
|
||||
}
|
||||
|
||||
TYPED_TEST_P(FooTest, HasPropertyA) { ... }
|
||||
|
||||
// Now the tricky part: you need to register all test patterns before
|
||||
// you can instantiate them. The first argument of the macro is the
|
||||
// test case name; the rest are the names of the tests in this test
|
||||
// case.
|
||||
REGISTER_TYPED_TEST_CASE_P(FooTest,
|
||||
DoesBlah, HasPropertyA);
|
||||
|
||||
// Finally, you are free to instantiate the pattern with the types you
|
||||
// want. If you put the above code in a header file, you can #include
|
||||
// it in multiple C++ source files and instantiate it multiple times.
|
||||
//
|
||||
// To distinguish different instances of the pattern, the first
|
||||
// argument to the INSTANTIATE_* macro is a prefix that will be added
|
||||
// to the actual test case name. Remember to pick unique prefixes for
|
||||
// different instances.
|
||||
typedef testing::Types<char, int, unsigned int> MyTypes;
|
||||
INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
|
||||
|
||||
// If the type list contains only one type, you can write that type
|
||||
// directly without Types<...>:
|
||||
// INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int);
|
||||
|
||||
#endif // 0
|
||||
|
||||
#include "gtest/internal/gtest-port.h"
|
||||
#include "gtest/internal/gtest-type-util.h"
|
||||
|
||||
// Implements typed tests.
|
||||
|
||||
#if GTEST_HAS_TYPED_TEST
|
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// Expands to the name of the typedef for the type parameters of the
|
||||
// given test case.
|
||||
# define GTEST_TYPE_PARAMS_(TestCaseName) gtest_type_params_##TestCaseName##_
|
||||
|
||||
// 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(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(\
|
||||
"", #CaseName, #TestName, 0); \
|
||||
template <typename gtest_TypeParam_> \
|
||||
void GTEST_TEST_CLASS_NAME_(CaseName, TestName)<gtest_TypeParam_>::TestBody()
|
||||
|
||||
#endif // GTEST_HAS_TYPED_TEST
|
||||
|
||||
// Implements type-parameterized tests.
|
||||
|
||||
#if GTEST_HAS_TYPED_TEST_P
|
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// Expands to the namespace name that the type-parameterized tests for
|
||||
// the given type-parameterized test case are defined in. The exact
|
||||
// name of the namespace is subject to change without notice.
|
||||
# define GTEST_CASE_NAMESPACE_(TestCaseName) \
|
||||
gtest_case_##TestCaseName##_
|
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// Expands to the name of the variable used to remember the names of
|
||||
// the defined tests in the given test case.
|
||||
# define GTEST_TYPED_TEST_CASE_P_STATE_(TestCaseName) \
|
||||
gtest_typed_test_case_p_state_##TestCaseName##_
|
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE DIRECTLY.
|
||||
//
|
||||
// Expands to the name of the variable used to remember the names of
|
||||
// the registered tests in the given test case.
|
||||
# define GTEST_REGISTERED_TEST_NAMES_(TestCaseName) \
|
||||
gtest_registered_test_names_##TestCaseName##_
|
||||
|
||||
// The variables defined in the type-parameterized test macros are
|
||||
// static as typically these macros are used in a .h file that can be
|
||||
// #included in multiple translation units linked together.
|
||||
# define TYPED_TEST_CASE_P(CaseName) \
|
||||
static ::testing::internal::TypedTestCasePState \
|
||||
GTEST_TYPED_TEST_CASE_P_STATE_(CaseName)
|
||||
|
||||
# define TYPED_TEST_P(CaseName, TestName) \
|
||||
namespace GTEST_CASE_NAMESPACE_(CaseName) { \
|
||||
template <typename gtest_TypeParam_> \
|
||||
class TestName : public CaseName<gtest_TypeParam_> { \
|
||||
private: \
|
||||
typedef CaseName<gtest_TypeParam_> TestFixture; \
|
||||
typedef gtest_TypeParam_ TypeParam; \
|
||||
virtual void TestBody(); \
|
||||
}; \
|
||||
static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \
|
||||
GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).AddTestName(\
|
||||
__FILE__, __LINE__, #CaseName, #TestName); \
|
||||
} \
|
||||
template <typename gtest_TypeParam_> \
|
||||
void GTEST_CASE_NAMESPACE_(CaseName)::TestName<gtest_TypeParam_>::TestBody()
|
||||
|
||||
# define REGISTER_TYPED_TEST_CASE_P(CaseName, ...) \
|
||||
namespace GTEST_CASE_NAMESPACE_(CaseName) { \
|
||||
typedef ::testing::internal::Templates<__VA_ARGS__>::type gtest_AllTests_; \
|
||||
} \
|
||||
static const char* const GTEST_REGISTERED_TEST_NAMES_(CaseName) = \
|
||||
GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).VerifyRegisteredTestNames(\
|
||||
__FILE__, __LINE__, #__VA_ARGS__)
|
||||
|
||||
// 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, #CaseName, GTEST_REGISTERED_TEST_NAMES_(CaseName))
|
||||
|
||||
#endif // GTEST_HAS_TYPED_TEST_P
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
|
2155
gtest/include/gtest/gtest.h
Normal file
2155
gtest/include/gtest/gtest.h
Normal file
File diff suppressed because it is too large
Load Diff
358
gtest/include/gtest/gtest_pred_impl.h
Normal file
358
gtest/include/gtest/gtest_pred_impl.h
Normal file
@ -0,0 +1,358 @@
|
||||
// Copyright 2006, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
// This file is AUTOMATICALLY GENERATED on 09/24/2010 by command
|
||||
// 'gen_gtest_pred_impl.py 5'. DO NOT EDIT BY HAND!
|
||||
//
|
||||
// Implements a family of generic predicate assertion macros.
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
|
||||
#define GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
|
||||
|
||||
// Makes sure this header is not included before gtest.h.
|
||||
#ifndef GTEST_INCLUDE_GTEST_GTEST_H_
|
||||
# error Do not include gtest_pred_impl.h directly. Include gtest.h instead.
|
||||
#endif // GTEST_INCLUDE_GTEST_GTEST_H_
|
||||
|
||||
// This header implements a family of generic predicate assertion
|
||||
// macros:
|
||||
//
|
||||
// ASSERT_PRED_FORMAT1(pred_format, v1)
|
||||
// ASSERT_PRED_FORMAT2(pred_format, v1, v2)
|
||||
// ...
|
||||
//
|
||||
// where pred_format is a function or functor that takes n (in the
|
||||
// case of ASSERT_PRED_FORMATn) values and their source expression
|
||||
// text, and returns a testing::AssertionResult. See the definition
|
||||
// of ASSERT_EQ in gtest.h for an example.
|
||||
//
|
||||
// If you don't care about formatting, you can use the more
|
||||
// restrictive version:
|
||||
//
|
||||
// ASSERT_PRED1(pred, v1)
|
||||
// ASSERT_PRED2(pred, v1, v2)
|
||||
// ...
|
||||
//
|
||||
// where pred is an n-ary function or functor that returns bool,
|
||||
// and the values v1, v2, ..., must support the << operator for
|
||||
// streaming to std::ostream.
|
||||
//
|
||||
// We also define the EXPECT_* variations.
|
||||
//
|
||||
// For now we only support predicates whose arity is at most 5.
|
||||
// Please email googletestframework@googlegroups.com if you need
|
||||
// support for higher arities.
|
||||
|
||||
// GTEST_ASSERT_ is the basic statement to which all of the assertions
|
||||
// in this file reduce. Don't use this in your code.
|
||||
|
||||
#define GTEST_ASSERT_(expression, on_failure) \
|
||||
GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
|
||||
if (const ::testing::AssertionResult gtest_ar = (expression)) \
|
||||
; \
|
||||
else \
|
||||
on_failure(gtest_ar.failure_message())
|
||||
|
||||
|
||||
// Helper function for implementing {EXPECT|ASSERT}_PRED1. Don't use
|
||||
// this in your code.
|
||||
template <typename Pred,
|
||||
typename T1>
|
||||
AssertionResult AssertPred1Helper(const char* pred_text,
|
||||
const char* e1,
|
||||
Pred pred,
|
||||
const T1& v1) {
|
||||
if (pred(v1)) return AssertionSuccess();
|
||||
|
||||
return AssertionFailure() << pred_text << "("
|
||||
<< e1 << ") evaluates to false, where"
|
||||
<< "\n" << e1 << " evaluates to " << v1;
|
||||
}
|
||||
|
||||
// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1.
|
||||
// Don't use this in your code.
|
||||
#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\
|
||||
GTEST_ASSERT_(pred_format(#v1, v1),\
|
||||
on_failure)
|
||||
|
||||
// Internal macro for implementing {EXPECT|ASSERT}_PRED1. Don't use
|
||||
// this in your code.
|
||||
#define GTEST_PRED1_(pred, v1, on_failure)\
|
||||
GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \
|
||||
#v1, \
|
||||
pred, \
|
||||
v1), on_failure)
|
||||
|
||||
// Unary predicate assertion macros.
|
||||
#define EXPECT_PRED_FORMAT1(pred_format, v1) \
|
||||
GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_)
|
||||
#define EXPECT_PRED1(pred, v1) \
|
||||
GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_)
|
||||
#define ASSERT_PRED_FORMAT1(pred_format, v1) \
|
||||
GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_)
|
||||
#define ASSERT_PRED1(pred, v1) \
|
||||
GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_)
|
||||
|
||||
|
||||
|
||||
// Helper function for implementing {EXPECT|ASSERT}_PRED2. Don't use
|
||||
// this in your code.
|
||||
template <typename Pred,
|
||||
typename T1,
|
||||
typename T2>
|
||||
AssertionResult AssertPred2Helper(const char* pred_text,
|
||||
const char* e1,
|
||||
const char* e2,
|
||||
Pred pred,
|
||||
const T1& v1,
|
||||
const T2& v2) {
|
||||
if (pred(v1, v2)) return AssertionSuccess();
|
||||
|
||||
return AssertionFailure() << pred_text << "("
|
||||
<< e1 << ", "
|
||||
<< e2 << ") evaluates to false, where"
|
||||
<< "\n" << e1 << " evaluates to " << v1
|
||||
<< "\n" << e2 << " evaluates to " << v2;
|
||||
}
|
||||
|
||||
// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2.
|
||||
// Don't use this in your code.
|
||||
#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\
|
||||
GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2),\
|
||||
on_failure)
|
||||
|
||||
// Internal macro for implementing {EXPECT|ASSERT}_PRED2. Don't use
|
||||
// this in your code.
|
||||
#define GTEST_PRED2_(pred, v1, v2, on_failure)\
|
||||
GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, \
|
||||
#v1, \
|
||||
#v2, \
|
||||
pred, \
|
||||
v1, \
|
||||
v2), on_failure)
|
||||
|
||||
// Binary predicate assertion macros.
|
||||
#define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \
|
||||
GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_)
|
||||
#define EXPECT_PRED2(pred, v1, v2) \
|
||||
GTEST_PRED2_(pred, v1, v2, GTEST_NONFATAL_FAILURE_)
|
||||
#define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \
|
||||
GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_)
|
||||
#define ASSERT_PRED2(pred, v1, v2) \
|
||||
GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_)
|
||||
|
||||
|
||||
|
||||
// Helper function for implementing {EXPECT|ASSERT}_PRED3. Don't use
|
||||
// this in your code.
|
||||
template <typename Pred,
|
||||
typename T1,
|
||||
typename T2,
|
||||
typename T3>
|
||||
AssertionResult AssertPred3Helper(const char* pred_text,
|
||||
const char* e1,
|
||||
const char* e2,
|
||||
const char* e3,
|
||||
Pred pred,
|
||||
const T1& v1,
|
||||
const T2& v2,
|
||||
const T3& v3) {
|
||||
if (pred(v1, v2, v3)) return AssertionSuccess();
|
||||
|
||||
return AssertionFailure() << pred_text << "("
|
||||
<< e1 << ", "
|
||||
<< e2 << ", "
|
||||
<< e3 << ") evaluates to false, where"
|
||||
<< "\n" << e1 << " evaluates to " << v1
|
||||
<< "\n" << e2 << " evaluates to " << v2
|
||||
<< "\n" << e3 << " evaluates to " << v3;
|
||||
}
|
||||
|
||||
// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3.
|
||||
// Don't use this in your code.
|
||||
#define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\
|
||||
GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3),\
|
||||
on_failure)
|
||||
|
||||
// Internal macro for implementing {EXPECT|ASSERT}_PRED3. Don't use
|
||||
// this in your code.
|
||||
#define GTEST_PRED3_(pred, v1, v2, v3, on_failure)\
|
||||
GTEST_ASSERT_(::testing::AssertPred3Helper(#pred, \
|
||||
#v1, \
|
||||
#v2, \
|
||||
#v3, \
|
||||
pred, \
|
||||
v1, \
|
||||
v2, \
|
||||
v3), on_failure)
|
||||
|
||||
// Ternary predicate assertion macros.
|
||||
#define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \
|
||||
GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
|
||||
#define EXPECT_PRED3(pred, v1, v2, v3) \
|
||||
GTEST_PRED3_(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
|
||||
#define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3) \
|
||||
GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE_)
|
||||
#define ASSERT_PRED3(pred, v1, v2, v3) \
|
||||
GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_)
|
||||
|
||||
|
||||
|
||||
// Helper function for implementing {EXPECT|ASSERT}_PRED4. Don't use
|
||||
// this in your code.
|
||||
template <typename Pred,
|
||||
typename T1,
|
||||
typename T2,
|
||||
typename T3,
|
||||
typename T4>
|
||||
AssertionResult AssertPred4Helper(const char* pred_text,
|
||||
const char* e1,
|
||||
const char* e2,
|
||||
const char* e3,
|
||||
const char* e4,
|
||||
Pred pred,
|
||||
const T1& v1,
|
||||
const T2& v2,
|
||||
const T3& v3,
|
||||
const T4& v4) {
|
||||
if (pred(v1, v2, v3, v4)) return AssertionSuccess();
|
||||
|
||||
return AssertionFailure() << pred_text << "("
|
||||
<< e1 << ", "
|
||||
<< e2 << ", "
|
||||
<< e3 << ", "
|
||||
<< e4 << ") evaluates to false, where"
|
||||
<< "\n" << e1 << " evaluates to " << v1
|
||||
<< "\n" << e2 << " evaluates to " << v2
|
||||
<< "\n" << e3 << " evaluates to " << v3
|
||||
<< "\n" << e4 << " evaluates to " << v4;
|
||||
}
|
||||
|
||||
// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4.
|
||||
// Don't use this in your code.
|
||||
#define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\
|
||||
GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4),\
|
||||
on_failure)
|
||||
|
||||
// Internal macro for implementing {EXPECT|ASSERT}_PRED4. Don't use
|
||||
// this in your code.
|
||||
#define GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)\
|
||||
GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, \
|
||||
#v1, \
|
||||
#v2, \
|
||||
#v3, \
|
||||
#v4, \
|
||||
pred, \
|
||||
v1, \
|
||||
v2, \
|
||||
v3, \
|
||||
v4), on_failure)
|
||||
|
||||
// 4-ary predicate assertion macros.
|
||||
#define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
|
||||
GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
|
||||
#define EXPECT_PRED4(pred, v1, v2, v3, v4) \
|
||||
GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
|
||||
#define ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
|
||||
GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
|
||||
#define ASSERT_PRED4(pred, v1, v2, v3, v4) \
|
||||
GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
|
||||
|
||||
|
||||
|
||||
// Helper function for implementing {EXPECT|ASSERT}_PRED5. Don't use
|
||||
// this in your code.
|
||||
template <typename Pred,
|
||||
typename T1,
|
||||
typename T2,
|
||||
typename T3,
|
||||
typename T4,
|
||||
typename T5>
|
||||
AssertionResult AssertPred5Helper(const char* pred_text,
|
||||
const char* e1,
|
||||
const char* e2,
|
||||
const char* e3,
|
||||
const char* e4,
|
||||
const char* e5,
|
||||
Pred pred,
|
||||
const T1& v1,
|
||||
const T2& v2,
|
||||
const T3& v3,
|
||||
const T4& v4,
|
||||
const T5& v5) {
|
||||
if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess();
|
||||
|
||||
return AssertionFailure() << pred_text << "("
|
||||
<< e1 << ", "
|
||||
<< e2 << ", "
|
||||
<< e3 << ", "
|
||||
<< e4 << ", "
|
||||
<< e5 << ") evaluates to false, where"
|
||||
<< "\n" << e1 << " evaluates to " << v1
|
||||
<< "\n" << e2 << " evaluates to " << v2
|
||||
<< "\n" << e3 << " evaluates to " << v3
|
||||
<< "\n" << e4 << " evaluates to " << v4
|
||||
<< "\n" << e5 << " evaluates to " << v5;
|
||||
}
|
||||
|
||||
// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5.
|
||||
// Don't use this in your code.
|
||||
#define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\
|
||||
GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5),\
|
||||
on_failure)
|
||||
|
||||
// Internal macro for implementing {EXPECT|ASSERT}_PRED5. Don't use
|
||||
// this in your code.
|
||||
#define GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)\
|
||||
GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, \
|
||||
#v1, \
|
||||
#v2, \
|
||||
#v3, \
|
||||
#v4, \
|
||||
#v5, \
|
||||
pred, \
|
||||
v1, \
|
||||
v2, \
|
||||
v3, \
|
||||
v4, \
|
||||
v5), on_failure)
|
||||
|
||||
// 5-ary predicate assertion macros.
|
||||
#define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
|
||||
GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
|
||||
#define EXPECT_PRED5(pred, v1, v2, v3, v4, v5) \
|
||||
GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
|
||||
#define ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
|
||||
GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
|
||||
#define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \
|
||||
GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
|
||||
|
||||
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
|
58
gtest/include/gtest/gtest_prod.h
Normal file
58
gtest/include/gtest/gtest_prod.h
Normal file
@ -0,0 +1,58 @@
|
||||
// Copyright 2006, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
//
|
||||
// Google C++ Testing Framework definitions useful in production code.
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_GTEST_PROD_H_
|
||||
#define GTEST_INCLUDE_GTEST_GTEST_PROD_H_
|
||||
|
||||
// When you need to test the private or protected members of a class,
|
||||
// use the FRIEND_TEST macro to declare your tests as friends of the
|
||||
// class. For example:
|
||||
//
|
||||
// class MyClass {
|
||||
// private:
|
||||
// void MyMethod();
|
||||
// FRIEND_TEST(MyClassTest, MyMethod);
|
||||
// };
|
||||
//
|
||||
// class MyClassTest : public testing::Test {
|
||||
// // ...
|
||||
// };
|
||||
//
|
||||
// TEST_F(MyClassTest, MyMethod) {
|
||||
// // Can call MyClass::MyMethod() here.
|
||||
// }
|
||||
|
||||
#define FRIEND_TEST(test_case_name, test_name)\
|
||||
friend class test_case_name##_##test_name##_Test
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_GTEST_PROD_H_
|
308
gtest/include/gtest/internal/gtest-death-test-internal.h
Normal file
308
gtest/include/gtest/internal/gtest-death-test-internal.h
Normal file
@ -0,0 +1,308 @@
|
||||
// Copyright 2005, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
|
||||
//
|
||||
// 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.
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
|
||||
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
|
||||
|
||||
#include "gtest/internal/gtest-internal.h"
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
namespace testing {
|
||||
namespace internal {
|
||||
|
||||
GTEST_DECLARE_string_(internal_run_death_test);
|
||||
|
||||
// Names of the flags (needed for parsing Google Test flags).
|
||||
const char kDeathTestStyleFlag[] = "death_test_style";
|
||||
const char kDeathTestUseFork[] = "death_test_use_fork";
|
||||
const char kInternalRunDeathTestFlag[] = "internal_run_death_test";
|
||||
|
||||
#if GTEST_HAS_DEATH_TEST
|
||||
|
||||
// DeathTest is a class that hides much of the complexity of the
|
||||
// GTEST_DEATH_TEST_ macro. It is abstract; its static Create method
|
||||
// returns a concrete class that depends on the prevailing death test
|
||||
// style, as defined by the --gtest_death_test_style and/or
|
||||
// --gtest_internal_run_death_test flags.
|
||||
|
||||
// In describing the results of death tests, these terms are used with
|
||||
// the corresponding definitions:
|
||||
//
|
||||
// exit status: The integer exit information in the format specified
|
||||
// by wait(2)
|
||||
// exit code: The integer code passed to exit(3), _exit(2), or
|
||||
// returned from main()
|
||||
class GTEST_API_ DeathTest {
|
||||
public:
|
||||
// Create returns false if there was an error determining the
|
||||
// appropriate action to take for the current death test; for example,
|
||||
// if the gtest_death_test_style flag is set to an invalid value.
|
||||
// The LastMessage method will return a more detailed message in that
|
||||
// case. Otherwise, the DeathTest pointer pointed to by the "test"
|
||||
// argument is set. If the death test should be skipped, the pointer
|
||||
// is set to NULL; otherwise, it is set to the address of a new concrete
|
||||
// DeathTest object that controls the execution of the current test.
|
||||
static bool Create(const char* statement, const RE* regex,
|
||||
const char* file, int line, DeathTest** test);
|
||||
DeathTest();
|
||||
virtual ~DeathTest() { }
|
||||
|
||||
// A helper class that aborts a death test when it's deleted.
|
||||
class ReturnSentinel {
|
||||
public:
|
||||
explicit ReturnSentinel(DeathTest* test) : test_(test) { }
|
||||
~ReturnSentinel() { test_->Abort(TEST_ENCOUNTERED_RETURN_STATEMENT); }
|
||||
private:
|
||||
DeathTest* const test_;
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ReturnSentinel);
|
||||
} GTEST_ATTRIBUTE_UNUSED_;
|
||||
|
||||
// An enumeration of possible roles that may be taken when a death
|
||||
// test is encountered. EXECUTE means that the death test logic should
|
||||
// be executed immediately. OVERSEE means that the program should prepare
|
||||
// the appropriate environment for a child process to execute the death
|
||||
// test, then wait for it to complete.
|
||||
enum TestRole { OVERSEE_TEST, EXECUTE_TEST };
|
||||
|
||||
// An enumeration of the three reasons that a test might be aborted.
|
||||
enum AbortReason {
|
||||
TEST_ENCOUNTERED_RETURN_STATEMENT,
|
||||
TEST_THREW_EXCEPTION,
|
||||
TEST_DID_NOT_DIE
|
||||
};
|
||||
|
||||
// Assumes one of the above roles.
|
||||
virtual TestRole AssumeRole() = 0;
|
||||
|
||||
// Waits for the death test to finish and returns its status.
|
||||
virtual int Wait() = 0;
|
||||
|
||||
// Returns true if the death test passed; that is, the test process
|
||||
// exited during the test, its exit status matches a user-supplied
|
||||
// predicate, and its stderr output matches a user-supplied regular
|
||||
// expression.
|
||||
// The user-supplied predicate may be a macro expression rather
|
||||
// than a function pointer or functor, or else Wait and Passed could
|
||||
// be combined.
|
||||
virtual bool Passed(bool exit_status_ok) = 0;
|
||||
|
||||
// Signals that the death test did not die as expected.
|
||||
virtual void Abort(AbortReason reason) = 0;
|
||||
|
||||
// Returns a human-readable outcome message regarding the outcome of
|
||||
// the last death test.
|
||||
static const char* LastMessage();
|
||||
|
||||
static void set_last_death_test_message(const String& message);
|
||||
|
||||
private:
|
||||
// A string containing a description of the outcome of the last death test.
|
||||
static String last_death_test_message_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest);
|
||||
};
|
||||
|
||||
// Factory interface for death tests. May be mocked out for testing.
|
||||
class DeathTestFactory {
|
||||
public:
|
||||
virtual ~DeathTestFactory() { }
|
||||
virtual bool Create(const char* statement, const RE* regex,
|
||||
const char* file, int line, DeathTest** test) = 0;
|
||||
};
|
||||
|
||||
// A concrete DeathTestFactory implementation for normal use.
|
||||
class DefaultDeathTestFactory : public DeathTestFactory {
|
||||
public:
|
||||
virtual bool Create(const char* statement, const RE* regex,
|
||||
const char* file, int line, DeathTest** test);
|
||||
};
|
||||
|
||||
// Returns true if exit_status describes a process that was terminated
|
||||
// by a signal, or exited normally with a nonzero exit code.
|
||||
GTEST_API_ bool ExitedUnsuccessfully(int exit_status);
|
||||
|
||||
// Traps C++ exceptions escaping statement and reports them as test
|
||||
// failures. Note that trapping SEH exceptions is not implemented here.
|
||||
# if GTEST_HAS_EXCEPTIONS
|
||||
# define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
|
||||
try { \
|
||||
GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
|
||||
} catch (const ::std::exception& gtest_exception) { \
|
||||
fprintf(\
|
||||
stderr, \
|
||||
"\n%s: Caught std::exception-derived exception escaping the " \
|
||||
"death test statement. Exception message: %s\n", \
|
||||
::testing::internal::FormatFileLocation(__FILE__, __LINE__).c_str(), \
|
||||
gtest_exception.what()); \
|
||||
fflush(stderr); \
|
||||
death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
|
||||
} catch (...) { \
|
||||
death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
|
||||
}
|
||||
|
||||
# else
|
||||
# define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
|
||||
GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
|
||||
|
||||
# endif
|
||||
|
||||
// This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*,
|
||||
// ASSERT_EXIT*, and EXPECT_EXIT*.
|
||||
# define GTEST_DEATH_TEST_(statement, predicate, regex, fail) \
|
||||
GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
|
||||
if (::testing::internal::AlwaysTrue()) { \
|
||||
const ::testing::internal::RE& gtest_regex = (regex); \
|
||||
::testing::internal::DeathTest* gtest_dt; \
|
||||
if (!::testing::internal::DeathTest::Create(#statement, >est_regex, \
|
||||
__FILE__, __LINE__, >est_dt)) { \
|
||||
goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \
|
||||
} \
|
||||
if (gtest_dt != NULL) { \
|
||||
::testing::internal::scoped_ptr< ::testing::internal::DeathTest> \
|
||||
gtest_dt_ptr(gtest_dt); \
|
||||
switch (gtest_dt->AssumeRole()) { \
|
||||
case ::testing::internal::DeathTest::OVERSEE_TEST: \
|
||||
if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) { \
|
||||
goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \
|
||||
} \
|
||||
break; \
|
||||
case ::testing::internal::DeathTest::EXECUTE_TEST: { \
|
||||
::testing::internal::DeathTest::ReturnSentinel \
|
||||
gtest_sentinel(gtest_dt); \
|
||||
GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt); \
|
||||
gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE); \
|
||||
break; \
|
||||
} \
|
||||
default: \
|
||||
break; \
|
||||
} \
|
||||
} \
|
||||
} else \
|
||||
GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__): \
|
||||
fail(::testing::internal::DeathTest::LastMessage())
|
||||
// The symbol "fail" here expands to something into which a message
|
||||
// can be streamed.
|
||||
|
||||
// A class representing the parsed contents of the
|
||||
// --gtest_internal_run_death_test flag, as it existed when
|
||||
// RUN_ALL_TESTS was called.
|
||||
class InternalRunDeathTestFlag {
|
||||
public:
|
||||
InternalRunDeathTestFlag(const String& a_file,
|
||||
int a_line,
|
||||
int an_index,
|
||||
int a_write_fd)
|
||||
: file_(a_file), line_(a_line), index_(an_index),
|
||||
write_fd_(a_write_fd) {}
|
||||
|
||||
~InternalRunDeathTestFlag() {
|
||||
if (write_fd_ >= 0)
|
||||
posix::Close(write_fd_);
|
||||
}
|
||||
|
||||
String file() const { return file_; }
|
||||
int line() const { return line_; }
|
||||
int index() const { return index_; }
|
||||
int write_fd() const { return write_fd_; }
|
||||
|
||||
private:
|
||||
String file_;
|
||||
int line_;
|
||||
int index_;
|
||||
int write_fd_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(InternalRunDeathTestFlag);
|
||||
};
|
||||
|
||||
// Returns a newly created InternalRunDeathTestFlag object with fields
|
||||
// initialized from the GTEST_FLAG(internal_run_death_test) flag if
|
||||
// the flag is specified; otherwise returns NULL.
|
||||
InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag();
|
||||
|
||||
#else // GTEST_HAS_DEATH_TEST
|
||||
|
||||
// This macro is used for implementing macros such as
|
||||
// EXPECT_DEATH_IF_SUPPORTED and ASSERT_DEATH_IF_SUPPORTED on systems where
|
||||
// death tests are not supported. Those macros must compile on such systems
|
||||
// iff EXPECT_DEATH and ASSERT_DEATH compile with the same parameters on
|
||||
// systems that support death tests. This allows one to write such a macro
|
||||
// on a system that does not support death tests and be sure that it will
|
||||
// compile on a death-test supporting system.
|
||||
//
|
||||
// Parameters:
|
||||
// statement - A statement that a macro such as EXPECT_DEATH would test
|
||||
// for program termination. This macro has to make sure this
|
||||
// statement is compiled but not executed, to ensure that
|
||||
// EXPECT_DEATH_IF_SUPPORTED compiles with a certain
|
||||
// parameter iff EXPECT_DEATH compiles with it.
|
||||
// regex - A regex that a macro such as EXPECT_DEATH would use to test
|
||||
// the output of statement. This parameter has to be
|
||||
// compiled but not evaluated by this macro, to ensure that
|
||||
// this macro only accepts expressions that a macro such as
|
||||
// EXPECT_DEATH would accept.
|
||||
// terminator - Must be an empty statement for EXPECT_DEATH_IF_SUPPORTED
|
||||
// and a return statement for ASSERT_DEATH_IF_SUPPORTED.
|
||||
// This ensures that ASSERT_DEATH_IF_SUPPORTED will not
|
||||
// compile inside functions where ASSERT_DEATH doesn't
|
||||
// compile.
|
||||
//
|
||||
// The branch that has an always false condition is used to ensure that
|
||||
// statement and regex are compiled (and thus syntactically correct) but
|
||||
// never executed. The unreachable code macro protects the terminator
|
||||
// statement from generating an 'unreachable code' warning in case
|
||||
// statement unconditionally returns or throws. The Message constructor at
|
||||
// the end allows the syntax of streaming additional messages into the
|
||||
// macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH.
|
||||
# define GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, terminator) \
|
||||
GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
|
||||
if (::testing::internal::AlwaysTrue()) { \
|
||||
GTEST_LOG_(WARNING) \
|
||||
<< "Death tests are not supported on this platform.\n" \
|
||||
<< "Statement '" #statement "' cannot be verified."; \
|
||||
} else if (::testing::internal::AlwaysFalse()) { \
|
||||
::testing::internal::RE::PartialMatch(".*", (regex)); \
|
||||
GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
|
||||
terminator; \
|
||||
} else \
|
||||
::testing::Message()
|
||||
|
||||
#endif // GTEST_HAS_DEATH_TEST
|
||||
|
||||
} // namespace internal
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
|
210
gtest/include/gtest/internal/gtest-filepath.h
Normal file
210
gtest/include/gtest/internal/gtest-filepath.h
Normal file
@ -0,0 +1,210 @@
|
||||
// Copyright 2008, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: keith.ray@gmail.com (Keith Ray)
|
||||
//
|
||||
// Google Test filepath utilities
|
||||
//
|
||||
// This header file declares classes and functions used internally by
|
||||
// Google Test. They are subject to change without notice.
|
||||
//
|
||||
// This file is #included in <gtest/internal/gtest-internal.h>.
|
||||
// Do not include this header file separately!
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
|
||||
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
|
||||
|
||||
#include "gtest/internal/gtest-string.h"
|
||||
|
||||
namespace testing {
|
||||
namespace internal {
|
||||
|
||||
// FilePath - a class for file and directory pathname manipulation which
|
||||
// handles platform-specific conventions (like the pathname separator).
|
||||
// Used for helper functions for naming files in a directory for xml output.
|
||||
// Except for Set methods, all methods are const or static, which provides an
|
||||
// "immutable value object" -- useful for peace of mind.
|
||||
// A FilePath with a value ending in a path separator ("like/this/") represents
|
||||
// a directory, otherwise it is assumed to represent a file. In either case,
|
||||
// it may or may not represent an actual file or directory in the file system.
|
||||
// Names are NOT checked for syntax correctness -- no checking for illegal
|
||||
// characters, malformed paths, etc.
|
||||
|
||||
class GTEST_API_ FilePath {
|
||||
public:
|
||||
FilePath() : pathname_("") { }
|
||||
FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { }
|
||||
|
||||
explicit FilePath(const char* pathname) : pathname_(pathname) {
|
||||
Normalize();
|
||||
}
|
||||
|
||||
explicit FilePath(const String& pathname) : pathname_(pathname) {
|
||||
Normalize();
|
||||
}
|
||||
|
||||
FilePath& operator=(const FilePath& rhs) {
|
||||
Set(rhs);
|
||||
return *this;
|
||||
}
|
||||
|
||||
void Set(const FilePath& rhs) {
|
||||
pathname_ = rhs.pathname_;
|
||||
}
|
||||
|
||||
String ToString() const { return pathname_; }
|
||||
const char* c_str() const { return pathname_.c_str(); }
|
||||
|
||||
// Returns the current working directory, or "" if unsuccessful.
|
||||
static FilePath GetCurrentDir();
|
||||
|
||||
// Given directory = "dir", base_name = "test", number = 0,
|
||||
// extension = "xml", returns "dir/test.xml". If number is greater
|
||||
// than zero (e.g., 12), returns "dir/test_12.xml".
|
||||
// On Windows platform, uses \ as the separator rather than /.
|
||||
static FilePath MakeFileName(const FilePath& directory,
|
||||
const FilePath& base_name,
|
||||
int number,
|
||||
const char* extension);
|
||||
|
||||
// Given directory = "dir", relative_path = "test.xml",
|
||||
// returns "dir/test.xml".
|
||||
// On Windows, uses \ as the separator rather than /.
|
||||
static FilePath ConcatPaths(const FilePath& directory,
|
||||
const FilePath& relative_path);
|
||||
|
||||
// Returns a pathname for a file that does not currently exist. The pathname
|
||||
// will be directory/base_name.extension or
|
||||
// directory/base_name_<number>.extension if directory/base_name.extension
|
||||
// already exists. The number will be incremented until a pathname is found
|
||||
// that does not already exist.
|
||||
// Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
|
||||
// There could be a race condition if two or more processes are calling this
|
||||
// function at the same time -- they could both pick the same filename.
|
||||
static FilePath GenerateUniqueFileName(const FilePath& directory,
|
||||
const FilePath& base_name,
|
||||
const char* extension);
|
||||
|
||||
// Returns true iff the path is NULL or "".
|
||||
bool IsEmpty() const { return c_str() == NULL || *c_str() == '\0'; }
|
||||
|
||||
// If input name has a trailing separator character, removes it and returns
|
||||
// the name, otherwise return the name string unmodified.
|
||||
// On Windows platform, uses \ as the separator, other platforms use /.
|
||||
FilePath RemoveTrailingPathSeparator() const;
|
||||
|
||||
// Returns a copy of the FilePath with the directory part removed.
|
||||
// Example: FilePath("path/to/file").RemoveDirectoryName() returns
|
||||
// FilePath("file"). If there is no directory part ("just_a_file"), it returns
|
||||
// the FilePath unmodified. If there is no file part ("just_a_dir/") it
|
||||
// returns an empty FilePath ("").
|
||||
// On Windows platform, '\' is the path separator, otherwise it is '/'.
|
||||
FilePath RemoveDirectoryName() const;
|
||||
|
||||
// RemoveFileName returns the directory path with the filename removed.
|
||||
// Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
|
||||
// If the FilePath is "a_file" or "/a_file", RemoveFileName returns
|
||||
// FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
|
||||
// not have a file, like "just/a/dir/", it returns the FilePath unmodified.
|
||||
// On Windows platform, '\' is the path separator, otherwise it is '/'.
|
||||
FilePath RemoveFileName() const;
|
||||
|
||||
// Returns a copy of the FilePath with the case-insensitive extension removed.
|
||||
// Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
|
||||
// FilePath("dir/file"). If a case-insensitive extension is not
|
||||
// found, returns a copy of the original FilePath.
|
||||
FilePath RemoveExtension(const char* extension) const;
|
||||
|
||||
// Creates directories so that path exists. Returns true if successful or if
|
||||
// the directories already exist; returns false if unable to create
|
||||
// directories for any reason. Will also return false if the FilePath does
|
||||
// not represent a directory (that is, it doesn't end with a path separator).
|
||||
bool CreateDirectoriesRecursively() const;
|
||||
|
||||
// Create the directory so that path exists. Returns true if successful or
|
||||
// if the directory already exists; returns false if unable to create the
|
||||
// directory for any reason, including if the parent directory does not
|
||||
// exist. Not named "CreateDirectory" because that's a macro on Windows.
|
||||
bool CreateFolder() const;
|
||||
|
||||
// Returns true if FilePath describes something in the file-system,
|
||||
// either a file, directory, or whatever, and that something exists.
|
||||
bool FileOrDirectoryExists() const;
|
||||
|
||||
// Returns true if pathname describes a directory in the file-system
|
||||
// that exists.
|
||||
bool DirectoryExists() const;
|
||||
|
||||
// Returns true if FilePath ends with a path separator, which indicates that
|
||||
// it is intended to represent a directory. Returns false otherwise.
|
||||
// This does NOT check that a directory (or file) actually exists.
|
||||
bool IsDirectory() const;
|
||||
|
||||
// Returns true if pathname describes a root directory. (Windows has one
|
||||
// root directory per disk drive.)
|
||||
bool IsRootDirectory() const;
|
||||
|
||||
// Returns true if pathname describes an absolute path.
|
||||
bool IsAbsolutePath() const;
|
||||
|
||||
private:
|
||||
// Replaces multiple consecutive separators with a single separator.
|
||||
// For example, "bar///foo" becomes "bar/foo". Does not eliminate other
|
||||
// redundancies that might be in a pathname involving "." or "..".
|
||||
//
|
||||
// A pathname with multiple consecutive separators may occur either through
|
||||
// user error or as a result of some scripts or APIs that generate a pathname
|
||||
// with a trailing separator. On other platforms the same API or script
|
||||
// may NOT generate a pathname with a trailing "/". Then elsewhere that
|
||||
// pathname may have another "/" and pathname components added to it,
|
||||
// without checking for the separator already being there.
|
||||
// The script language and operating system may allow paths like "foo//bar"
|
||||
// but some of the functions in FilePath will not handle that correctly. In
|
||||
// particular, RemoveTrailingPathSeparator() only removes one separator, and
|
||||
// it is called in CreateDirectoriesRecursively() assuming that it will change
|
||||
// a pathname from directory syntax (trailing separator) to filename syntax.
|
||||
//
|
||||
// On Windows this method also replaces the alternate path separator '/' with
|
||||
// the primary path separator '\\', so that for example "bar\\/\\foo" becomes
|
||||
// "bar\\foo".
|
||||
|
||||
void Normalize();
|
||||
|
||||
// Returns a pointer to the last occurence of a valid path separator in
|
||||
// the FilePath. On Windows, for example, both '/' and '\' are valid path
|
||||
// separators. Returns NULL if no path separator was found.
|
||||
const char* FindLastPathSeparator() const;
|
||||
|
||||
String pathname_;
|
||||
}; // class FilePath
|
||||
|
||||
} // namespace internal
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
|
1226
gtest/include/gtest/internal/gtest-internal.h
Normal file
1226
gtest/include/gtest/internal/gtest-internal.h
Normal file
File diff suppressed because it is too large
Load Diff
233
gtest/include/gtest/internal/gtest-linked_ptr.h
Normal file
233
gtest/include/gtest/internal/gtest-linked_ptr.h
Normal file
@ -0,0 +1,233 @@
|
||||
// Copyright 2003 Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Authors: Dan Egnor (egnor@google.com)
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
// Used properly, this deletes the object when the last reference goes away.
|
||||
// There are several caveats:
|
||||
// - Like all reference counting schemes, cycles lead to leaks.
|
||||
// - Each smart pointer is actually two pointers (8 bytes instead of 4).
|
||||
// - Every time a pointer is assigned, the entire list of pointers to that
|
||||
// object is traversed. This class is therefore NOT SUITABLE when there
|
||||
// will often be more than two or three pointers to a particular object.
|
||||
// - References are only tracked as long as linked_ptr<> objects are copied.
|
||||
// If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS
|
||||
// will happen (double deletion).
|
||||
//
|
||||
// A good use of this class is storing object references in STL containers.
|
||||
// You can safely put linked_ptr<> in a vector<>.
|
||||
// Other uses may not be as good.
|
||||
//
|
||||
// Note: If you use an incomplete type with linked_ptr<>, the class
|
||||
// *containing* linked_ptr<> must have a constructor and destructor (even
|
||||
// if they do nothing!).
|
||||
//
|
||||
// Bill Gibbons suggested we use something like this.
|
||||
//
|
||||
// Thread Safety:
|
||||
// Unlike other linked_ptr implementations, in this implementation
|
||||
// a linked_ptr object is thread-safe in the sense that:
|
||||
// - it's safe to copy linked_ptr objects concurrently,
|
||||
// - it's safe to copy *from* a linked_ptr and read its underlying
|
||||
// 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(wan@google.com): rename this to safe_linked_ptr to avoid
|
||||
// confusion with normal linked_ptr.
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
|
||||
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include "gtest/internal/gtest-port.h"
|
||||
|
||||
namespace testing {
|
||||
namespace internal {
|
||||
|
||||
// Protects copying of all linked_ptr objects.
|
||||
GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_linked_ptr_mutex);
|
||||
|
||||
// This is used internally by all instances of linked_ptr<>. It needs to be
|
||||
// a non-template class because different types of linked_ptr<> can refer to
|
||||
// the same object (linked_ptr<Superclass>(obj) vs linked_ptr<Subclass>(obj)).
|
||||
// So, it needs to be possible for different types of linked_ptr to participate
|
||||
// in the same circular linked list, so we need a single class type here.
|
||||
//
|
||||
// DO NOT USE THIS CLASS DIRECTLY YOURSELF. Use linked_ptr<T>.
|
||||
class linked_ptr_internal {
|
||||
public:
|
||||
// Create a new circle that includes only this instance.
|
||||
void join_new() {
|
||||
next_ = this;
|
||||
}
|
||||
|
||||
// Many linked_ptr operations may change p.link_ for some linked_ptr
|
||||
// variable p in the same circle as this object. Therefore we need
|
||||
// to prevent two such operations from occurring concurrently.
|
||||
//
|
||||
// Note that different types of linked_ptr objects can coexist in a
|
||||
// circle (e.g. linked_ptr<Base>, linked_ptr<Derived1>, and
|
||||
// linked_ptr<Derived2>). Therefore we must use a single mutex to
|
||||
// protect all linked_ptr objects. This can create serious
|
||||
// contention in production code, but is acceptable in a testing
|
||||
// framework.
|
||||
|
||||
// Join an existing circle.
|
||||
// L < g_linked_ptr_mutex
|
||||
void join(linked_ptr_internal const* ptr) {
|
||||
MutexLock lock(&g_linked_ptr_mutex);
|
||||
|
||||
linked_ptr_internal const* p = ptr;
|
||||
while (p->next_ != ptr) p = p->next_;
|
||||
p->next_ = this;
|
||||
next_ = ptr;
|
||||
}
|
||||
|
||||
// Leave whatever circle we're part of. Returns true if we were the
|
||||
// last member of the circle. Once this is done, you can join() another.
|
||||
// L < g_linked_ptr_mutex
|
||||
bool depart() {
|
||||
MutexLock lock(&g_linked_ptr_mutex);
|
||||
|
||||
if (next_ == this) return true;
|
||||
linked_ptr_internal const* p = next_;
|
||||
while (p->next_ != this) p = p->next_;
|
||||
p->next_ = next_;
|
||||
return false;
|
||||
}
|
||||
|
||||
private:
|
||||
mutable linked_ptr_internal const* next_;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
class linked_ptr {
|
||||
public:
|
||||
typedef T element_type;
|
||||
|
||||
// Take over ownership of a raw pointer. This should happen as soon as
|
||||
// possible after the object is created.
|
||||
explicit linked_ptr(T* ptr = NULL) { capture(ptr); }
|
||||
~linked_ptr() { depart(); }
|
||||
|
||||
// Copy an existing linked_ptr<>, adding ourselves to the list of references.
|
||||
template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); }
|
||||
linked_ptr(linked_ptr const& ptr) { // NOLINT
|
||||
assert(&ptr != this);
|
||||
copy(&ptr);
|
||||
}
|
||||
|
||||
// Assignment releases the old value and acquires the new.
|
||||
template <typename U> linked_ptr& operator=(linked_ptr<U> const& ptr) {
|
||||
depart();
|
||||
copy(&ptr);
|
||||
return *this;
|
||||
}
|
||||
|
||||
linked_ptr& operator=(linked_ptr const& ptr) {
|
||||
if (&ptr != this) {
|
||||
depart();
|
||||
copy(&ptr);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
// Smart pointer members.
|
||||
void reset(T* ptr = NULL) {
|
||||
depart();
|
||||
capture(ptr);
|
||||
}
|
||||
T* get() const { return value_; }
|
||||
T* operator->() const { return value_; }
|
||||
T& operator*() const { return *value_; }
|
||||
|
||||
bool operator==(T* p) const { return value_ == p; }
|
||||
bool operator!=(T* p) const { return value_ != p; }
|
||||
template <typename U>
|
||||
bool operator==(linked_ptr<U> const& ptr) const {
|
||||
return value_ == ptr.get();
|
||||
}
|
||||
template <typename U>
|
||||
bool operator!=(linked_ptr<U> const& ptr) const {
|
||||
return value_ != ptr.get();
|
||||
}
|
||||
|
||||
private:
|
||||
template <typename U>
|
||||
friend class linked_ptr;
|
||||
|
||||
T* value_;
|
||||
linked_ptr_internal link_;
|
||||
|
||||
void depart() {
|
||||
if (link_.depart()) delete value_;
|
||||
}
|
||||
|
||||
void capture(T* ptr) {
|
||||
value_ = ptr;
|
||||
link_.join_new();
|
||||
}
|
||||
|
||||
template <typename U> void copy(linked_ptr<U> const* ptr) {
|
||||
value_ = ptr->get();
|
||||
if (value_)
|
||||
link_.join(&ptr->link_);
|
||||
else
|
||||
link_.join_new();
|
||||
}
|
||||
};
|
||||
|
||||
template<typename T> inline
|
||||
bool operator==(T* ptr, const linked_ptr<T>& x) {
|
||||
return ptr == x.get();
|
||||
}
|
||||
|
||||
template<typename T> inline
|
||||
bool operator!=(T* ptr, const linked_ptr<T>& x) {
|
||||
return ptr != x.get();
|
||||
}
|
||||
|
||||
// A function to convert T* into linked_ptr<T>
|
||||
// Doing e.g. make_linked_ptr(new FooBarBaz<type>(arg)) is a shorter notation
|
||||
// for linked_ptr<FooBarBaz<type> >(new FooBarBaz<type>(arg))
|
||||
template <typename T>
|
||||
linked_ptr<T> make_linked_ptr(T* ptr) {
|
||||
return linked_ptr<T>(ptr);
|
||||
}
|
||||
|
||||
} // namespace internal
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
|
4822
gtest/include/gtest/internal/gtest-param-util-generated.h
Normal file
4822
gtest/include/gtest/internal/gtest-param-util-generated.h
Normal file
File diff suppressed because it is too large
Load Diff
301
gtest/include/gtest/internal/gtest-param-util-generated.h.pump
Normal file
301
gtest/include/gtest/internal/gtest-param-util-generated.h.pump
Normal file
@ -0,0 +1,301 @@
|
||||
$$ -*- mode: c++; -*-
|
||||
$var n = 50 $$ Maximum length of Values arguments we want to support.
|
||||
$var maxtuple = 10 $$ Maximum number of Combine arguments we want to support.
|
||||
// Copyright 2008 Google Inc.
|
||||
// All Rights Reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: vladl@google.com (Vlad Losev)
|
||||
|
||||
// Type and function utilities for implementing parameterized tests.
|
||||
// This file is generated by a SCRIPT. DO NOT EDIT BY HAND!
|
||||
//
|
||||
// Currently Google Test supports at most $n arguments in Values,
|
||||
// and at most $maxtuple arguments in Combine. Please contact
|
||||
// googletestframework@googlegroups.com if you need more.
|
||||
// Please note that the number of arguments to Combine is limited
|
||||
// by the maximum arity of the implementation of tr1::tuple which is
|
||||
// currently set at $maxtuple.
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
|
||||
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
|
||||
|
||||
// scripts/fuse_gtest.py depends on gtest's own header being #included
|
||||
// *unconditionally*. Therefore these #includes cannot be moved
|
||||
// inside #if GTEST_HAS_PARAM_TEST.
|
||||
#include "gtest/internal/gtest-param-util.h"
|
||||
#include "gtest/internal/gtest-port.h"
|
||||
|
||||
#if GTEST_HAS_PARAM_TEST
|
||||
|
||||
namespace testing {
|
||||
|
||||
// Forward declarations of ValuesIn(), which is implemented in
|
||||
// include/gtest/gtest-param-test.h.
|
||||
template <typename ForwardIterator>
|
||||
internal::ParamGenerator<
|
||||
typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
|
||||
ValuesIn(ForwardIterator begin, ForwardIterator end);
|
||||
|
||||
template <typename T, size_t N>
|
||||
internal::ParamGenerator<T> ValuesIn(const T (&array)[N]);
|
||||
|
||||
template <class Container>
|
||||
internal::ParamGenerator<typename Container::value_type> ValuesIn(
|
||||
const Container& container);
|
||||
|
||||
namespace internal {
|
||||
|
||||
// Used in the Values() function to provide polymorphic capabilities.
|
||||
template <typename T1>
|
||||
class ValueArray1 {
|
||||
public:
|
||||
explicit ValueArray1(T1 v1) : v1_(v1) {}
|
||||
|
||||
template <typename T>
|
||||
operator ParamGenerator<T>() const { return ValuesIn(&v1_, &v1_ + 1); }
|
||||
|
||||
private:
|
||||
// No implementation - assignment is unsupported.
|
||||
void operator=(const ValueArray1& other);
|
||||
|
||||
const T1 v1_;
|
||||
};
|
||||
|
||||
$range i 2..n
|
||||
$for i [[
|
||||
$range j 1..i
|
||||
|
||||
template <$for j, [[typename T$j]]>
|
||||
class ValueArray$i {
|
||||
public:
|
||||
ValueArray$i($for j, [[T$j v$j]]) : $for j, [[v$(j)_(v$j)]] {}
|
||||
|
||||
template <typename T>
|
||||
operator ParamGenerator<T>() const {
|
||||
const T array[] = {$for j, [[v$(j)_]]};
|
||||
return ValuesIn(array);
|
||||
}
|
||||
|
||||
private:
|
||||
// No implementation - assignment is unsupported.
|
||||
void operator=(const ValueArray$i& other);
|
||||
|
||||
$for j [[
|
||||
|
||||
const T$j v$(j)_;
|
||||
]]
|
||||
|
||||
};
|
||||
|
||||
]]
|
||||
|
||||
# if GTEST_HAS_COMBINE
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// Generates values from the Cartesian product of values produced
|
||||
// by the argument generators.
|
||||
//
|
||||
$range i 2..maxtuple
|
||||
$for i [[
|
||||
$range j 1..i
|
||||
$range k 2..i
|
||||
|
||||
template <$for j, [[typename T$j]]>
|
||||
class CartesianProductGenerator$i
|
||||
: public ParamGeneratorInterface< ::std::tr1::tuple<$for j, [[T$j]]> > {
|
||||
public:
|
||||
typedef ::std::tr1::tuple<$for j, [[T$j]]> ParamType;
|
||||
|
||||
CartesianProductGenerator$i($for j, [[const ParamGenerator<T$j>& g$j]])
|
||||
: $for j, [[g$(j)_(g$j)]] {}
|
||||
virtual ~CartesianProductGenerator$i() {}
|
||||
|
||||
virtual ParamIteratorInterface<ParamType>* Begin() const {
|
||||
return new Iterator(this, $for j, [[g$(j)_, g$(j)_.begin()]]);
|
||||
}
|
||||
virtual ParamIteratorInterface<ParamType>* End() const {
|
||||
return new Iterator(this, $for j, [[g$(j)_, g$(j)_.end()]]);
|
||||
}
|
||||
|
||||
private:
|
||||
class Iterator : public ParamIteratorInterface<ParamType> {
|
||||
public:
|
||||
Iterator(const ParamGeneratorInterface<ParamType>* base, $for j, [[
|
||||
|
||||
const ParamGenerator<T$j>& g$j,
|
||||
const typename ParamGenerator<T$j>::iterator& current$(j)]])
|
||||
: base_(base),
|
||||
$for j, [[
|
||||
|
||||
begin$(j)_(g$j.begin()), end$(j)_(g$j.end()), current$(j)_(current$j)
|
||||
]] {
|
||||
ComputeCurrentValue();
|
||||
}
|
||||
virtual ~Iterator() {}
|
||||
|
||||
virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
|
||||
return base_;
|
||||
}
|
||||
// Advance should not be called on beyond-of-range iterators
|
||||
// so no component iterators must be beyond end of range, either.
|
||||
virtual void Advance() {
|
||||
assert(!AtEnd());
|
||||
++current$(i)_;
|
||||
|
||||
$for k [[
|
||||
if (current$(i+2-k)_ == end$(i+2-k)_) {
|
||||
current$(i+2-k)_ = begin$(i+2-k)_;
|
||||
++current$(i+2-k-1)_;
|
||||
}
|
||||
|
||||
]]
|
||||
ComputeCurrentValue();
|
||||
}
|
||||
virtual ParamIteratorInterface<ParamType>* Clone() const {
|
||||
return new Iterator(*this);
|
||||
}
|
||||
virtual const ParamType* Current() const { return ¤t_value_; }
|
||||
virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
|
||||
// Having the same base generator guarantees that the other
|
||||
// iterator is of the same type and we can downcast.
|
||||
GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
|
||||
<< "The program attempted to compare iterators "
|
||||
<< "from different generators." << std::endl;
|
||||
const Iterator* typed_other =
|
||||
CheckedDowncastToActualType<const Iterator>(&other);
|
||||
// We must report iterators equal if they both point beyond their
|
||||
// respective ranges. That can happen in a variety of fashions,
|
||||
// so we have to consult AtEnd().
|
||||
return (AtEnd() && typed_other->AtEnd()) ||
|
||||
($for j && [[
|
||||
|
||||
current$(j)_ == typed_other->current$(j)_
|
||||
]]);
|
||||
}
|
||||
|
||||
private:
|
||||
Iterator(const Iterator& other)
|
||||
: base_(other.base_), $for j, [[
|
||||
|
||||
begin$(j)_(other.begin$(j)_),
|
||||
end$(j)_(other.end$(j)_),
|
||||
current$(j)_(other.current$(j)_)
|
||||
]] {
|
||||
ComputeCurrentValue();
|
||||
}
|
||||
|
||||
void ComputeCurrentValue() {
|
||||
if (!AtEnd())
|
||||
current_value_ = ParamType($for j, [[*current$(j)_]]);
|
||||
}
|
||||
bool AtEnd() const {
|
||||
// We must report iterator past the end of the range when either of the
|
||||
// component iterators has reached the end of its range.
|
||||
return
|
||||
$for j || [[
|
||||
|
||||
current$(j)_ == end$(j)_
|
||||
]];
|
||||
}
|
||||
|
||||
// No implementation - assignment is unsupported.
|
||||
void operator=(const Iterator& other);
|
||||
|
||||
const ParamGeneratorInterface<ParamType>* const base_;
|
||||
// begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
|
||||
// current[i]_ is the actual traversing iterator.
|
||||
$for j [[
|
||||
|
||||
const typename ParamGenerator<T$j>::iterator begin$(j)_;
|
||||
const typename ParamGenerator<T$j>::iterator end$(j)_;
|
||||
typename ParamGenerator<T$j>::iterator current$(j)_;
|
||||
]]
|
||||
|
||||
ParamType current_value_;
|
||||
}; // class CartesianProductGenerator$i::Iterator
|
||||
|
||||
// No implementation - assignment is unsupported.
|
||||
void operator=(const CartesianProductGenerator$i& other);
|
||||
|
||||
|
||||
$for j [[
|
||||
const ParamGenerator<T$j> g$(j)_;
|
||||
|
||||
]]
|
||||
}; // class CartesianProductGenerator$i
|
||||
|
||||
|
||||
]]
|
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// Helper classes providing Combine() with polymorphic features. They allow
|
||||
// casting CartesianProductGeneratorN<T> to ParamGenerator<U> if T is
|
||||
// convertible to U.
|
||||
//
|
||||
$range i 2..maxtuple
|
||||
$for i [[
|
||||
$range j 1..i
|
||||
|
||||
template <$for j, [[class Generator$j]]>
|
||||
class CartesianProductHolder$i {
|
||||
public:
|
||||
CartesianProductHolder$i($for j, [[const Generator$j& g$j]])
|
||||
: $for j, [[g$(j)_(g$j)]] {}
|
||||
template <$for j, [[typename T$j]]>
|
||||
operator ParamGenerator< ::std::tr1::tuple<$for j, [[T$j]]> >() const {
|
||||
return ParamGenerator< ::std::tr1::tuple<$for j, [[T$j]]> >(
|
||||
new CartesianProductGenerator$i<$for j, [[T$j]]>(
|
||||
$for j,[[
|
||||
|
||||
static_cast<ParamGenerator<T$j> >(g$(j)_)
|
||||
]]));
|
||||
}
|
||||
|
||||
private:
|
||||
// No implementation - assignment is unsupported.
|
||||
void operator=(const CartesianProductHolder$i& other);
|
||||
|
||||
|
||||
$for j [[
|
||||
const Generator$j g$(j)_;
|
||||
|
||||
]]
|
||||
}; // class CartesianProductHolder$i
|
||||
|
||||
]]
|
||||
|
||||
# endif // GTEST_HAS_COMBINE
|
||||
|
||||
} // namespace internal
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_HAS_PARAM_TEST
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
|
619
gtest/include/gtest/internal/gtest-param-util.h
Normal file
619
gtest/include/gtest/internal/gtest-param-util.h
Normal file
@ -0,0 +1,619 @@
|
||||
// Copyright 2008 Google Inc.
|
||||
// All Rights Reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: vladl@google.com (Vlad Losev)
|
||||
|
||||
// Type and function utilities for implementing parameterized tests.
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
|
||||
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
|
||||
|
||||
#include <iterator>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
// scripts/fuse_gtest.py depends on gtest's own header being #included
|
||||
// *unconditionally*. Therefore these #includes cannot be moved
|
||||
// inside #if GTEST_HAS_PARAM_TEST.
|
||||
#include "gtest/internal/gtest-internal.h"
|
||||
#include "gtest/internal/gtest-linked_ptr.h"
|
||||
#include "gtest/internal/gtest-port.h"
|
||||
#include "gtest/gtest-printers.h"
|
||||
|
||||
#if GTEST_HAS_PARAM_TEST
|
||||
|
||||
namespace testing {
|
||||
namespace internal {
|
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// Outputs a message explaining invalid registration of different
|
||||
// fixture class for the same test case. This may happen when
|
||||
// TEST_P macro is used to define two tests with the same name
|
||||
// but in different namespaces.
|
||||
GTEST_API_ void ReportInvalidTestCaseType(const char* test_case_name,
|
||||
const char* file, int line);
|
||||
|
||||
template <typename> class ParamGeneratorInterface;
|
||||
template <typename> class ParamGenerator;
|
||||
|
||||
// Interface for iterating over elements provided by an implementation
|
||||
// of ParamGeneratorInterface<T>.
|
||||
template <typename T>
|
||||
class ParamIteratorInterface {
|
||||
public:
|
||||
virtual ~ParamIteratorInterface() {}
|
||||
// A pointer to the base generator instance.
|
||||
// Used only for the purposes of iterator comparison
|
||||
// to make sure that two iterators belong to the same generator.
|
||||
virtual const ParamGeneratorInterface<T>* BaseGenerator() const = 0;
|
||||
// Advances iterator to point to the next element
|
||||
// provided by the generator. The caller is responsible
|
||||
// for not calling Advance() on an iterator equal to
|
||||
// BaseGenerator()->End().
|
||||
virtual void Advance() = 0;
|
||||
// Clones the iterator object. Used for implementing copy semantics
|
||||
// of ParamIterator<T>.
|
||||
virtual ParamIteratorInterface* Clone() const = 0;
|
||||
// Dereferences the current iterator and provides (read-only) access
|
||||
// to the pointed value. It is the caller's responsibility not to call
|
||||
// Current() on an iterator equal to BaseGenerator()->End().
|
||||
// Used for implementing ParamGenerator<T>::operator*().
|
||||
virtual const T* Current() const = 0;
|
||||
// Determines whether the given iterator and other point to the same
|
||||
// element in the sequence generated by the generator.
|
||||
// Used for implementing ParamGenerator<T>::operator==().
|
||||
virtual bool Equals(const ParamIteratorInterface& other) const = 0;
|
||||
};
|
||||
|
||||
// Class iterating over elements provided by an implementation of
|
||||
// ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T>
|
||||
// and implements the const forward iterator concept.
|
||||
template <typename T>
|
||||
class ParamIterator {
|
||||
public:
|
||||
typedef T value_type;
|
||||
typedef const T& reference;
|
||||
typedef ptrdiff_t difference_type;
|
||||
|
||||
// ParamIterator assumes ownership of the impl_ pointer.
|
||||
ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {}
|
||||
ParamIterator& operator=(const ParamIterator& other) {
|
||||
if (this != &other)
|
||||
impl_.reset(other.impl_->Clone());
|
||||
return *this;
|
||||
}
|
||||
|
||||
const T& operator*() const { return *impl_->Current(); }
|
||||
const T* operator->() const { return impl_->Current(); }
|
||||
// Prefix version of operator++.
|
||||
ParamIterator& operator++() {
|
||||
impl_->Advance();
|
||||
return *this;
|
||||
}
|
||||
// Postfix version of operator++.
|
||||
ParamIterator operator++(int /*unused*/) {
|
||||
ParamIteratorInterface<T>* clone = impl_->Clone();
|
||||
impl_->Advance();
|
||||
return ParamIterator(clone);
|
||||
}
|
||||
bool operator==(const ParamIterator& other) const {
|
||||
return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_);
|
||||
}
|
||||
bool operator!=(const ParamIterator& other) const {
|
||||
return !(*this == other);
|
||||
}
|
||||
|
||||
private:
|
||||
friend class ParamGenerator<T>;
|
||||
explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {}
|
||||
scoped_ptr<ParamIteratorInterface<T> > impl_;
|
||||
};
|
||||
|
||||
// ParamGeneratorInterface<T> is the binary interface to access generators
|
||||
// defined in other translation units.
|
||||
template <typename T>
|
||||
class ParamGeneratorInterface {
|
||||
public:
|
||||
typedef T ParamType;
|
||||
|
||||
virtual ~ParamGeneratorInterface() {}
|
||||
|
||||
// Generator interface definition
|
||||
virtual ParamIteratorInterface<T>* Begin() const = 0;
|
||||
virtual ParamIteratorInterface<T>* End() const = 0;
|
||||
};
|
||||
|
||||
// Wraps ParamGeneratorInterface<T> and provides general generator syntax
|
||||
// compatible with the STL Container concept.
|
||||
// This class implements copy initialization semantics and the contained
|
||||
// ParamGeneratorInterface<T> instance is shared among all copies
|
||||
// of the original object. This is possible because that instance is immutable.
|
||||
template<typename T>
|
||||
class ParamGenerator {
|
||||
public:
|
||||
typedef ParamIterator<T> iterator;
|
||||
|
||||
explicit ParamGenerator(ParamGeneratorInterface<T>* impl) : impl_(impl) {}
|
||||
ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {}
|
||||
|
||||
ParamGenerator& operator=(const ParamGenerator& other) {
|
||||
impl_ = other.impl_;
|
||||
return *this;
|
||||
}
|
||||
|
||||
iterator begin() const { return iterator(impl_->Begin()); }
|
||||
iterator end() const { return iterator(impl_->End()); }
|
||||
|
||||
private:
|
||||
linked_ptr<const ParamGeneratorInterface<T> > impl_;
|
||||
};
|
||||
|
||||
// Generates values from a range of two comparable values. Can be used to
|
||||
// generate sequences of user-defined types that implement operator+() and
|
||||
// operator<().
|
||||
// This class is used in the Range() function.
|
||||
template <typename T, typename IncrementT>
|
||||
class RangeGenerator : public ParamGeneratorInterface<T> {
|
||||
public:
|
||||
RangeGenerator(T begin, T end, IncrementT step)
|
||||
: begin_(begin), end_(end),
|
||||
step_(step), end_index_(CalculateEndIndex(begin, end, step)) {}
|
||||
virtual ~RangeGenerator() {}
|
||||
|
||||
virtual ParamIteratorInterface<T>* Begin() const {
|
||||
return new Iterator(this, begin_, 0, step_);
|
||||
}
|
||||
virtual ParamIteratorInterface<T>* End() const {
|
||||
return new Iterator(this, end_, end_index_, step_);
|
||||
}
|
||||
|
||||
private:
|
||||
class Iterator : public ParamIteratorInterface<T> {
|
||||
public:
|
||||
Iterator(const ParamGeneratorInterface<T>* base, T value, int index,
|
||||
IncrementT step)
|
||||
: base_(base), value_(value), index_(index), step_(step) {}
|
||||
virtual ~Iterator() {}
|
||||
|
||||
virtual const ParamGeneratorInterface<T>* BaseGenerator() const {
|
||||
return base_;
|
||||
}
|
||||
virtual void Advance() {
|
||||
value_ = value_ + step_;
|
||||
index_++;
|
||||
}
|
||||
virtual ParamIteratorInterface<T>* Clone() const {
|
||||
return new Iterator(*this);
|
||||
}
|
||||
virtual const T* Current() const { return &value_; }
|
||||
virtual bool Equals(const ParamIteratorInterface<T>& other) const {
|
||||
// Having the same base generator guarantees that the other
|
||||
// iterator is of the same type and we can downcast.
|
||||
GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
|
||||
<< "The program attempted to compare iterators "
|
||||
<< "from different generators." << std::endl;
|
||||
const int other_index =
|
||||
CheckedDowncastToActualType<const Iterator>(&other)->index_;
|
||||
return index_ == other_index;
|
||||
}
|
||||
|
||||
private:
|
||||
Iterator(const Iterator& other)
|
||||
: ParamIteratorInterface<T>(),
|
||||
base_(other.base_), value_(other.value_), index_(other.index_),
|
||||
step_(other.step_) {}
|
||||
|
||||
// No implementation - assignment is unsupported.
|
||||
void operator=(const Iterator& other);
|
||||
|
||||
const ParamGeneratorInterface<T>* const base_;
|
||||
T value_;
|
||||
int index_;
|
||||
const IncrementT step_;
|
||||
}; // class RangeGenerator::Iterator
|
||||
|
||||
static int CalculateEndIndex(const T& begin,
|
||||
const T& end,
|
||||
const IncrementT& step) {
|
||||
int end_index = 0;
|
||||
for (T i = begin; i < end; i = i + step)
|
||||
end_index++;
|
||||
return end_index;
|
||||
}
|
||||
|
||||
// No implementation - assignment is unsupported.
|
||||
void operator=(const RangeGenerator& other);
|
||||
|
||||
const T begin_;
|
||||
const T end_;
|
||||
const IncrementT step_;
|
||||
// The index for the end() iterator. All the elements in the generated
|
||||
// sequence are indexed (0-based) to aid iterator comparison.
|
||||
const int end_index_;
|
||||
}; // class RangeGenerator
|
||||
|
||||
|
||||
// Generates values from a pair of STL-style iterators. Used in the
|
||||
// ValuesIn() function. The elements are copied from the source range
|
||||
// since the source can be located on the stack, and the generator
|
||||
// is likely to persist beyond that stack frame.
|
||||
template <typename T>
|
||||
class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
|
||||
public:
|
||||
template <typename ForwardIterator>
|
||||
ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end)
|
||||
: container_(begin, end) {}
|
||||
virtual ~ValuesInIteratorRangeGenerator() {}
|
||||
|
||||
virtual ParamIteratorInterface<T>* Begin() const {
|
||||
return new Iterator(this, container_.begin());
|
||||
}
|
||||
virtual ParamIteratorInterface<T>* End() const {
|
||||
return new Iterator(this, container_.end());
|
||||
}
|
||||
|
||||
private:
|
||||
typedef typename ::std::vector<T> ContainerType;
|
||||
|
||||
class Iterator : public ParamIteratorInterface<T> {
|
||||
public:
|
||||
Iterator(const ParamGeneratorInterface<T>* base,
|
||||
typename ContainerType::const_iterator iterator)
|
||||
: base_(base), iterator_(iterator) {}
|
||||
virtual ~Iterator() {}
|
||||
|
||||
virtual const ParamGeneratorInterface<T>* BaseGenerator() const {
|
||||
return base_;
|
||||
}
|
||||
virtual void Advance() {
|
||||
++iterator_;
|
||||
value_.reset();
|
||||
}
|
||||
virtual ParamIteratorInterface<T>* Clone() const {
|
||||
return new Iterator(*this);
|
||||
}
|
||||
// We need to use cached value referenced by iterator_ because *iterator_
|
||||
// can return a temporary object (and of type other then T), so just
|
||||
// having "return &*iterator_;" doesn't work.
|
||||
// value_ is updated here and not in Advance() because Advance()
|
||||
// can advance iterator_ beyond the end of the range, and we cannot
|
||||
// detect that fact. The client code, on the other hand, is
|
||||
// responsible for not calling Current() on an out-of-range iterator.
|
||||
virtual const T* Current() const {
|
||||
if (value_.get() == NULL)
|
||||
value_.reset(new T(*iterator_));
|
||||
return value_.get();
|
||||
}
|
||||
virtual bool Equals(const ParamIteratorInterface<T>& other) const {
|
||||
// Having the same base generator guarantees that the other
|
||||
// iterator is of the same type and we can downcast.
|
||||
GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
|
||||
<< "The program attempted to compare iterators "
|
||||
<< "from different generators." << std::endl;
|
||||
return iterator_ ==
|
||||
CheckedDowncastToActualType<const Iterator>(&other)->iterator_;
|
||||
}
|
||||
|
||||
private:
|
||||
Iterator(const Iterator& other)
|
||||
// The explicit constructor call suppresses a false warning
|
||||
// emitted by gcc when supplied with the -Wextra option.
|
||||
: ParamIteratorInterface<T>(),
|
||||
base_(other.base_),
|
||||
iterator_(other.iterator_) {}
|
||||
|
||||
const ParamGeneratorInterface<T>* const base_;
|
||||
typename ContainerType::const_iterator iterator_;
|
||||
// A cached value of *iterator_. We keep it here to allow access by
|
||||
// pointer in the wrapping iterator's operator->().
|
||||
// value_ needs to be mutable to be accessed in Current().
|
||||
// Use of scoped_ptr helps manage cached value's lifetime,
|
||||
// which is bound by the lifespan of the iterator itself.
|
||||
mutable scoped_ptr<const T> value_;
|
||||
}; // class ValuesInIteratorRangeGenerator::Iterator
|
||||
|
||||
// No implementation - assignment is unsupported.
|
||||
void operator=(const ValuesInIteratorRangeGenerator& other);
|
||||
|
||||
const ContainerType container_;
|
||||
}; // class ValuesInIteratorRangeGenerator
|
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// Stores a parameter value and later creates tests parameterized with that
|
||||
// value.
|
||||
template <class TestClass>
|
||||
class ParameterizedTestFactory : public TestFactoryBase {
|
||||
public:
|
||||
typedef typename TestClass::ParamType ParamType;
|
||||
explicit ParameterizedTestFactory(ParamType parameter) :
|
||||
parameter_(parameter) {}
|
||||
virtual Test* CreateTest() {
|
||||
TestClass::SetParam(¶meter_);
|
||||
return new TestClass();
|
||||
}
|
||||
|
||||
private:
|
||||
const ParamType parameter_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory);
|
||||
};
|
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// TestMetaFactoryBase is a base class for meta-factories that create
|
||||
// test factories for passing into MakeAndRegisterTestInfo function.
|
||||
template <class ParamType>
|
||||
class TestMetaFactoryBase {
|
||||
public:
|
||||
virtual ~TestMetaFactoryBase() {}
|
||||
|
||||
virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0;
|
||||
};
|
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// TestMetaFactory creates test factories for passing into
|
||||
// MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives
|
||||
// ownership of test factory pointer, same factory object cannot be passed
|
||||
// into that method twice. But ParameterizedTestCaseInfo is going to call
|
||||
// it for each Test/Parameter value combination. Thus it needs meta factory
|
||||
// creator class.
|
||||
template <class TestCase>
|
||||
class TestMetaFactory
|
||||
: public TestMetaFactoryBase<typename TestCase::ParamType> {
|
||||
public:
|
||||
typedef typename TestCase::ParamType ParamType;
|
||||
|
||||
TestMetaFactory() {}
|
||||
|
||||
virtual TestFactoryBase* CreateTestFactory(ParamType parameter) {
|
||||
return new ParameterizedTestFactory<TestCase>(parameter);
|
||||
}
|
||||
|
||||
private:
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory);
|
||||
};
|
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// ParameterizedTestCaseInfoBase is a generic interface
|
||||
// to ParameterizedTestCaseInfo classes. ParameterizedTestCaseInfoBase
|
||||
// accumulates test information provided by TEST_P macro invocations
|
||||
// and generators provided by INSTANTIATE_TEST_CASE_P macro invocations
|
||||
// and uses that information to register all resulting test instances
|
||||
// in RegisterTests method. The ParameterizeTestCaseRegistry class holds
|
||||
// a collection of pointers to the ParameterizedTestCaseInfo objects
|
||||
// and calls RegisterTests() on each of them when asked.
|
||||
class ParameterizedTestCaseInfoBase {
|
||||
public:
|
||||
virtual ~ParameterizedTestCaseInfoBase() {}
|
||||
|
||||
// Base part of test case name for display purposes.
|
||||
virtual const string& GetTestCaseName() const = 0;
|
||||
// Test case id to verify identity.
|
||||
virtual TypeId GetTestCaseTypeId() const = 0;
|
||||
// UnitTest class invokes this method to register tests in this
|
||||
// test case right before running them in RUN_ALL_TESTS macro.
|
||||
// This method should not be called more then once on any single
|
||||
// instance of a ParameterizedTestCaseInfoBase derived class.
|
||||
virtual void RegisterTests() = 0;
|
||||
|
||||
protected:
|
||||
ParameterizedTestCaseInfoBase() {}
|
||||
|
||||
private:
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfoBase);
|
||||
};
|
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// ParameterizedTestCaseInfo accumulates tests obtained from TEST_P
|
||||
// macro invocations for a particular test case and generators
|
||||
// obtained from INSTANTIATE_TEST_CASE_P macro invocations for that
|
||||
// test case. It registers tests with all values generated by all
|
||||
// generators when asked.
|
||||
template <class TestCase>
|
||||
class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase {
|
||||
public:
|
||||
// ParamType and GeneratorCreationFunc are private types but are required
|
||||
// for declarations of public methods AddTestPattern() and
|
||||
// AddTestCaseInstantiation().
|
||||
typedef typename TestCase::ParamType ParamType;
|
||||
// A function that returns an instance of appropriate generator type.
|
||||
typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
|
||||
|
||||
explicit ParameterizedTestCaseInfo(const char* name)
|
||||
: test_case_name_(name) {}
|
||||
|
||||
// Test case base name for display purposes.
|
||||
virtual const string& GetTestCaseName() const { return test_case_name_; }
|
||||
// Test case id to verify identity.
|
||||
virtual TypeId GetTestCaseTypeId() const { return GetTypeId<TestCase>(); }
|
||||
// TEST_P macro uses AddTestPattern() to record information
|
||||
// about a single test in a LocalTestInfo structure.
|
||||
// test_case_name is the base name of the test case (without invocation
|
||||
// prefix). test_base_name is the name of an individual test without
|
||||
// parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is
|
||||
// test case base name and DoBar is test base name.
|
||||
void AddTestPattern(const char* test_case_name,
|
||||
const char* test_base_name,
|
||||
TestMetaFactoryBase<ParamType>* meta_factory) {
|
||||
tests_.push_back(linked_ptr<TestInfo>(new TestInfo(test_case_name,
|
||||
test_base_name,
|
||||
meta_factory)));
|
||||
}
|
||||
// INSTANTIATE_TEST_CASE_P macro uses AddGenerator() to record information
|
||||
// about a generator.
|
||||
int AddTestCaseInstantiation(const string& instantiation_name,
|
||||
GeneratorCreationFunc* func,
|
||||
const char* /* file */,
|
||||
int /* line */) {
|
||||
instantiations_.push_back(::std::make_pair(instantiation_name, func));
|
||||
return 0; // Return value used only to run this method in namespace scope.
|
||||
}
|
||||
// UnitTest class invokes this method to register tests in this test case
|
||||
// test cases right before running tests in RUN_ALL_TESTS macro.
|
||||
// This method should not be called more then once on any single
|
||||
// instance of a ParameterizedTestCaseInfoBase derived class.
|
||||
// UnitTest has a guard to prevent from calling this method more then once.
|
||||
virtual void RegisterTests() {
|
||||
for (typename TestInfoContainer::iterator test_it = tests_.begin();
|
||||
test_it != tests_.end(); ++test_it) {
|
||||
linked_ptr<TestInfo> test_info = *test_it;
|
||||
for (typename InstantiationContainer::iterator gen_it =
|
||||
instantiations_.begin(); gen_it != instantiations_.end();
|
||||
++gen_it) {
|
||||
const string& instantiation_name = gen_it->first;
|
||||
ParamGenerator<ParamType> generator((*gen_it->second)());
|
||||
|
||||
Message test_case_name_stream;
|
||||
if ( !instantiation_name.empty() )
|
||||
test_case_name_stream << instantiation_name << "/";
|
||||
test_case_name_stream << test_info->test_case_base_name;
|
||||
|
||||
int i = 0;
|
||||
for (typename ParamGenerator<ParamType>::iterator param_it =
|
||||
generator.begin();
|
||||
param_it != generator.end(); ++param_it, ++i) {
|
||||
Message test_name_stream;
|
||||
test_name_stream << test_info->test_base_name << "/" << i;
|
||||
MakeAndRegisterTestInfo(
|
||||
test_case_name_stream.GetString().c_str(),
|
||||
test_name_stream.GetString().c_str(),
|
||||
NULL, // No type parameter.
|
||||
PrintToString(*param_it).c_str(),
|
||||
GetTestCaseTypeId(),
|
||||
TestCase::SetUpTestCase,
|
||||
TestCase::TearDownTestCase,
|
||||
test_info->test_meta_factory->CreateTestFactory(*param_it));
|
||||
} // for param_it
|
||||
} // for gen_it
|
||||
} // for test_it
|
||||
} // RegisterTests
|
||||
|
||||
private:
|
||||
// LocalTestInfo structure keeps information about a single test registered
|
||||
// with TEST_P macro.
|
||||
struct TestInfo {
|
||||
TestInfo(const char* a_test_case_base_name,
|
||||
const char* a_test_base_name,
|
||||
TestMetaFactoryBase<ParamType>* a_test_meta_factory) :
|
||||
test_case_base_name(a_test_case_base_name),
|
||||
test_base_name(a_test_base_name),
|
||||
test_meta_factory(a_test_meta_factory) {}
|
||||
|
||||
const string test_case_base_name;
|
||||
const string test_base_name;
|
||||
const scoped_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory;
|
||||
};
|
||||
typedef ::std::vector<linked_ptr<TestInfo> > TestInfoContainer;
|
||||
// Keeps pairs of <Instantiation name, Sequence generator creation function>
|
||||
// received from INSTANTIATE_TEST_CASE_P macros.
|
||||
typedef ::std::vector<std::pair<string, GeneratorCreationFunc*> >
|
||||
InstantiationContainer;
|
||||
|
||||
const string test_case_name_;
|
||||
TestInfoContainer tests_;
|
||||
InstantiationContainer instantiations_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfo);
|
||||
}; // class ParameterizedTestCaseInfo
|
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// ParameterizedTestCaseRegistry contains a map of ParameterizedTestCaseInfoBase
|
||||
// classes accessed by test case names. TEST_P and INSTANTIATE_TEST_CASE_P
|
||||
// macros use it to locate their corresponding ParameterizedTestCaseInfo
|
||||
// descriptors.
|
||||
class ParameterizedTestCaseRegistry {
|
||||
public:
|
||||
ParameterizedTestCaseRegistry() {}
|
||||
~ParameterizedTestCaseRegistry() {
|
||||
for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
|
||||
it != test_case_infos_.end(); ++it) {
|
||||
delete *it;
|
||||
}
|
||||
}
|
||||
|
||||
// Looks up or creates and returns a structure containing information about
|
||||
// tests and instantiations of a particular test case.
|
||||
template <class TestCase>
|
||||
ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
|
||||
const char* test_case_name,
|
||||
const char* file,
|
||||
int line) {
|
||||
ParameterizedTestCaseInfo<TestCase>* typed_test_info = NULL;
|
||||
for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
|
||||
it != test_case_infos_.end(); ++it) {
|
||||
if ((*it)->GetTestCaseName() == test_case_name) {
|
||||
if ((*it)->GetTestCaseTypeId() != GetTypeId<TestCase>()) {
|
||||
// Complain about incorrect usage of Google Test facilities
|
||||
// and terminate the program since we cannot guaranty correct
|
||||
// test case setup and tear-down in this case.
|
||||
ReportInvalidTestCaseType(test_case_name, file, line);
|
||||
posix::Abort();
|
||||
} else {
|
||||
// At this point we are sure that the object we found is of the same
|
||||
// type we are looking for, so we downcast it to that type
|
||||
// without further checks.
|
||||
typed_test_info = CheckedDowncastToActualType<
|
||||
ParameterizedTestCaseInfo<TestCase> >(*it);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (typed_test_info == NULL) {
|
||||
typed_test_info = new ParameterizedTestCaseInfo<TestCase>(test_case_name);
|
||||
test_case_infos_.push_back(typed_test_info);
|
||||
}
|
||||
return typed_test_info;
|
||||
}
|
||||
void RegisterTests() {
|
||||
for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
|
||||
it != test_case_infos_.end(); ++it) {
|
||||
(*it)->RegisterTests();
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
typedef ::std::vector<ParameterizedTestCaseInfoBase*> TestCaseInfoContainer;
|
||||
|
||||
TestCaseInfoContainer test_case_infos_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseRegistry);
|
||||
};
|
||||
|
||||
} // namespace internal
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_HAS_PARAM_TEST
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
|
1775
gtest/include/gtest/internal/gtest-port.h
Normal file
1775
gtest/include/gtest/internal/gtest-port.h
Normal file
File diff suppressed because it is too large
Load Diff
350
gtest/include/gtest/internal/gtest-string.h
Normal file
350
gtest/include/gtest/internal/gtest-string.h
Normal file
@ -0,0 +1,350 @@
|
||||
// Copyright 2005, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
|
||||
//
|
||||
// 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>.
|
||||
// It should not be #included by other files.
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
|
||||
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
// string.h is not guaranteed to provide strcpy on C++ Builder.
|
||||
# include <mem.h>
|
||||
#endif
|
||||
|
||||
#include <string.h>
|
||||
#include "gtest/internal/gtest-port.h"
|
||||
|
||||
#include <string>
|
||||
|
||||
namespace testing {
|
||||
namespace internal {
|
||||
|
||||
// String - a UTF-8 string class.
|
||||
//
|
||||
// For historic reasons, we don't use std::string.
|
||||
//
|
||||
// TODO(wan@google.com): replace this class with std::string or
|
||||
// implement it in terms of the latter.
|
||||
//
|
||||
// Note that String can represent both NULL and the empty string,
|
||||
// while std::string cannot represent NULL.
|
||||
//
|
||||
// NULL and the empty string are considered different. NULL is less
|
||||
// than anything (including the empty string) except itself.
|
||||
//
|
||||
// This class only provides minimum functionality necessary for
|
||||
// implementing Google Test. We do not intend to implement a full-fledged
|
||||
// string class here.
|
||||
//
|
||||
// Since the purpose of this class is to provide a substitute for
|
||||
// std::string on platforms where it cannot be used, we define a copy
|
||||
// constructor and assignment operators such that we don't need
|
||||
// conditional compilation in a lot of places.
|
||||
//
|
||||
// In order to make the representation efficient, the d'tor of String
|
||||
// is not virtual. Therefore DO NOT INHERIT FROM String.
|
||||
class GTEST_API_ String {
|
||||
public:
|
||||
// Static utility methods
|
||||
|
||||
// Returns the input enclosed in double quotes if it's not NULL;
|
||||
// otherwise returns "(null)". For example, "\"Hello\"" is returned
|
||||
// for input "Hello".
|
||||
//
|
||||
// This is useful for printing a C string in the syntax of a literal.
|
||||
//
|
||||
// Known issue: escape sequences are not handled yet.
|
||||
static String ShowCStringQuoted(const char* c_str);
|
||||
|
||||
// Clones a 0-terminated C string, allocating memory using new. The
|
||||
// caller is responsible for deleting the return value using
|
||||
// delete[]. Returns the cloned string, or NULL if the input is
|
||||
// NULL.
|
||||
//
|
||||
// This is different from strdup() in string.h, which allocates
|
||||
// memory using malloc().
|
||||
static const char* CloneCString(const char* c_str);
|
||||
|
||||
#if GTEST_OS_WINDOWS_MOBILE
|
||||
// Windows CE does not have the 'ANSI' versions of Win32 APIs. To be
|
||||
// able to pass strings to Win32 APIs on CE we need to convert them
|
||||
// to 'Unicode', UTF-16.
|
||||
|
||||
// Creates a UTF-16 wide string from the given ANSI string, allocating
|
||||
// memory using new. The caller is responsible for deleting the return
|
||||
// value using delete[]. Returns the wide string, or NULL if the
|
||||
// input is NULL.
|
||||
//
|
||||
// The wide string is created using the ANSI codepage (CP_ACP) to
|
||||
// match the behaviour of the ANSI versions of Win32 calls and the
|
||||
// C runtime.
|
||||
static LPCWSTR AnsiToUtf16(const char* c_str);
|
||||
|
||||
// Creates an ANSI string from the given wide string, allocating
|
||||
// memory using new. The caller is responsible for deleting the return
|
||||
// value using delete[]. Returns the ANSI string, or NULL if the
|
||||
// input is NULL.
|
||||
//
|
||||
// The returned string is created using the ANSI codepage (CP_ACP) to
|
||||
// match the behaviour of the ANSI versions of Win32 calls and the
|
||||
// C runtime.
|
||||
static const char* Utf16ToAnsi(LPCWSTR utf16_str);
|
||||
#endif
|
||||
|
||||
// Compares two C strings. Returns true iff they have the same content.
|
||||
//
|
||||
// Unlike strcmp(), this function can handle NULL argument(s). A
|
||||
// NULL C string is considered different to any non-NULL C string,
|
||||
// including the empty string.
|
||||
static bool CStringEquals(const char* lhs, const char* rhs);
|
||||
|
||||
// Converts a wide C string to a String using the UTF-8 encoding.
|
||||
// NULL will be converted to "(null)". If an error occurred during
|
||||
// the conversion, "(failed to convert from wide string)" is
|
||||
// returned.
|
||||
static String ShowWideCString(const wchar_t* wide_c_str);
|
||||
|
||||
// Similar to ShowWideCString(), except that this function encloses
|
||||
// the converted string in double quotes.
|
||||
static String ShowWideCStringQuoted(const wchar_t* wide_c_str);
|
||||
|
||||
// Compares two wide C strings. Returns true iff they have the same
|
||||
// content.
|
||||
//
|
||||
// Unlike wcscmp(), this function can handle NULL argument(s). A
|
||||
// NULL C string is considered different to any non-NULL C string,
|
||||
// including the empty string.
|
||||
static bool WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs);
|
||||
|
||||
// Compares two C strings, ignoring case. Returns true iff they
|
||||
// have the same content.
|
||||
//
|
||||
// Unlike strcasecmp(), this function can handle NULL argument(s).
|
||||
// A NULL C string is considered different to any non-NULL C string,
|
||||
// including the empty string.
|
||||
static bool CaseInsensitiveCStringEquals(const char* lhs,
|
||||
const char* rhs);
|
||||
|
||||
// Compares two wide C strings, ignoring case. Returns true iff they
|
||||
// have the same content.
|
||||
//
|
||||
// Unlike wcscasecmp(), this function can handle NULL argument(s).
|
||||
// A NULL C string is considered different to any non-NULL wide C string,
|
||||
// including the empty string.
|
||||
// NB: The implementations on different platforms slightly differ.
|
||||
// On windows, this method uses _wcsicmp which compares according to LC_CTYPE
|
||||
// environment variable. On GNU platform this method uses wcscasecmp
|
||||
// which compares according to LC_CTYPE category of the current locale.
|
||||
// On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
|
||||
// current locale.
|
||||
static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
|
||||
const wchar_t* rhs);
|
||||
|
||||
// Formats a list of arguments to a String, using the same format
|
||||
// spec string as for printf.
|
||||
//
|
||||
// We do not use the StringPrintf class as it is not universally
|
||||
// available.
|
||||
//
|
||||
// The result is limited to 4096 characters (including the tailing
|
||||
// 0). If 4096 characters are not enough to format the input,
|
||||
// "<buffer exceeded>" is returned.
|
||||
static String Format(const char* format, ...);
|
||||
|
||||
// C'tors
|
||||
|
||||
// The default c'tor constructs a NULL string.
|
||||
String() : c_str_(NULL), length_(0) {}
|
||||
|
||||
// Constructs a String by cloning a 0-terminated C string.
|
||||
String(const char* a_c_str) { // NOLINT
|
||||
if (a_c_str == NULL) {
|
||||
c_str_ = NULL;
|
||||
length_ = 0;
|
||||
} else {
|
||||
ConstructNonNull(a_c_str, strlen(a_c_str));
|
||||
}
|
||||
}
|
||||
|
||||
// Constructs a String by copying a given number of chars from a
|
||||
// buffer. E.g. String("hello", 3) creates the string "hel",
|
||||
// String("a\0bcd", 4) creates "a\0bc", String(NULL, 0) creates "",
|
||||
// and String(NULL, 1) results in access violation.
|
||||
String(const char* buffer, size_t a_length) {
|
||||
ConstructNonNull(buffer, a_length);
|
||||
}
|
||||
|
||||
// The copy c'tor creates a new copy of the string. The two
|
||||
// String objects do not share content.
|
||||
String(const String& str) : c_str_(NULL), length_(0) { *this = str; }
|
||||
|
||||
// D'tor. String is intended to be a final class, so the d'tor
|
||||
// doesn't need to be virtual.
|
||||
~String() { delete[] c_str_; }
|
||||
|
||||
// Allows a String to be implicitly converted to an ::std::string or
|
||||
// ::string, and vice versa. Converting a String containing a NULL
|
||||
// pointer to ::std::string or ::string is undefined behavior.
|
||||
// Converting a ::std::string or ::string containing an embedded NUL
|
||||
// character to a String will result in the prefix up to the first
|
||||
// NUL character.
|
||||
String(const ::std::string& str) {
|
||||
ConstructNonNull(str.c_str(), str.length());
|
||||
}
|
||||
|
||||
operator ::std::string() const { return ::std::string(c_str(), length()); }
|
||||
|
||||
#if GTEST_HAS_GLOBAL_STRING
|
||||
String(const ::string& str) {
|
||||
ConstructNonNull(str.c_str(), str.length());
|
||||
}
|
||||
|
||||
operator ::string() const { return ::string(c_str(), length()); }
|
||||
#endif // GTEST_HAS_GLOBAL_STRING
|
||||
|
||||
// Returns true iff this is an empty string (i.e. "").
|
||||
bool empty() const { return (c_str() != NULL) && (length() == 0); }
|
||||
|
||||
// Compares this with another String.
|
||||
// Returns < 0 if this is less than rhs, 0 if this is equal to rhs, or > 0
|
||||
// if this is greater than rhs.
|
||||
int Compare(const String& rhs) const;
|
||||
|
||||
// Returns true iff this String equals the given C string. A NULL
|
||||
// string and a non-NULL string are considered not equal.
|
||||
bool operator==(const char* a_c_str) const { return Compare(a_c_str) == 0; }
|
||||
|
||||
// Returns true iff this String is less than the given String. A
|
||||
// NULL string is considered less than "".
|
||||
bool operator<(const String& rhs) const { return Compare(rhs) < 0; }
|
||||
|
||||
// Returns true iff this String doesn't equal the given C string. A NULL
|
||||
// string and a non-NULL string are considered not equal.
|
||||
bool operator!=(const char* a_c_str) const { return !(*this == a_c_str); }
|
||||
|
||||
// Returns true iff this String ends with the given suffix. *Any*
|
||||
// String is considered to end with a NULL or empty suffix.
|
||||
bool EndsWith(const char* suffix) const;
|
||||
|
||||
// Returns true iff this String ends with the given suffix, not considering
|
||||
// case. Any String is considered to end with a NULL or empty suffix.
|
||||
bool EndsWithCaseInsensitive(const char* suffix) const;
|
||||
|
||||
// Returns the length of the encapsulated string, or 0 if the
|
||||
// string is NULL.
|
||||
size_t length() const { return length_; }
|
||||
|
||||
// Gets the 0-terminated C string this String object represents.
|
||||
// The String object still owns the string. Therefore the caller
|
||||
// should NOT delete the return value.
|
||||
const char* c_str() const { return c_str_; }
|
||||
|
||||
// Assigns a C string to this object. Self-assignment works.
|
||||
const String& operator=(const char* a_c_str) {
|
||||
return *this = String(a_c_str);
|
||||
}
|
||||
|
||||
// Assigns a String object to this object. Self-assignment works.
|
||||
const String& operator=(const String& rhs) {
|
||||
if (this != &rhs) {
|
||||
delete[] c_str_;
|
||||
if (rhs.c_str() == NULL) {
|
||||
c_str_ = NULL;
|
||||
length_ = 0;
|
||||
} else {
|
||||
ConstructNonNull(rhs.c_str(), rhs.length());
|
||||
}
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
private:
|
||||
// Constructs a non-NULL String from the given content. This
|
||||
// function can only be called when c_str_ has not been allocated.
|
||||
// ConstructNonNull(NULL, 0) results in an empty string ("").
|
||||
// ConstructNonNull(NULL, non_zero) is undefined behavior.
|
||||
void ConstructNonNull(const char* buffer, size_t a_length) {
|
||||
char* const str = new char[a_length + 1];
|
||||
memcpy(str, buffer, a_length);
|
||||
str[a_length] = '\0';
|
||||
c_str_ = str;
|
||||
length_ = a_length;
|
||||
}
|
||||
|
||||
const char* c_str_;
|
||||
size_t length_;
|
||||
}; // class String
|
||||
|
||||
// Streams a String to an ostream. Each '\0' character in the String
|
||||
// is replaced with "\\0".
|
||||
inline ::std::ostream& operator<<(::std::ostream& os, const String& str) {
|
||||
if (str.c_str() == NULL) {
|
||||
os << "(null)";
|
||||
} else {
|
||||
const char* const c_str = str.c_str();
|
||||
for (size_t i = 0; i != str.length(); i++) {
|
||||
if (c_str[i] == '\0') {
|
||||
os << "\\0";
|
||||
} else {
|
||||
os << c_str[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
return os;
|
||||
}
|
||||
|
||||
// Gets the content of the stringstream's buffer as a String. Each '\0'
|
||||
// character in the buffer is replaced with "\\0".
|
||||
GTEST_API_ String StringStreamToString(::std::stringstream* stream);
|
||||
|
||||
// Converts a streamable value to a String. A NULL pointer is
|
||||
// converted to "(null)". When the input value is a ::string,
|
||||
// ::std::string, ::wstring, or ::std::wstring object, each NUL
|
||||
// character in it is replaced with "\\0".
|
||||
|
||||
// Declared here but defined in gtest.h, so that it has access
|
||||
// to the definition of the Message class, required by the ARM
|
||||
// compiler.
|
||||
template <typename T>
|
||||
String StreamableToString(const T& streamable);
|
||||
|
||||
} // namespace internal
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
|
968
gtest/include/gtest/internal/gtest-tuple.h
Normal file
968
gtest/include/gtest/internal/gtest-tuple.h
Normal file
@ -0,0 +1,968 @@
|
||||
// This file was GENERATED by a script. DO NOT EDIT BY HAND!!!
|
||||
|
||||
// Copyright 2009 Google Inc.
|
||||
// All Rights Reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
// Implements a subset of TR1 tuple needed by Google Test and Google Mock.
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
|
||||
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
|
||||
|
||||
#include <utility> // For ::std::pair.
|
||||
|
||||
// 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
|
||||
// private as public.
|
||||
// Sun Studio versions < 12 also have the above bug.
|
||||
#if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590)
|
||||
# define GTEST_DECLARE_TUPLE_AS_FRIEND_ public:
|
||||
#else
|
||||
# define GTEST_DECLARE_TUPLE_AS_FRIEND_ \
|
||||
template <GTEST_10_TYPENAMES_(U)> friend class tuple; \
|
||||
private:
|
||||
#endif
|
||||
|
||||
// GTEST_n_TUPLE_(T) is the type of an n-tuple.
|
||||
#define GTEST_0_TUPLE_(T) tuple<>
|
||||
#define GTEST_1_TUPLE_(T) tuple<T##0, void, void, void, void, void, void, \
|
||||
void, void, void>
|
||||
#define GTEST_2_TUPLE_(T) tuple<T##0, T##1, void, void, void, void, void, \
|
||||
void, void, void>
|
||||
#define GTEST_3_TUPLE_(T) tuple<T##0, T##1, T##2, void, void, void, void, \
|
||||
void, void, void>
|
||||
#define GTEST_4_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, void, void, void, \
|
||||
void, void, void>
|
||||
#define GTEST_5_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, void, void, \
|
||||
void, void, void>
|
||||
#define GTEST_6_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, void, \
|
||||
void, void, void>
|
||||
#define GTEST_7_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
|
||||
void, void, void>
|
||||
#define GTEST_8_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
|
||||
T##7, void, void>
|
||||
#define GTEST_9_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
|
||||
T##7, T##8, void>
|
||||
#define GTEST_10_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
|
||||
T##7, T##8, T##9>
|
||||
|
||||
// GTEST_n_TYPENAMES_(T) declares a list of n typenames.
|
||||
#define GTEST_0_TYPENAMES_(T)
|
||||
#define GTEST_1_TYPENAMES_(T) typename T##0
|
||||
#define GTEST_2_TYPENAMES_(T) typename T##0, typename T##1
|
||||
#define GTEST_3_TYPENAMES_(T) typename T##0, typename T##1, typename T##2
|
||||
#define GTEST_4_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
|
||||
typename T##3
|
||||
#define GTEST_5_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
|
||||
typename T##3, typename T##4
|
||||
#define GTEST_6_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
|
||||
typename T##3, typename T##4, typename T##5
|
||||
#define GTEST_7_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
|
||||
typename T##3, typename T##4, typename T##5, typename T##6
|
||||
#define GTEST_8_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
|
||||
typename T##3, typename T##4, typename T##5, typename T##6, typename T##7
|
||||
#define GTEST_9_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
|
||||
typename T##3, typename T##4, typename T##5, typename T##6, \
|
||||
typename T##7, typename T##8
|
||||
#define GTEST_10_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
|
||||
typename T##3, typename T##4, typename T##5, typename T##6, \
|
||||
typename T##7, typename T##8, typename T##9
|
||||
|
||||
// In theory, defining stuff in the ::std namespace is undefined
|
||||
// behavior. We can do this as we are playing the role of a standard
|
||||
// library vendor.
|
||||
namespace std {
|
||||
namespace tr1 {
|
||||
|
||||
template <typename T0 = void, typename T1 = void, typename T2 = void,
|
||||
typename T3 = void, typename T4 = void, typename T5 = void,
|
||||
typename T6 = void, typename T7 = void, typename T8 = void,
|
||||
typename T9 = void>
|
||||
class tuple;
|
||||
|
||||
// Anything in namespace gtest_internal is Google Test's INTERNAL
|
||||
// IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code.
|
||||
namespace gtest_internal {
|
||||
|
||||
// ByRef<T>::type is T if T is a reference; otherwise it's const T&.
|
||||
template <typename T>
|
||||
struct ByRef { typedef const T& type; }; // NOLINT
|
||||
template <typename T>
|
||||
struct ByRef<T&> { typedef T& type; }; // NOLINT
|
||||
|
||||
// A handy wrapper for ByRef.
|
||||
#define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type
|
||||
|
||||
// AddRef<T>::type is T if T is a reference; otherwise it's T&. This
|
||||
// is the same as tr1::add_reference<T>::type.
|
||||
template <typename T>
|
||||
struct AddRef { typedef T& type; }; // NOLINT
|
||||
template <typename T>
|
||||
struct AddRef<T&> { typedef T& type; }; // NOLINT
|
||||
|
||||
// A handy wrapper for AddRef.
|
||||
#define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type
|
||||
|
||||
// A helper for implementing get<k>().
|
||||
template <int k> class Get;
|
||||
|
||||
// A helper for implementing tuple_element<k, T>. kIndexValid is true
|
||||
// iff k < the number of fields in tuple type T.
|
||||
template <bool kIndexValid, int kIndex, class Tuple>
|
||||
struct TupleElement;
|
||||
|
||||
template <GTEST_10_TYPENAMES_(T)>
|
||||
struct TupleElement<true, 0, GTEST_10_TUPLE_(T)> { typedef T0 type; };
|
||||
|
||||
template <GTEST_10_TYPENAMES_(T)>
|
||||
struct TupleElement<true, 1, GTEST_10_TUPLE_(T)> { typedef T1 type; };
|
||||
|
||||
template <GTEST_10_TYPENAMES_(T)>
|
||||
struct TupleElement<true, 2, GTEST_10_TUPLE_(T)> { typedef T2 type; };
|
||||
|
||||
template <GTEST_10_TYPENAMES_(T)>
|
||||
struct TupleElement<true, 3, GTEST_10_TUPLE_(T)> { typedef T3 type; };
|
||||
|
||||
template <GTEST_10_TYPENAMES_(T)>
|
||||
struct TupleElement<true, 4, GTEST_10_TUPLE_(T)> { typedef T4 type; };
|
||||
|
||||
template <GTEST_10_TYPENAMES_(T)>
|
||||
struct TupleElement<true, 5, GTEST_10_TUPLE_(T)> { typedef T5 type; };
|
||||
|
||||
template <GTEST_10_TYPENAMES_(T)>
|
||||
struct TupleElement<true, 6, GTEST_10_TUPLE_(T)> { typedef T6 type; };
|
||||
|
||||
template <GTEST_10_TYPENAMES_(T)>
|
||||
struct TupleElement<true, 7, GTEST_10_TUPLE_(T)> { typedef T7 type; };
|
||||
|
||||
template <GTEST_10_TYPENAMES_(T)>
|
||||
struct TupleElement<true, 8, GTEST_10_TUPLE_(T)> { typedef T8 type; };
|
||||
|
||||
template <GTEST_10_TYPENAMES_(T)>
|
||||
struct TupleElement<true, 9, GTEST_10_TUPLE_(T)> { typedef T9 type; };
|
||||
|
||||
} // namespace gtest_internal
|
||||
|
||||
template <>
|
||||
class tuple<> {
|
||||
public:
|
||||
tuple() {}
|
||||
tuple(const tuple& /* t */) {}
|
||||
tuple& operator=(const tuple& /* t */) { return *this; }
|
||||
};
|
||||
|
||||
template <GTEST_1_TYPENAMES_(T)>
|
||||
class GTEST_1_TUPLE_(T) {
|
||||
public:
|
||||
template <int k> friend class gtest_internal::Get;
|
||||
|
||||
tuple() : f0_() {}
|
||||
|
||||
explicit tuple(GTEST_BY_REF_(T0) f0) : f0_(f0) {}
|
||||
|
||||
tuple(const tuple& t) : f0_(t.f0_) {}
|
||||
|
||||
template <GTEST_1_TYPENAMES_(U)>
|
||||
tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {}
|
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); }
|
||||
|
||||
template <GTEST_1_TYPENAMES_(U)>
|
||||
tuple& operator=(const GTEST_1_TUPLE_(U)& t) {
|
||||
return CopyFrom(t);
|
||||
}
|
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_
|
||||
|
||||
template <GTEST_1_TYPENAMES_(U)>
|
||||
tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) {
|
||||
f0_ = t.f0_;
|
||||
return *this;
|
||||
}
|
||||
|
||||
T0 f0_;
|
||||
};
|
||||
|
||||
template <GTEST_2_TYPENAMES_(T)>
|
||||
class GTEST_2_TUPLE_(T) {
|
||||
public:
|
||||
template <int k> friend class gtest_internal::Get;
|
||||
|
||||
tuple() : f0_(), f1_() {}
|
||||
|
||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1) : f0_(f0),
|
||||
f1_(f1) {}
|
||||
|
||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_) {}
|
||||
|
||||
template <GTEST_2_TYPENAMES_(U)>
|
||||
tuple(const GTEST_2_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_) {}
|
||||
template <typename U0, typename U1>
|
||||
tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {}
|
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); }
|
||||
|
||||
template <GTEST_2_TYPENAMES_(U)>
|
||||
tuple& operator=(const GTEST_2_TUPLE_(U)& t) {
|
||||
return CopyFrom(t);
|
||||
}
|
||||
template <typename U0, typename U1>
|
||||
tuple& operator=(const ::std::pair<U0, U1>& p) {
|
||||
f0_ = p.first;
|
||||
f1_ = p.second;
|
||||
return *this;
|
||||
}
|
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_
|
||||
|
||||
template <GTEST_2_TYPENAMES_(U)>
|
||||
tuple& CopyFrom(const GTEST_2_TUPLE_(U)& t) {
|
||||
f0_ = t.f0_;
|
||||
f1_ = t.f1_;
|
||||
return *this;
|
||||
}
|
||||
|
||||
T0 f0_;
|
||||
T1 f1_;
|
||||
};
|
||||
|
||||
template <GTEST_3_TYPENAMES_(T)>
|
||||
class GTEST_3_TUPLE_(T) {
|
||||
public:
|
||||
template <int k> friend class gtest_internal::Get;
|
||||
|
||||
tuple() : f0_(), f1_(), f2_() {}
|
||||
|
||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
|
||||
GTEST_BY_REF_(T2) f2) : f0_(f0), f1_(f1), f2_(f2) {}
|
||||
|
||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
|
||||
|
||||
template <GTEST_3_TYPENAMES_(U)>
|
||||
tuple(const GTEST_3_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
|
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); }
|
||||
|
||||
template <GTEST_3_TYPENAMES_(U)>
|
||||
tuple& operator=(const GTEST_3_TUPLE_(U)& t) {
|
||||
return CopyFrom(t);
|
||||
}
|
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_
|
||||
|
||||
template <GTEST_3_TYPENAMES_(U)>
|
||||
tuple& CopyFrom(const GTEST_3_TUPLE_(U)& t) {
|
||||
f0_ = t.f0_;
|
||||
f1_ = t.f1_;
|
||||
f2_ = t.f2_;
|
||||
return *this;
|
||||
}
|
||||
|
||||
T0 f0_;
|
||||
T1 f1_;
|
||||
T2 f2_;
|
||||
};
|
||||
|
||||
template <GTEST_4_TYPENAMES_(T)>
|
||||
class GTEST_4_TUPLE_(T) {
|
||||
public:
|
||||
template <int k> friend class gtest_internal::Get;
|
||||
|
||||
tuple() : f0_(), f1_(), f2_(), f3_() {}
|
||||
|
||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
|
||||
GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3) : f0_(f0), f1_(f1), f2_(f2),
|
||||
f3_(f3) {}
|
||||
|
||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_) {}
|
||||
|
||||
template <GTEST_4_TYPENAMES_(U)>
|
||||
tuple(const GTEST_4_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
|
||||
f3_(t.f3_) {}
|
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); }
|
||||
|
||||
template <GTEST_4_TYPENAMES_(U)>
|
||||
tuple& operator=(const GTEST_4_TUPLE_(U)& t) {
|
||||
return CopyFrom(t);
|
||||
}
|
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_
|
||||
|
||||
template <GTEST_4_TYPENAMES_(U)>
|
||||
tuple& CopyFrom(const GTEST_4_TUPLE_(U)& t) {
|
||||
f0_ = t.f0_;
|
||||
f1_ = t.f1_;
|
||||
f2_ = t.f2_;
|
||||
f3_ = t.f3_;
|
||||
return *this;
|
||||
}
|
||||
|
||||
T0 f0_;
|
||||
T1 f1_;
|
||||
T2 f2_;
|
||||
T3 f3_;
|
||||
};
|
||||
|
||||
template <GTEST_5_TYPENAMES_(T)>
|
||||
class GTEST_5_TUPLE_(T) {
|
||||
public:
|
||||
template <int k> friend class gtest_internal::Get;
|
||||
|
||||
tuple() : f0_(), f1_(), f2_(), f3_(), f4_() {}
|
||||
|
||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
|
||||
GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3,
|
||||
GTEST_BY_REF_(T4) f4) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4) {}
|
||||
|
||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
|
||||
f4_(t.f4_) {}
|
||||
|
||||
template <GTEST_5_TYPENAMES_(U)>
|
||||
tuple(const GTEST_5_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
|
||||
f3_(t.f3_), f4_(t.f4_) {}
|
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); }
|
||||
|
||||
template <GTEST_5_TYPENAMES_(U)>
|
||||
tuple& operator=(const GTEST_5_TUPLE_(U)& t) {
|
||||
return CopyFrom(t);
|
||||
}
|
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_
|
||||
|
||||
template <GTEST_5_TYPENAMES_(U)>
|
||||
tuple& CopyFrom(const GTEST_5_TUPLE_(U)& t) {
|
||||
f0_ = t.f0_;
|
||||
f1_ = t.f1_;
|
||||
f2_ = t.f2_;
|
||||
f3_ = t.f3_;
|
||||
f4_ = t.f4_;
|
||||
return *this;
|
||||
}
|
||||
|
||||
T0 f0_;
|
||||
T1 f1_;
|
||||
T2 f2_;
|
||||
T3 f3_;
|
||||
T4 f4_;
|
||||
};
|
||||
|
||||
template <GTEST_6_TYPENAMES_(T)>
|
||||
class GTEST_6_TUPLE_(T) {
|
||||
public:
|
||||
template <int k> friend class gtest_internal::Get;
|
||||
|
||||
tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_() {}
|
||||
|
||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
|
||||
GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
|
||||
GTEST_BY_REF_(T5) f5) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
|
||||
f5_(f5) {}
|
||||
|
||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
|
||||
f4_(t.f4_), f5_(t.f5_) {}
|
||||
|
||||
template <GTEST_6_TYPENAMES_(U)>
|
||||
tuple(const GTEST_6_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
|
||||
f3_(t.f3_), f4_(t.f4_), f5_(t.f5_) {}
|
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); }
|
||||
|
||||
template <GTEST_6_TYPENAMES_(U)>
|
||||
tuple& operator=(const GTEST_6_TUPLE_(U)& t) {
|
||||
return CopyFrom(t);
|
||||
}
|
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_
|
||||
|
||||
template <GTEST_6_TYPENAMES_(U)>
|
||||
tuple& CopyFrom(const GTEST_6_TUPLE_(U)& t) {
|
||||
f0_ = t.f0_;
|
||||
f1_ = t.f1_;
|
||||
f2_ = t.f2_;
|
||||
f3_ = t.f3_;
|
||||
f4_ = t.f4_;
|
||||
f5_ = t.f5_;
|
||||
return *this;
|
||||
}
|
||||
|
||||
T0 f0_;
|
||||
T1 f1_;
|
||||
T2 f2_;
|
||||
T3 f3_;
|
||||
T4 f4_;
|
||||
T5 f5_;
|
||||
};
|
||||
|
||||
template <GTEST_7_TYPENAMES_(T)>
|
||||
class GTEST_7_TUPLE_(T) {
|
||||
public:
|
||||
template <int k> friend class gtest_internal::Get;
|
||||
|
||||
tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_() {}
|
||||
|
||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
|
||||
GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
|
||||
GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6) : f0_(f0), f1_(f1), f2_(f2),
|
||||
f3_(f3), f4_(f4), f5_(f5), f6_(f6) {}
|
||||
|
||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
|
||||
f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
|
||||
|
||||
template <GTEST_7_TYPENAMES_(U)>
|
||||
tuple(const GTEST_7_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
|
||||
f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
|
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); }
|
||||
|
||||
template <GTEST_7_TYPENAMES_(U)>
|
||||
tuple& operator=(const GTEST_7_TUPLE_(U)& t) {
|
||||
return CopyFrom(t);
|
||||
}
|
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_
|
||||
|
||||
template <GTEST_7_TYPENAMES_(U)>
|
||||
tuple& CopyFrom(const GTEST_7_TUPLE_(U)& t) {
|
||||
f0_ = t.f0_;
|
||||
f1_ = t.f1_;
|
||||
f2_ = t.f2_;
|
||||
f3_ = t.f3_;
|
||||
f4_ = t.f4_;
|
||||
f5_ = t.f5_;
|
||||
f6_ = t.f6_;
|
||||
return *this;
|
||||
}
|
||||
|
||||
T0 f0_;
|
||||
T1 f1_;
|
||||
T2 f2_;
|
||||
T3 f3_;
|
||||
T4 f4_;
|
||||
T5 f5_;
|
||||
T6 f6_;
|
||||
};
|
||||
|
||||
template <GTEST_8_TYPENAMES_(T)>
|
||||
class GTEST_8_TUPLE_(T) {
|
||||
public:
|
||||
template <int k> friend class gtest_internal::Get;
|
||||
|
||||
tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_() {}
|
||||
|
||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
|
||||
GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
|
||||
GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6,
|
||||
GTEST_BY_REF_(T7) f7) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
|
||||
f5_(f5), f6_(f6), f7_(f7) {}
|
||||
|
||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
|
||||
f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
|
||||
|
||||
template <GTEST_8_TYPENAMES_(U)>
|
||||
tuple(const GTEST_8_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
|
||||
f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
|
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); }
|
||||
|
||||
template <GTEST_8_TYPENAMES_(U)>
|
||||
tuple& operator=(const GTEST_8_TUPLE_(U)& t) {
|
||||
return CopyFrom(t);
|
||||
}
|
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_
|
||||
|
||||
template <GTEST_8_TYPENAMES_(U)>
|
||||
tuple& CopyFrom(const GTEST_8_TUPLE_(U)& t) {
|
||||
f0_ = t.f0_;
|
||||
f1_ = t.f1_;
|
||||
f2_ = t.f2_;
|
||||
f3_ = t.f3_;
|
||||
f4_ = t.f4_;
|
||||
f5_ = t.f5_;
|
||||
f6_ = t.f6_;
|
||||
f7_ = t.f7_;
|
||||
return *this;
|
||||
}
|
||||
|
||||
T0 f0_;
|
||||
T1 f1_;
|
||||
T2 f2_;
|
||||
T3 f3_;
|
||||
T4 f4_;
|
||||
T5 f5_;
|
||||
T6 f6_;
|
||||
T7 f7_;
|
||||
};
|
||||
|
||||
template <GTEST_9_TYPENAMES_(T)>
|
||||
class GTEST_9_TUPLE_(T) {
|
||||
public:
|
||||
template <int k> friend class gtest_internal::Get;
|
||||
|
||||
tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_() {}
|
||||
|
||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
|
||||
GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
|
||||
GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
|
||||
GTEST_BY_REF_(T8) f8) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
|
||||
f5_(f5), f6_(f6), f7_(f7), f8_(f8) {}
|
||||
|
||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
|
||||
f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
|
||||
|
||||
template <GTEST_9_TYPENAMES_(U)>
|
||||
tuple(const GTEST_9_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
|
||||
f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
|
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); }
|
||||
|
||||
template <GTEST_9_TYPENAMES_(U)>
|
||||
tuple& operator=(const GTEST_9_TUPLE_(U)& t) {
|
||||
return CopyFrom(t);
|
||||
}
|
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_
|
||||
|
||||
template <GTEST_9_TYPENAMES_(U)>
|
||||
tuple& CopyFrom(const GTEST_9_TUPLE_(U)& t) {
|
||||
f0_ = t.f0_;
|
||||
f1_ = t.f1_;
|
||||
f2_ = t.f2_;
|
||||
f3_ = t.f3_;
|
||||
f4_ = t.f4_;
|
||||
f5_ = t.f5_;
|
||||
f6_ = t.f6_;
|
||||
f7_ = t.f7_;
|
||||
f8_ = t.f8_;
|
||||
return *this;
|
||||
}
|
||||
|
||||
T0 f0_;
|
||||
T1 f1_;
|
||||
T2 f2_;
|
||||
T3 f3_;
|
||||
T4 f4_;
|
||||
T5 f5_;
|
||||
T6 f6_;
|
||||
T7 f7_;
|
||||
T8 f8_;
|
||||
};
|
||||
|
||||
template <GTEST_10_TYPENAMES_(T)>
|
||||
class tuple {
|
||||
public:
|
||||
template <int k> friend class gtest_internal::Get;
|
||||
|
||||
tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_(),
|
||||
f9_() {}
|
||||
|
||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
|
||||
GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
|
||||
GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
|
||||
GTEST_BY_REF_(T8) f8, GTEST_BY_REF_(T9) f9) : f0_(f0), f1_(f1), f2_(f2),
|
||||
f3_(f3), f4_(f4), f5_(f5), f6_(f6), f7_(f7), f8_(f8), f9_(f9) {}
|
||||
|
||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
|
||||
f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), f9_(t.f9_) {}
|
||||
|
||||
template <GTEST_10_TYPENAMES_(U)>
|
||||
tuple(const GTEST_10_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
|
||||
f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_),
|
||||
f9_(t.f9_) {}
|
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); }
|
||||
|
||||
template <GTEST_10_TYPENAMES_(U)>
|
||||
tuple& operator=(const GTEST_10_TUPLE_(U)& t) {
|
||||
return CopyFrom(t);
|
||||
}
|
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_
|
||||
|
||||
template <GTEST_10_TYPENAMES_(U)>
|
||||
tuple& CopyFrom(const GTEST_10_TUPLE_(U)& t) {
|
||||
f0_ = t.f0_;
|
||||
f1_ = t.f1_;
|
||||
f2_ = t.f2_;
|
||||
f3_ = t.f3_;
|
||||
f4_ = t.f4_;
|
||||
f5_ = t.f5_;
|
||||
f6_ = t.f6_;
|
||||
f7_ = t.f7_;
|
||||
f8_ = t.f8_;
|
||||
f9_ = t.f9_;
|
||||
return *this;
|
||||
}
|
||||
|
||||
T0 f0_;
|
||||
T1 f1_;
|
||||
T2 f2_;
|
||||
T3 f3_;
|
||||
T4 f4_;
|
||||
T5 f5_;
|
||||
T6 f6_;
|
||||
T7 f7_;
|
||||
T8 f8_;
|
||||
T9 f9_;
|
||||
};
|
||||
|
||||
// 6.1.3.2 Tuple creation functions.
|
||||
|
||||
// Known limitations: we don't support passing an
|
||||
// std::tr1::reference_wrapper<T> to make_tuple(). And we don't
|
||||
// implement tie().
|
||||
|
||||
inline tuple<> make_tuple() { return tuple<>(); }
|
||||
|
||||
template <GTEST_1_TYPENAMES_(T)>
|
||||
inline GTEST_1_TUPLE_(T) make_tuple(const T0& f0) {
|
||||
return GTEST_1_TUPLE_(T)(f0);
|
||||
}
|
||||
|
||||
template <GTEST_2_TYPENAMES_(T)>
|
||||
inline GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) {
|
||||
return GTEST_2_TUPLE_(T)(f0, f1);
|
||||
}
|
||||
|
||||
template <GTEST_3_TYPENAMES_(T)>
|
||||
inline GTEST_3_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2) {
|
||||
return GTEST_3_TUPLE_(T)(f0, f1, f2);
|
||||
}
|
||||
|
||||
template <GTEST_4_TYPENAMES_(T)>
|
||||
inline GTEST_4_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
|
||||
const T3& f3) {
|
||||
return GTEST_4_TUPLE_(T)(f0, f1, f2, f3);
|
||||
}
|
||||
|
||||
template <GTEST_5_TYPENAMES_(T)>
|
||||
inline GTEST_5_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
|
||||
const T3& f3, const T4& f4) {
|
||||
return GTEST_5_TUPLE_(T)(f0, f1, f2, f3, f4);
|
||||
}
|
||||
|
||||
template <GTEST_6_TYPENAMES_(T)>
|
||||
inline GTEST_6_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
|
||||
const T3& f3, const T4& f4, const T5& f5) {
|
||||
return GTEST_6_TUPLE_(T)(f0, f1, f2, f3, f4, f5);
|
||||
}
|
||||
|
||||
template <GTEST_7_TYPENAMES_(T)>
|
||||
inline GTEST_7_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
|
||||
const T3& f3, const T4& f4, const T5& f5, const T6& f6) {
|
||||
return GTEST_7_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6);
|
||||
}
|
||||
|
||||
template <GTEST_8_TYPENAMES_(T)>
|
||||
inline GTEST_8_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
|
||||
const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7) {
|
||||
return GTEST_8_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7);
|
||||
}
|
||||
|
||||
template <GTEST_9_TYPENAMES_(T)>
|
||||
inline GTEST_9_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
|
||||
const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
|
||||
const T8& f8) {
|
||||
return GTEST_9_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8);
|
||||
}
|
||||
|
||||
template <GTEST_10_TYPENAMES_(T)>
|
||||
inline GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
|
||||
const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
|
||||
const T8& f8, const T9& f9) {
|
||||
return GTEST_10_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9);
|
||||
}
|
||||
|
||||
// 6.1.3.3 Tuple helper classes.
|
||||
|
||||
template <typename Tuple> struct tuple_size;
|
||||
|
||||
template <GTEST_0_TYPENAMES_(T)>
|
||||
struct tuple_size<GTEST_0_TUPLE_(T)> { static const int value = 0; };
|
||||
|
||||
template <GTEST_1_TYPENAMES_(T)>
|
||||
struct tuple_size<GTEST_1_TUPLE_(T)> { static const int value = 1; };
|
||||
|
||||
template <GTEST_2_TYPENAMES_(T)>
|
||||
struct tuple_size<GTEST_2_TUPLE_(T)> { static const int value = 2; };
|
||||
|
||||
template <GTEST_3_TYPENAMES_(T)>
|
||||
struct tuple_size<GTEST_3_TUPLE_(T)> { static const int value = 3; };
|
||||
|
||||
template <GTEST_4_TYPENAMES_(T)>
|
||||
struct tuple_size<GTEST_4_TUPLE_(T)> { static const int value = 4; };
|
||||
|
||||
template <GTEST_5_TYPENAMES_(T)>
|
||||
struct tuple_size<GTEST_5_TUPLE_(T)> { static const int value = 5; };
|
||||
|
||||
template <GTEST_6_TYPENAMES_(T)>
|
||||
struct tuple_size<GTEST_6_TUPLE_(T)> { static const int value = 6; };
|
||||
|
||||
template <GTEST_7_TYPENAMES_(T)>
|
||||
struct tuple_size<GTEST_7_TUPLE_(T)> { static const int value = 7; };
|
||||
|
||||
template <GTEST_8_TYPENAMES_(T)>
|
||||
struct tuple_size<GTEST_8_TUPLE_(T)> { static const int value = 8; };
|
||||
|
||||
template <GTEST_9_TYPENAMES_(T)>
|
||||
struct tuple_size<GTEST_9_TUPLE_(T)> { static const int value = 9; };
|
||||
|
||||
template <GTEST_10_TYPENAMES_(T)>
|
||||
struct tuple_size<GTEST_10_TUPLE_(T)> { static const int value = 10; };
|
||||
|
||||
template <int k, class Tuple>
|
||||
struct tuple_element {
|
||||
typedef typename gtest_internal::TupleElement<
|
||||
k < (tuple_size<Tuple>::value), k, Tuple>::type type;
|
||||
};
|
||||
|
||||
#define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type
|
||||
|
||||
// 6.1.3.4 Element access.
|
||||
|
||||
namespace gtest_internal {
|
||||
|
||||
template <>
|
||||
class Get<0> {
|
||||
public:
|
||||
template <class Tuple>
|
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
|
||||
Field(Tuple& t) { return t.f0_; } // NOLINT
|
||||
|
||||
template <class Tuple>
|
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
|
||||
ConstField(const Tuple& t) { return t.f0_; }
|
||||
};
|
||||
|
||||
template <>
|
||||
class Get<1> {
|
||||
public:
|
||||
template <class Tuple>
|
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
|
||||
Field(Tuple& t) { return t.f1_; } // NOLINT
|
||||
|
||||
template <class Tuple>
|
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
|
||||
ConstField(const Tuple& t) { return t.f1_; }
|
||||
};
|
||||
|
||||
template <>
|
||||
class Get<2> {
|
||||
public:
|
||||
template <class Tuple>
|
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
|
||||
Field(Tuple& t) { return t.f2_; } // NOLINT
|
||||
|
||||
template <class Tuple>
|
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
|
||||
ConstField(const Tuple& t) { return t.f2_; }
|
||||
};
|
||||
|
||||
template <>
|
||||
class Get<3> {
|
||||
public:
|
||||
template <class Tuple>
|
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
|
||||
Field(Tuple& t) { return t.f3_; } // NOLINT
|
||||
|
||||
template <class Tuple>
|
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
|
||||
ConstField(const Tuple& t) { return t.f3_; }
|
||||
};
|
||||
|
||||
template <>
|
||||
class Get<4> {
|
||||
public:
|
||||
template <class Tuple>
|
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
|
||||
Field(Tuple& t) { return t.f4_; } // NOLINT
|
||||
|
||||
template <class Tuple>
|
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
|
||||
ConstField(const Tuple& t) { return t.f4_; }
|
||||
};
|
||||
|
||||
template <>
|
||||
class Get<5> {
|
||||
public:
|
||||
template <class Tuple>
|
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
|
||||
Field(Tuple& t) { return t.f5_; } // NOLINT
|
||||
|
||||
template <class Tuple>
|
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
|
||||
ConstField(const Tuple& t) { return t.f5_; }
|
||||
};
|
||||
|
||||
template <>
|
||||
class Get<6> {
|
||||
public:
|
||||
template <class Tuple>
|
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
|
||||
Field(Tuple& t) { return t.f6_; } // NOLINT
|
||||
|
||||
template <class Tuple>
|
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
|
||||
ConstField(const Tuple& t) { return t.f6_; }
|
||||
};
|
||||
|
||||
template <>
|
||||
class Get<7> {
|
||||
public:
|
||||
template <class Tuple>
|
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
|
||||
Field(Tuple& t) { return t.f7_; } // NOLINT
|
||||
|
||||
template <class Tuple>
|
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
|
||||
ConstField(const Tuple& t) { return t.f7_; }
|
||||
};
|
||||
|
||||
template <>
|
||||
class Get<8> {
|
||||
public:
|
||||
template <class Tuple>
|
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
|
||||
Field(Tuple& t) { return t.f8_; } // NOLINT
|
||||
|
||||
template <class Tuple>
|
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
|
||||
ConstField(const Tuple& t) { return t.f8_; }
|
||||
};
|
||||
|
||||
template <>
|
||||
class Get<9> {
|
||||
public:
|
||||
template <class Tuple>
|
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
|
||||
Field(Tuple& t) { return t.f9_; } // NOLINT
|
||||
|
||||
template <class Tuple>
|
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
|
||||
ConstField(const Tuple& t) { return t.f9_; }
|
||||
};
|
||||
|
||||
} // namespace gtest_internal
|
||||
|
||||
template <int k, GTEST_10_TYPENAMES_(T)>
|
||||
GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T)))
|
||||
get(GTEST_10_TUPLE_(T)& t) {
|
||||
return gtest_internal::Get<k>::Field(t);
|
||||
}
|
||||
|
||||
template <int k, GTEST_10_TYPENAMES_(T)>
|
||||
GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T)))
|
||||
get(const GTEST_10_TUPLE_(T)& t) {
|
||||
return gtest_internal::Get<k>::ConstField(t);
|
||||
}
|
||||
|
||||
// 6.1.3.5 Relational operators
|
||||
|
||||
// We only implement == and !=, as we don't have a need for the rest yet.
|
||||
|
||||
namespace gtest_internal {
|
||||
|
||||
// SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the
|
||||
// first k fields of t1 equals the first k fields of t2.
|
||||
// SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if
|
||||
// k1 != k2.
|
||||
template <int kSize1, int kSize2>
|
||||
struct SameSizeTuplePrefixComparator;
|
||||
|
||||
template <>
|
||||
struct SameSizeTuplePrefixComparator<0, 0> {
|
||||
template <class Tuple1, class Tuple2>
|
||||
static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) {
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
template <int k>
|
||||
struct SameSizeTuplePrefixComparator<k, k> {
|
||||
template <class Tuple1, class Tuple2>
|
||||
static bool Eq(const Tuple1& t1, const Tuple2& t2) {
|
||||
return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) &&
|
||||
::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace gtest_internal
|
||||
|
||||
template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
|
||||
inline bool operator==(const GTEST_10_TUPLE_(T)& t,
|
||||
const GTEST_10_TUPLE_(U)& u) {
|
||||
return gtest_internal::SameSizeTuplePrefixComparator<
|
||||
tuple_size<GTEST_10_TUPLE_(T)>::value,
|
||||
tuple_size<GTEST_10_TUPLE_(U)>::value>::Eq(t, u);
|
||||
}
|
||||
|
||||
template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
|
||||
inline bool operator!=(const GTEST_10_TUPLE_(T)& t,
|
||||
const GTEST_10_TUPLE_(U)& u) { return !(t == u); }
|
||||
|
||||
// 6.1.4 Pairs.
|
||||
// Unimplemented.
|
||||
|
||||
} // namespace tr1
|
||||
} // namespace std
|
||||
|
||||
#undef GTEST_0_TUPLE_
|
||||
#undef GTEST_1_TUPLE_
|
||||
#undef GTEST_2_TUPLE_
|
||||
#undef GTEST_3_TUPLE_
|
||||
#undef GTEST_4_TUPLE_
|
||||
#undef GTEST_5_TUPLE_
|
||||
#undef GTEST_6_TUPLE_
|
||||
#undef GTEST_7_TUPLE_
|
||||
#undef GTEST_8_TUPLE_
|
||||
#undef GTEST_9_TUPLE_
|
||||
#undef GTEST_10_TUPLE_
|
||||
|
||||
#undef GTEST_0_TYPENAMES_
|
||||
#undef GTEST_1_TYPENAMES_
|
||||
#undef GTEST_2_TYPENAMES_
|
||||
#undef GTEST_3_TYPENAMES_
|
||||
#undef GTEST_4_TYPENAMES_
|
||||
#undef GTEST_5_TYPENAMES_
|
||||
#undef GTEST_6_TYPENAMES_
|
||||
#undef GTEST_7_TYPENAMES_
|
||||
#undef GTEST_8_TYPENAMES_
|
||||
#undef GTEST_9_TYPENAMES_
|
||||
#undef GTEST_10_TYPENAMES_
|
||||
|
||||
#undef GTEST_DECLARE_TUPLE_AS_FRIEND_
|
||||
#undef GTEST_BY_REF_
|
||||
#undef GTEST_ADD_REF_
|
||||
#undef GTEST_TUPLE_ELEMENT_
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
|
336
gtest/include/gtest/internal/gtest-tuple.h.pump
Normal file
336
gtest/include/gtest/internal/gtest-tuple.h.pump
Normal file
@ -0,0 +1,336 @@
|
||||
$$ -*- mode: c++; -*-
|
||||
$var n = 10 $$ Maximum number of tuple fields we want to support.
|
||||
$$ This meta comment fixes auto-indentation in Emacs. }}
|
||||
// Copyright 2009 Google Inc.
|
||||
// All Rights Reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
// Implements a subset of TR1 tuple needed by Google Test and Google Mock.
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
|
||||
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
|
||||
|
||||
#include <utility> // For ::std::pair.
|
||||
|
||||
// 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
|
||||
// private as public.
|
||||
// Sun Studio versions < 12 also have the above bug.
|
||||
#if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590)
|
||||
# define GTEST_DECLARE_TUPLE_AS_FRIEND_ public:
|
||||
#else
|
||||
# define GTEST_DECLARE_TUPLE_AS_FRIEND_ \
|
||||
template <GTEST_$(n)_TYPENAMES_(U)> friend class tuple; \
|
||||
private:
|
||||
#endif
|
||||
|
||||
|
||||
$range i 0..n-1
|
||||
$range j 0..n
|
||||
$range k 1..n
|
||||
// GTEST_n_TUPLE_(T) is the type of an n-tuple.
|
||||
#define GTEST_0_TUPLE_(T) tuple<>
|
||||
|
||||
$for k [[
|
||||
$range m 0..k-1
|
||||
$range m2 k..n-1
|
||||
#define GTEST_$(k)_TUPLE_(T) tuple<$for m, [[T##$m]]$for m2 [[, void]]>
|
||||
|
||||
]]
|
||||
|
||||
// GTEST_n_TYPENAMES_(T) declares a list of n typenames.
|
||||
|
||||
$for j [[
|
||||
$range m 0..j-1
|
||||
#define GTEST_$(j)_TYPENAMES_(T) $for m, [[typename T##$m]]
|
||||
|
||||
|
||||
]]
|
||||
|
||||
// In theory, defining stuff in the ::std namespace is undefined
|
||||
// behavior. We can do this as we are playing the role of a standard
|
||||
// library vendor.
|
||||
namespace std {
|
||||
namespace tr1 {
|
||||
|
||||
template <$for i, [[typename T$i = void]]>
|
||||
class tuple;
|
||||
|
||||
// Anything in namespace gtest_internal is Google Test's INTERNAL
|
||||
// IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code.
|
||||
namespace gtest_internal {
|
||||
|
||||
// ByRef<T>::type is T if T is a reference; otherwise it's const T&.
|
||||
template <typename T>
|
||||
struct ByRef { typedef const T& type; }; // NOLINT
|
||||
template <typename T>
|
||||
struct ByRef<T&> { typedef T& type; }; // NOLINT
|
||||
|
||||
// A handy wrapper for ByRef.
|
||||
#define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type
|
||||
|
||||
// AddRef<T>::type is T if T is a reference; otherwise it's T&. This
|
||||
// is the same as tr1::add_reference<T>::type.
|
||||
template <typename T>
|
||||
struct AddRef { typedef T& type; }; // NOLINT
|
||||
template <typename T>
|
||||
struct AddRef<T&> { typedef T& type; }; // NOLINT
|
||||
|
||||
// A handy wrapper for AddRef.
|
||||
#define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type
|
||||
|
||||
// A helper for implementing get<k>().
|
||||
template <int k> class Get;
|
||||
|
||||
// A helper for implementing tuple_element<k, T>. kIndexValid is true
|
||||
// iff k < the number of fields in tuple type T.
|
||||
template <bool kIndexValid, int kIndex, class Tuple>
|
||||
struct TupleElement;
|
||||
|
||||
|
||||
$for i [[
|
||||
template <GTEST_$(n)_TYPENAMES_(T)>
|
||||
struct TupleElement<true, $i, GTEST_$(n)_TUPLE_(T)> [[]]
|
||||
{ typedef T$i type; };
|
||||
|
||||
|
||||
]]
|
||||
} // namespace gtest_internal
|
||||
|
||||
template <>
|
||||
class tuple<> {
|
||||
public:
|
||||
tuple() {}
|
||||
tuple(const tuple& /* t */) {}
|
||||
tuple& operator=(const tuple& /* t */) { return *this; }
|
||||
};
|
||||
|
||||
|
||||
$for k [[
|
||||
$range m 0..k-1
|
||||
template <GTEST_$(k)_TYPENAMES_(T)>
|
||||
class $if k < n [[GTEST_$(k)_TUPLE_(T)]] $else [[tuple]] {
|
||||
public:
|
||||
template <int k> friend class gtest_internal::Get;
|
||||
|
||||
tuple() : $for m, [[f$(m)_()]] {}
|
||||
|
||||
explicit tuple($for m, [[GTEST_BY_REF_(T$m) f$m]]) : [[]]
|
||||
$for m, [[f$(m)_(f$m)]] {}
|
||||
|
||||
tuple(const tuple& t) : $for m, [[f$(m)_(t.f$(m)_)]] {}
|
||||
|
||||
template <GTEST_$(k)_TYPENAMES_(U)>
|
||||
tuple(const GTEST_$(k)_TUPLE_(U)& t) : $for m, [[f$(m)_(t.f$(m)_)]] {}
|
||||
|
||||
$if k == 2 [[
|
||||
template <typename U0, typename U1>
|
||||
tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {}
|
||||
|
||||
]]
|
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); }
|
||||
|
||||
template <GTEST_$(k)_TYPENAMES_(U)>
|
||||
tuple& operator=(const GTEST_$(k)_TUPLE_(U)& t) {
|
||||
return CopyFrom(t);
|
||||
}
|
||||
|
||||
$if k == 2 [[
|
||||
template <typename U0, typename U1>
|
||||
tuple& operator=(const ::std::pair<U0, U1>& p) {
|
||||
f0_ = p.first;
|
||||
f1_ = p.second;
|
||||
return *this;
|
||||
}
|
||||
|
||||
]]
|
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_
|
||||
|
||||
template <GTEST_$(k)_TYPENAMES_(U)>
|
||||
tuple& CopyFrom(const GTEST_$(k)_TUPLE_(U)& t) {
|
||||
|
||||
$for m [[
|
||||
f$(m)_ = t.f$(m)_;
|
||||
|
||||
]]
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
$for m [[
|
||||
T$m f$(m)_;
|
||||
|
||||
]]
|
||||
};
|
||||
|
||||
|
||||
]]
|
||||
// 6.1.3.2 Tuple creation functions.
|
||||
|
||||
// Known limitations: we don't support passing an
|
||||
// std::tr1::reference_wrapper<T> to make_tuple(). And we don't
|
||||
// implement tie().
|
||||
|
||||
inline tuple<> make_tuple() { return tuple<>(); }
|
||||
|
||||
$for k [[
|
||||
$range m 0..k-1
|
||||
|
||||
template <GTEST_$(k)_TYPENAMES_(T)>
|
||||
inline GTEST_$(k)_TUPLE_(T) make_tuple($for m, [[const T$m& f$m]]) {
|
||||
return GTEST_$(k)_TUPLE_(T)($for m, [[f$m]]);
|
||||
}
|
||||
|
||||
]]
|
||||
|
||||
// 6.1.3.3 Tuple helper classes.
|
||||
|
||||
template <typename Tuple> struct tuple_size;
|
||||
|
||||
|
||||
$for j [[
|
||||
template <GTEST_$(j)_TYPENAMES_(T)>
|
||||
struct tuple_size<GTEST_$(j)_TUPLE_(T)> { static const int value = $j; };
|
||||
|
||||
|
||||
]]
|
||||
template <int k, class Tuple>
|
||||
struct tuple_element {
|
||||
typedef typename gtest_internal::TupleElement<
|
||||
k < (tuple_size<Tuple>::value), k, Tuple>::type type;
|
||||
};
|
||||
|
||||
#define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type
|
||||
|
||||
// 6.1.3.4 Element access.
|
||||
|
||||
namespace gtest_internal {
|
||||
|
||||
|
||||
$for i [[
|
||||
template <>
|
||||
class Get<$i> {
|
||||
public:
|
||||
template <class Tuple>
|
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_($i, Tuple))
|
||||
Field(Tuple& t) { return t.f$(i)_; } // NOLINT
|
||||
|
||||
template <class Tuple>
|
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_($i, Tuple))
|
||||
ConstField(const Tuple& t) { return t.f$(i)_; }
|
||||
};
|
||||
|
||||
|
||||
]]
|
||||
} // namespace gtest_internal
|
||||
|
||||
template <int k, GTEST_$(n)_TYPENAMES_(T)>
|
||||
GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_$(n)_TUPLE_(T)))
|
||||
get(GTEST_$(n)_TUPLE_(T)& t) {
|
||||
return gtest_internal::Get<k>::Field(t);
|
||||
}
|
||||
|
||||
template <int k, GTEST_$(n)_TYPENAMES_(T)>
|
||||
GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_$(n)_TUPLE_(T)))
|
||||
get(const GTEST_$(n)_TUPLE_(T)& t) {
|
||||
return gtest_internal::Get<k>::ConstField(t);
|
||||
}
|
||||
|
||||
// 6.1.3.5 Relational operators
|
||||
|
||||
// We only implement == and !=, as we don't have a need for the rest yet.
|
||||
|
||||
namespace gtest_internal {
|
||||
|
||||
// SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the
|
||||
// first k fields of t1 equals the first k fields of t2.
|
||||
// SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if
|
||||
// k1 != k2.
|
||||
template <int kSize1, int kSize2>
|
||||
struct SameSizeTuplePrefixComparator;
|
||||
|
||||
template <>
|
||||
struct SameSizeTuplePrefixComparator<0, 0> {
|
||||
template <class Tuple1, class Tuple2>
|
||||
static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) {
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
template <int k>
|
||||
struct SameSizeTuplePrefixComparator<k, k> {
|
||||
template <class Tuple1, class Tuple2>
|
||||
static bool Eq(const Tuple1& t1, const Tuple2& t2) {
|
||||
return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) &&
|
||||
::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace gtest_internal
|
||||
|
||||
template <GTEST_$(n)_TYPENAMES_(T), GTEST_$(n)_TYPENAMES_(U)>
|
||||
inline bool operator==(const GTEST_$(n)_TUPLE_(T)& t,
|
||||
const GTEST_$(n)_TUPLE_(U)& u) {
|
||||
return gtest_internal::SameSizeTuplePrefixComparator<
|
||||
tuple_size<GTEST_$(n)_TUPLE_(T)>::value,
|
||||
tuple_size<GTEST_$(n)_TUPLE_(U)>::value>::Eq(t, u);
|
||||
}
|
||||
|
||||
template <GTEST_$(n)_TYPENAMES_(T), GTEST_$(n)_TYPENAMES_(U)>
|
||||
inline bool operator!=(const GTEST_$(n)_TUPLE_(T)& t,
|
||||
const GTEST_$(n)_TUPLE_(U)& u) { return !(t == u); }
|
||||
|
||||
// 6.1.4 Pairs.
|
||||
// Unimplemented.
|
||||
|
||||
} // namespace tr1
|
||||
} // namespace std
|
||||
|
||||
|
||||
$for j [[
|
||||
#undef GTEST_$(j)_TUPLE_
|
||||
|
||||
]]
|
||||
|
||||
|
||||
$for j [[
|
||||
#undef GTEST_$(j)_TYPENAMES_
|
||||
|
||||
]]
|
||||
|
||||
#undef GTEST_DECLARE_TUPLE_AS_FRIEND_
|
||||
#undef GTEST_BY_REF_
|
||||
#undef GTEST_ADD_REF_
|
||||
#undef GTEST_TUPLE_ELEMENT_
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
|
3330
gtest/include/gtest/internal/gtest-type-util.h
Normal file
3330
gtest/include/gtest/internal/gtest-type-util.h
Normal file
File diff suppressed because it is too large
Load Diff
296
gtest/include/gtest/internal/gtest-type-util.h.pump
Normal file
296
gtest/include/gtest/internal/gtest-type-util.h.pump
Normal file
@ -0,0 +1,296 @@
|
||||
$$ -*- mode: c++; -*-
|
||||
$var n = 50 $$ Maximum length of type lists we want to support.
|
||||
// Copyright 2008 Google Inc.
|
||||
// All Rights Reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
// Type utilities needed for implementing typed and type-parameterized
|
||||
// tests. This file is generated by a SCRIPT. DO NOT EDIT BY HAND!
|
||||
//
|
||||
// Currently we support at most $n types in a list, and at most $n
|
||||
// type-parameterized tests in one type-parameterized test case.
|
||||
// Please contact googletestframework@googlegroups.com if you need
|
||||
// more.
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
|
||||
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
|
||||
|
||||
#include "gtest/internal/gtest-port.h"
|
||||
#include "gtest/internal/gtest-string.h"
|
||||
|
||||
// #ifdef __GNUC__ is too general here. It is possible to use gcc without using
|
||||
// libstdc++ (which is where cxxabi.h comes from).
|
||||
# ifdef __GLIBCXX__
|
||||
# include <cxxabi.h>
|
||||
# elif defined(__HP_aCC)
|
||||
# include <acxx_demangle.h>
|
||||
# endif // __GLIBCXX__
|
||||
|
||||
namespace testing {
|
||||
namespace internal {
|
||||
|
||||
// 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.
|
||||
template <typename T>
|
||||
String GetTypeName() {
|
||||
# if GTEST_HAS_RTTI
|
||||
|
||||
const char* const name = typeid(T).name();
|
||||
# if defined(__GLIBCXX__) || defined(__HP_aCC)
|
||||
int status = 0;
|
||||
// gcc's implementation of typeid(T).name() mangles the type name,
|
||||
// so we have to demangle it.
|
||||
# ifdef __GLIBCXX__
|
||||
using abi::__cxa_demangle;
|
||||
# endif // __GLIBCXX__
|
||||
char* const readable_name = __cxa_demangle(name, 0, 0, &status);
|
||||
const String name_str(status == 0 ? readable_name : name);
|
||||
free(readable_name);
|
||||
return name_str;
|
||||
# else
|
||||
return name;
|
||||
# endif // __GLIBCXX__ || __HP_aCC
|
||||
|
||||
# else
|
||||
|
||||
return "<type>";
|
||||
|
||||
# endif // GTEST_HAS_RTTI
|
||||
}
|
||||
|
||||
#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
|
||||
|
||||
// AssertyTypeEq<T1, T2>::type is defined iff T1 and T2 are the same
|
||||
// type. This can be used as a compile-time assertion to ensure that
|
||||
// two types are equal.
|
||||
|
||||
template <typename T1, typename T2>
|
||||
struct AssertTypeEq;
|
||||
|
||||
template <typename T>
|
||||
struct AssertTypeEq<T, T> {
|
||||
typedef bool type;
|
||||
};
|
||||
|
||||
// A unique type used as the default value for the arguments of class
|
||||
// template Types. This allows us to simulate variadic templates
|
||||
// (e.g. Types<int>, Type<int, double>, and etc), which C++ doesn't
|
||||
// support directly.
|
||||
struct None {};
|
||||
|
||||
// The following family of struct and struct templates are used to
|
||||
// represent type lists. In particular, TypesN<T1, T2, ..., TN>
|
||||
// represents a type list with N types (T1, T2, ..., and TN) in it.
|
||||
// Except for Types0, every struct in the family has two member types:
|
||||
// Head for the first type in the list, and Tail for the rest of the
|
||||
// list.
|
||||
|
||||
// The empty type list.
|
||||
struct Types0 {};
|
||||
|
||||
// Type lists of length 1, 2, 3, and so on.
|
||||
|
||||
template <typename T1>
|
||||
struct Types1 {
|
||||
typedef T1 Head;
|
||||
typedef Types0 Tail;
|
||||
};
|
||||
|
||||
$range i 2..n
|
||||
|
||||
$for i [[
|
||||
$range j 1..i
|
||||
$range k 2..i
|
||||
template <$for j, [[typename T$j]]>
|
||||
struct Types$i {
|
||||
typedef T1 Head;
|
||||
typedef Types$(i-1)<$for k, [[T$k]]> Tail;
|
||||
};
|
||||
|
||||
|
||||
]]
|
||||
|
||||
} // namespace internal
|
||||
|
||||
// We don't want to require the users to write TypesN<...> directly,
|
||||
// as that would require them to count the length. Types<...> is much
|
||||
// easier to write, but generates horrible messages when there is a
|
||||
// compiler error, as gcc insists on printing out each template
|
||||
// argument, even if it has the default value (this means Types<int>
|
||||
// will appear as Types<int, None, None, ..., None> in the compiler
|
||||
// errors).
|
||||
//
|
||||
// Our solution is to combine the best part of the two approaches: a
|
||||
// user would write Types<T1, ..., TN>, and Google Test will translate
|
||||
// that to TypesN<T1, ..., TN> internally to make error messages
|
||||
// readable. The translation is done by the 'type' member of the
|
||||
// Types template.
|
||||
|
||||
$range i 1..n
|
||||
template <$for i, [[typename T$i = internal::None]]>
|
||||
struct Types {
|
||||
typedef internal::Types$n<$for i, [[T$i]]> type;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Types<$for i, [[internal::None]]> {
|
||||
typedef internal::Types0 type;
|
||||
};
|
||||
|
||||
$range i 1..n-1
|
||||
$for i [[
|
||||
$range j 1..i
|
||||
$range k i+1..n
|
||||
template <$for j, [[typename T$j]]>
|
||||
struct Types<$for j, [[T$j]]$for k[[, internal::None]]> {
|
||||
typedef internal::Types$i<$for j, [[T$j]]> type;
|
||||
};
|
||||
|
||||
]]
|
||||
|
||||
namespace internal {
|
||||
|
||||
# define GTEST_TEMPLATE_ template <typename T> class
|
||||
|
||||
// The template "selector" struct TemplateSel<Tmpl> is used to
|
||||
// represent Tmpl, which must be a class template with one type
|
||||
// parameter, as a type. TemplateSel<Tmpl>::Bind<T>::type is defined
|
||||
// as the type Tmpl<T>. This allows us to actually instantiate the
|
||||
// template "selected" by TemplateSel<Tmpl>.
|
||||
//
|
||||
// This trick is necessary for simulating typedef for class templates,
|
||||
// which C++ doesn't support directly.
|
||||
template <GTEST_TEMPLATE_ Tmpl>
|
||||
struct TemplateSel {
|
||||
template <typename T>
|
||||
struct Bind {
|
||||
typedef Tmpl<T> type;
|
||||
};
|
||||
};
|
||||
|
||||
# define GTEST_BIND_(TmplSel, T) \
|
||||
TmplSel::template Bind<T>::type
|
||||
|
||||
// A unique struct template used as the default value for the
|
||||
// arguments of class template Templates. This allows us to simulate
|
||||
// variadic templates (e.g. Templates<int>, Templates<int, double>,
|
||||
// and etc), which C++ doesn't support directly.
|
||||
template <typename T>
|
||||
struct NoneT {};
|
||||
|
||||
// The following family of struct and struct templates are used to
|
||||
// represent template lists. In particular, TemplatesN<T1, T2, ...,
|
||||
// TN> represents a list of N templates (T1, T2, ..., and TN). Except
|
||||
// for Templates0, every struct in the family has two member types:
|
||||
// Head for the selector of the first template in the list, and Tail
|
||||
// for the rest of the list.
|
||||
|
||||
// The empty template list.
|
||||
struct Templates0 {};
|
||||
|
||||
// Template lists of length 1, 2, 3, and so on.
|
||||
|
||||
template <GTEST_TEMPLATE_ T1>
|
||||
struct Templates1 {
|
||||
typedef TemplateSel<T1> Head;
|
||||
typedef Templates0 Tail;
|
||||
};
|
||||
|
||||
$range i 2..n
|
||||
|
||||
$for i [[
|
||||
$range j 1..i
|
||||
$range k 2..i
|
||||
template <$for j, [[GTEST_TEMPLATE_ T$j]]>
|
||||
struct Templates$i {
|
||||
typedef TemplateSel<T1> Head;
|
||||
typedef Templates$(i-1)<$for k, [[T$k]]> Tail;
|
||||
};
|
||||
|
||||
|
||||
]]
|
||||
|
||||
// We don't want to require the users to write TemplatesN<...> directly,
|
||||
// as that would require them to count the length. Templates<...> is much
|
||||
// easier to write, but generates horrible messages when there is a
|
||||
// compiler error, as gcc insists on printing out each template
|
||||
// argument, even if it has the default value (this means Templates<list>
|
||||
// will appear as Templates<list, NoneT, NoneT, ..., NoneT> in the compiler
|
||||
// errors).
|
||||
//
|
||||
// Our solution is to combine the best part of the two approaches: a
|
||||
// user would write Templates<T1, ..., TN>, and Google Test will translate
|
||||
// that to TemplatesN<T1, ..., TN> internally to make error messages
|
||||
// readable. The translation is done by the 'type' member of the
|
||||
// Templates template.
|
||||
|
||||
$range i 1..n
|
||||
template <$for i, [[GTEST_TEMPLATE_ T$i = NoneT]]>
|
||||
struct Templates {
|
||||
typedef Templates$n<$for i, [[T$i]]> type;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Templates<$for i, [[NoneT]]> {
|
||||
typedef Templates0 type;
|
||||
};
|
||||
|
||||
$range i 1..n-1
|
||||
$for i [[
|
||||
$range j 1..i
|
||||
$range k i+1..n
|
||||
template <$for j, [[GTEST_TEMPLATE_ T$j]]>
|
||||
struct Templates<$for j, [[T$j]]$for k[[, NoneT]]> {
|
||||
typedef Templates$i<$for j, [[T$j]]> type;
|
||||
};
|
||||
|
||||
]]
|
||||
|
||||
// The TypeList template makes it possible to use either a single type
|
||||
// or a Types<...> list in TYPED_TEST_CASE() and
|
||||
// INSTANTIATE_TYPED_TEST_CASE_P().
|
||||
|
||||
template <typename T>
|
||||
struct TypeList { typedef Types1<T> type; };
|
||||
|
||||
|
||||
$range i 1..n
|
||||
template <$for i, [[typename T$i]]>
|
||||
struct TypeList<Types<$for i, [[T$i]]> > {
|
||||
typedef typename Types<$for i, [[T$i]]>::type type;
|
||||
};
|
||||
|
||||
#endif // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
|
||||
|
||||
} // namespace internal
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
|
48
gtest/src/gtest-all.cc
Normal file
48
gtest/src/gtest-all.cc
Normal file
@ -0,0 +1,48 @@
|
||||
// Copyright 2008, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: mheule@google.com (Markus Heule)
|
||||
//
|
||||
// Google C++ Testing Framework (Google Test)
|
||||
//
|
||||
// Sometimes it's desirable to build Google Test by compiling a single file.
|
||||
// This file serves this purpose.
|
||||
|
||||
// This line ensures that gtest.h can be compiled on its own, even
|
||||
// when it's fused.
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
// The following lines pull in the real gtest *.cc files.
|
||||
#include "src/gtest.cc"
|
||||
#include "src/gtest-death-test.cc"
|
||||
#include "src/gtest-filepath.cc"
|
||||
#include "src/gtest-port.cc"
|
||||
#include "src/gtest-printers.cc"
|
||||
#include "src/gtest-test-part.cc"
|
||||
#include "src/gtest-typed-test.cc"
|
1234
gtest/src/gtest-death-test.cc
Normal file
1234
gtest/src/gtest-death-test.cc
Normal file
File diff suppressed because it is too large
Load Diff
380
gtest/src/gtest-filepath.cc
Normal file
380
gtest/src/gtest-filepath.cc
Normal file
@ -0,0 +1,380 @@
|
||||
// Copyright 2008, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Authors: keith.ray@gmail.com (Keith Ray)
|
||||
|
||||
#include "gtest/internal/gtest-filepath.h"
|
||||
#include "gtest/internal/gtest-port.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#if GTEST_OS_WINDOWS_MOBILE
|
||||
# include <windows.h>
|
||||
#elif GTEST_OS_WINDOWS
|
||||
# include <direct.h>
|
||||
# include <io.h>
|
||||
#elif GTEST_OS_SYMBIAN || GTEST_OS_NACL
|
||||
// Symbian OpenC and NaCl have PATH_MAX in sys/syslimits.h
|
||||
# include <sys/syslimits.h>
|
||||
#else
|
||||
# include <limits.h>
|
||||
# include <climits> // Some Linux distributions define PATH_MAX here.
|
||||
#endif // GTEST_OS_WINDOWS_MOBILE
|
||||
|
||||
#if GTEST_OS_WINDOWS
|
||||
# define GTEST_PATH_MAX_ _MAX_PATH
|
||||
#elif defined(PATH_MAX)
|
||||
# define GTEST_PATH_MAX_ PATH_MAX
|
||||
#elif defined(_XOPEN_PATH_MAX)
|
||||
# define GTEST_PATH_MAX_ _XOPEN_PATH_MAX
|
||||
#else
|
||||
# define GTEST_PATH_MAX_ _POSIX_PATH_MAX
|
||||
#endif // GTEST_OS_WINDOWS
|
||||
|
||||
#include "gtest/internal/gtest-string.h"
|
||||
|
||||
namespace testing {
|
||||
namespace internal {
|
||||
|
||||
#if GTEST_OS_WINDOWS
|
||||
// On Windows, '\\' is the standard path separator, but many tools and the
|
||||
// Windows API also accept '/' as an alternate path separator. Unless otherwise
|
||||
// noted, a file path can contain either kind of path separators, or a mixture
|
||||
// of them.
|
||||
const char kPathSeparator = '\\';
|
||||
const char kAlternatePathSeparator = '/';
|
||||
const char kPathSeparatorString[] = "\\";
|
||||
const char kAlternatePathSeparatorString[] = "/";
|
||||
# if GTEST_OS_WINDOWS_MOBILE
|
||||
// Windows CE doesn't have a current directory. You should not use
|
||||
// the current directory in tests on Windows CE, but this at least
|
||||
// provides a reasonable fallback.
|
||||
const char kCurrentDirectoryString[] = "\\";
|
||||
// Windows CE doesn't define INVALID_FILE_ATTRIBUTES
|
||||
const DWORD kInvalidFileAttributes = 0xffffffff;
|
||||
# else
|
||||
const char kCurrentDirectoryString[] = ".\\";
|
||||
# endif // GTEST_OS_WINDOWS_MOBILE
|
||||
#else
|
||||
const char kPathSeparator = '/';
|
||||
const char kPathSeparatorString[] = "/";
|
||||
const char kCurrentDirectoryString[] = "./";
|
||||
#endif // GTEST_OS_WINDOWS
|
||||
|
||||
// Returns whether the given character is a valid path separator.
|
||||
static bool IsPathSeparator(char c) {
|
||||
#if GTEST_HAS_ALT_PATH_SEP_
|
||||
return (c == kPathSeparator) || (c == kAlternatePathSeparator);
|
||||
#else
|
||||
return c == kPathSeparator;
|
||||
#endif
|
||||
}
|
||||
|
||||
// Returns the current working directory, or "" if unsuccessful.
|
||||
FilePath FilePath::GetCurrentDir() {
|
||||
#if GTEST_OS_WINDOWS_MOBILE
|
||||
// Windows CE doesn't have a current directory, so we just return
|
||||
// something reasonable.
|
||||
return FilePath(kCurrentDirectoryString);
|
||||
#elif GTEST_OS_WINDOWS
|
||||
char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
|
||||
return FilePath(_getcwd(cwd, sizeof(cwd)) == NULL ? "" : cwd);
|
||||
#else
|
||||
char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
|
||||
return FilePath(getcwd(cwd, sizeof(cwd)) == NULL ? "" : cwd);
|
||||
#endif // GTEST_OS_WINDOWS_MOBILE
|
||||
}
|
||||
|
||||
// Returns a copy of the FilePath with the case-insensitive extension removed.
|
||||
// Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
|
||||
// FilePath("dir/file"). If a case-insensitive extension is not
|
||||
// found, returns a copy of the original FilePath.
|
||||
FilePath FilePath::RemoveExtension(const char* extension) const {
|
||||
String dot_extension(String::Format(".%s", extension));
|
||||
if (pathname_.EndsWithCaseInsensitive(dot_extension.c_str())) {
|
||||
return FilePath(String(pathname_.c_str(), pathname_.length() - 4));
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
// Returns a pointer to the last occurence of a valid path separator in
|
||||
// the FilePath. On Windows, for example, both '/' and '\' are valid path
|
||||
// separators. Returns NULL if no path separator was found.
|
||||
const char* FilePath::FindLastPathSeparator() const {
|
||||
const char* const last_sep = strrchr(c_str(), kPathSeparator);
|
||||
#if GTEST_HAS_ALT_PATH_SEP_
|
||||
const char* const last_alt_sep = strrchr(c_str(), kAlternatePathSeparator);
|
||||
// Comparing two pointers of which only one is NULL is undefined.
|
||||
if (last_alt_sep != NULL &&
|
||||
(last_sep == NULL || last_alt_sep > last_sep)) {
|
||||
return last_alt_sep;
|
||||
}
|
||||
#endif
|
||||
return last_sep;
|
||||
}
|
||||
|
||||
// Returns a copy of the FilePath with the directory part removed.
|
||||
// Example: FilePath("path/to/file").RemoveDirectoryName() returns
|
||||
// FilePath("file"). If there is no directory part ("just_a_file"), it returns
|
||||
// the FilePath unmodified. If there is no file part ("just_a_dir/") it
|
||||
// returns an empty FilePath ("").
|
||||
// On Windows platform, '\' is the path separator, otherwise it is '/'.
|
||||
FilePath FilePath::RemoveDirectoryName() const {
|
||||
const char* const last_sep = FindLastPathSeparator();
|
||||
return last_sep ? FilePath(String(last_sep + 1)) : *this;
|
||||
}
|
||||
|
||||
// RemoveFileName returns the directory path with the filename removed.
|
||||
// Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
|
||||
// If the FilePath is "a_file" or "/a_file", RemoveFileName returns
|
||||
// FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
|
||||
// not have a file, like "just/a/dir/", it returns the FilePath unmodified.
|
||||
// On Windows platform, '\' is the path separator, otherwise it is '/'.
|
||||
FilePath FilePath::RemoveFileName() const {
|
||||
const char* const last_sep = FindLastPathSeparator();
|
||||
String dir;
|
||||
if (last_sep) {
|
||||
dir = String(c_str(), last_sep + 1 - c_str());
|
||||
} else {
|
||||
dir = kCurrentDirectoryString;
|
||||
}
|
||||
return FilePath(dir);
|
||||
}
|
||||
|
||||
// Helper functions for naming files in a directory for xml output.
|
||||
|
||||
// Given directory = "dir", base_name = "test", number = 0,
|
||||
// extension = "xml", returns "dir/test.xml". If number is greater
|
||||
// than zero (e.g., 12), returns "dir/test_12.xml".
|
||||
// On Windows platform, uses \ as the separator rather than /.
|
||||
FilePath FilePath::MakeFileName(const FilePath& directory,
|
||||
const FilePath& base_name,
|
||||
int number,
|
||||
const char* extension) {
|
||||
String file;
|
||||
if (number == 0) {
|
||||
file = String::Format("%s.%s", base_name.c_str(), extension);
|
||||
} else {
|
||||
file = String::Format("%s_%d.%s", base_name.c_str(), number, extension);
|
||||
}
|
||||
return ConcatPaths(directory, FilePath(file));
|
||||
}
|
||||
|
||||
// Given directory = "dir", relative_path = "test.xml", returns "dir/test.xml".
|
||||
// On Windows, uses \ as the separator rather than /.
|
||||
FilePath FilePath::ConcatPaths(const FilePath& directory,
|
||||
const FilePath& relative_path) {
|
||||
if (directory.IsEmpty())
|
||||
return relative_path;
|
||||
const FilePath dir(directory.RemoveTrailingPathSeparator());
|
||||
return FilePath(String::Format("%s%c%s", dir.c_str(), kPathSeparator,
|
||||
relative_path.c_str()));
|
||||
}
|
||||
|
||||
// Returns true if pathname describes something findable in the file-system,
|
||||
// either a file, directory, or whatever.
|
||||
bool FilePath::FileOrDirectoryExists() const {
|
||||
#if GTEST_OS_WINDOWS_MOBILE
|
||||
LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str());
|
||||
const DWORD attributes = GetFileAttributes(unicode);
|
||||
delete [] unicode;
|
||||
return attributes != kInvalidFileAttributes;
|
||||
#else
|
||||
posix::StatStruct file_stat;
|
||||
return posix::Stat(pathname_.c_str(), &file_stat) == 0;
|
||||
#endif // GTEST_OS_WINDOWS_MOBILE
|
||||
}
|
||||
|
||||
// Returns true if pathname describes a directory in the file-system
|
||||
// that exists.
|
||||
bool FilePath::DirectoryExists() const {
|
||||
bool result = false;
|
||||
#if GTEST_OS_WINDOWS
|
||||
// Don't strip off trailing separator if path is a root directory on
|
||||
// Windows (like "C:\\").
|
||||
const FilePath& path(IsRootDirectory() ? *this :
|
||||
RemoveTrailingPathSeparator());
|
||||
#else
|
||||
const FilePath& path(*this);
|
||||
#endif
|
||||
|
||||
#if GTEST_OS_WINDOWS_MOBILE
|
||||
LPCWSTR unicode = String::AnsiToUtf16(path.c_str());
|
||||
const DWORD attributes = GetFileAttributes(unicode);
|
||||
delete [] unicode;
|
||||
if ((attributes != kInvalidFileAttributes) &&
|
||||
(attributes & FILE_ATTRIBUTE_DIRECTORY)) {
|
||||
result = true;
|
||||
}
|
||||
#else
|
||||
posix::StatStruct file_stat;
|
||||
result = posix::Stat(path.c_str(), &file_stat) == 0 &&
|
||||
posix::IsDir(file_stat);
|
||||
#endif // GTEST_OS_WINDOWS_MOBILE
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// Returns true if pathname describes a root directory. (Windows has one
|
||||
// root directory per disk drive.)
|
||||
bool FilePath::IsRootDirectory() const {
|
||||
#if GTEST_OS_WINDOWS
|
||||
// TODO(wan@google.com): 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();
|
||||
#else
|
||||
return pathname_.length() == 1 && IsPathSeparator(pathname_.c_str()[0]);
|
||||
#endif
|
||||
}
|
||||
|
||||
// Returns true if pathname describes an absolute path.
|
||||
bool FilePath::IsAbsolutePath() const {
|
||||
const char* const name = pathname_.c_str();
|
||||
#if GTEST_OS_WINDOWS
|
||||
return pathname_.length() >= 3 &&
|
||||
((name[0] >= 'a' && name[0] <= 'z') ||
|
||||
(name[0] >= 'A' && name[0] <= 'Z')) &&
|
||||
name[1] == ':' &&
|
||||
IsPathSeparator(name[2]);
|
||||
#else
|
||||
return IsPathSeparator(name[0]);
|
||||
#endif
|
||||
}
|
||||
|
||||
// Returns a pathname for a file that does not currently exist. The pathname
|
||||
// will be directory/base_name.extension or
|
||||
// directory/base_name_<number>.extension if directory/base_name.extension
|
||||
// already exists. The number will be incremented until a pathname is found
|
||||
// that does not already exist.
|
||||
// Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
|
||||
// There could be a race condition if two or more processes are calling this
|
||||
// function at the same time -- they could both pick the same filename.
|
||||
FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
|
||||
const FilePath& base_name,
|
||||
const char* extension) {
|
||||
FilePath full_pathname;
|
||||
int number = 0;
|
||||
do {
|
||||
full_pathname.Set(MakeFileName(directory, base_name, number++, extension));
|
||||
} while (full_pathname.FileOrDirectoryExists());
|
||||
return full_pathname;
|
||||
}
|
||||
|
||||
// Returns true if FilePath ends with a path separator, which indicates that
|
||||
// it is intended to represent a directory. Returns false otherwise.
|
||||
// This does NOT check that a directory (or file) actually exists.
|
||||
bool FilePath::IsDirectory() const {
|
||||
return !pathname_.empty() &&
|
||||
IsPathSeparator(pathname_.c_str()[pathname_.length() - 1]);
|
||||
}
|
||||
|
||||
// Create directories so that path exists. Returns true if successful or if
|
||||
// the directories already exist; returns false if unable to create directories
|
||||
// for any reason.
|
||||
bool FilePath::CreateDirectoriesRecursively() const {
|
||||
if (!this->IsDirectory()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (pathname_.length() == 0 || this->DirectoryExists()) {
|
||||
return true;
|
||||
}
|
||||
|
||||
const FilePath parent(this->RemoveTrailingPathSeparator().RemoveFileName());
|
||||
return parent.CreateDirectoriesRecursively() && this->CreateFolder();
|
||||
}
|
||||
|
||||
// Create the directory so that path exists. Returns true if successful or
|
||||
// if the directory already exists; returns false if unable to create the
|
||||
// directory for any reason, including if the parent directory does not
|
||||
// exist. Not named "CreateDirectory" because that's a macro on Windows.
|
||||
bool FilePath::CreateFolder() const {
|
||||
#if GTEST_OS_WINDOWS_MOBILE
|
||||
FilePath removed_sep(this->RemoveTrailingPathSeparator());
|
||||
LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str());
|
||||
int result = CreateDirectory(unicode, NULL) ? 0 : -1;
|
||||
delete [] unicode;
|
||||
#elif GTEST_OS_WINDOWS
|
||||
int result = _mkdir(pathname_.c_str());
|
||||
#else
|
||||
int result = mkdir(pathname_.c_str(), 0777);
|
||||
#endif // GTEST_OS_WINDOWS_MOBILE
|
||||
|
||||
if (result == -1) {
|
||||
return this->DirectoryExists(); // An error is OK if the directory exists.
|
||||
}
|
||||
return true; // No error.
|
||||
}
|
||||
|
||||
// If input name has a trailing separator character, remove it and return the
|
||||
// name, otherwise return the name string unmodified.
|
||||
// On Windows platform, uses \ as the separator, other platforms use /.
|
||||
FilePath FilePath::RemoveTrailingPathSeparator() const {
|
||||
return IsDirectory()
|
||||
? FilePath(String(pathname_.c_str(), pathname_.length() - 1))
|
||||
: *this;
|
||||
}
|
||||
|
||||
// Removes any redundant separators that might be in the pathname.
|
||||
// For example, "bar///foo" becomes "bar/foo". Does not eliminate other
|
||||
// redundancies that might be in a pathname involving "." or "..".
|
||||
// TODO(wan@google.com): handle Windows network shares (e.g. \\server\share).
|
||||
void FilePath::Normalize() {
|
||||
if (pathname_.c_str() == NULL) {
|
||||
pathname_ = "";
|
||||
return;
|
||||
}
|
||||
const char* src = pathname_.c_str();
|
||||
char* const dest = new char[pathname_.length() + 1];
|
||||
char* dest_ptr = dest;
|
||||
memset(dest_ptr, 0, pathname_.length() + 1);
|
||||
|
||||
while (*src != '\0') {
|
||||
*dest_ptr = *src;
|
||||
if (!IsPathSeparator(*src)) {
|
||||
src++;
|
||||
} else {
|
||||
#if GTEST_HAS_ALT_PATH_SEP_
|
||||
if (*dest_ptr == kAlternatePathSeparator) {
|
||||
*dest_ptr = kPathSeparator;
|
||||
}
|
||||
#endif
|
||||
while (IsPathSeparator(*src))
|
||||
src++;
|
||||
}
|
||||
dest_ptr++;
|
||||
}
|
||||
*dest_ptr = '\0';
|
||||
pathname_ = dest;
|
||||
delete[] dest;
|
||||
}
|
||||
|
||||
} // namespace internal
|
||||
} // namespace testing
|
1038
gtest/src/gtest-internal-inl.h
Normal file
1038
gtest/src/gtest-internal-inl.h
Normal file
File diff suppressed because it is too large
Load Diff
746
gtest/src/gtest-port.cc
Normal file
746
gtest/src/gtest-port.cc
Normal file
@ -0,0 +1,746 @@
|
||||
// Copyright 2008, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
#include "gtest/internal/gtest-port.h"
|
||||
|
||||
#include <limits.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#if GTEST_OS_WINDOWS_MOBILE
|
||||
# include <windows.h> // For TerminateProcess()
|
||||
#elif GTEST_OS_WINDOWS
|
||||
# include <io.h>
|
||||
# include <sys/stat.h>
|
||||
#else
|
||||
# include <unistd.h>
|
||||
#endif // GTEST_OS_WINDOWS_MOBILE
|
||||
|
||||
#if GTEST_OS_MAC
|
||||
# include <mach/mach_init.h>
|
||||
# include <mach/task.h>
|
||||
# include <mach/vm_map.h>
|
||||
#endif // GTEST_OS_MAC
|
||||
|
||||
#include "gtest/gtest-spi.h"
|
||||
#include "gtest/gtest-message.h"
|
||||
#include "gtest/internal/gtest-internal.h"
|
||||
#include "gtest/internal/gtest-string.h"
|
||||
|
||||
// Indicates that this translation unit is part of Google Test's
|
||||
// implementation. It must come before gtest-internal-inl.h is
|
||||
// included, or there will be a compiler error. This trick is to
|
||||
// prevent a user from accidentally including gtest-internal-inl.h in
|
||||
// his code.
|
||||
#define GTEST_IMPLEMENTATION_ 1
|
||||
#include "src/gtest-internal-inl.h"
|
||||
#undef GTEST_IMPLEMENTATION_
|
||||
|
||||
namespace testing {
|
||||
namespace internal {
|
||||
|
||||
#if defined(_MSC_VER) || defined(__BORLANDC__)
|
||||
// MSVC and C++Builder do not provide a definition of STDERR_FILENO.
|
||||
const int kStdOutFileno = 1;
|
||||
const int kStdErrFileno = 2;
|
||||
#else
|
||||
const int kStdOutFileno = STDOUT_FILENO;
|
||||
const int kStdErrFileno = STDERR_FILENO;
|
||||
#endif // _MSC_VER
|
||||
|
||||
#if GTEST_OS_MAC
|
||||
|
||||
// Returns the number of threads running in the process, or 0 to indicate that
|
||||
// we cannot detect it.
|
||||
size_t GetThreadCount() {
|
||||
const task_t task = mach_task_self();
|
||||
mach_msg_type_number_t thread_count;
|
||||
thread_act_array_t thread_list;
|
||||
const kern_return_t status = task_threads(task, &thread_list, &thread_count);
|
||||
if (status == KERN_SUCCESS) {
|
||||
// task_threads allocates resources in thread_list and we need to free them
|
||||
// to avoid leaks.
|
||||
vm_deallocate(task,
|
||||
reinterpret_cast<vm_address_t>(thread_list),
|
||||
sizeof(thread_t) * thread_count);
|
||||
return static_cast<size_t>(thread_count);
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
size_t GetThreadCount() {
|
||||
// There's no portable way to detect the number of threads, so we just
|
||||
// return 0 to indicate that we cannot detect it.
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif // GTEST_OS_MAC
|
||||
|
||||
#if GTEST_USES_POSIX_RE
|
||||
|
||||
// Implements RE. Currently only needed for death tests.
|
||||
|
||||
RE::~RE() {
|
||||
if (is_valid_) {
|
||||
// regfree'ing an invalid regex might crash because the content
|
||||
// of the regex is undefined. Since the regex's are essentially
|
||||
// the same, one cannot be valid (or invalid) without the other
|
||||
// being so too.
|
||||
regfree(&partial_regex_);
|
||||
regfree(&full_regex_);
|
||||
}
|
||||
free(const_cast<char*>(pattern_));
|
||||
}
|
||||
|
||||
// Returns true iff regular expression re matches the entire str.
|
||||
bool RE::FullMatch(const char* str, const RE& re) {
|
||||
if (!re.is_valid_) return false;
|
||||
|
||||
regmatch_t match;
|
||||
return regexec(&re.full_regex_, str, 1, &match, 0) == 0;
|
||||
}
|
||||
|
||||
// Returns true iff regular expression re matches a substring of str
|
||||
// (including str itself).
|
||||
bool RE::PartialMatch(const char* str, const RE& re) {
|
||||
if (!re.is_valid_) return false;
|
||||
|
||||
regmatch_t match;
|
||||
return regexec(&re.partial_regex_, str, 1, &match, 0) == 0;
|
||||
}
|
||||
|
||||
// Initializes an RE from its string representation.
|
||||
void RE::Init(const char* regex) {
|
||||
pattern_ = posix::StrDup(regex);
|
||||
|
||||
// Reserves enough bytes to hold the regular expression used for a
|
||||
// full match.
|
||||
const size_t full_regex_len = strlen(regex) + 10;
|
||||
char* const full_pattern = new char[full_regex_len];
|
||||
|
||||
snprintf(full_pattern, full_regex_len, "^(%s)$", regex);
|
||||
is_valid_ = regcomp(&full_regex_, full_pattern, REG_EXTENDED) == 0;
|
||||
// We want to call regcomp(&partial_regex_, ...) even if the
|
||||
// previous expression returns false. Otherwise partial_regex_ may
|
||||
// not be properly initialized can may cause trouble when it's
|
||||
// freed.
|
||||
//
|
||||
// Some implementation of POSIX regex (e.g. on at least some
|
||||
// versions of Cygwin) doesn't accept the empty string as a valid
|
||||
// regex. We change it to an equivalent form "()" to be safe.
|
||||
if (is_valid_) {
|
||||
const char* const partial_regex = (*regex == '\0') ? "()" : regex;
|
||||
is_valid_ = regcomp(&partial_regex_, partial_regex, REG_EXTENDED) == 0;
|
||||
}
|
||||
EXPECT_TRUE(is_valid_)
|
||||
<< "Regular expression \"" << regex
|
||||
<< "\" is not a valid POSIX Extended regular expression.";
|
||||
|
||||
delete[] full_pattern;
|
||||
}
|
||||
|
||||
#elif GTEST_USES_SIMPLE_RE
|
||||
|
||||
// Returns true iff ch appears anywhere in str (excluding the
|
||||
// terminating '\0' character).
|
||||
bool IsInSet(char ch, const char* str) {
|
||||
return ch != '\0' && strchr(str, ch) != NULL;
|
||||
}
|
||||
|
||||
// Returns true iff ch belongs to the given classification. Unlike
|
||||
// similar functions in <ctype.h>, these aren't affected by the
|
||||
// current locale.
|
||||
bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
|
||||
bool IsAsciiPunct(char ch) {
|
||||
return IsInSet(ch, "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~");
|
||||
}
|
||||
bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
|
||||
bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
|
||||
bool IsAsciiWordChar(char ch) {
|
||||
return ('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') ||
|
||||
('0' <= ch && ch <= '9') || ch == '_';
|
||||
}
|
||||
|
||||
// Returns true iff "\\c" is a supported escape sequence.
|
||||
bool IsValidEscape(char c) {
|
||||
return (IsAsciiPunct(c) || IsInSet(c, "dDfnrsStvwW"));
|
||||
}
|
||||
|
||||
// Returns true iff the given atom (specified by escaped and pattern)
|
||||
// matches ch. The result is undefined if the atom is invalid.
|
||||
bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
|
||||
if (escaped) { // "\\p" where p is pattern_char.
|
||||
switch (pattern_char) {
|
||||
case 'd': return IsAsciiDigit(ch);
|
||||
case 'D': return !IsAsciiDigit(ch);
|
||||
case 'f': return ch == '\f';
|
||||
case 'n': return ch == '\n';
|
||||
case 'r': return ch == '\r';
|
||||
case 's': return IsAsciiWhiteSpace(ch);
|
||||
case 'S': return !IsAsciiWhiteSpace(ch);
|
||||
case 't': return ch == '\t';
|
||||
case 'v': return ch == '\v';
|
||||
case 'w': return IsAsciiWordChar(ch);
|
||||
case 'W': return !IsAsciiWordChar(ch);
|
||||
}
|
||||
return IsAsciiPunct(pattern_char) && pattern_char == ch;
|
||||
}
|
||||
|
||||
return (pattern_char == '.' && ch != '\n') || pattern_char == ch;
|
||||
}
|
||||
|
||||
// Helper function used by ValidateRegex() to format error messages.
|
||||
String FormatRegexSyntaxError(const char* regex, int index) {
|
||||
return (Message() << "Syntax error at index " << index
|
||||
<< " in simple regular expression \"" << regex << "\": ").GetString();
|
||||
}
|
||||
|
||||
// Generates non-fatal failures and returns false if regex is invalid;
|
||||
// otherwise returns true.
|
||||
bool ValidateRegex(const char* regex) {
|
||||
if (regex == NULL) {
|
||||
// TODO(wan@google.com): 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.";
|
||||
return false;
|
||||
}
|
||||
|
||||
bool is_valid = true;
|
||||
|
||||
// True iff ?, *, or + can follow the previous atom.
|
||||
bool prev_repeatable = false;
|
||||
for (int i = 0; regex[i]; i++) {
|
||||
if (regex[i] == '\\') { // An escape sequence
|
||||
i++;
|
||||
if (regex[i] == '\0') {
|
||||
ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1)
|
||||
<< "'\\' cannot appear at the end.";
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!IsValidEscape(regex[i])) {
|
||||
ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1)
|
||||
<< "invalid escape sequence \"\\" << regex[i] << "\".";
|
||||
is_valid = false;
|
||||
}
|
||||
prev_repeatable = true;
|
||||
} else { // Not an escape sequence.
|
||||
const char ch = regex[i];
|
||||
|
||||
if (ch == '^' && i > 0) {
|
||||
ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
|
||||
<< "'^' can only appear at the beginning.";
|
||||
is_valid = false;
|
||||
} else if (ch == '$' && regex[i + 1] != '\0') {
|
||||
ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
|
||||
<< "'$' can only appear at the end.";
|
||||
is_valid = false;
|
||||
} else if (IsInSet(ch, "()[]{}|")) {
|
||||
ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
|
||||
<< "'" << ch << "' is unsupported.";
|
||||
is_valid = false;
|
||||
} else if (IsRepeat(ch) && !prev_repeatable) {
|
||||
ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
|
||||
<< "'" << ch << "' can only follow a repeatable token.";
|
||||
is_valid = false;
|
||||
}
|
||||
|
||||
prev_repeatable = !IsInSet(ch, "^$?*+");
|
||||
}
|
||||
}
|
||||
|
||||
return is_valid;
|
||||
}
|
||||
|
||||
// Matches a repeated regex atom followed by a valid simple regular
|
||||
// expression. The regex atom is defined as c if escaped is false,
|
||||
// or \c otherwise. repeat is the repetition meta character (?, *,
|
||||
// or +). The behavior is undefined if str contains too many
|
||||
// characters to be indexable by size_t, in which case the test will
|
||||
// probably time out anyway. We are fine with this limitation as
|
||||
// std::string has it too.
|
||||
bool MatchRepetitionAndRegexAtHead(
|
||||
bool escaped, char c, char repeat, const char* regex,
|
||||
const char* str) {
|
||||
const size_t min_count = (repeat == '+') ? 1 : 0;
|
||||
const size_t max_count = (repeat == '?') ? 1 :
|
||||
static_cast<size_t>(-1) - 1;
|
||||
// We cannot call numeric_limits::max() as it conflicts with the
|
||||
// max() macro on Windows.
|
||||
|
||||
for (size_t i = 0; i <= max_count; ++i) {
|
||||
// We know that the atom matches each of the first i characters in str.
|
||||
if (i >= min_count && MatchRegexAtHead(regex, str + i)) {
|
||||
// We have enough matches at the head, and the tail matches too.
|
||||
// Since we only care about *whether* the pattern matches str
|
||||
// (as opposed to *how* it matches), there is no need to find a
|
||||
// greedy match.
|
||||
return true;
|
||||
}
|
||||
if (str[i] == '\0' || !AtomMatchesChar(escaped, c, str[i]))
|
||||
return false;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// Returns true iff regex matches a prefix of str. regex must be a
|
||||
// valid simple regular expression and not start with "^", or the
|
||||
// result is undefined.
|
||||
bool MatchRegexAtHead(const char* regex, const char* str) {
|
||||
if (*regex == '\0') // An empty regex matches a prefix of anything.
|
||||
return true;
|
||||
|
||||
// "$" only matches the end of a string. Note that regex being
|
||||
// valid guarantees that there's nothing after "$" in it.
|
||||
if (*regex == '$')
|
||||
return *str == '\0';
|
||||
|
||||
// Is the first thing in regex an escape sequence?
|
||||
const bool escaped = *regex == '\\';
|
||||
if (escaped)
|
||||
++regex;
|
||||
if (IsRepeat(regex[1])) {
|
||||
// MatchRepetitionAndRegexAtHead() calls MatchRegexAtHead(), so
|
||||
// here's an indirect recursion. It terminates as the regex gets
|
||||
// shorter in each recursion.
|
||||
return MatchRepetitionAndRegexAtHead(
|
||||
escaped, regex[0], regex[1], regex + 2, str);
|
||||
} else {
|
||||
// regex isn't empty, isn't "$", and doesn't start with a
|
||||
// repetition. We match the first atom of regex with the first
|
||||
// character of str and recurse.
|
||||
return (*str != '\0') && AtomMatchesChar(escaped, *regex, *str) &&
|
||||
MatchRegexAtHead(regex + 1, str + 1);
|
||||
}
|
||||
}
|
||||
|
||||
// Returns true iff regex matches any substring of str. regex must be
|
||||
// a valid simple regular expression, or the result is undefined.
|
||||
//
|
||||
// The algorithm is recursive, but the recursion depth doesn't exceed
|
||||
// the regex length, so we won't need to worry about running out of
|
||||
// stack space normally. In rare cases the time complexity can be
|
||||
// exponential with respect to the regex length + the string length,
|
||||
// but usually it's must faster (often close to linear).
|
||||
bool MatchRegexAnywhere(const char* regex, const char* str) {
|
||||
if (regex == NULL || str == NULL)
|
||||
return false;
|
||||
|
||||
if (*regex == '^')
|
||||
return MatchRegexAtHead(regex + 1, str);
|
||||
|
||||
// A successful match can be anywhere in str.
|
||||
do {
|
||||
if (MatchRegexAtHead(regex, str))
|
||||
return true;
|
||||
} while (*str++ != '\0');
|
||||
return false;
|
||||
}
|
||||
|
||||
// Implements the RE class.
|
||||
|
||||
RE::~RE() {
|
||||
free(const_cast<char*>(pattern_));
|
||||
free(const_cast<char*>(full_pattern_));
|
||||
}
|
||||
|
||||
// Returns true iff regular expression re matches the entire str.
|
||||
bool RE::FullMatch(const char* str, const RE& re) {
|
||||
return re.is_valid_ && MatchRegexAnywhere(re.full_pattern_, str);
|
||||
}
|
||||
|
||||
// Returns true iff regular expression re matches a substring of str
|
||||
// (including str itself).
|
||||
bool RE::PartialMatch(const char* str, const RE& re) {
|
||||
return re.is_valid_ && MatchRegexAnywhere(re.pattern_, str);
|
||||
}
|
||||
|
||||
// Initializes an RE from its string representation.
|
||||
void RE::Init(const char* regex) {
|
||||
pattern_ = full_pattern_ = NULL;
|
||||
if (regex != NULL) {
|
||||
pattern_ = posix::StrDup(regex);
|
||||
}
|
||||
|
||||
is_valid_ = ValidateRegex(regex);
|
||||
if (!is_valid_) {
|
||||
// No need to calculate the full pattern when the regex is invalid.
|
||||
return;
|
||||
}
|
||||
|
||||
const size_t len = strlen(regex);
|
||||
// Reserves enough bytes to hold the regular expression used for a
|
||||
// full match: we need space to prepend a '^', append a '$', and
|
||||
// terminate the string with '\0'.
|
||||
char* buffer = static_cast<char*>(malloc(len + 3));
|
||||
full_pattern_ = buffer;
|
||||
|
||||
if (*regex != '^')
|
||||
*buffer++ = '^'; // Makes sure full_pattern_ starts with '^'.
|
||||
|
||||
// We don't use snprintf or strncpy, as they trigger a warning when
|
||||
// compiled with VC++ 8.0.
|
||||
memcpy(buffer, regex, len);
|
||||
buffer += len;
|
||||
|
||||
if (len == 0 || regex[len - 1] != '$')
|
||||
*buffer++ = '$'; // Makes sure full_pattern_ ends with '$'.
|
||||
|
||||
*buffer = '\0';
|
||||
}
|
||||
|
||||
#endif // GTEST_USES_POSIX_RE
|
||||
|
||||
const char kUnknownFile[] = "unknown file";
|
||||
|
||||
// Formats a source file path and a line number as they would appear
|
||||
// in an error message from the compiler used to compile this code.
|
||||
GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
|
||||
const char* const file_name = file == NULL ? kUnknownFile : file;
|
||||
|
||||
if (line < 0) {
|
||||
return String::Format("%s:", file_name).c_str();
|
||||
}
|
||||
#ifdef _MSC_VER
|
||||
return String::Format("%s(%d):", file_name, line).c_str();
|
||||
#else
|
||||
return String::Format("%s:%d:", file_name, line).c_str();
|
||||
#endif // _MSC_VER
|
||||
}
|
||||
|
||||
// Formats a file location for compiler-independent XML output.
|
||||
// Although this function is not platform dependent, we put it next to
|
||||
// FormatFileLocation in order to contrast the two functions.
|
||||
// Note that FormatCompilerIndependentFileLocation() does NOT append colon
|
||||
// to the file location it produces, unlike FormatFileLocation().
|
||||
GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
|
||||
const char* file, int line) {
|
||||
const char* const file_name = file == NULL ? kUnknownFile : file;
|
||||
|
||||
if (line < 0)
|
||||
return file_name;
|
||||
else
|
||||
return String::Format("%s:%d", file_name, line).c_str();
|
||||
}
|
||||
|
||||
|
||||
GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line)
|
||||
: severity_(severity) {
|
||||
const char* const marker =
|
||||
severity == GTEST_INFO ? "[ INFO ]" :
|
||||
severity == GTEST_WARNING ? "[WARNING]" :
|
||||
severity == GTEST_ERROR ? "[ ERROR ]" : "[ FATAL ]";
|
||||
GetStream() << ::std::endl << marker << " "
|
||||
<< FormatFileLocation(file, line).c_str() << ": ";
|
||||
}
|
||||
|
||||
// Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
|
||||
GTestLog::~GTestLog() {
|
||||
GetStream() << ::std::endl;
|
||||
if (severity_ == GTEST_FATAL) {
|
||||
fflush(stderr);
|
||||
posix::Abort();
|
||||
}
|
||||
}
|
||||
// Disable Microsoft deprecation warnings for POSIX functions called from
|
||||
// this class (creat, dup, dup2, and close)
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable: 4996)
|
||||
#endif // _MSC_VER
|
||||
|
||||
#if GTEST_HAS_STREAM_REDIRECTION
|
||||
|
||||
// Object that captures an output stream (stdout/stderr).
|
||||
class CapturedStream {
|
||||
public:
|
||||
// The ctor redirects the stream to a temporary file.
|
||||
CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
|
||||
|
||||
# if GTEST_OS_WINDOWS
|
||||
char temp_dir_path[MAX_PATH + 1] = { '\0' }; // NOLINT
|
||||
char temp_file_path[MAX_PATH + 1] = { '\0' }; // NOLINT
|
||||
|
||||
::GetTempPathA(sizeof(temp_dir_path), temp_dir_path);
|
||||
const UINT success = ::GetTempFileNameA(temp_dir_path,
|
||||
"gtest_redir",
|
||||
0, // Generate unique file name.
|
||||
temp_file_path);
|
||||
GTEST_CHECK_(success != 0)
|
||||
<< "Unable to create a temporary file in " << temp_dir_path;
|
||||
const int captured_fd = creat(temp_file_path, _S_IREAD | _S_IWRITE);
|
||||
GTEST_CHECK_(captured_fd != -1) << "Unable to open temporary file "
|
||||
<< temp_file_path;
|
||||
filename_ = temp_file_path;
|
||||
# else
|
||||
// There's no guarantee that a test has write access to the
|
||||
// current directory, so we create the temporary file in the /tmp
|
||||
// directory instead.
|
||||
char name_template[] = "/tmp/captured_stream.XXXXXX";
|
||||
const int captured_fd = mkstemp(name_template);
|
||||
filename_ = name_template;
|
||||
# endif // GTEST_OS_WINDOWS
|
||||
fflush(NULL);
|
||||
dup2(captured_fd, fd_);
|
||||
close(captured_fd);
|
||||
}
|
||||
|
||||
~CapturedStream() {
|
||||
remove(filename_.c_str());
|
||||
}
|
||||
|
||||
String GetCapturedString() {
|
||||
if (uncaptured_fd_ != -1) {
|
||||
// Restores the original stream.
|
||||
fflush(NULL);
|
||||
dup2(uncaptured_fd_, fd_);
|
||||
close(uncaptured_fd_);
|
||||
uncaptured_fd_ = -1;
|
||||
}
|
||||
|
||||
FILE* const file = posix::FOpen(filename_.c_str(), "r");
|
||||
const String content = ReadEntireFile(file);
|
||||
posix::FClose(file);
|
||||
return content;
|
||||
}
|
||||
|
||||
private:
|
||||
// Reads the entire content of a file as a String.
|
||||
static String ReadEntireFile(FILE* file);
|
||||
|
||||
// Returns the size (in bytes) of a file.
|
||||
static size_t GetFileSize(FILE* file);
|
||||
|
||||
const int fd_; // A stream to capture.
|
||||
int uncaptured_fd_;
|
||||
// Name of the temporary file holding the stderr output.
|
||||
::std::string filename_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(CapturedStream);
|
||||
};
|
||||
|
||||
// Returns the size (in bytes) of a file.
|
||||
size_t CapturedStream::GetFileSize(FILE* file) {
|
||||
fseek(file, 0, SEEK_END);
|
||||
return static_cast<size_t>(ftell(file));
|
||||
}
|
||||
|
||||
// Reads the entire content of a file as a string.
|
||||
String CapturedStream::ReadEntireFile(FILE* file) {
|
||||
const size_t file_size = GetFileSize(file);
|
||||
char* const buffer = new char[file_size];
|
||||
|
||||
size_t bytes_last_read = 0; // # of bytes read in the last fread()
|
||||
size_t bytes_read = 0; // # of bytes read so far
|
||||
|
||||
fseek(file, 0, SEEK_SET);
|
||||
|
||||
// Keeps reading the file until we cannot read further or the
|
||||
// pre-determined file size is reached.
|
||||
do {
|
||||
bytes_last_read = fread(buffer+bytes_read, 1, file_size-bytes_read, file);
|
||||
bytes_read += bytes_last_read;
|
||||
} while (bytes_last_read > 0 && bytes_read < file_size);
|
||||
|
||||
const String content(buffer, bytes_read);
|
||||
delete[] buffer;
|
||||
|
||||
return content;
|
||||
}
|
||||
|
||||
# ifdef _MSC_VER
|
||||
# pragma warning(pop)
|
||||
# endif // _MSC_VER
|
||||
|
||||
static CapturedStream* g_captured_stderr = NULL;
|
||||
static CapturedStream* g_captured_stdout = NULL;
|
||||
|
||||
// Starts capturing an output stream (stdout/stderr).
|
||||
void CaptureStream(int fd, const char* stream_name, CapturedStream** stream) {
|
||||
if (*stream != NULL) {
|
||||
GTEST_LOG_(FATAL) << "Only one " << stream_name
|
||||
<< " capturer can exist at a time.";
|
||||
}
|
||||
*stream = new CapturedStream(fd);
|
||||
}
|
||||
|
||||
// Stops capturing the output stream and returns the captured string.
|
||||
String GetCapturedStream(CapturedStream** captured_stream) {
|
||||
const String content = (*captured_stream)->GetCapturedString();
|
||||
|
||||
delete *captured_stream;
|
||||
*captured_stream = NULL;
|
||||
|
||||
return content;
|
||||
}
|
||||
|
||||
// Starts capturing stdout.
|
||||
void CaptureStdout() {
|
||||
CaptureStream(kStdOutFileno, "stdout", &g_captured_stdout);
|
||||
}
|
||||
|
||||
// Starts capturing stderr.
|
||||
void CaptureStderr() {
|
||||
CaptureStream(kStdErrFileno, "stderr", &g_captured_stderr);
|
||||
}
|
||||
|
||||
// Stops capturing stdout and returns the captured string.
|
||||
String GetCapturedStdout() { return GetCapturedStream(&g_captured_stdout); }
|
||||
|
||||
// Stops capturing stderr and returns the captured string.
|
||||
String GetCapturedStderr() { return GetCapturedStream(&g_captured_stderr); }
|
||||
|
||||
#endif // GTEST_HAS_STREAM_REDIRECTION
|
||||
|
||||
#if GTEST_HAS_DEATH_TEST
|
||||
|
||||
// A copy of all command line arguments. Set by InitGoogleTest().
|
||||
::std::vector<String> g_argvs;
|
||||
|
||||
// Returns the command line as a vector of strings.
|
||||
const ::std::vector<String>& GetArgvs() { return g_argvs; }
|
||||
|
||||
#endif // GTEST_HAS_DEATH_TEST
|
||||
|
||||
#if GTEST_OS_WINDOWS_MOBILE
|
||||
namespace posix {
|
||||
void Abort() {
|
||||
DebugBreak();
|
||||
TerminateProcess(GetCurrentProcess(), 1);
|
||||
}
|
||||
} // namespace posix
|
||||
#endif // GTEST_OS_WINDOWS_MOBILE
|
||||
|
||||
// Returns the name of the environment variable corresponding to the
|
||||
// given flag. For example, FlagToEnvVar("foo") will return
|
||||
// "GTEST_FOO" in the open-source version.
|
||||
static String FlagToEnvVar(const char* flag) {
|
||||
const String full_flag =
|
||||
(Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
|
||||
|
||||
Message env_var;
|
||||
for (size_t i = 0; i != full_flag.length(); i++) {
|
||||
env_var << ToUpper(full_flag.c_str()[i]);
|
||||
}
|
||||
|
||||
return env_var.GetString();
|
||||
}
|
||||
|
||||
// Parses 'str' for a 32-bit signed integer. If successful, writes
|
||||
// the result to *value and returns true; otherwise leaves *value
|
||||
// unchanged and returns false.
|
||||
bool ParseInt32(const Message& src_text, const char* str, Int32* value) {
|
||||
// Parses the environment variable as a decimal integer.
|
||||
char* end = NULL;
|
||||
const long long_value = strtol(str, &end, 10); // NOLINT
|
||||
|
||||
// Has strtol() consumed all characters in the string?
|
||||
if (*end != '\0') {
|
||||
// No - an invalid character was encountered.
|
||||
Message msg;
|
||||
msg << "WARNING: " << src_text
|
||||
<< " is expected to be a 32-bit integer, but actually"
|
||||
<< " has value \"" << str << "\".\n";
|
||||
printf("%s", msg.GetString().c_str());
|
||||
fflush(stdout);
|
||||
return false;
|
||||
}
|
||||
|
||||
// Is the parsed value in the range of an Int32?
|
||||
const Int32 result = static_cast<Int32>(long_value);
|
||||
if (long_value == LONG_MAX || long_value == LONG_MIN ||
|
||||
// The parsed value overflows as a long. (strtol() returns
|
||||
// LONG_MAX or LONG_MIN when the input overflows.)
|
||||
result != long_value
|
||||
// The parsed value overflows as an Int32.
|
||||
) {
|
||||
Message msg;
|
||||
msg << "WARNING: " << src_text
|
||||
<< " is expected to be a 32-bit integer, but actually"
|
||||
<< " has value " << str << ", which overflows.\n";
|
||||
printf("%s", msg.GetString().c_str());
|
||||
fflush(stdout);
|
||||
return false;
|
||||
}
|
||||
|
||||
*value = result;
|
||||
return true;
|
||||
}
|
||||
|
||||
// Reads and returns the Boolean environment variable corresponding to
|
||||
// the given flag; if it's not set, returns default_value.
|
||||
//
|
||||
// The value is considered true iff it's not "0".
|
||||
bool BoolFromGTestEnv(const char* flag, bool default_value) {
|
||||
const String env_var = FlagToEnvVar(flag);
|
||||
const char* const string_value = posix::GetEnv(env_var.c_str());
|
||||
return string_value == NULL ?
|
||||
default_value : strcmp(string_value, "0") != 0;
|
||||
}
|
||||
|
||||
// Reads and returns a 32-bit integer stored in the environment
|
||||
// variable corresponding to the given flag; if it isn't set or
|
||||
// doesn't represent a valid 32-bit integer, returns default_value.
|
||||
Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
|
||||
const String env_var = FlagToEnvVar(flag);
|
||||
const char* const string_value = posix::GetEnv(env_var.c_str());
|
||||
if (string_value == NULL) {
|
||||
// The environment variable is not set.
|
||||
return default_value;
|
||||
}
|
||||
|
||||
Int32 result = default_value;
|
||||
if (!ParseInt32(Message() << "Environment variable " << env_var,
|
||||
string_value, &result)) {
|
||||
printf("The default value %s is used.\n",
|
||||
(Message() << default_value).GetString().c_str());
|
||||
fflush(stdout);
|
||||
return default_value;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// Reads and returns the string environment variable corresponding to
|
||||
// the given flag; if it's not set, returns default_value.
|
||||
const char* StringFromGTestEnv(const char* flag, const char* default_value) {
|
||||
const String env_var = FlagToEnvVar(flag);
|
||||
const char* const value = posix::GetEnv(env_var.c_str());
|
||||
return value == NULL ? default_value : value;
|
||||
}
|
||||
|
||||
} // namespace internal
|
||||
} // namespace testing
|
356
gtest/src/gtest-printers.cc
Normal file
356
gtest/src/gtest-printers.cc
Normal file
@ -0,0 +1,356 @@
|
||||
// Copyright 2007, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
// Google Test - The Google C++ Testing Framework
|
||||
//
|
||||
// This file implements a universal value printer that can print a
|
||||
// value of any type T:
|
||||
//
|
||||
// void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
|
||||
//
|
||||
// It uses the << operator when possible, and prints the bytes in the
|
||||
// object otherwise. A user can override its behavior for a class
|
||||
// type Foo by defining either operator<<(::std::ostream&, const Foo&)
|
||||
// or void PrintTo(const Foo&, ::std::ostream*) in the namespace that
|
||||
// defines Foo.
|
||||
|
||||
#include "gtest/gtest-printers.h"
|
||||
#include <ctype.h>
|
||||
#include <stdio.h>
|
||||
#include <ostream> // NOLINT
|
||||
#include <string>
|
||||
#include "gtest/internal/gtest-port.h"
|
||||
|
||||
namespace testing {
|
||||
|
||||
namespace {
|
||||
|
||||
using ::std::ostream;
|
||||
|
||||
#if GTEST_OS_WINDOWS_MOBILE // Windows CE does not define _snprintf_s.
|
||||
# define snprintf _snprintf
|
||||
#elif _MSC_VER >= 1400 // VC 8.0 and later deprecate snprintf and _snprintf.
|
||||
# define snprintf _snprintf_s
|
||||
#elif _MSC_VER
|
||||
# define snprintf _snprintf
|
||||
#endif // GTEST_OS_WINDOWS_MOBILE
|
||||
|
||||
// Prints a segment of bytes in the given object.
|
||||
void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start,
|
||||
size_t count, ostream* os) {
|
||||
char text[5] = "";
|
||||
for (size_t i = 0; i != count; i++) {
|
||||
const size_t j = start + i;
|
||||
if (i != 0) {
|
||||
// Organizes the bytes into groups of 2 for easy parsing by
|
||||
// human.
|
||||
if ((j % 2) == 0)
|
||||
*os << ' ';
|
||||
else
|
||||
*os << '-';
|
||||
}
|
||||
snprintf(text, sizeof(text), "%02X", obj_bytes[j]);
|
||||
*os << text;
|
||||
}
|
||||
}
|
||||
|
||||
// Prints the bytes in the given value to the given ostream.
|
||||
void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t count,
|
||||
ostream* os) {
|
||||
// Tells the user how big the object is.
|
||||
*os << count << "-byte object <";
|
||||
|
||||
const size_t kThreshold = 132;
|
||||
const size_t kChunkSize = 64;
|
||||
// If the object size is bigger than kThreshold, we'll have to omit
|
||||
// some details by printing only the first and the last kChunkSize
|
||||
// bytes.
|
||||
// TODO(wan): let the user control the threshold using a flag.
|
||||
if (count < kThreshold) {
|
||||
PrintByteSegmentInObjectTo(obj_bytes, 0, count, os);
|
||||
} else {
|
||||
PrintByteSegmentInObjectTo(obj_bytes, 0, kChunkSize, os);
|
||||
*os << " ... ";
|
||||
// Rounds up to 2-byte boundary.
|
||||
const size_t resume_pos = (count - kChunkSize + 1)/2*2;
|
||||
PrintByteSegmentInObjectTo(obj_bytes, resume_pos, count - resume_pos, os);
|
||||
}
|
||||
*os << ">";
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
namespace internal2 {
|
||||
|
||||
// Delegates to PrintBytesInObjectToImpl() to print the bytes in the
|
||||
// given object. The delegation simplifies the implementation, which
|
||||
// uses the << operator and thus is easier done outside of the
|
||||
// ::testing::internal namespace, which contains a << operator that
|
||||
// sometimes conflicts with the one in STL.
|
||||
void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
|
||||
ostream* os) {
|
||||
PrintBytesInObjectToImpl(obj_bytes, count, os);
|
||||
}
|
||||
|
||||
} // namespace internal2
|
||||
|
||||
namespace internal {
|
||||
|
||||
// Depending on the value of a char (or wchar_t), we print it in one
|
||||
// of three formats:
|
||||
// - as is if it's a printable ASCII (e.g. 'a', '2', ' '),
|
||||
// - as a hexidecimal escape sequence (e.g. '\x7F'), or
|
||||
// - as a special escape sequence (e.g. '\r', '\n').
|
||||
enum CharFormat {
|
||||
kAsIs,
|
||||
kHexEscape,
|
||||
kSpecialEscape
|
||||
};
|
||||
|
||||
// Returns true if c is a printable ASCII character. We test the
|
||||
// value of c directly instead of calling isprint(), which is buggy on
|
||||
// Windows Mobile.
|
||||
inline bool IsPrintableAscii(wchar_t c) {
|
||||
return 0x20 <= c && c <= 0x7E;
|
||||
}
|
||||
|
||||
// Prints a wide or narrow char c as a character literal without the
|
||||
// quotes, escaping it when necessary; returns how c was formatted.
|
||||
// The template argument UnsignedChar is the unsigned version of Char,
|
||||
// which is the type of c.
|
||||
template <typename UnsignedChar, typename Char>
|
||||
static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
|
||||
switch (static_cast<wchar_t>(c)) {
|
||||
case L'\0':
|
||||
*os << "\\0";
|
||||
break;
|
||||
case L'\'':
|
||||
*os << "\\'";
|
||||
break;
|
||||
case L'\\':
|
||||
*os << "\\\\";
|
||||
break;
|
||||
case L'\a':
|
||||
*os << "\\a";
|
||||
break;
|
||||
case L'\b':
|
||||
*os << "\\b";
|
||||
break;
|
||||
case L'\f':
|
||||
*os << "\\f";
|
||||
break;
|
||||
case L'\n':
|
||||
*os << "\\n";
|
||||
break;
|
||||
case L'\r':
|
||||
*os << "\\r";
|
||||
break;
|
||||
case L'\t':
|
||||
*os << "\\t";
|
||||
break;
|
||||
case L'\v':
|
||||
*os << "\\v";
|
||||
break;
|
||||
default:
|
||||
if (IsPrintableAscii(c)) {
|
||||
*os << static_cast<char>(c);
|
||||
return kAsIs;
|
||||
} else {
|
||||
*os << String::Format("\\x%X", static_cast<UnsignedChar>(c));
|
||||
return kHexEscape;
|
||||
}
|
||||
}
|
||||
return kSpecialEscape;
|
||||
}
|
||||
|
||||
// Prints a char c as if it's part of a string literal, escaping it when
|
||||
// necessary; returns how c was formatted.
|
||||
static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
|
||||
switch (c) {
|
||||
case L'\'':
|
||||
*os << "'";
|
||||
return kAsIs;
|
||||
case L'"':
|
||||
*os << "\\\"";
|
||||
return kSpecialEscape;
|
||||
default:
|
||||
return PrintAsCharLiteralTo<wchar_t>(c, os);
|
||||
}
|
||||
}
|
||||
|
||||
// Prints a char c as if it's part of a string literal, escaping it when
|
||||
// necessary; returns how c was formatted.
|
||||
static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
|
||||
return PrintAsWideStringLiteralTo(static_cast<unsigned char>(c), os);
|
||||
}
|
||||
|
||||
// Prints a wide or narrow character c and its code. '\0' is printed
|
||||
// as "'\\0'", other unprintable characters are also properly escaped
|
||||
// using the standard C++ escape sequence. The template argument
|
||||
// UnsignedChar is the unsigned version of Char, which is the type of c.
|
||||
template <typename UnsignedChar, typename Char>
|
||||
void PrintCharAndCodeTo(Char c, ostream* os) {
|
||||
// First, print c as a literal in the most readable form we can find.
|
||||
*os << ((sizeof(c) > 1) ? "L'" : "'");
|
||||
const CharFormat format = PrintAsCharLiteralTo<UnsignedChar>(c, os);
|
||||
*os << "'";
|
||||
|
||||
// To aid user debugging, we also print c's code in decimal, unless
|
||||
// it's 0 (in which case c was printed as '\\0', making the code
|
||||
// obvious).
|
||||
if (c == 0)
|
||||
return;
|
||||
*os << " (" << String::Format("%d", c).c_str();
|
||||
|
||||
// For more convenience, we print c's code again in hexidecimal,
|
||||
// unless c was already printed in the form '\x##' or the code is in
|
||||
// [1, 9].
|
||||
if (format == kHexEscape || (1 <= c && c <= 9)) {
|
||||
// Do nothing.
|
||||
} else {
|
||||
*os << String::Format(", 0x%X",
|
||||
static_cast<UnsignedChar>(c)).c_str();
|
||||
}
|
||||
*os << ")";
|
||||
}
|
||||
|
||||
void PrintTo(unsigned char c, ::std::ostream* os) {
|
||||
PrintCharAndCodeTo<unsigned char>(c, os);
|
||||
}
|
||||
void PrintTo(signed char c, ::std::ostream* os) {
|
||||
PrintCharAndCodeTo<unsigned char>(c, os);
|
||||
}
|
||||
|
||||
// Prints a wchar_t as a symbol if it is printable or as its internal
|
||||
// code otherwise and also as its code. L'\0' is printed as "L'\\0'".
|
||||
void PrintTo(wchar_t wc, ostream* os) {
|
||||
PrintCharAndCodeTo<wchar_t>(wc, os);
|
||||
}
|
||||
|
||||
// Prints the given array of characters to the ostream.
|
||||
// The array starts at *begin, the length is len, it may include '\0' characters
|
||||
// and may not be null-terminated.
|
||||
static void PrintCharsAsStringTo(const char* begin, size_t len, ostream* os) {
|
||||
*os << "\"";
|
||||
bool is_previous_hex = false;
|
||||
for (size_t index = 0; index < len; ++index) {
|
||||
const char cur = begin[index];
|
||||
if (is_previous_hex && IsXDigit(cur)) {
|
||||
// Previous character is of '\x..' form and this character can be
|
||||
// interpreted as another hexadecimal digit in its number. Break string to
|
||||
// disambiguate.
|
||||
*os << "\" \"";
|
||||
}
|
||||
is_previous_hex = PrintAsNarrowStringLiteralTo(cur, os) == kHexEscape;
|
||||
}
|
||||
*os << "\"";
|
||||
}
|
||||
|
||||
// Prints a (const) char array of 'len' elements, starting at address 'begin'.
|
||||
void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
|
||||
PrintCharsAsStringTo(begin, len, os);
|
||||
}
|
||||
|
||||
// Prints the given array of wide characters to the ostream.
|
||||
// The array starts at *begin, the length is len, it may include L'\0'
|
||||
// characters and may not be null-terminated.
|
||||
static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
|
||||
ostream* os) {
|
||||
*os << "L\"";
|
||||
bool is_previous_hex = false;
|
||||
for (size_t index = 0; index < len; ++index) {
|
||||
const wchar_t cur = begin[index];
|
||||
if (is_previous_hex && isascii(cur) && IsXDigit(static_cast<char>(cur))) {
|
||||
// Previous character is of '\x..' form and this character can be
|
||||
// interpreted as another hexadecimal digit in its number. Break string to
|
||||
// disambiguate.
|
||||
*os << "\" L\"";
|
||||
}
|
||||
is_previous_hex = PrintAsWideStringLiteralTo(cur, os) == kHexEscape;
|
||||
}
|
||||
*os << "\"";
|
||||
}
|
||||
|
||||
// Prints the given C string to the ostream.
|
||||
void PrintTo(const char* s, ostream* os) {
|
||||
if (s == NULL) {
|
||||
*os << "NULL";
|
||||
} else {
|
||||
*os << ImplicitCast_<const void*>(s) << " pointing to ";
|
||||
PrintCharsAsStringTo(s, strlen(s), os);
|
||||
}
|
||||
}
|
||||
|
||||
// MSVC compiler can be configured to define whar_t as a typedef
|
||||
// of unsigned short. Defining an overload for const wchar_t* in that case
|
||||
// would cause pointers to unsigned shorts be printed as wide strings,
|
||||
// possibly accessing more memory than intended and causing invalid
|
||||
// memory accesses. MSVC defines _NATIVE_WCHAR_T_DEFINED symbol when
|
||||
// wchar_t is implemented as a native type.
|
||||
#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
|
||||
// Prints the given wide C string to the ostream.
|
||||
void PrintTo(const wchar_t* s, ostream* os) {
|
||||
if (s == NULL) {
|
||||
*os << "NULL";
|
||||
} else {
|
||||
*os << ImplicitCast_<const void*>(s) << " pointing to ";
|
||||
PrintWideCharsAsStringTo(s, wcslen(s), os);
|
||||
}
|
||||
}
|
||||
#endif // wchar_t is native
|
||||
|
||||
// Prints a ::string object.
|
||||
#if GTEST_HAS_GLOBAL_STRING
|
||||
void PrintStringTo(const ::string& s, ostream* os) {
|
||||
PrintCharsAsStringTo(s.data(), s.size(), os);
|
||||
}
|
||||
#endif // GTEST_HAS_GLOBAL_STRING
|
||||
|
||||
void PrintStringTo(const ::std::string& s, ostream* os) {
|
||||
PrintCharsAsStringTo(s.data(), s.size(), os);
|
||||
}
|
||||
|
||||
// Prints a ::wstring object.
|
||||
#if GTEST_HAS_GLOBAL_WSTRING
|
||||
void PrintWideStringTo(const ::wstring& s, ostream* os) {
|
||||
PrintWideCharsAsStringTo(s.data(), s.size(), os);
|
||||
}
|
||||
#endif // GTEST_HAS_GLOBAL_WSTRING
|
||||
|
||||
#if GTEST_HAS_STD_WSTRING
|
||||
void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
|
||||
PrintWideCharsAsStringTo(s.data(), s.size(), os);
|
||||
}
|
||||
#endif // GTEST_HAS_STD_WSTRING
|
||||
|
||||
} // namespace internal
|
||||
|
||||
} // namespace testing
|
110
gtest/src/gtest-test-part.cc
Normal file
110
gtest/src/gtest-test-part.cc
Normal file
@ -0,0 +1,110 @@
|
||||
// Copyright 2008, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: mheule@google.com (Markus Heule)
|
||||
//
|
||||
// The Google C++ Testing Framework (Google Test)
|
||||
|
||||
#include "gtest/gtest-test-part.h"
|
||||
|
||||
// Indicates that this translation unit is part of Google Test's
|
||||
// implementation. It must come before gtest-internal-inl.h is
|
||||
// included, or there will be a compiler error. This trick is to
|
||||
// prevent a user from accidentally including gtest-internal-inl.h in
|
||||
// his code.
|
||||
#define GTEST_IMPLEMENTATION_ 1
|
||||
#include "src/gtest-internal-inl.h"
|
||||
#undef GTEST_IMPLEMENTATION_
|
||||
|
||||
namespace testing {
|
||||
|
||||
using internal::GetUnitTestImpl;
|
||||
|
||||
// Gets the summary of the failure message by omitting the stack trace
|
||||
// in it.
|
||||
internal::String TestPartResult::ExtractSummary(const char* message) {
|
||||
const char* const stack_trace = strstr(message, internal::kStackTraceMarker);
|
||||
return stack_trace == NULL ? internal::String(message) :
|
||||
internal::String(message, stack_trace - message);
|
||||
}
|
||||
|
||||
// Prints a TestPartResult object.
|
||||
std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
|
||||
return os
|
||||
<< result.file_name() << ":" << result.line_number() << ": "
|
||||
<< (result.type() == TestPartResult::kSuccess ? "Success" :
|
||||
result.type() == TestPartResult::kFatalFailure ? "Fatal failure" :
|
||||
"Non-fatal failure") << ":\n"
|
||||
<< result.message() << std::endl;
|
||||
}
|
||||
|
||||
// Appends a TestPartResult to the array.
|
||||
void TestPartResultArray::Append(const TestPartResult& result) {
|
||||
array_.push_back(result);
|
||||
}
|
||||
|
||||
// Returns the TestPartResult at the given index (0-based).
|
||||
const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
|
||||
if (index < 0 || index >= size()) {
|
||||
printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
|
||||
internal::posix::Abort();
|
||||
}
|
||||
|
||||
return array_[index];
|
||||
}
|
||||
|
||||
// Returns the number of TestPartResult objects in the array.
|
||||
int TestPartResultArray::size() const {
|
||||
return static_cast<int>(array_.size());
|
||||
}
|
||||
|
||||
namespace internal {
|
||||
|
||||
HasNewFatalFailureHelper::HasNewFatalFailureHelper()
|
||||
: has_new_fatal_failure_(false),
|
||||
original_reporter_(GetUnitTestImpl()->
|
||||
GetTestPartResultReporterForCurrentThread()) {
|
||||
GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(this);
|
||||
}
|
||||
|
||||
HasNewFatalFailureHelper::~HasNewFatalFailureHelper() {
|
||||
GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(
|
||||
original_reporter_);
|
||||
}
|
||||
|
||||
void HasNewFatalFailureHelper::ReportTestPartResult(
|
||||
const TestPartResult& result) {
|
||||
if (result.fatally_failed())
|
||||
has_new_fatal_failure_ = true;
|
||||
original_reporter_->ReportTestPartResult(result);
|
||||
}
|
||||
|
||||
} // namespace internal
|
||||
|
||||
} // namespace testing
|
110
gtest/src/gtest-typed-test.cc
Normal file
110
gtest/src/gtest-typed-test.cc
Normal file
@ -0,0 +1,110 @@
|
||||
// Copyright 2008 Google Inc.
|
||||
// All Rights Reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
#include "gtest/gtest-typed-test.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
namespace testing {
|
||||
namespace internal {
|
||||
|
||||
#if GTEST_HAS_TYPED_TEST_P
|
||||
|
||||
// Skips to the first non-space char in str. Returns an empty string if str
|
||||
// contains only whitespace characters.
|
||||
static const char* SkipSpaces(const char* str) {
|
||||
while (IsSpace(*str))
|
||||
str++;
|
||||
return str;
|
||||
}
|
||||
|
||||
// Verifies that registered_tests match the test names in
|
||||
// defined_test_names_; returns registered_tests if successful, or
|
||||
// aborts the program otherwise.
|
||||
const char* TypedTestCasePState::VerifyRegisteredTestNames(
|
||||
const char* file, int line, const char* registered_tests) {
|
||||
typedef ::std::set<const char*>::const_iterator DefinedTestIter;
|
||||
registered_ = true;
|
||||
|
||||
// Skip initial whitespace in registered_tests since some
|
||||
// preprocessors prefix stringizied literals with whitespace.
|
||||
registered_tests = SkipSpaces(registered_tests);
|
||||
|
||||
Message errors;
|
||||
::std::set<String> tests;
|
||||
for (const char* names = registered_tests; names != NULL;
|
||||
names = SkipComma(names)) {
|
||||
const String name = GetPrefixUntilComma(names);
|
||||
if (tests.count(name) != 0) {
|
||||
errors << "Test " << name << " is listed more than once.\n";
|
||||
continue;
|
||||
}
|
||||
|
||||
bool found = false;
|
||||
for (DefinedTestIter it = defined_test_names_.begin();
|
||||
it != defined_test_names_.end();
|
||||
++it) {
|
||||
if (name == *it) {
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (found) {
|
||||
tests.insert(name);
|
||||
} else {
|
||||
errors << "No test named " << name
|
||||
<< " can be found in this test case.\n";
|
||||
}
|
||||
}
|
||||
|
||||
for (DefinedTestIter it = defined_test_names_.begin();
|
||||
it != defined_test_names_.end();
|
||||
++it) {
|
||||
if (tests.count(*it) == 0) {
|
||||
errors << "You forgot to list test " << *it << ".\n";
|
||||
}
|
||||
}
|
||||
|
||||
const String& errors_str = errors.GetString();
|
||||
if (errors_str != "") {
|
||||
fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(),
|
||||
errors_str.c_str());
|
||||
fflush(stderr);
|
||||
posix::Abort();
|
||||
}
|
||||
|
||||
return registered_tests;
|
||||
}
|
||||
|
||||
#endif // GTEST_HAS_TYPED_TEST_P
|
||||
|
||||
} // namespace internal
|
||||
} // namespace testing
|
File diff suppressed because it is too large
Load Diff
39
gtest/src/gtest_main.cc
Normal file
39
gtest/src/gtest_main.cc
Normal file
@ -0,0 +1,39 @@
|
||||
// Copyright 2006, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
GTEST_API_ int main(int argc, char **argv) {
|
||||
std::cout << "Running main() from gtest_main.cc\n";
|
||||
|
||||
testing::InitGoogleTest(&argc, argv);
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
93
gtest/test/gtest-death-test_ex_test.cc
Normal file
93
gtest/test/gtest-death-test_ex_test.cc
Normal file
@ -0,0 +1,93 @@
|
||||
// Copyright 2010, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: vladl@google.com (Vlad Losev)
|
||||
//
|
||||
// Tests that verify interaction of exceptions and death tests.
|
||||
|
||||
#include "gtest/gtest-death-test.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#if GTEST_HAS_DEATH_TEST
|
||||
|
||||
# if GTEST_HAS_SEH
|
||||
# include <windows.h> // For RaiseException().
|
||||
# endif
|
||||
|
||||
# include "gtest/gtest-spi.h"
|
||||
|
||||
# if GTEST_HAS_EXCEPTIONS
|
||||
|
||||
# include <exception> // For std::exception.
|
||||
|
||||
// Tests that death tests report thrown exceptions as failures and that the
|
||||
// exceptions do not escape death test macros.
|
||||
TEST(CxxExceptionDeathTest, ExceptionIsFailure) {
|
||||
try {
|
||||
EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(throw 1, ""), "threw an exception");
|
||||
} catch (...) { // NOLINT
|
||||
FAIL() << "An exception escaped a death test macro invocation "
|
||||
<< "with catch_exceptions "
|
||||
<< (testing::GTEST_FLAG(catch_exceptions) ? "enabled" : "disabled");
|
||||
}
|
||||
}
|
||||
|
||||
class TestException : public std::exception {
|
||||
public:
|
||||
virtual const char* what() const throw() { return "exceptional message"; }
|
||||
};
|
||||
|
||||
TEST(CxxExceptionDeathTest, PrintsMessageForStdExceptions) {
|
||||
// Verifies that the exception message is quoted in the failure text.
|
||||
EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(throw TestException(), ""),
|
||||
"exceptional message");
|
||||
// Verifies that the location is mentioned in the failure text.
|
||||
EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(throw TestException(), ""),
|
||||
"gtest-death-test_ex_test.cc");
|
||||
}
|
||||
# endif // GTEST_HAS_EXCEPTIONS
|
||||
|
||||
# if GTEST_HAS_SEH
|
||||
// Tests that enabling interception of SEH exceptions with the
|
||||
// catch_exceptions flag does not interfere with SEH exceptions being
|
||||
// treated as death by death tests.
|
||||
TEST(SehExceptionDeasTest, CatchExceptionsDoesNotInterfere) {
|
||||
EXPECT_DEATH(RaiseException(42, 0x0, 0, NULL), "")
|
||||
<< "with catch_exceptions "
|
||||
<< (testing::GTEST_FLAG(catch_exceptions) ? "enabled" : "disabled");
|
||||
}
|
||||
# endif
|
||||
|
||||
#endif // GTEST_HAS_DEATH_TEST
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
testing::InitGoogleTest(&argc, argv);
|
||||
testing::GTEST_FLAG(catch_exceptions) = GTEST_ENABLE_CATCH_EXCEPTIONS_ != 0;
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
1296
gtest/test/gtest-death-test_test.cc
Normal file
1296
gtest/test/gtest-death-test_test.cc
Normal file
File diff suppressed because it is too large
Load Diff
696
gtest/test/gtest-filepath_test.cc
Normal file
696
gtest/test/gtest-filepath_test.cc
Normal file
@ -0,0 +1,696 @@
|
||||
// Copyright 2008, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Authors: keith.ray@gmail.com (Keith Ray)
|
||||
//
|
||||
// Google Test filepath utilities
|
||||
//
|
||||
// This file tests classes and functions used internally by
|
||||
// Google Test. They are subject to change without notice.
|
||||
//
|
||||
// This file is #included from gtest_unittest.cc, to avoid changing
|
||||
// build or make-files for some existing Google Test clients. Do not
|
||||
// #include this file anywhere else!
|
||||
|
||||
#include "gtest/internal/gtest-filepath.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
// Indicates that this translation unit is part of Google Test's
|
||||
// implementation. It must come before gtest-internal-inl.h is
|
||||
// included, or there will be a compiler error. This trick is to
|
||||
// prevent a user from accidentally including gtest-internal-inl.h in
|
||||
// his code.
|
||||
#define GTEST_IMPLEMENTATION_ 1
|
||||
#include "src/gtest-internal-inl.h"
|
||||
#undef GTEST_IMPLEMENTATION_
|
||||
|
||||
#if GTEST_OS_WINDOWS_MOBILE
|
||||
# include <windows.h> // NOLINT
|
||||
#elif GTEST_OS_WINDOWS
|
||||
# include <direct.h> // NOLINT
|
||||
#endif // GTEST_OS_WINDOWS_MOBILE
|
||||
|
||||
namespace testing {
|
||||
namespace internal {
|
||||
namespace {
|
||||
|
||||
#if GTEST_OS_WINDOWS_MOBILE
|
||||
// TODO(wan@google.com): Move these to the POSIX adapter section in
|
||||
// gtest-port.h.
|
||||
|
||||
// Windows CE doesn't have the remove C function.
|
||||
int remove(const char* path) {
|
||||
LPCWSTR wpath = String::AnsiToUtf16(path);
|
||||
int ret = DeleteFile(wpath) ? 0 : -1;
|
||||
delete [] wpath;
|
||||
return ret;
|
||||
}
|
||||
// Windows CE doesn't have the _rmdir C function.
|
||||
int _rmdir(const char* path) {
|
||||
FilePath filepath(path);
|
||||
LPCWSTR wpath = String::AnsiToUtf16(
|
||||
filepath.RemoveTrailingPathSeparator().c_str());
|
||||
int ret = RemoveDirectory(wpath) ? 0 : -1;
|
||||
delete [] wpath;
|
||||
return ret;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
TEST(GetCurrentDirTest, ReturnsCurrentDir) {
|
||||
const FilePath original_dir = FilePath::GetCurrentDir();
|
||||
EXPECT_FALSE(original_dir.IsEmpty());
|
||||
|
||||
posix::ChDir(GTEST_PATH_SEP_);
|
||||
const FilePath cwd = FilePath::GetCurrentDir();
|
||||
posix::ChDir(original_dir.c_str());
|
||||
|
||||
# if GTEST_OS_WINDOWS
|
||||
|
||||
// Skips the ":".
|
||||
const char* const cwd_without_drive = strchr(cwd.c_str(), ':');
|
||||
ASSERT_TRUE(cwd_without_drive != NULL);
|
||||
EXPECT_STREQ(GTEST_PATH_SEP_, cwd_without_drive + 1);
|
||||
|
||||
# else
|
||||
|
||||
EXPECT_STREQ(GTEST_PATH_SEP_, cwd.c_str());
|
||||
|
||||
# endif
|
||||
}
|
||||
|
||||
#endif // GTEST_OS_WINDOWS_MOBILE
|
||||
|
||||
TEST(IsEmptyTest, ReturnsTrueForEmptyPath) {
|
||||
EXPECT_TRUE(FilePath("").IsEmpty());
|
||||
EXPECT_TRUE(FilePath(NULL).IsEmpty());
|
||||
}
|
||||
|
||||
TEST(IsEmptyTest, ReturnsFalseForNonEmptyPath) {
|
||||
EXPECT_FALSE(FilePath("a").IsEmpty());
|
||||
EXPECT_FALSE(FilePath(".").IsEmpty());
|
||||
EXPECT_FALSE(FilePath("a/b").IsEmpty());
|
||||
EXPECT_FALSE(FilePath("a\\b\\").IsEmpty());
|
||||
}
|
||||
|
||||
// RemoveDirectoryName "" -> ""
|
||||
TEST(RemoveDirectoryNameTest, WhenEmptyName) {
|
||||
EXPECT_STREQ("", FilePath("").RemoveDirectoryName().c_str());
|
||||
}
|
||||
|
||||
// RemoveDirectoryName "afile" -> "afile"
|
||||
TEST(RemoveDirectoryNameTest, ButNoDirectory) {
|
||||
EXPECT_STREQ("afile",
|
||||
FilePath("afile").RemoveDirectoryName().c_str());
|
||||
}
|
||||
|
||||
// RemoveDirectoryName "/afile" -> "afile"
|
||||
TEST(RemoveDirectoryNameTest, RootFileShouldGiveFileName) {
|
||||
EXPECT_STREQ("afile",
|
||||
FilePath(GTEST_PATH_SEP_ "afile").RemoveDirectoryName().c_str());
|
||||
}
|
||||
|
||||
// RemoveDirectoryName "adir/" -> ""
|
||||
TEST(RemoveDirectoryNameTest, WhereThereIsNoFileName) {
|
||||
EXPECT_STREQ("",
|
||||
FilePath("adir" GTEST_PATH_SEP_).RemoveDirectoryName().c_str());
|
||||
}
|
||||
|
||||
// RemoveDirectoryName "adir/afile" -> "afile"
|
||||
TEST(RemoveDirectoryNameTest, ShouldGiveFileName) {
|
||||
EXPECT_STREQ("afile",
|
||||
FilePath("adir" GTEST_PATH_SEP_ "afile").RemoveDirectoryName().c_str());
|
||||
}
|
||||
|
||||
// RemoveDirectoryName "adir/subdir/afile" -> "afile"
|
||||
TEST(RemoveDirectoryNameTest, ShouldAlsoGiveFileName) {
|
||||
EXPECT_STREQ("afile",
|
||||
FilePath("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_ "afile")
|
||||
.RemoveDirectoryName().c_str());
|
||||
}
|
||||
|
||||
#if GTEST_HAS_ALT_PATH_SEP_
|
||||
|
||||
// Tests that RemoveDirectoryName() works with the alternate separator
|
||||
// on Windows.
|
||||
|
||||
// RemoveDirectoryName("/afile") -> "afile"
|
||||
TEST(RemoveDirectoryNameTest, RootFileShouldGiveFileNameForAlternateSeparator) {
|
||||
EXPECT_STREQ("afile",
|
||||
FilePath("/afile").RemoveDirectoryName().c_str());
|
||||
}
|
||||
|
||||
// RemoveDirectoryName("adir/") -> ""
|
||||
TEST(RemoveDirectoryNameTest, WhereThereIsNoFileNameForAlternateSeparator) {
|
||||
EXPECT_STREQ("",
|
||||
FilePath("adir/").RemoveDirectoryName().c_str());
|
||||
}
|
||||
|
||||
// RemoveDirectoryName("adir/afile") -> "afile"
|
||||
TEST(RemoveDirectoryNameTest, ShouldGiveFileNameForAlternateSeparator) {
|
||||
EXPECT_STREQ("afile",
|
||||
FilePath("adir/afile").RemoveDirectoryName().c_str());
|
||||
}
|
||||
|
||||
// RemoveDirectoryName("adir/subdir/afile") -> "afile"
|
||||
TEST(RemoveDirectoryNameTest, ShouldAlsoGiveFileNameForAlternateSeparator) {
|
||||
EXPECT_STREQ("afile",
|
||||
FilePath("adir/subdir/afile").RemoveDirectoryName().c_str());
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
// RemoveFileName "" -> "./"
|
||||
TEST(RemoveFileNameTest, EmptyName) {
|
||||
#if GTEST_OS_WINDOWS_MOBILE
|
||||
// On Windows CE, we use the root as the current directory.
|
||||
EXPECT_STREQ(GTEST_PATH_SEP_,
|
||||
FilePath("").RemoveFileName().c_str());
|
||||
#else
|
||||
EXPECT_STREQ("." GTEST_PATH_SEP_,
|
||||
FilePath("").RemoveFileName().c_str());
|
||||
#endif
|
||||
}
|
||||
|
||||
// RemoveFileName "adir/" -> "adir/"
|
||||
TEST(RemoveFileNameTest, ButNoFile) {
|
||||
EXPECT_STREQ("adir" GTEST_PATH_SEP_,
|
||||
FilePath("adir" GTEST_PATH_SEP_).RemoveFileName().c_str());
|
||||
}
|
||||
|
||||
// RemoveFileName "adir/afile" -> "adir/"
|
||||
TEST(RemoveFileNameTest, GivesDirName) {
|
||||
EXPECT_STREQ("adir" GTEST_PATH_SEP_,
|
||||
FilePath("adir" GTEST_PATH_SEP_ "afile")
|
||||
.RemoveFileName().c_str());
|
||||
}
|
||||
|
||||
// RemoveFileName "adir/subdir/afile" -> "adir/subdir/"
|
||||
TEST(RemoveFileNameTest, GivesDirAndSubDirName) {
|
||||
EXPECT_STREQ("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_,
|
||||
FilePath("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_ "afile")
|
||||
.RemoveFileName().c_str());
|
||||
}
|
||||
|
||||
// RemoveFileName "/afile" -> "/"
|
||||
TEST(RemoveFileNameTest, GivesRootDir) {
|
||||
EXPECT_STREQ(GTEST_PATH_SEP_,
|
||||
FilePath(GTEST_PATH_SEP_ "afile").RemoveFileName().c_str());
|
||||
}
|
||||
|
||||
#if GTEST_HAS_ALT_PATH_SEP_
|
||||
|
||||
// Tests that RemoveFileName() works with the alternate separator on
|
||||
// Windows.
|
||||
|
||||
// RemoveFileName("adir/") -> "adir/"
|
||||
TEST(RemoveFileNameTest, ButNoFileForAlternateSeparator) {
|
||||
EXPECT_STREQ("adir" GTEST_PATH_SEP_,
|
||||
FilePath("adir/").RemoveFileName().c_str());
|
||||
}
|
||||
|
||||
// RemoveFileName("adir/afile") -> "adir/"
|
||||
TEST(RemoveFileNameTest, GivesDirNameForAlternateSeparator) {
|
||||
EXPECT_STREQ("adir" GTEST_PATH_SEP_,
|
||||
FilePath("adir/afile").RemoveFileName().c_str());
|
||||
}
|
||||
|
||||
// RemoveFileName("adir/subdir/afile") -> "adir/subdir/"
|
||||
TEST(RemoveFileNameTest, GivesDirAndSubDirNameForAlternateSeparator) {
|
||||
EXPECT_STREQ("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_,
|
||||
FilePath("adir/subdir/afile").RemoveFileName().c_str());
|
||||
}
|
||||
|
||||
// RemoveFileName("/afile") -> "\"
|
||||
TEST(RemoveFileNameTest, GivesRootDirForAlternateSeparator) {
|
||||
EXPECT_STREQ(GTEST_PATH_SEP_,
|
||||
FilePath("/afile").RemoveFileName().c_str());
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
TEST(MakeFileNameTest, GenerateWhenNumberIsZero) {
|
||||
FilePath actual = FilePath::MakeFileName(FilePath("foo"), FilePath("bar"),
|
||||
0, "xml");
|
||||
EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.c_str());
|
||||
}
|
||||
|
||||
TEST(MakeFileNameTest, GenerateFileNameNumberGtZero) {
|
||||
FilePath actual = FilePath::MakeFileName(FilePath("foo"), FilePath("bar"),
|
||||
12, "xml");
|
||||
EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar_12.xml", actual.c_str());
|
||||
}
|
||||
|
||||
TEST(MakeFileNameTest, GenerateFileNameWithSlashNumberIsZero) {
|
||||
FilePath actual = FilePath::MakeFileName(FilePath("foo" GTEST_PATH_SEP_),
|
||||
FilePath("bar"), 0, "xml");
|
||||
EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.c_str());
|
||||
}
|
||||
|
||||
TEST(MakeFileNameTest, GenerateFileNameWithSlashNumberGtZero) {
|
||||
FilePath actual = FilePath::MakeFileName(FilePath("foo" GTEST_PATH_SEP_),
|
||||
FilePath("bar"), 12, "xml");
|
||||
EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar_12.xml", actual.c_str());
|
||||
}
|
||||
|
||||
TEST(MakeFileNameTest, GenerateWhenNumberIsZeroAndDirIsEmpty) {
|
||||
FilePath actual = FilePath::MakeFileName(FilePath(""), FilePath("bar"),
|
||||
0, "xml");
|
||||
EXPECT_STREQ("bar.xml", actual.c_str());
|
||||
}
|
||||
|
||||
TEST(MakeFileNameTest, GenerateWhenNumberIsNotZeroAndDirIsEmpty) {
|
||||
FilePath actual = FilePath::MakeFileName(FilePath(""), FilePath("bar"),
|
||||
14, "xml");
|
||||
EXPECT_STREQ("bar_14.xml", actual.c_str());
|
||||
}
|
||||
|
||||
TEST(ConcatPathsTest, WorksWhenDirDoesNotEndWithPathSep) {
|
||||
FilePath actual = FilePath::ConcatPaths(FilePath("foo"),
|
||||
FilePath("bar.xml"));
|
||||
EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.c_str());
|
||||
}
|
||||
|
||||
TEST(ConcatPathsTest, WorksWhenPath1EndsWithPathSep) {
|
||||
FilePath actual = FilePath::ConcatPaths(FilePath("foo" GTEST_PATH_SEP_),
|
||||
FilePath("bar.xml"));
|
||||
EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.c_str());
|
||||
}
|
||||
|
||||
TEST(ConcatPathsTest, Path1BeingEmpty) {
|
||||
FilePath actual = FilePath::ConcatPaths(FilePath(""),
|
||||
FilePath("bar.xml"));
|
||||
EXPECT_STREQ("bar.xml", actual.c_str());
|
||||
}
|
||||
|
||||
TEST(ConcatPathsTest, Path2BeingEmpty) {
|
||||
FilePath actual = FilePath::ConcatPaths(FilePath("foo"),
|
||||
FilePath(""));
|
||||
EXPECT_STREQ("foo" GTEST_PATH_SEP_, actual.c_str());
|
||||
}
|
||||
|
||||
TEST(ConcatPathsTest, BothPathBeingEmpty) {
|
||||
FilePath actual = FilePath::ConcatPaths(FilePath(""),
|
||||
FilePath(""));
|
||||
EXPECT_STREQ("", actual.c_str());
|
||||
}
|
||||
|
||||
TEST(ConcatPathsTest, Path1ContainsPathSep) {
|
||||
FilePath actual = FilePath::ConcatPaths(FilePath("foo" GTEST_PATH_SEP_ "bar"),
|
||||
FilePath("foobar.xml"));
|
||||
EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_ "foobar.xml",
|
||||
actual.c_str());
|
||||
}
|
||||
|
||||
TEST(ConcatPathsTest, Path2ContainsPathSep) {
|
||||
FilePath actual = FilePath::ConcatPaths(
|
||||
FilePath("foo" GTEST_PATH_SEP_),
|
||||
FilePath("bar" GTEST_PATH_SEP_ "bar.xml"));
|
||||
EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_ "bar.xml",
|
||||
actual.c_str());
|
||||
}
|
||||
|
||||
TEST(ConcatPathsTest, Path2EndsWithPathSep) {
|
||||
FilePath actual = FilePath::ConcatPaths(FilePath("foo"),
|
||||
FilePath("bar" GTEST_PATH_SEP_));
|
||||
EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_, actual.c_str());
|
||||
}
|
||||
|
||||
// RemoveTrailingPathSeparator "" -> ""
|
||||
TEST(RemoveTrailingPathSeparatorTest, EmptyString) {
|
||||
EXPECT_STREQ("",
|
||||
FilePath("").RemoveTrailingPathSeparator().c_str());
|
||||
}
|
||||
|
||||
// RemoveTrailingPathSeparator "foo" -> "foo"
|
||||
TEST(RemoveTrailingPathSeparatorTest, FileNoSlashString) {
|
||||
EXPECT_STREQ("foo",
|
||||
FilePath("foo").RemoveTrailingPathSeparator().c_str());
|
||||
}
|
||||
|
||||
// RemoveTrailingPathSeparator "foo/" -> "foo"
|
||||
TEST(RemoveTrailingPathSeparatorTest, ShouldRemoveTrailingSeparator) {
|
||||
EXPECT_STREQ(
|
||||
"foo",
|
||||
FilePath("foo" GTEST_PATH_SEP_).RemoveTrailingPathSeparator().c_str());
|
||||
#if GTEST_HAS_ALT_PATH_SEP_
|
||||
EXPECT_STREQ("foo",
|
||||
FilePath("foo/").RemoveTrailingPathSeparator().c_str());
|
||||
#endif
|
||||
}
|
||||
|
||||
// RemoveTrailingPathSeparator "foo/bar/" -> "foo/bar/"
|
||||
TEST(RemoveTrailingPathSeparatorTest, ShouldRemoveLastSeparator) {
|
||||
EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar",
|
||||
FilePath("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_)
|
||||
.RemoveTrailingPathSeparator().c_str());
|
||||
}
|
||||
|
||||
// RemoveTrailingPathSeparator "foo/bar" -> "foo/bar"
|
||||
TEST(RemoveTrailingPathSeparatorTest, ShouldReturnUnmodified) {
|
||||
EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar",
|
||||
FilePath("foo" GTEST_PATH_SEP_ "bar")
|
||||
.RemoveTrailingPathSeparator().c_str());
|
||||
}
|
||||
|
||||
TEST(DirectoryTest, RootDirectoryExists) {
|
||||
#if GTEST_OS_WINDOWS // We are on Windows.
|
||||
char current_drive[_MAX_PATH]; // NOLINT
|
||||
current_drive[0] = static_cast<char>(_getdrive() + 'A' - 1);
|
||||
current_drive[1] = ':';
|
||||
current_drive[2] = '\\';
|
||||
current_drive[3] = '\0';
|
||||
EXPECT_TRUE(FilePath(current_drive).DirectoryExists());
|
||||
#else
|
||||
EXPECT_TRUE(FilePath("/").DirectoryExists());
|
||||
#endif // GTEST_OS_WINDOWS
|
||||
}
|
||||
|
||||
#if GTEST_OS_WINDOWS
|
||||
TEST(DirectoryTest, RootOfWrongDriveDoesNotExists) {
|
||||
const int saved_drive_ = _getdrive();
|
||||
// Find a drive that doesn't exist. Start with 'Z' to avoid common ones.
|
||||
for (char drive = 'Z'; drive >= 'A'; drive--)
|
||||
if (_chdrive(drive - 'A' + 1) == -1) {
|
||||
char non_drive[_MAX_PATH]; // NOLINT
|
||||
non_drive[0] = drive;
|
||||
non_drive[1] = ':';
|
||||
non_drive[2] = '\\';
|
||||
non_drive[3] = '\0';
|
||||
EXPECT_FALSE(FilePath(non_drive).DirectoryExists());
|
||||
break;
|
||||
}
|
||||
_chdrive(saved_drive_);
|
||||
}
|
||||
#endif // GTEST_OS_WINDOWS
|
||||
|
||||
#if !GTEST_OS_WINDOWS_MOBILE
|
||||
// Windows CE _does_ consider an empty directory to exist.
|
||||
TEST(DirectoryTest, EmptyPathDirectoryDoesNotExist) {
|
||||
EXPECT_FALSE(FilePath("").DirectoryExists());
|
||||
}
|
||||
#endif // !GTEST_OS_WINDOWS_MOBILE
|
||||
|
||||
TEST(DirectoryTest, CurrentDirectoryExists) {
|
||||
#if GTEST_OS_WINDOWS // We are on Windows.
|
||||
# ifndef _WIN32_CE // Windows CE doesn't have a current directory.
|
||||
|
||||
EXPECT_TRUE(FilePath(".").DirectoryExists());
|
||||
EXPECT_TRUE(FilePath(".\\").DirectoryExists());
|
||||
|
||||
# endif // _WIN32_CE
|
||||
#else
|
||||
EXPECT_TRUE(FilePath(".").DirectoryExists());
|
||||
EXPECT_TRUE(FilePath("./").DirectoryExists());
|
||||
#endif // GTEST_OS_WINDOWS
|
||||
}
|
||||
|
||||
TEST(NormalizeTest, NullStringsEqualEmptyDirectory) {
|
||||
EXPECT_STREQ("", FilePath(NULL).c_str());
|
||||
EXPECT_STREQ("", FilePath(String(NULL)).c_str());
|
||||
}
|
||||
|
||||
// "foo/bar" == foo//bar" == "foo///bar"
|
||||
TEST(NormalizeTest, MultipleConsecutiveSepaparatorsInMidstring) {
|
||||
EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar",
|
||||
FilePath("foo" GTEST_PATH_SEP_ "bar").c_str());
|
||||
EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar",
|
||||
FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").c_str());
|
||||
EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar",
|
||||
FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_
|
||||
GTEST_PATH_SEP_ "bar").c_str());
|
||||
}
|
||||
|
||||
// "/bar" == //bar" == "///bar"
|
||||
TEST(NormalizeTest, MultipleConsecutiveSepaparatorsAtStringStart) {
|
||||
EXPECT_STREQ(GTEST_PATH_SEP_ "bar",
|
||||
FilePath(GTEST_PATH_SEP_ "bar").c_str());
|
||||
EXPECT_STREQ(GTEST_PATH_SEP_ "bar",
|
||||
FilePath(GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").c_str());
|
||||
EXPECT_STREQ(GTEST_PATH_SEP_ "bar",
|
||||
FilePath(GTEST_PATH_SEP_ GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").c_str());
|
||||
}
|
||||
|
||||
// "foo/" == foo//" == "foo///"
|
||||
TEST(NormalizeTest, MultipleConsecutiveSepaparatorsAtStringEnd) {
|
||||
EXPECT_STREQ("foo" GTEST_PATH_SEP_,
|
||||
FilePath("foo" GTEST_PATH_SEP_).c_str());
|
||||
EXPECT_STREQ("foo" GTEST_PATH_SEP_,
|
||||
FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_).c_str());
|
||||
EXPECT_STREQ("foo" GTEST_PATH_SEP_,
|
||||
FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_ GTEST_PATH_SEP_).c_str());
|
||||
}
|
||||
|
||||
#if GTEST_HAS_ALT_PATH_SEP_
|
||||
|
||||
// Tests that separators at the end of the string are normalized
|
||||
// regardless of their combination (e.g. "foo\" =="foo/\" ==
|
||||
// "foo\\/").
|
||||
TEST(NormalizeTest, MixAlternateSeparatorAtStringEnd) {
|
||||
EXPECT_STREQ("foo" GTEST_PATH_SEP_,
|
||||
FilePath("foo/").c_str());
|
||||
EXPECT_STREQ("foo" GTEST_PATH_SEP_,
|
||||
FilePath("foo" GTEST_PATH_SEP_ "/").c_str());
|
||||
EXPECT_STREQ("foo" GTEST_PATH_SEP_,
|
||||
FilePath("foo//" GTEST_PATH_SEP_).c_str());
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
TEST(AssignmentOperatorTest, DefaultAssignedToNonDefault) {
|
||||
FilePath default_path;
|
||||
FilePath non_default_path("path");
|
||||
non_default_path = default_path;
|
||||
EXPECT_STREQ("", non_default_path.c_str());
|
||||
EXPECT_STREQ("", default_path.c_str()); // RHS var is unchanged.
|
||||
}
|
||||
|
||||
TEST(AssignmentOperatorTest, NonDefaultAssignedToDefault) {
|
||||
FilePath non_default_path("path");
|
||||
FilePath default_path;
|
||||
default_path = non_default_path;
|
||||
EXPECT_STREQ("path", default_path.c_str());
|
||||
EXPECT_STREQ("path", non_default_path.c_str()); // RHS var is unchanged.
|
||||
}
|
||||
|
||||
TEST(AssignmentOperatorTest, ConstAssignedToNonConst) {
|
||||
const FilePath const_default_path("const_path");
|
||||
FilePath non_default_path("path");
|
||||
non_default_path = const_default_path;
|
||||
EXPECT_STREQ("const_path", non_default_path.c_str());
|
||||
}
|
||||
|
||||
class DirectoryCreationTest : public Test {
|
||||
protected:
|
||||
virtual void SetUp() {
|
||||
testdata_path_.Set(FilePath(String::Format("%s%s%s",
|
||||
TempDir().c_str(), GetCurrentExecutableName().c_str(),
|
||||
"_directory_creation" GTEST_PATH_SEP_ "test" GTEST_PATH_SEP_)));
|
||||
testdata_file_.Set(testdata_path_.RemoveTrailingPathSeparator());
|
||||
|
||||
unique_file0_.Set(FilePath::MakeFileName(testdata_path_, FilePath("unique"),
|
||||
0, "txt"));
|
||||
unique_file1_.Set(FilePath::MakeFileName(testdata_path_, FilePath("unique"),
|
||||
1, "txt"));
|
||||
|
||||
remove(testdata_file_.c_str());
|
||||
remove(unique_file0_.c_str());
|
||||
remove(unique_file1_.c_str());
|
||||
posix::RmDir(testdata_path_.c_str());
|
||||
}
|
||||
|
||||
virtual void TearDown() {
|
||||
remove(testdata_file_.c_str());
|
||||
remove(unique_file0_.c_str());
|
||||
remove(unique_file1_.c_str());
|
||||
posix::RmDir(testdata_path_.c_str());
|
||||
}
|
||||
|
||||
String TempDir() const {
|
||||
#if GTEST_OS_WINDOWS_MOBILE
|
||||
return String("\\temp\\");
|
||||
#elif GTEST_OS_WINDOWS
|
||||
const char* temp_dir = posix::GetEnv("TEMP");
|
||||
if (temp_dir == NULL || temp_dir[0] == '\0')
|
||||
return String("\\temp\\");
|
||||
else if (String(temp_dir).EndsWith("\\"))
|
||||
return String(temp_dir);
|
||||
else
|
||||
return String::Format("%s\\", temp_dir);
|
||||
#else
|
||||
return String("/tmp/");
|
||||
#endif // GTEST_OS_WINDOWS_MOBILE
|
||||
}
|
||||
|
||||
void CreateTextFile(const char* filename) {
|
||||
FILE* f = posix::FOpen(filename, "w");
|
||||
fprintf(f, "text\n");
|
||||
fclose(f);
|
||||
}
|
||||
|
||||
// Strings representing a directory and a file, with identical paths
|
||||
// except for the trailing separator character that distinquishes
|
||||
// a directory named 'test' from a file named 'test'. Example names:
|
||||
FilePath testdata_path_; // "/tmp/directory_creation/test/"
|
||||
FilePath testdata_file_; // "/tmp/directory_creation/test"
|
||||
FilePath unique_file0_; // "/tmp/directory_creation/test/unique.txt"
|
||||
FilePath unique_file1_; // "/tmp/directory_creation/test/unique_1.txt"
|
||||
};
|
||||
|
||||
TEST_F(DirectoryCreationTest, CreateDirectoriesRecursively) {
|
||||
EXPECT_FALSE(testdata_path_.DirectoryExists()) << testdata_path_.c_str();
|
||||
EXPECT_TRUE(testdata_path_.CreateDirectoriesRecursively());
|
||||
EXPECT_TRUE(testdata_path_.DirectoryExists());
|
||||
}
|
||||
|
||||
TEST_F(DirectoryCreationTest, CreateDirectoriesForAlreadyExistingPath) {
|
||||
EXPECT_FALSE(testdata_path_.DirectoryExists()) << testdata_path_.c_str();
|
||||
EXPECT_TRUE(testdata_path_.CreateDirectoriesRecursively());
|
||||
// Call 'create' again... should still succeed.
|
||||
EXPECT_TRUE(testdata_path_.CreateDirectoriesRecursively());
|
||||
}
|
||||
|
||||
TEST_F(DirectoryCreationTest, CreateDirectoriesAndUniqueFilename) {
|
||||
FilePath file_path(FilePath::GenerateUniqueFileName(testdata_path_,
|
||||
FilePath("unique"), "txt"));
|
||||
EXPECT_STREQ(unique_file0_.c_str(), file_path.c_str());
|
||||
EXPECT_FALSE(file_path.FileOrDirectoryExists()); // file not there
|
||||
|
||||
testdata_path_.CreateDirectoriesRecursively();
|
||||
EXPECT_FALSE(file_path.FileOrDirectoryExists()); // file still not there
|
||||
CreateTextFile(file_path.c_str());
|
||||
EXPECT_TRUE(file_path.FileOrDirectoryExists());
|
||||
|
||||
FilePath file_path2(FilePath::GenerateUniqueFileName(testdata_path_,
|
||||
FilePath("unique"), "txt"));
|
||||
EXPECT_STREQ(unique_file1_.c_str(), file_path2.c_str());
|
||||
EXPECT_FALSE(file_path2.FileOrDirectoryExists()); // file not there
|
||||
CreateTextFile(file_path2.c_str());
|
||||
EXPECT_TRUE(file_path2.FileOrDirectoryExists());
|
||||
}
|
||||
|
||||
TEST_F(DirectoryCreationTest, CreateDirectoriesFail) {
|
||||
// force a failure by putting a file where we will try to create a directory.
|
||||
CreateTextFile(testdata_file_.c_str());
|
||||
EXPECT_TRUE(testdata_file_.FileOrDirectoryExists());
|
||||
EXPECT_FALSE(testdata_file_.DirectoryExists());
|
||||
EXPECT_FALSE(testdata_file_.CreateDirectoriesRecursively());
|
||||
}
|
||||
|
||||
TEST(NoDirectoryCreationTest, CreateNoDirectoriesForDefaultXmlFile) {
|
||||
const FilePath test_detail_xml("test_detail.xml");
|
||||
EXPECT_FALSE(test_detail_xml.CreateDirectoriesRecursively());
|
||||
}
|
||||
|
||||
TEST(FilePathTest, DefaultConstructor) {
|
||||
FilePath fp;
|
||||
EXPECT_STREQ("", fp.c_str());
|
||||
}
|
||||
|
||||
TEST(FilePathTest, CharAndCopyConstructors) {
|
||||
const FilePath fp("spicy");
|
||||
EXPECT_STREQ("spicy", fp.c_str());
|
||||
|
||||
const FilePath fp_copy(fp);
|
||||
EXPECT_STREQ("spicy", fp_copy.c_str());
|
||||
}
|
||||
|
||||
TEST(FilePathTest, StringConstructor) {
|
||||
const FilePath fp(String("cider"));
|
||||
EXPECT_STREQ("cider", fp.c_str());
|
||||
}
|
||||
|
||||
TEST(FilePathTest, Set) {
|
||||
const FilePath apple("apple");
|
||||
FilePath mac("mac");
|
||||
mac.Set(apple); // Implement Set() since overloading operator= is forbidden.
|
||||
EXPECT_STREQ("apple", mac.c_str());
|
||||
EXPECT_STREQ("apple", apple.c_str());
|
||||
}
|
||||
|
||||
TEST(FilePathTest, ToString) {
|
||||
const FilePath file("drink");
|
||||
String str(file.ToString());
|
||||
EXPECT_STREQ("drink", str.c_str());
|
||||
}
|
||||
|
||||
TEST(FilePathTest, RemoveExtension) {
|
||||
EXPECT_STREQ("app", FilePath("app.exe").RemoveExtension("exe").c_str());
|
||||
EXPECT_STREQ("APP", FilePath("APP.EXE").RemoveExtension("exe").c_str());
|
||||
}
|
||||
|
||||
TEST(FilePathTest, RemoveExtensionWhenThereIsNoExtension) {
|
||||
EXPECT_STREQ("app", FilePath("app").RemoveExtension("exe").c_str());
|
||||
}
|
||||
|
||||
TEST(FilePathTest, IsDirectory) {
|
||||
EXPECT_FALSE(FilePath("cola").IsDirectory());
|
||||
EXPECT_TRUE(FilePath("koala" GTEST_PATH_SEP_).IsDirectory());
|
||||
#if GTEST_HAS_ALT_PATH_SEP_
|
||||
EXPECT_TRUE(FilePath("koala/").IsDirectory());
|
||||
#endif
|
||||
}
|
||||
|
||||
TEST(FilePathTest, IsAbsolutePath) {
|
||||
EXPECT_FALSE(FilePath("is" GTEST_PATH_SEP_ "relative").IsAbsolutePath());
|
||||
EXPECT_FALSE(FilePath("").IsAbsolutePath());
|
||||
#if GTEST_OS_WINDOWS
|
||||
EXPECT_TRUE(FilePath("c:\\" GTEST_PATH_SEP_ "is_not"
|
||||
GTEST_PATH_SEP_ "relative").IsAbsolutePath());
|
||||
EXPECT_FALSE(FilePath("c:foo" GTEST_PATH_SEP_ "bar").IsAbsolutePath());
|
||||
EXPECT_TRUE(FilePath("c:/" GTEST_PATH_SEP_ "is_not"
|
||||
GTEST_PATH_SEP_ "relative").IsAbsolutePath());
|
||||
#else
|
||||
EXPECT_TRUE(FilePath(GTEST_PATH_SEP_ "is_not" GTEST_PATH_SEP_ "relative")
|
||||
.IsAbsolutePath());
|
||||
#endif // GTEST_OS_WINDOWS
|
||||
}
|
||||
|
||||
TEST(FilePathTest, IsRootDirectory) {
|
||||
#if GTEST_OS_WINDOWS
|
||||
EXPECT_TRUE(FilePath("a:\\").IsRootDirectory());
|
||||
EXPECT_TRUE(FilePath("Z:/").IsRootDirectory());
|
||||
EXPECT_TRUE(FilePath("e://").IsRootDirectory());
|
||||
EXPECT_FALSE(FilePath("").IsRootDirectory());
|
||||
EXPECT_FALSE(FilePath("b:").IsRootDirectory());
|
||||
EXPECT_FALSE(FilePath("b:a").IsRootDirectory());
|
||||
EXPECT_FALSE(FilePath("8:/").IsRootDirectory());
|
||||
EXPECT_FALSE(FilePath("c|/").IsRootDirectory());
|
||||
#else
|
||||
EXPECT_TRUE(FilePath("/").IsRootDirectory());
|
||||
EXPECT_TRUE(FilePath("//").IsRootDirectory());
|
||||
EXPECT_FALSE(FilePath("").IsRootDirectory());
|
||||
EXPECT_FALSE(FilePath("\\").IsRootDirectory());
|
||||
EXPECT_FALSE(FilePath("/x").IsRootDirectory());
|
||||
#endif
|
||||
}
|
||||
|
||||
} // namespace
|
||||
} // namespace internal
|
||||
} // namespace testing
|
155
gtest/test/gtest-linked_ptr_test.cc
Normal file
155
gtest/test/gtest-linked_ptr_test.cc
Normal file
@ -0,0 +1,155 @@
|
||||
// Copyright 2003, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Authors: Dan Egnor (egnor@google.com)
|
||||
// Ported to Windows: Vadim Berman (vadimb@google.com)
|
||||
|
||||
#include "gtest/internal/gtest-linked_ptr.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
namespace {
|
||||
|
||||
using testing::Message;
|
||||
using testing::internal::linked_ptr;
|
||||
|
||||
int num;
|
||||
Message* history = NULL;
|
||||
|
||||
// Class which tracks allocation/deallocation
|
||||
class A {
|
||||
public:
|
||||
A(): mynum(num++) { *history << "A" << mynum << " ctor\n"; }
|
||||
virtual ~A() { *history << "A" << mynum << " dtor\n"; }
|
||||
virtual void Use() { *history << "A" << mynum << " use\n"; }
|
||||
protected:
|
||||
int mynum;
|
||||
};
|
||||
|
||||
// Subclass
|
||||
class B : public A {
|
||||
public:
|
||||
B() { *history << "B" << mynum << " ctor\n"; }
|
||||
~B() { *history << "B" << mynum << " dtor\n"; }
|
||||
virtual void Use() { *history << "B" << mynum << " use\n"; }
|
||||
};
|
||||
|
||||
class LinkedPtrTest : public testing::Test {
|
||||
public:
|
||||
LinkedPtrTest() {
|
||||
num = 0;
|
||||
history = new Message;
|
||||
}
|
||||
|
||||
virtual ~LinkedPtrTest() {
|
||||
delete history;
|
||||
history = NULL;
|
||||
}
|
||||
};
|
||||
|
||||
TEST_F(LinkedPtrTest, GeneralTest) {
|
||||
{
|
||||
linked_ptr<A> a0, a1, a2;
|
||||
// Use explicit function call notation here to suppress self-assign warning.
|
||||
a0.operator=(a0);
|
||||
a1 = a2;
|
||||
ASSERT_EQ(a0.get(), static_cast<A*>(NULL));
|
||||
ASSERT_EQ(a1.get(), static_cast<A*>(NULL));
|
||||
ASSERT_EQ(a2.get(), static_cast<A*>(NULL));
|
||||
ASSERT_TRUE(a0 == NULL);
|
||||
ASSERT_TRUE(a1 == NULL);
|
||||
ASSERT_TRUE(a2 == NULL);
|
||||
|
||||
{
|
||||
linked_ptr<A> a3(new A);
|
||||
a0 = a3;
|
||||
ASSERT_TRUE(a0 == a3);
|
||||
ASSERT_TRUE(a0 != NULL);
|
||||
ASSERT_TRUE(a0.get() == a3);
|
||||
ASSERT_TRUE(a0 == a3.get());
|
||||
linked_ptr<A> a4(a0);
|
||||
a1 = a4;
|
||||
linked_ptr<A> a5(new A);
|
||||
ASSERT_TRUE(a5.get() != a3);
|
||||
ASSERT_TRUE(a5 != a3.get());
|
||||
a2 = a5;
|
||||
linked_ptr<B> b0(new B);
|
||||
linked_ptr<A> a6(b0);
|
||||
ASSERT_TRUE(b0 == a6);
|
||||
ASSERT_TRUE(a6 == b0);
|
||||
ASSERT_TRUE(b0 != NULL);
|
||||
a5 = b0;
|
||||
a5 = b0;
|
||||
a3->Use();
|
||||
a4->Use();
|
||||
a5->Use();
|
||||
a6->Use();
|
||||
b0->Use();
|
||||
(*b0).Use();
|
||||
b0.get()->Use();
|
||||
}
|
||||
|
||||
a0->Use();
|
||||
a1->Use();
|
||||
a2->Use();
|
||||
|
||||
a1 = a2;
|
||||
a2.reset(new A);
|
||||
a0.reset();
|
||||
|
||||
linked_ptr<A> a7;
|
||||
}
|
||||
|
||||
ASSERT_STREQ(
|
||||
"A0 ctor\n"
|
||||
"A1 ctor\n"
|
||||
"A2 ctor\n"
|
||||
"B2 ctor\n"
|
||||
"A0 use\n"
|
||||
"A0 use\n"
|
||||
"B2 use\n"
|
||||
"B2 use\n"
|
||||
"B2 use\n"
|
||||
"B2 use\n"
|
||||
"B2 use\n"
|
||||
"B2 dtor\n"
|
||||
"A2 dtor\n"
|
||||
"A0 use\n"
|
||||
"A0 use\n"
|
||||
"A1 use\n"
|
||||
"A3 ctor\n"
|
||||
"A0 dtor\n"
|
||||
"A3 dtor\n"
|
||||
"A1 dtor\n",
|
||||
history->GetString().c_str()
|
||||
);
|
||||
}
|
||||
|
||||
} // Unnamed namespace
|
313
gtest/test/gtest-listener_test.cc
Normal file
313
gtest/test/gtest-listener_test.cc
Normal file
@ -0,0 +1,313 @@
|
||||
// Copyright 2009 Google Inc. All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: vladl@google.com (Vlad Losev)
|
||||
//
|
||||
// The Google C++ Testing Framework (Google Test)
|
||||
//
|
||||
// This file verifies Google Test event listeners receive events at the
|
||||
// right times.
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
#include <vector>
|
||||
|
||||
using ::testing::AddGlobalTestEnvironment;
|
||||
using ::testing::Environment;
|
||||
using ::testing::InitGoogleTest;
|
||||
using ::testing::Test;
|
||||
using ::testing::TestCase;
|
||||
using ::testing::TestEventListener;
|
||||
using ::testing::TestInfo;
|
||||
using ::testing::TestPartResult;
|
||||
using ::testing::UnitTest;
|
||||
using ::testing::internal::String;
|
||||
|
||||
// Used by tests to register their events.
|
||||
std::vector<String>* g_events = NULL;
|
||||
|
||||
namespace testing {
|
||||
namespace internal {
|
||||
|
||||
class EventRecordingListener : public TestEventListener {
|
||||
public:
|
||||
EventRecordingListener(const char* name) : name_(name) {}
|
||||
|
||||
protected:
|
||||
virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {
|
||||
g_events->push_back(GetFullMethodName("OnTestProgramStart"));
|
||||
}
|
||||
|
||||
virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
|
||||
int iteration) {
|
||||
Message message;
|
||||
message << GetFullMethodName("OnTestIterationStart")
|
||||
<< "(" << iteration << ")";
|
||||
g_events->push_back(message.GetString());
|
||||
}
|
||||
|
||||
virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {
|
||||
g_events->push_back(GetFullMethodName("OnEnvironmentsSetUpStart"));
|
||||
}
|
||||
|
||||
virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {
|
||||
g_events->push_back(GetFullMethodName("OnEnvironmentsSetUpEnd"));
|
||||
}
|
||||
|
||||
virtual void OnTestCaseStart(const TestCase& /*test_case*/) {
|
||||
g_events->push_back(GetFullMethodName("OnTestCaseStart"));
|
||||
}
|
||||
|
||||
virtual void OnTestStart(const TestInfo& /*test_info*/) {
|
||||
g_events->push_back(GetFullMethodName("OnTestStart"));
|
||||
}
|
||||
|
||||
virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {
|
||||
g_events->push_back(GetFullMethodName("OnTestPartResult"));
|
||||
}
|
||||
|
||||
virtual void OnTestEnd(const TestInfo& /*test_info*/) {
|
||||
g_events->push_back(GetFullMethodName("OnTestEnd"));
|
||||
}
|
||||
|
||||
virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {
|
||||
g_events->push_back(GetFullMethodName("OnTestCaseEnd"));
|
||||
}
|
||||
|
||||
virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {
|
||||
g_events->push_back(GetFullMethodName("OnEnvironmentsTearDownStart"));
|
||||
}
|
||||
|
||||
virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {
|
||||
g_events->push_back(GetFullMethodName("OnEnvironmentsTearDownEnd"));
|
||||
}
|
||||
|
||||
virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
|
||||
int iteration) {
|
||||
Message message;
|
||||
message << GetFullMethodName("OnTestIterationEnd")
|
||||
<< "(" << iteration << ")";
|
||||
g_events->push_back(message.GetString());
|
||||
}
|
||||
|
||||
virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {
|
||||
g_events->push_back(GetFullMethodName("OnTestProgramEnd"));
|
||||
}
|
||||
|
||||
private:
|
||||
String GetFullMethodName(const char* name) {
|
||||
Message message;
|
||||
message << name_ << "." << name;
|
||||
return message.GetString();
|
||||
}
|
||||
|
||||
String name_;
|
||||
};
|
||||
|
||||
class EnvironmentInvocationCatcher : public Environment {
|
||||
protected:
|
||||
virtual void SetUp() {
|
||||
g_events->push_back(String("Environment::SetUp"));
|
||||
}
|
||||
|
||||
virtual void TearDown() {
|
||||
g_events->push_back(String("Environment::TearDown"));
|
||||
}
|
||||
};
|
||||
|
||||
class ListenerTest : public Test {
|
||||
protected:
|
||||
static void SetUpTestCase() {
|
||||
g_events->push_back(String("ListenerTest::SetUpTestCase"));
|
||||
}
|
||||
|
||||
static void TearDownTestCase() {
|
||||
g_events->push_back(String("ListenerTest::TearDownTestCase"));
|
||||
}
|
||||
|
||||
virtual void SetUp() {
|
||||
g_events->push_back(String("ListenerTest::SetUp"));
|
||||
}
|
||||
|
||||
virtual void TearDown() {
|
||||
g_events->push_back(String("ListenerTest::TearDown"));
|
||||
}
|
||||
};
|
||||
|
||||
TEST_F(ListenerTest, DoesFoo) {
|
||||
// Test execution order within a test case is not guaranteed so we are not
|
||||
// recording the test name.
|
||||
g_events->push_back(String("ListenerTest::* Test Body"));
|
||||
SUCCEED(); // Triggers OnTestPartResult.
|
||||
}
|
||||
|
||||
TEST_F(ListenerTest, DoesBar) {
|
||||
g_events->push_back(String("ListenerTest::* Test Body"));
|
||||
SUCCEED(); // Triggers OnTestPartResult.
|
||||
}
|
||||
|
||||
} // namespace internal
|
||||
|
||||
} // namespace testing
|
||||
|
||||
using ::testing::internal::EnvironmentInvocationCatcher;
|
||||
using ::testing::internal::EventRecordingListener;
|
||||
|
||||
void VerifyResults(const std::vector<String>& data,
|
||||
const char* const* expected_data,
|
||||
int expected_data_size) {
|
||||
const int actual_size = data.size();
|
||||
// If the following assertion fails, a new entry will be appended to
|
||||
// data. Hence we save data.size() first.
|
||||
EXPECT_EQ(expected_data_size, actual_size);
|
||||
|
||||
// Compares the common prefix.
|
||||
const int shorter_size = expected_data_size <= actual_size ?
|
||||
expected_data_size : actual_size;
|
||||
int i = 0;
|
||||
for (; i < shorter_size; ++i) {
|
||||
ASSERT_STREQ(expected_data[i], data[i].c_str())
|
||||
<< "at position " << i;
|
||||
}
|
||||
|
||||
// Prints extra elements in the actual data.
|
||||
for (; i < actual_size; ++i) {
|
||||
printf(" Actual event #%d: %s\n", i, data[i].c_str());
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
std::vector<String> events;
|
||||
g_events = &events;
|
||||
InitGoogleTest(&argc, argv);
|
||||
|
||||
UnitTest::GetInstance()->listeners().Append(
|
||||
new EventRecordingListener("1st"));
|
||||
UnitTest::GetInstance()->listeners().Append(
|
||||
new EventRecordingListener("2nd"));
|
||||
|
||||
AddGlobalTestEnvironment(new EnvironmentInvocationCatcher);
|
||||
|
||||
GTEST_CHECK_(events.size() == 0)
|
||||
<< "AddGlobalTestEnvironment should not generate any events itself.";
|
||||
|
||||
::testing::GTEST_FLAG(repeat) = 2;
|
||||
int ret_val = RUN_ALL_TESTS();
|
||||
|
||||
const char* const expected_events[] = {
|
||||
"1st.OnTestProgramStart",
|
||||
"2nd.OnTestProgramStart",
|
||||
"1st.OnTestIterationStart(0)",
|
||||
"2nd.OnTestIterationStart(0)",
|
||||
"1st.OnEnvironmentsSetUpStart",
|
||||
"2nd.OnEnvironmentsSetUpStart",
|
||||
"Environment::SetUp",
|
||||
"2nd.OnEnvironmentsSetUpEnd",
|
||||
"1st.OnEnvironmentsSetUpEnd",
|
||||
"1st.OnTestCaseStart",
|
||||
"2nd.OnTestCaseStart",
|
||||
"ListenerTest::SetUpTestCase",
|
||||
"1st.OnTestStart",
|
||||
"2nd.OnTestStart",
|
||||
"ListenerTest::SetUp",
|
||||
"ListenerTest::* Test Body",
|
||||
"1st.OnTestPartResult",
|
||||
"2nd.OnTestPartResult",
|
||||
"ListenerTest::TearDown",
|
||||
"2nd.OnTestEnd",
|
||||
"1st.OnTestEnd",
|
||||
"1st.OnTestStart",
|
||||
"2nd.OnTestStart",
|
||||
"ListenerTest::SetUp",
|
||||
"ListenerTest::* Test Body",
|
||||
"1st.OnTestPartResult",
|
||||
"2nd.OnTestPartResult",
|
||||
"ListenerTest::TearDown",
|
||||
"2nd.OnTestEnd",
|
||||
"1st.OnTestEnd",
|
||||
"ListenerTest::TearDownTestCase",
|
||||
"2nd.OnTestCaseEnd",
|
||||
"1st.OnTestCaseEnd",
|
||||
"1st.OnEnvironmentsTearDownStart",
|
||||
"2nd.OnEnvironmentsTearDownStart",
|
||||
"Environment::TearDown",
|
||||
"2nd.OnEnvironmentsTearDownEnd",
|
||||
"1st.OnEnvironmentsTearDownEnd",
|
||||
"2nd.OnTestIterationEnd(0)",
|
||||
"1st.OnTestIterationEnd(0)",
|
||||
"1st.OnTestIterationStart(1)",
|
||||
"2nd.OnTestIterationStart(1)",
|
||||
"1st.OnEnvironmentsSetUpStart",
|
||||
"2nd.OnEnvironmentsSetUpStart",
|
||||
"Environment::SetUp",
|
||||
"2nd.OnEnvironmentsSetUpEnd",
|
||||
"1st.OnEnvironmentsSetUpEnd",
|
||||
"1st.OnTestCaseStart",
|
||||
"2nd.OnTestCaseStart",
|
||||
"ListenerTest::SetUpTestCase",
|
||||
"1st.OnTestStart",
|
||||
"2nd.OnTestStart",
|
||||
"ListenerTest::SetUp",
|
||||
"ListenerTest::* Test Body",
|
||||
"1st.OnTestPartResult",
|
||||
"2nd.OnTestPartResult",
|
||||
"ListenerTest::TearDown",
|
||||
"2nd.OnTestEnd",
|
||||
"1st.OnTestEnd",
|
||||
"1st.OnTestStart",
|
||||
"2nd.OnTestStart",
|
||||
"ListenerTest::SetUp",
|
||||
"ListenerTest::* Test Body",
|
||||
"1st.OnTestPartResult",
|
||||
"2nd.OnTestPartResult",
|
||||
"ListenerTest::TearDown",
|
||||
"2nd.OnTestEnd",
|
||||
"1st.OnTestEnd",
|
||||
"ListenerTest::TearDownTestCase",
|
||||
"2nd.OnTestCaseEnd",
|
||||
"1st.OnTestCaseEnd",
|
||||
"1st.OnEnvironmentsTearDownStart",
|
||||
"2nd.OnEnvironmentsTearDownStart",
|
||||
"Environment::TearDown",
|
||||
"2nd.OnEnvironmentsTearDownEnd",
|
||||
"1st.OnEnvironmentsTearDownEnd",
|
||||
"2nd.OnTestIterationEnd(1)",
|
||||
"1st.OnTestIterationEnd(1)",
|
||||
"2nd.OnTestProgramEnd",
|
||||
"1st.OnTestProgramEnd"
|
||||
};
|
||||
VerifyResults(events,
|
||||
expected_events,
|
||||
sizeof(expected_events)/sizeof(expected_events[0]));
|
||||
|
||||
// We need to check manually for ad hoc test failures that happen after
|
||||
// RUN_ALL_TESTS finishes.
|
||||
if (UnitTest::GetInstance()->Failed())
|
||||
ret_val = 1;
|
||||
|
||||
return ret_val;
|
||||
}
|
166
gtest/test/gtest-message_test.cc
Normal file
166
gtest/test/gtest-message_test.cc
Normal file
@ -0,0 +1,166 @@
|
||||
// Copyright 2005, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
//
|
||||
// Tests for the Message class.
|
||||
|
||||
#include "gtest/gtest-message.h"
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
namespace {
|
||||
|
||||
using ::testing::Message;
|
||||
|
||||
// A helper function that turns a Message into a C string.
|
||||
const char* ToCString(const Message& msg) {
|
||||
static testing::internal::String result;
|
||||
result = msg.GetString();
|
||||
return result.c_str();
|
||||
}
|
||||
|
||||
// Tests the testing::Message class
|
||||
|
||||
// Tests the default constructor.
|
||||
TEST(MessageTest, DefaultConstructor) {
|
||||
const Message msg;
|
||||
EXPECT_STREQ("", ToCString(msg));
|
||||
}
|
||||
|
||||
// Tests the copy constructor.
|
||||
TEST(MessageTest, CopyConstructor) {
|
||||
const Message msg1("Hello");
|
||||
const Message msg2(msg1);
|
||||
EXPECT_STREQ("Hello", ToCString(msg2));
|
||||
}
|
||||
|
||||
// Tests constructing a Message from a C-string.
|
||||
TEST(MessageTest, ConstructsFromCString) {
|
||||
Message msg("Hello");
|
||||
EXPECT_STREQ("Hello", ToCString(msg));
|
||||
}
|
||||
|
||||
// Tests streaming a float.
|
||||
TEST(MessageTest, StreamsFloat) {
|
||||
const char* const s = ToCString(Message() << 1.23456F << " " << 2.34567F);
|
||||
// Both numbers should be printed with enough precision.
|
||||
EXPECT_PRED_FORMAT2(testing::IsSubstring, "1.234560", s);
|
||||
EXPECT_PRED_FORMAT2(testing::IsSubstring, " 2.345669", s);
|
||||
}
|
||||
|
||||
// Tests streaming a double.
|
||||
TEST(MessageTest, StreamsDouble) {
|
||||
const char* const s = ToCString(Message() << 1260570880.4555497 << " "
|
||||
<< 1260572265.1954534);
|
||||
// Both numbers should be printed with enough precision.
|
||||
EXPECT_PRED_FORMAT2(testing::IsSubstring, "1260570880.45", s);
|
||||
EXPECT_PRED_FORMAT2(testing::IsSubstring, " 1260572265.19", s);
|
||||
}
|
||||
|
||||
// Tests streaming a non-char pointer.
|
||||
TEST(MessageTest, StreamsPointer) {
|
||||
int n = 0;
|
||||
int* p = &n;
|
||||
EXPECT_STRNE("(null)", ToCString(Message() << p));
|
||||
}
|
||||
|
||||
// Tests streaming a NULL non-char pointer.
|
||||
TEST(MessageTest, StreamsNullPointer) {
|
||||
int* p = NULL;
|
||||
EXPECT_STREQ("(null)", ToCString(Message() << p));
|
||||
}
|
||||
|
||||
// Tests streaming a C string.
|
||||
TEST(MessageTest, StreamsCString) {
|
||||
EXPECT_STREQ("Foo", ToCString(Message() << "Foo"));
|
||||
}
|
||||
|
||||
// Tests streaming a NULL C string.
|
||||
TEST(MessageTest, StreamsNullCString) {
|
||||
char* p = NULL;
|
||||
EXPECT_STREQ("(null)", ToCString(Message() << p));
|
||||
}
|
||||
|
||||
// Tests streaming std::string.
|
||||
TEST(MessageTest, StreamsString) {
|
||||
const ::std::string str("Hello");
|
||||
EXPECT_STREQ("Hello", ToCString(Message() << str));
|
||||
}
|
||||
|
||||
// Tests that we can output strings containing embedded NULs.
|
||||
TEST(MessageTest, StreamsStringWithEmbeddedNUL) {
|
||||
const char char_array_with_nul[] =
|
||||
"Here's a NUL\0 and some more string";
|
||||
const ::std::string string_with_nul(char_array_with_nul,
|
||||
sizeof(char_array_with_nul) - 1);
|
||||
EXPECT_STREQ("Here's a NUL\\0 and some more string",
|
||||
ToCString(Message() << string_with_nul));
|
||||
}
|
||||
|
||||
// Tests streaming a NUL char.
|
||||
TEST(MessageTest, StreamsNULChar) {
|
||||
EXPECT_STREQ("\\0", ToCString(Message() << '\0'));
|
||||
}
|
||||
|
||||
// Tests streaming int.
|
||||
TEST(MessageTest, StreamsInt) {
|
||||
EXPECT_STREQ("123", ToCString(Message() << 123));
|
||||
}
|
||||
|
||||
// Tests that basic IO manipulators (endl, ends, and flush) can be
|
||||
// streamed to Message.
|
||||
TEST(MessageTest, StreamsBasicIoManip) {
|
||||
EXPECT_STREQ("Line 1.\nA NUL char \\0 in line 2.",
|
||||
ToCString(Message() << "Line 1." << std::endl
|
||||
<< "A NUL char " << std::ends << std::flush
|
||||
<< " in line 2."));
|
||||
}
|
||||
|
||||
// Tests Message::GetString()
|
||||
TEST(MessageTest, GetString) {
|
||||
Message msg;
|
||||
msg << 1 << " lamb";
|
||||
EXPECT_STREQ("1 lamb", msg.GetString().c_str());
|
||||
}
|
||||
|
||||
// Tests streaming a Message object to an ostream.
|
||||
TEST(MessageTest, StreamsToOStream) {
|
||||
Message msg("Hello");
|
||||
::std::stringstream ss;
|
||||
ss << msg;
|
||||
EXPECT_STREQ("Hello", testing::internal::StringStreamToString(&ss).c_str());
|
||||
}
|
||||
|
||||
// Tests that a Message object doesn't take up too much stack space.
|
||||
TEST(MessageTest, DoesNotTakeUpMuchStackSpace) {
|
||||
EXPECT_LE(sizeof(Message), 16U);
|
||||
}
|
||||
|
||||
} // namespace
|
212
gtest/test/gtest-options_test.cc
Normal file
212
gtest/test/gtest-options_test.cc
Normal file
@ -0,0 +1,212 @@
|
||||
// Copyright 2008, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Authors: keith.ray@gmail.com (Keith Ray)
|
||||
//
|
||||
// Google Test UnitTestOptions tests
|
||||
//
|
||||
// This file tests classes and functions used internally by
|
||||
// Google Test. They are subject to change without notice.
|
||||
//
|
||||
// This file is #included from gtest.cc, to avoid changing build or
|
||||
// make-files on Windows and other platforms. Do not #include this file
|
||||
// anywhere else!
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#if GTEST_OS_WINDOWS_MOBILE
|
||||
# include <windows.h>
|
||||
#elif GTEST_OS_WINDOWS
|
||||
# include <direct.h>
|
||||
#endif // GTEST_OS_WINDOWS_MOBILE
|
||||
|
||||
// Indicates that this translation unit is part of Google Test's
|
||||
// implementation. It must come before gtest-internal-inl.h is
|
||||
// included, or there will be a compiler error. This trick is to
|
||||
// prevent a user from accidentally including gtest-internal-inl.h in
|
||||
// his code.
|
||||
#define GTEST_IMPLEMENTATION_ 1
|
||||
#include "src/gtest-internal-inl.h"
|
||||
#undef GTEST_IMPLEMENTATION_
|
||||
|
||||
namespace testing {
|
||||
namespace internal {
|
||||
namespace {
|
||||
|
||||
// Turns the given relative path into an absolute path.
|
||||
FilePath GetAbsolutePathOf(const FilePath& relative_path) {
|
||||
return FilePath::ConcatPaths(FilePath::GetCurrentDir(), relative_path);
|
||||
}
|
||||
|
||||
// Testing UnitTestOptions::GetOutputFormat/GetOutputFile.
|
||||
|
||||
TEST(XmlOutputTest, GetOutputFormatDefault) {
|
||||
GTEST_FLAG(output) = "";
|
||||
EXPECT_STREQ("", UnitTestOptions::GetOutputFormat().c_str());
|
||||
}
|
||||
|
||||
TEST(XmlOutputTest, GetOutputFormat) {
|
||||
GTEST_FLAG(output) = "xml:filename";
|
||||
EXPECT_STREQ("xml", UnitTestOptions::GetOutputFormat().c_str());
|
||||
}
|
||||
|
||||
TEST(XmlOutputTest, GetOutputFileDefault) {
|
||||
GTEST_FLAG(output) = "";
|
||||
EXPECT_STREQ(GetAbsolutePathOf(FilePath("test_detail.xml")).c_str(),
|
||||
UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
|
||||
}
|
||||
|
||||
TEST(XmlOutputTest, GetOutputFileSingleFile) {
|
||||
GTEST_FLAG(output) = "xml:filename.abc";
|
||||
EXPECT_STREQ(GetAbsolutePathOf(FilePath("filename.abc")).c_str(),
|
||||
UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
|
||||
}
|
||||
|
||||
TEST(XmlOutputTest, GetOutputFileFromDirectoryPath) {
|
||||
GTEST_FLAG(output) = "xml:path" GTEST_PATH_SEP_;
|
||||
const std::string expected_output_file =
|
||||
GetAbsolutePathOf(
|
||||
FilePath(std::string("path") + GTEST_PATH_SEP_ +
|
||||
GetCurrentExecutableName().c_str() + ".xml")).c_str();
|
||||
const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile();
|
||||
#if GTEST_OS_WINDOWS
|
||||
EXPECT_STRCASEEQ(expected_output_file.c_str(), output_file.c_str());
|
||||
#else
|
||||
EXPECT_EQ(expected_output_file, output_file.c_str());
|
||||
#endif
|
||||
}
|
||||
|
||||
TEST(OutputFileHelpersTest, GetCurrentExecutableName) {
|
||||
const std::string exe_str = GetCurrentExecutableName().c_str();
|
||||
#if GTEST_OS_WINDOWS
|
||||
const bool success =
|
||||
_strcmpi("gtest-options_test", exe_str.c_str()) == 0 ||
|
||||
_strcmpi("gtest-options-ex_test", exe_str.c_str()) == 0 ||
|
||||
_strcmpi("gtest_all_test", exe_str.c_str()) == 0 ||
|
||||
_strcmpi("gtest_dll_test", exe_str.c_str()) == 0;
|
||||
#else
|
||||
// TODO(wan@google.com): remove the hard-coded "lt-" prefix when
|
||||
// Chandler Carruth's libtool replacement is ready.
|
||||
const bool success =
|
||||
exe_str == "gtest-options_test" ||
|
||||
exe_str == "gtest_all_test" ||
|
||||
exe_str == "lt-gtest_all_test" ||
|
||||
exe_str == "gtest_dll_test";
|
||||
#endif // GTEST_OS_WINDOWS
|
||||
if (!success)
|
||||
FAIL() << "GetCurrentExecutableName() returns " << exe_str;
|
||||
}
|
||||
|
||||
class XmlOutputChangeDirTest : public Test {
|
||||
protected:
|
||||
virtual void SetUp() {
|
||||
original_working_dir_ = FilePath::GetCurrentDir();
|
||||
posix::ChDir("..");
|
||||
// This will make the test fail if run from the root directory.
|
||||
EXPECT_STRNE(original_working_dir_.c_str(),
|
||||
FilePath::GetCurrentDir().c_str());
|
||||
}
|
||||
|
||||
virtual void TearDown() {
|
||||
posix::ChDir(original_working_dir_.c_str());
|
||||
}
|
||||
|
||||
FilePath original_working_dir_;
|
||||
};
|
||||
|
||||
TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithDefault) {
|
||||
GTEST_FLAG(output) = "";
|
||||
EXPECT_STREQ(FilePath::ConcatPaths(original_working_dir_,
|
||||
FilePath("test_detail.xml")).c_str(),
|
||||
UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
|
||||
}
|
||||
|
||||
TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithDefaultXML) {
|
||||
GTEST_FLAG(output) = "xml";
|
||||
EXPECT_STREQ(FilePath::ConcatPaths(original_working_dir_,
|
||||
FilePath("test_detail.xml")).c_str(),
|
||||
UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
|
||||
}
|
||||
|
||||
TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativeFile) {
|
||||
GTEST_FLAG(output) = "xml:filename.abc";
|
||||
EXPECT_STREQ(FilePath::ConcatPaths(original_working_dir_,
|
||||
FilePath("filename.abc")).c_str(),
|
||||
UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
|
||||
}
|
||||
|
||||
TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativePath) {
|
||||
GTEST_FLAG(output) = "xml:path" GTEST_PATH_SEP_;
|
||||
const std::string expected_output_file =
|
||||
FilePath::ConcatPaths(
|
||||
original_working_dir_,
|
||||
FilePath(std::string("path") + GTEST_PATH_SEP_ +
|
||||
GetCurrentExecutableName().c_str() + ".xml")).c_str();
|
||||
const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile();
|
||||
#if GTEST_OS_WINDOWS
|
||||
EXPECT_STRCASEEQ(expected_output_file.c_str(), output_file.c_str());
|
||||
#else
|
||||
EXPECT_EQ(expected_output_file, output_file.c_str());
|
||||
#endif
|
||||
}
|
||||
|
||||
TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsoluteFile) {
|
||||
#if GTEST_OS_WINDOWS
|
||||
GTEST_FLAG(output) = "xml:c:\\tmp\\filename.abc";
|
||||
EXPECT_STREQ(FilePath("c:\\tmp\\filename.abc").c_str(),
|
||||
UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
|
||||
#else
|
||||
GTEST_FLAG(output) ="xml:/tmp/filename.abc";
|
||||
EXPECT_STREQ(FilePath("/tmp/filename.abc").c_str(),
|
||||
UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
|
||||
#endif
|
||||
}
|
||||
|
||||
TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsolutePath) {
|
||||
#if GTEST_OS_WINDOWS
|
||||
const std::string path = "c:\\tmp\\";
|
||||
#else
|
||||
const std::string path = "/tmp/";
|
||||
#endif
|
||||
|
||||
GTEST_FLAG(output) = "xml:" + path;
|
||||
const std::string expected_output_file =
|
||||
path + GetCurrentExecutableName().c_str() + ".xml";
|
||||
const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile();
|
||||
|
||||
#if GTEST_OS_WINDOWS
|
||||
EXPECT_STRCASEEQ(expected_output_file.c_str(), output_file.c_str());
|
||||
#else
|
||||
EXPECT_EQ(expected_output_file, output_file.c_str());
|
||||
#endif
|
||||
}
|
||||
|
||||
} // namespace
|
||||
} // namespace internal
|
||||
} // namespace testing
|
65
gtest/test/gtest-param-test2_test.cc
Normal file
65
gtest/test/gtest-param-test2_test.cc
Normal file
@ -0,0 +1,65 @@
|
||||
// Copyright 2008, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: vladl@google.com (Vlad Losev)
|
||||
//
|
||||
// Tests for Google Test itself. This verifies that the basic constructs of
|
||||
// Google Test work.
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#include "test/gtest-param-test_test.h"
|
||||
|
||||
#if GTEST_HAS_PARAM_TEST
|
||||
|
||||
using ::testing::Values;
|
||||
using ::testing::internal::ParamGenerator;
|
||||
|
||||
// Tests that generators defined in a different translation unit
|
||||
// are functional. The test using extern_gen is defined
|
||||
// in gtest-param-test_test.cc.
|
||||
ParamGenerator<int> extern_gen = Values(33);
|
||||
|
||||
// Tests that a parameterized test case can be defined in one translation unit
|
||||
// and instantiated in another. The test is defined in gtest-param-test_test.cc
|
||||
// and ExternalInstantiationTest fixture class is defined in
|
||||
// gtest-param-test_test.h.
|
||||
INSTANTIATE_TEST_CASE_P(MultiplesOf33,
|
||||
ExternalInstantiationTest,
|
||||
Values(33, 66));
|
||||
|
||||
// Tests that a parameterized test case can be instantiated
|
||||
// in multiple translation units. Another instantiation is defined
|
||||
// in gtest-param-test_test.cc and InstantiationInMultipleTranslaionUnitsTest
|
||||
// fixture is defined in gtest-param-test_test.h
|
||||
INSTANTIATE_TEST_CASE_P(Sequence2,
|
||||
InstantiationInMultipleTranslaionUnitsTest,
|
||||
Values(42*3, 42*4, 42*5));
|
||||
|
||||
#endif // GTEST_HAS_PARAM_TEST
|
895
gtest/test/gtest-param-test_test.cc
Normal file
895
gtest/test/gtest-param-test_test.cc
Normal file
@ -0,0 +1,895 @@
|
||||
// Copyright 2008, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: vladl@google.com (Vlad Losev)
|
||||
//
|
||||
// Tests for Google Test itself. This file verifies that the parameter
|
||||
// generators objects produce correct parameter sequences and that
|
||||
// Google Test runtime instantiates correct tests from those sequences.
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#if GTEST_HAS_PARAM_TEST
|
||||
|
||||
# include <algorithm>
|
||||
# include <iostream>
|
||||
# include <list>
|
||||
# include <sstream>
|
||||
# include <string>
|
||||
# include <vector>
|
||||
|
||||
// To include gtest-internal-inl.h.
|
||||
# define GTEST_IMPLEMENTATION_ 1
|
||||
# include "src/gtest-internal-inl.h" // for UnitTestOptions
|
||||
# undef GTEST_IMPLEMENTATION_
|
||||
|
||||
# include "test/gtest-param-test_test.h"
|
||||
|
||||
using ::std::vector;
|
||||
using ::std::sort;
|
||||
|
||||
using ::testing::AddGlobalTestEnvironment;
|
||||
using ::testing::Bool;
|
||||
using ::testing::Message;
|
||||
using ::testing::Range;
|
||||
using ::testing::TestWithParam;
|
||||
using ::testing::Values;
|
||||
using ::testing::ValuesIn;
|
||||
|
||||
# if GTEST_HAS_COMBINE
|
||||
using ::testing::Combine;
|
||||
using ::std::tr1::get;
|
||||
using ::std::tr1::make_tuple;
|
||||
using ::std::tr1::tuple;
|
||||
# endif // GTEST_HAS_COMBINE
|
||||
|
||||
using ::testing::internal::ParamGenerator;
|
||||
using ::testing::internal::UnitTestOptions;
|
||||
|
||||
// Prints a value to a string.
|
||||
//
|
||||
// TODO(wan@google.com): remove PrintValue() when we move matchers and
|
||||
// EXPECT_THAT() from Google Mock to Google Test. At that time, we
|
||||
// can write EXPECT_THAT(x, Eq(y)) to compare two tuples x and y, as
|
||||
// EXPECT_THAT() and the matchers know how to print tuples.
|
||||
template <typename T>
|
||||
::std::string PrintValue(const T& value) {
|
||||
::std::stringstream stream;
|
||||
stream << value;
|
||||
return stream.str();
|
||||
}
|
||||
|
||||
# if GTEST_HAS_COMBINE
|
||||
|
||||
// These overloads allow printing tuples in our tests. We cannot
|
||||
// define an operator<< for tuples, as that definition needs to be in
|
||||
// the std namespace in order to be picked up by Google Test via
|
||||
// Argument-Dependent Lookup, yet defining anything in the std
|
||||
// namespace in non-STL code is undefined behavior.
|
||||
|
||||
template <typename T1, typename T2>
|
||||
::std::string PrintValue(const tuple<T1, T2>& value) {
|
||||
::std::stringstream stream;
|
||||
stream << "(" << get<0>(value) << ", " << get<1>(value) << ")";
|
||||
return stream.str();
|
||||
}
|
||||
|
||||
template <typename T1, typename T2, typename T3>
|
||||
::std::string PrintValue(const tuple<T1, T2, T3>& value) {
|
||||
::std::stringstream stream;
|
||||
stream << "(" << get<0>(value) << ", " << get<1>(value)
|
||||
<< ", "<< get<2>(value) << ")";
|
||||
return stream.str();
|
||||
}
|
||||
|
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5,
|
||||
typename T6, typename T7, typename T8, typename T9, typename T10>
|
||||
::std::string PrintValue(
|
||||
const tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& value) {
|
||||
::std::stringstream stream;
|
||||
stream << "(" << get<0>(value) << ", " << get<1>(value)
|
||||
<< ", "<< get<2>(value) << ", " << get<3>(value)
|
||||
<< ", "<< get<4>(value) << ", " << get<5>(value)
|
||||
<< ", "<< get<6>(value) << ", " << get<7>(value)
|
||||
<< ", "<< get<8>(value) << ", " << get<9>(value) << ")";
|
||||
return stream.str();
|
||||
}
|
||||
|
||||
# endif // GTEST_HAS_COMBINE
|
||||
|
||||
// Verifies that a sequence generated by the generator and accessed
|
||||
// via the iterator object matches the expected one using Google Test
|
||||
// assertions.
|
||||
template <typename T, size_t N>
|
||||
void VerifyGenerator(const ParamGenerator<T>& generator,
|
||||
const T (&expected_values)[N]) {
|
||||
typename ParamGenerator<T>::iterator it = generator.begin();
|
||||
for (size_t i = 0; i < N; ++i) {
|
||||
ASSERT_FALSE(it == generator.end())
|
||||
<< "At element " << i << " when accessing via an iterator "
|
||||
<< "created with the copy constructor.\n";
|
||||
// We cannot use EXPECT_EQ() here as the values may be tuples,
|
||||
// which don't support <<.
|
||||
EXPECT_TRUE(expected_values[i] == *it)
|
||||
<< "where i is " << i
|
||||
<< ", expected_values[i] is " << PrintValue(expected_values[i])
|
||||
<< ", *it is " << PrintValue(*it)
|
||||
<< ", and 'it' is an iterator created with the copy constructor.\n";
|
||||
it++;
|
||||
}
|
||||
EXPECT_TRUE(it == generator.end())
|
||||
<< "At the presumed end of sequence when accessing via an iterator "
|
||||
<< "created with the copy constructor.\n";
|
||||
|
||||
// Test the iterator assignment. The following lines verify that
|
||||
// the sequence accessed via an iterator initialized via the
|
||||
// assignment operator (as opposed to a copy constructor) matches
|
||||
// just the same.
|
||||
it = generator.begin();
|
||||
for (size_t i = 0; i < N; ++i) {
|
||||
ASSERT_FALSE(it == generator.end())
|
||||
<< "At element " << i << " when accessing via an iterator "
|
||||
<< "created with the assignment operator.\n";
|
||||
EXPECT_TRUE(expected_values[i] == *it)
|
||||
<< "where i is " << i
|
||||
<< ", expected_values[i] is " << PrintValue(expected_values[i])
|
||||
<< ", *it is " << PrintValue(*it)
|
||||
<< ", and 'it' is an iterator created with the copy constructor.\n";
|
||||
it++;
|
||||
}
|
||||
EXPECT_TRUE(it == generator.end())
|
||||
<< "At the presumed end of sequence when accessing via an iterator "
|
||||
<< "created with the assignment operator.\n";
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void VerifyGeneratorIsEmpty(const ParamGenerator<T>& generator) {
|
||||
typename ParamGenerator<T>::iterator it = generator.begin();
|
||||
EXPECT_TRUE(it == generator.end());
|
||||
|
||||
it = generator.begin();
|
||||
EXPECT_TRUE(it == generator.end());
|
||||
}
|
||||
|
||||
// Generator tests. They test that each of the provided generator functions
|
||||
// generates an expected sequence of values. The general test pattern
|
||||
// instantiates a generator using one of the generator functions,
|
||||
// checks the sequence produced by the generator using its iterator API,
|
||||
// and then resets the iterator back to the beginning of the sequence
|
||||
// and checks the sequence again.
|
||||
|
||||
// Tests that iterators produced by generator functions conform to the
|
||||
// ForwardIterator concept.
|
||||
TEST(IteratorTest, ParamIteratorConformsToForwardIteratorConcept) {
|
||||
const ParamGenerator<int> gen = Range(0, 10);
|
||||
ParamGenerator<int>::iterator it = gen.begin();
|
||||
|
||||
// Verifies that iterator initialization works as expected.
|
||||
ParamGenerator<int>::iterator it2 = it;
|
||||
EXPECT_TRUE(*it == *it2) << "Initialized iterators must point to the "
|
||||
<< "element same as its source points to";
|
||||
|
||||
// Verifies that iterator assignment works as expected.
|
||||
it++;
|
||||
EXPECT_FALSE(*it == *it2);
|
||||
it2 = it;
|
||||
EXPECT_TRUE(*it == *it2) << "Assigned iterators must point to the "
|
||||
<< "element same as its source points to";
|
||||
|
||||
// Verifies that prefix operator++() returns *this.
|
||||
EXPECT_EQ(&it, &(++it)) << "Result of the prefix operator++ must be "
|
||||
<< "refer to the original object";
|
||||
|
||||
// Verifies that the result of the postfix operator++ points to the value
|
||||
// pointed to by the original iterator.
|
||||
int original_value = *it; // Have to compute it outside of macro call to be
|
||||
// unaffected by the parameter evaluation order.
|
||||
EXPECT_EQ(original_value, *(it++));
|
||||
|
||||
// Verifies that prefix and postfix operator++() advance an iterator
|
||||
// all the same.
|
||||
it2 = it;
|
||||
it++;
|
||||
++it2;
|
||||
EXPECT_TRUE(*it == *it2);
|
||||
}
|
||||
|
||||
// Tests that Range() generates the expected sequence.
|
||||
TEST(RangeTest, IntRangeWithDefaultStep) {
|
||||
const ParamGenerator<int> gen = Range(0, 3);
|
||||
const int expected_values[] = {0, 1, 2};
|
||||
VerifyGenerator(gen, expected_values);
|
||||
}
|
||||
|
||||
// Edge case. Tests that Range() generates the single element sequence
|
||||
// as expected when provided with range limits that are equal.
|
||||
TEST(RangeTest, IntRangeSingleValue) {
|
||||
const ParamGenerator<int> gen = Range(0, 1);
|
||||
const int expected_values[] = {0};
|
||||
VerifyGenerator(gen, expected_values);
|
||||
}
|
||||
|
||||
// Edge case. Tests that Range() with generates empty sequence when
|
||||
// supplied with an empty range.
|
||||
TEST(RangeTest, IntRangeEmpty) {
|
||||
const ParamGenerator<int> gen = Range(0, 0);
|
||||
VerifyGeneratorIsEmpty(gen);
|
||||
}
|
||||
|
||||
// Tests that Range() with custom step (greater then one) generates
|
||||
// the expected sequence.
|
||||
TEST(RangeTest, IntRangeWithCustomStep) {
|
||||
const ParamGenerator<int> gen = Range(0, 9, 3);
|
||||
const int expected_values[] = {0, 3, 6};
|
||||
VerifyGenerator(gen, expected_values);
|
||||
}
|
||||
|
||||
// Tests that Range() with custom step (greater then one) generates
|
||||
// the expected sequence when the last element does not fall on the
|
||||
// upper range limit. Sequences generated by Range() must not have
|
||||
// elements beyond the range limits.
|
||||
TEST(RangeTest, IntRangeWithCustomStepOverUpperBound) {
|
||||
const ParamGenerator<int> gen = Range(0, 4, 3);
|
||||
const int expected_values[] = {0, 3};
|
||||
VerifyGenerator(gen, expected_values);
|
||||
}
|
||||
|
||||
// Verifies that Range works with user-defined types that define
|
||||
// copy constructor, operator=(), operator+(), and operator<().
|
||||
class DogAdder {
|
||||
public:
|
||||
explicit DogAdder(const char* a_value) : value_(a_value) {}
|
||||
DogAdder(const DogAdder& other) : value_(other.value_.c_str()) {}
|
||||
|
||||
DogAdder operator=(const DogAdder& other) {
|
||||
if (this != &other)
|
||||
value_ = other.value_;
|
||||
return *this;
|
||||
}
|
||||
DogAdder operator+(const DogAdder& other) const {
|
||||
Message msg;
|
||||
msg << value_.c_str() << other.value_.c_str();
|
||||
return DogAdder(msg.GetString().c_str());
|
||||
}
|
||||
bool operator<(const DogAdder& other) const {
|
||||
return value_ < other.value_;
|
||||
}
|
||||
const ::testing::internal::String& value() const { return value_; }
|
||||
|
||||
private:
|
||||
::testing::internal::String value_;
|
||||
};
|
||||
|
||||
TEST(RangeTest, WorksWithACustomType) {
|
||||
const ParamGenerator<DogAdder> gen =
|
||||
Range(DogAdder("cat"), DogAdder("catdogdog"), DogAdder("dog"));
|
||||
ParamGenerator<DogAdder>::iterator it = gen.begin();
|
||||
|
||||
ASSERT_FALSE(it == gen.end());
|
||||
EXPECT_STREQ("cat", it->value().c_str());
|
||||
|
||||
ASSERT_FALSE(++it == gen.end());
|
||||
EXPECT_STREQ("catdog", it->value().c_str());
|
||||
|
||||
EXPECT_TRUE(++it == gen.end());
|
||||
}
|
||||
|
||||
class IntWrapper {
|
||||
public:
|
||||
explicit IntWrapper(int a_value) : value_(a_value) {}
|
||||
IntWrapper(const IntWrapper& other) : value_(other.value_) {}
|
||||
|
||||
IntWrapper operator=(const IntWrapper& other) {
|
||||
value_ = other.value_;
|
||||
return *this;
|
||||
}
|
||||
// operator+() adds a different type.
|
||||
IntWrapper operator+(int other) const { return IntWrapper(value_ + other); }
|
||||
bool operator<(const IntWrapper& other) const {
|
||||
return value_ < other.value_;
|
||||
}
|
||||
int value() const { return value_; }
|
||||
|
||||
private:
|
||||
int value_;
|
||||
};
|
||||
|
||||
TEST(RangeTest, WorksWithACustomTypeWithDifferentIncrementType) {
|
||||
const ParamGenerator<IntWrapper> gen = Range(IntWrapper(0), IntWrapper(2));
|
||||
ParamGenerator<IntWrapper>::iterator it = gen.begin();
|
||||
|
||||
ASSERT_FALSE(it == gen.end());
|
||||
EXPECT_EQ(0, it->value());
|
||||
|
||||
ASSERT_FALSE(++it == gen.end());
|
||||
EXPECT_EQ(1, it->value());
|
||||
|
||||
EXPECT_TRUE(++it == gen.end());
|
||||
}
|
||||
|
||||
// Tests that ValuesIn() with an array parameter generates
|
||||
// the expected sequence.
|
||||
TEST(ValuesInTest, ValuesInArray) {
|
||||
int array[] = {3, 5, 8};
|
||||
const ParamGenerator<int> gen = ValuesIn(array);
|
||||
VerifyGenerator(gen, array);
|
||||
}
|
||||
|
||||
// Tests that ValuesIn() with a const array parameter generates
|
||||
// the expected sequence.
|
||||
TEST(ValuesInTest, ValuesInConstArray) {
|
||||
const int array[] = {3, 5, 8};
|
||||
const ParamGenerator<int> gen = ValuesIn(array);
|
||||
VerifyGenerator(gen, array);
|
||||
}
|
||||
|
||||
// Edge case. Tests that ValuesIn() with an array parameter containing a
|
||||
// single element generates the single element sequence.
|
||||
TEST(ValuesInTest, ValuesInSingleElementArray) {
|
||||
int array[] = {42};
|
||||
const ParamGenerator<int> gen = ValuesIn(array);
|
||||
VerifyGenerator(gen, array);
|
||||
}
|
||||
|
||||
// Tests that ValuesIn() generates the expected sequence for an STL
|
||||
// container (vector).
|
||||
TEST(ValuesInTest, ValuesInVector) {
|
||||
typedef ::std::vector<int> ContainerType;
|
||||
ContainerType values;
|
||||
values.push_back(3);
|
||||
values.push_back(5);
|
||||
values.push_back(8);
|
||||
const ParamGenerator<int> gen = ValuesIn(values);
|
||||
|
||||
const int expected_values[] = {3, 5, 8};
|
||||
VerifyGenerator(gen, expected_values);
|
||||
}
|
||||
|
||||
// Tests that ValuesIn() generates the expected sequence.
|
||||
TEST(ValuesInTest, ValuesInIteratorRange) {
|
||||
typedef ::std::vector<int> ContainerType;
|
||||
ContainerType values;
|
||||
values.push_back(3);
|
||||
values.push_back(5);
|
||||
values.push_back(8);
|
||||
const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());
|
||||
|
||||
const int expected_values[] = {3, 5, 8};
|
||||
VerifyGenerator(gen, expected_values);
|
||||
}
|
||||
|
||||
// Edge case. Tests that ValuesIn() provided with an iterator range specifying a
|
||||
// single value generates a single-element sequence.
|
||||
TEST(ValuesInTest, ValuesInSingleElementIteratorRange) {
|
||||
typedef ::std::vector<int> ContainerType;
|
||||
ContainerType values;
|
||||
values.push_back(42);
|
||||
const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());
|
||||
|
||||
const int expected_values[] = {42};
|
||||
VerifyGenerator(gen, expected_values);
|
||||
}
|
||||
|
||||
// Edge case. Tests that ValuesIn() provided with an empty iterator range
|
||||
// generates an empty sequence.
|
||||
TEST(ValuesInTest, ValuesInEmptyIteratorRange) {
|
||||
typedef ::std::vector<int> ContainerType;
|
||||
ContainerType values;
|
||||
const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());
|
||||
|
||||
VerifyGeneratorIsEmpty(gen);
|
||||
}
|
||||
|
||||
// Tests that the Values() generates the expected sequence.
|
||||
TEST(ValuesTest, ValuesWorks) {
|
||||
const ParamGenerator<int> gen = Values(3, 5, 8);
|
||||
|
||||
const int expected_values[] = {3, 5, 8};
|
||||
VerifyGenerator(gen, expected_values);
|
||||
}
|
||||
|
||||
// Tests that Values() generates the expected sequences from elements of
|
||||
// different types convertible to ParamGenerator's parameter type.
|
||||
TEST(ValuesTest, ValuesWorksForValuesOfCompatibleTypes) {
|
||||
const ParamGenerator<double> gen = Values(3, 5.0f, 8.0);
|
||||
|
||||
const double expected_values[] = {3.0, 5.0, 8.0};
|
||||
VerifyGenerator(gen, expected_values);
|
||||
}
|
||||
|
||||
TEST(ValuesTest, ValuesWorksForMaxLengthList) {
|
||||
const ParamGenerator<int> gen = Values(
|
||||
10, 20, 30, 40, 50, 60, 70, 80, 90, 100,
|
||||
110, 120, 130, 140, 150, 160, 170, 180, 190, 200,
|
||||
210, 220, 230, 240, 250, 260, 270, 280, 290, 300,
|
||||
310, 320, 330, 340, 350, 360, 370, 380, 390, 400,
|
||||
410, 420, 430, 440, 450, 460, 470, 480, 490, 500);
|
||||
|
||||
const int expected_values[] = {
|
||||
10, 20, 30, 40, 50, 60, 70, 80, 90, 100,
|
||||
110, 120, 130, 140, 150, 160, 170, 180, 190, 200,
|
||||
210, 220, 230, 240, 250, 260, 270, 280, 290, 300,
|
||||
310, 320, 330, 340, 350, 360, 370, 380, 390, 400,
|
||||
410, 420, 430, 440, 450, 460, 470, 480, 490, 500};
|
||||
VerifyGenerator(gen, expected_values);
|
||||
}
|
||||
|
||||
// Edge case test. Tests that single-parameter Values() generates the sequence
|
||||
// with the single value.
|
||||
TEST(ValuesTest, ValuesWithSingleParameter) {
|
||||
const ParamGenerator<int> gen = Values(42);
|
||||
|
||||
const int expected_values[] = {42};
|
||||
VerifyGenerator(gen, expected_values);
|
||||
}
|
||||
|
||||
// Tests that Bool() generates sequence (false, true).
|
||||
TEST(BoolTest, BoolWorks) {
|
||||
const ParamGenerator<bool> gen = Bool();
|
||||
|
||||
const bool expected_values[] = {false, true};
|
||||
VerifyGenerator(gen, expected_values);
|
||||
}
|
||||
|
||||
# if GTEST_HAS_COMBINE
|
||||
|
||||
// Tests that Combine() with two parameters generates the expected sequence.
|
||||
TEST(CombineTest, CombineWithTwoParameters) {
|
||||
const char* foo = "foo";
|
||||
const char* bar = "bar";
|
||||
const ParamGenerator<tuple<const char*, int> > gen =
|
||||
Combine(Values(foo, bar), Values(3, 4));
|
||||
|
||||
tuple<const char*, int> expected_values[] = {
|
||||
make_tuple(foo, 3), make_tuple(foo, 4),
|
||||
make_tuple(bar, 3), make_tuple(bar, 4)};
|
||||
VerifyGenerator(gen, expected_values);
|
||||
}
|
||||
|
||||
// Tests that Combine() with three parameters generates the expected sequence.
|
||||
TEST(CombineTest, CombineWithThreeParameters) {
|
||||
const ParamGenerator<tuple<int, int, int> > gen = Combine(Values(0, 1),
|
||||
Values(3, 4),
|
||||
Values(5, 6));
|
||||
tuple<int, int, int> expected_values[] = {
|
||||
make_tuple(0, 3, 5), make_tuple(0, 3, 6),
|
||||
make_tuple(0, 4, 5), make_tuple(0, 4, 6),
|
||||
make_tuple(1, 3, 5), make_tuple(1, 3, 6),
|
||||
make_tuple(1, 4, 5), make_tuple(1, 4, 6)};
|
||||
VerifyGenerator(gen, expected_values);
|
||||
}
|
||||
|
||||
// Tests that the Combine() with the first parameter generating a single value
|
||||
// sequence generates a sequence with the number of elements equal to the
|
||||
// number of elements in the sequence generated by the second parameter.
|
||||
TEST(CombineTest, CombineWithFirstParameterSingleValue) {
|
||||
const ParamGenerator<tuple<int, int> > gen = Combine(Values(42),
|
||||
Values(0, 1));
|
||||
|
||||
tuple<int, int> expected_values[] = {make_tuple(42, 0), make_tuple(42, 1)};
|
||||
VerifyGenerator(gen, expected_values);
|
||||
}
|
||||
|
||||
// Tests that the Combine() with the second parameter generating a single value
|
||||
// sequence generates a sequence with the number of elements equal to the
|
||||
// number of elements in the sequence generated by the first parameter.
|
||||
TEST(CombineTest, CombineWithSecondParameterSingleValue) {
|
||||
const ParamGenerator<tuple<int, int> > gen = Combine(Values(0, 1),
|
||||
Values(42));
|
||||
|
||||
tuple<int, int> expected_values[] = {make_tuple(0, 42), make_tuple(1, 42)};
|
||||
VerifyGenerator(gen, expected_values);
|
||||
}
|
||||
|
||||
// Tests that when the first parameter produces an empty sequence,
|
||||
// Combine() produces an empty sequence, too.
|
||||
TEST(CombineTest, CombineWithFirstParameterEmptyRange) {
|
||||
const ParamGenerator<tuple<int, int> > gen = Combine(Range(0, 0),
|
||||
Values(0, 1));
|
||||
VerifyGeneratorIsEmpty(gen);
|
||||
}
|
||||
|
||||
// Tests that when the second parameter produces an empty sequence,
|
||||
// Combine() produces an empty sequence, too.
|
||||
TEST(CombineTest, CombineWithSecondParameterEmptyRange) {
|
||||
const ParamGenerator<tuple<int, int> > gen = Combine(Values(0, 1),
|
||||
Range(1, 1));
|
||||
VerifyGeneratorIsEmpty(gen);
|
||||
}
|
||||
|
||||
// Edge case. Tests that combine works with the maximum number
|
||||
// of parameters supported by Google Test (currently 10).
|
||||
TEST(CombineTest, CombineWithMaxNumberOfParameters) {
|
||||
const char* foo = "foo";
|
||||
const char* bar = "bar";
|
||||
const ParamGenerator<tuple<const char*, int, int, int, int, int, int, int,
|
||||
int, int> > gen = Combine(Values(foo, bar),
|
||||
Values(1), Values(2),
|
||||
Values(3), Values(4),
|
||||
Values(5), Values(6),
|
||||
Values(7), Values(8),
|
||||
Values(9));
|
||||
|
||||
tuple<const char*, int, int, int, int, int, int, int, int, int>
|
||||
expected_values[] = {make_tuple(foo, 1, 2, 3, 4, 5, 6, 7, 8, 9),
|
||||
make_tuple(bar, 1, 2, 3, 4, 5, 6, 7, 8, 9)};
|
||||
VerifyGenerator(gen, expected_values);
|
||||
}
|
||||
|
||||
# endif // GTEST_HAS_COMBINE
|
||||
|
||||
// Tests that an generator produces correct sequence after being
|
||||
// assigned from another generator.
|
||||
TEST(ParamGeneratorTest, AssignmentWorks) {
|
||||
ParamGenerator<int> gen = Values(1, 2);
|
||||
const ParamGenerator<int> gen2 = Values(3, 4);
|
||||
gen = gen2;
|
||||
|
||||
const int expected_values[] = {3, 4};
|
||||
VerifyGenerator(gen, expected_values);
|
||||
}
|
||||
|
||||
// This test verifies that the tests are expanded and run as specified:
|
||||
// one test per element from the sequence produced by the generator
|
||||
// specified in INSTANTIATE_TEST_CASE_P. It also verifies that the test's
|
||||
// fixture constructor, SetUp(), and TearDown() have run and have been
|
||||
// supplied with the correct parameters.
|
||||
|
||||
// The use of environment object allows detection of the case where no test
|
||||
// case functionality is run at all. In this case TestCaseTearDown will not
|
||||
// be able to detect missing tests, naturally.
|
||||
template <int kExpectedCalls>
|
||||
class TestGenerationEnvironment : public ::testing::Environment {
|
||||
public:
|
||||
static TestGenerationEnvironment* Instance() {
|
||||
static TestGenerationEnvironment* instance = new TestGenerationEnvironment;
|
||||
return instance;
|
||||
}
|
||||
|
||||
void FixtureConstructorExecuted() { fixture_constructor_count_++; }
|
||||
void SetUpExecuted() { set_up_count_++; }
|
||||
void TearDownExecuted() { tear_down_count_++; }
|
||||
void TestBodyExecuted() { test_body_count_++; }
|
||||
|
||||
virtual void TearDown() {
|
||||
// If all MultipleTestGenerationTest tests have been de-selected
|
||||
// by the filter flag, the following checks make no sense.
|
||||
bool perform_check = false;
|
||||
|
||||
for (int i = 0; i < kExpectedCalls; ++i) {
|
||||
Message msg;
|
||||
msg << "TestsExpandedAndRun/" << i;
|
||||
if (UnitTestOptions::FilterMatchesTest(
|
||||
"TestExpansionModule/MultipleTestGenerationTest",
|
||||
msg.GetString().c_str())) {
|
||||
perform_check = true;
|
||||
}
|
||||
}
|
||||
if (perform_check) {
|
||||
EXPECT_EQ(kExpectedCalls, fixture_constructor_count_)
|
||||
<< "Fixture constructor of ParamTestGenerationTest test case "
|
||||
<< "has not been run as expected.";
|
||||
EXPECT_EQ(kExpectedCalls, set_up_count_)
|
||||
<< "Fixture SetUp method of ParamTestGenerationTest test case "
|
||||
<< "has not been run as expected.";
|
||||
EXPECT_EQ(kExpectedCalls, tear_down_count_)
|
||||
<< "Fixture TearDown method of ParamTestGenerationTest test case "
|
||||
<< "has not been run as expected.";
|
||||
EXPECT_EQ(kExpectedCalls, test_body_count_)
|
||||
<< "Test in ParamTestGenerationTest test case "
|
||||
<< "has not been run as expected.";
|
||||
}
|
||||
}
|
||||
private:
|
||||
TestGenerationEnvironment() : fixture_constructor_count_(0), set_up_count_(0),
|
||||
tear_down_count_(0), test_body_count_(0) {}
|
||||
|
||||
int fixture_constructor_count_;
|
||||
int set_up_count_;
|
||||
int tear_down_count_;
|
||||
int test_body_count_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationEnvironment);
|
||||
};
|
||||
|
||||
const int test_generation_params[] = {36, 42, 72};
|
||||
|
||||
class TestGenerationTest : public TestWithParam<int> {
|
||||
public:
|
||||
enum {
|
||||
PARAMETER_COUNT =
|
||||
sizeof(test_generation_params)/sizeof(test_generation_params[0])
|
||||
};
|
||||
|
||||
typedef TestGenerationEnvironment<PARAMETER_COUNT> Environment;
|
||||
|
||||
TestGenerationTest() {
|
||||
Environment::Instance()->FixtureConstructorExecuted();
|
||||
current_parameter_ = GetParam();
|
||||
}
|
||||
virtual void SetUp() {
|
||||
Environment::Instance()->SetUpExecuted();
|
||||
EXPECT_EQ(current_parameter_, GetParam());
|
||||
}
|
||||
virtual void TearDown() {
|
||||
Environment::Instance()->TearDownExecuted();
|
||||
EXPECT_EQ(current_parameter_, GetParam());
|
||||
}
|
||||
|
||||
static void SetUpTestCase() {
|
||||
bool all_tests_in_test_case_selected = true;
|
||||
|
||||
for (int i = 0; i < PARAMETER_COUNT; ++i) {
|
||||
Message test_name;
|
||||
test_name << "TestsExpandedAndRun/" << i;
|
||||
if ( !UnitTestOptions::FilterMatchesTest(
|
||||
"TestExpansionModule/MultipleTestGenerationTest",
|
||||
test_name.GetString())) {
|
||||
all_tests_in_test_case_selected = false;
|
||||
}
|
||||
}
|
||||
EXPECT_TRUE(all_tests_in_test_case_selected)
|
||||
<< "When running the TestGenerationTest test case all of its tests\n"
|
||||
<< "must be selected by the filter flag for the test case to pass.\n"
|
||||
<< "If not all of them are enabled, we can't reliably conclude\n"
|
||||
<< "that the correct number of tests have been generated.";
|
||||
|
||||
collected_parameters_.clear();
|
||||
}
|
||||
|
||||
static void TearDownTestCase() {
|
||||
vector<int> expected_values(test_generation_params,
|
||||
test_generation_params + PARAMETER_COUNT);
|
||||
// Test execution order is not guaranteed by Google Test,
|
||||
// so the order of values in collected_parameters_ can be
|
||||
// different and we have to sort to compare.
|
||||
sort(expected_values.begin(), expected_values.end());
|
||||
sort(collected_parameters_.begin(), collected_parameters_.end());
|
||||
|
||||
EXPECT_TRUE(collected_parameters_ == expected_values);
|
||||
}
|
||||
protected:
|
||||
int current_parameter_;
|
||||
static vector<int> collected_parameters_;
|
||||
|
||||
private:
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationTest);
|
||||
};
|
||||
vector<int> TestGenerationTest::collected_parameters_;
|
||||
|
||||
TEST_P(TestGenerationTest, TestsExpandedAndRun) {
|
||||
Environment::Instance()->TestBodyExecuted();
|
||||
EXPECT_EQ(current_parameter_, GetParam());
|
||||
collected_parameters_.push_back(GetParam());
|
||||
}
|
||||
INSTANTIATE_TEST_CASE_P(TestExpansionModule, TestGenerationTest,
|
||||
ValuesIn(test_generation_params));
|
||||
|
||||
// This test verifies that the element sequence (third parameter of
|
||||
// INSTANTIATE_TEST_CASE_P) is evaluated in InitGoogleTest() and neither at
|
||||
// the call site of INSTANTIATE_TEST_CASE_P nor in RUN_ALL_TESTS(). For
|
||||
// that, we declare param_value_ to be a static member of
|
||||
// GeneratorEvaluationTest and initialize it to 0. We set it to 1 in
|
||||
// main(), just before invocation of InitGoogleTest(). After calling
|
||||
// InitGoogleTest(), we set the value to 2. If the sequence is evaluated
|
||||
// before or after InitGoogleTest, INSTANTIATE_TEST_CASE_P will create a
|
||||
// test with parameter other than 1, and the test body will fail the
|
||||
// assertion.
|
||||
class GeneratorEvaluationTest : public TestWithParam<int> {
|
||||
public:
|
||||
static int param_value() { return param_value_; }
|
||||
static void set_param_value(int param_value) { param_value_ = param_value; }
|
||||
|
||||
private:
|
||||
static int param_value_;
|
||||
};
|
||||
int GeneratorEvaluationTest::param_value_ = 0;
|
||||
|
||||
TEST_P(GeneratorEvaluationTest, GeneratorsEvaluatedInMain) {
|
||||
EXPECT_EQ(1, GetParam());
|
||||
}
|
||||
INSTANTIATE_TEST_CASE_P(GenEvalModule,
|
||||
GeneratorEvaluationTest,
|
||||
Values(GeneratorEvaluationTest::param_value()));
|
||||
|
||||
// Tests that generators defined in a different translation unit are
|
||||
// functional. Generator extern_gen is defined in gtest-param-test_test2.cc.
|
||||
extern ParamGenerator<int> extern_gen;
|
||||
class ExternalGeneratorTest : public TestWithParam<int> {};
|
||||
TEST_P(ExternalGeneratorTest, ExternalGenerator) {
|
||||
// Sequence produced by extern_gen contains only a single value
|
||||
// which we verify here.
|
||||
EXPECT_EQ(GetParam(), 33);
|
||||
}
|
||||
INSTANTIATE_TEST_CASE_P(ExternalGeneratorModule,
|
||||
ExternalGeneratorTest,
|
||||
extern_gen);
|
||||
|
||||
// Tests that a parameterized test case can be defined in one translation
|
||||
// unit and instantiated in another. This test will be instantiated in
|
||||
// gtest-param-test_test2.cc. ExternalInstantiationTest fixture class is
|
||||
// defined in gtest-param-test_test.h.
|
||||
TEST_P(ExternalInstantiationTest, IsMultipleOf33) {
|
||||
EXPECT_EQ(0, GetParam() % 33);
|
||||
}
|
||||
|
||||
// Tests that a parameterized test case can be instantiated with multiple
|
||||
// generators.
|
||||
class MultipleInstantiationTest : public TestWithParam<int> {};
|
||||
TEST_P(MultipleInstantiationTest, AllowsMultipleInstances) {
|
||||
}
|
||||
INSTANTIATE_TEST_CASE_P(Sequence1, MultipleInstantiationTest, Values(1, 2));
|
||||
INSTANTIATE_TEST_CASE_P(Sequence2, MultipleInstantiationTest, Range(3, 5));
|
||||
|
||||
// Tests that a parameterized test case can be instantiated
|
||||
// in multiple translation units. This test will be instantiated
|
||||
// here and in gtest-param-test_test2.cc.
|
||||
// InstantiationInMultipleTranslationUnitsTest fixture class
|
||||
// is defined in gtest-param-test_test.h.
|
||||
TEST_P(InstantiationInMultipleTranslaionUnitsTest, IsMultipleOf42) {
|
||||
EXPECT_EQ(0, GetParam() % 42);
|
||||
}
|
||||
INSTANTIATE_TEST_CASE_P(Sequence1,
|
||||
InstantiationInMultipleTranslaionUnitsTest,
|
||||
Values(42, 42*2));
|
||||
|
||||
// Tests that each iteration of parameterized test runs in a separate test
|
||||
// object.
|
||||
class SeparateInstanceTest : public TestWithParam<int> {
|
||||
public:
|
||||
SeparateInstanceTest() : count_(0) {}
|
||||
|
||||
static void TearDownTestCase() {
|
||||
EXPECT_GE(global_count_, 2)
|
||||
<< "If some (but not all) SeparateInstanceTest tests have been "
|
||||
<< "filtered out this test will fail. Make sure that all "
|
||||
<< "GeneratorEvaluationTest are selected or de-selected together "
|
||||
<< "by the test filter.";
|
||||
}
|
||||
|
||||
protected:
|
||||
int count_;
|
||||
static int global_count_;
|
||||
};
|
||||
int SeparateInstanceTest::global_count_ = 0;
|
||||
|
||||
TEST_P(SeparateInstanceTest, TestsRunInSeparateInstances) {
|
||||
EXPECT_EQ(0, count_++);
|
||||
global_count_++;
|
||||
}
|
||||
INSTANTIATE_TEST_CASE_P(FourElemSequence, SeparateInstanceTest, Range(1, 4));
|
||||
|
||||
// Tests that all instantiations of a test have named appropriately. Test
|
||||
// defined with TEST_P(TestCaseName, TestName) and instantiated with
|
||||
// INSTANTIATE_TEST_CASE_P(SequenceName, TestCaseName, generator) must be named
|
||||
// SequenceName/TestCaseName.TestName/i, where i is the 0-based index of the
|
||||
// sequence element used to instantiate the test.
|
||||
class NamingTest : public TestWithParam<int> {};
|
||||
|
||||
TEST_P(NamingTest, TestsReportCorrectNamesAndParameters) {
|
||||
const ::testing::TestInfo* const test_info =
|
||||
::testing::UnitTest::GetInstance()->current_test_info();
|
||||
|
||||
EXPECT_STREQ("ZeroToFiveSequence/NamingTest", test_info->test_case_name());
|
||||
|
||||
Message index_stream;
|
||||
index_stream << "TestsReportCorrectNamesAndParameters/" << GetParam();
|
||||
EXPECT_STREQ(index_stream.GetString().c_str(), test_info->name());
|
||||
|
||||
EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param());
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ZeroToFiveSequence, NamingTest, Range(0, 5));
|
||||
|
||||
// Class that cannot be streamed into an ostream. It needs to be copyable
|
||||
// (and, in case of MSVC, also assignable) in order to be a test parameter
|
||||
// type. Its default copy constructor and assignment operator do exactly
|
||||
// what we need.
|
||||
class Unstreamable {
|
||||
public:
|
||||
explicit Unstreamable(int value) : value_(value) {}
|
||||
|
||||
private:
|
||||
int value_;
|
||||
};
|
||||
|
||||
class CommentTest : public TestWithParam<Unstreamable> {};
|
||||
|
||||
TEST_P(CommentTest, TestsCorrectlyReportUnstreamableParams) {
|
||||
const ::testing::TestInfo* const test_info =
|
||||
::testing::UnitTest::GetInstance()->current_test_info();
|
||||
|
||||
EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param());
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(InstantiationWithComments,
|
||||
CommentTest,
|
||||
Values(Unstreamable(1)));
|
||||
|
||||
// Verify that we can create a hierarchy of test fixtures, where the base
|
||||
// class fixture is not parameterized and the derived class is. In this case
|
||||
// ParameterizedDerivedTest inherits from NonParameterizedBaseTest. We
|
||||
// perform simple tests on both.
|
||||
class NonParameterizedBaseTest : public ::testing::Test {
|
||||
public:
|
||||
NonParameterizedBaseTest() : n_(17) { }
|
||||
protected:
|
||||
int n_;
|
||||
};
|
||||
|
||||
class ParameterizedDerivedTest : public NonParameterizedBaseTest,
|
||||
public ::testing::WithParamInterface<int> {
|
||||
protected:
|
||||
ParameterizedDerivedTest() : count_(0) { }
|
||||
int count_;
|
||||
static int global_count_;
|
||||
};
|
||||
|
||||
int ParameterizedDerivedTest::global_count_ = 0;
|
||||
|
||||
TEST_F(NonParameterizedBaseTest, FixtureIsInitialized) {
|
||||
EXPECT_EQ(17, n_);
|
||||
}
|
||||
|
||||
TEST_P(ParameterizedDerivedTest, SeesSequence) {
|
||||
EXPECT_EQ(17, n_);
|
||||
EXPECT_EQ(0, count_++);
|
||||
EXPECT_EQ(GetParam(), global_count_++);
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(RangeZeroToFive, ParameterizedDerivedTest, Range(0, 5));
|
||||
|
||||
#endif // GTEST_HAS_PARAM_TEST
|
||||
|
||||
TEST(CompileTest, CombineIsDefinedOnlyWhenGtestHasParamTestIsDefined) {
|
||||
#if GTEST_HAS_COMBINE && !GTEST_HAS_PARAM_TEST
|
||||
FAIL() << "GTEST_HAS_COMBINE is defined while GTEST_HAS_PARAM_TEST is not\n"
|
||||
#endif
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
#if GTEST_HAS_PARAM_TEST
|
||||
// Used in TestGenerationTest test case.
|
||||
AddGlobalTestEnvironment(TestGenerationTest::Environment::Instance());
|
||||
// Used in GeneratorEvaluationTest test case. Tests that the updated value
|
||||
// will be picked up for instantiating tests in GeneratorEvaluationTest.
|
||||
GeneratorEvaluationTest::set_param_value(1);
|
||||
#endif // GTEST_HAS_PARAM_TEST
|
||||
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
|
||||
#if GTEST_HAS_PARAM_TEST
|
||||
// Used in GeneratorEvaluationTest test case. Tests that value updated
|
||||
// here will NOT be used for instantiating tests in
|
||||
// GeneratorEvaluationTest.
|
||||
GeneratorEvaluationTest::set_param_value(2);
|
||||
#endif // GTEST_HAS_PARAM_TEST
|
||||
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
55
gtest/test/gtest-param-test_test.h
Normal file
55
gtest/test/gtest-param-test_test.h
Normal file
@ -0,0 +1,55 @@
|
||||
// Copyright 2008, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Authors: vladl@google.com (Vlad Losev)
|
||||
//
|
||||
// The Google C++ Testing Framework (Google Test)
|
||||
//
|
||||
// This header file provides classes and functions used internally
|
||||
// for testing Google Test itself.
|
||||
|
||||
#ifndef GTEST_TEST_GTEST_PARAM_TEST_TEST_H_
|
||||
#define GTEST_TEST_GTEST_PARAM_TEST_TEST_H_
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#if GTEST_HAS_PARAM_TEST
|
||||
|
||||
// Test fixture for testing definition and instantiation of a test
|
||||
// in separate translation units.
|
||||
class ExternalInstantiationTest : public ::testing::TestWithParam<int> {};
|
||||
|
||||
// Test fixture for testing instantiation of a test in multiple
|
||||
// translation units.
|
||||
class InstantiationInMultipleTranslaionUnitsTest
|
||||
: public ::testing::TestWithParam<int> {};
|
||||
|
||||
#endif // GTEST_HAS_PARAM_TEST
|
||||
|
||||
#endif // GTEST_TEST_GTEST_PARAM_TEST_TEST_H_
|
1206
gtest/test/gtest-port_test.cc
Normal file
1206
gtest/test/gtest-port_test.cc
Normal file
File diff suppressed because it is too large
Load Diff
1307
gtest/test/gtest-printers_test.cc
Normal file
1307
gtest/test/gtest-printers_test.cc
Normal file
File diff suppressed because it is too large
Load Diff
208
gtest/test/gtest-test-part_test.cc
Normal file
208
gtest/test/gtest-test-part_test.cc
Normal file
@ -0,0 +1,208 @@
|
||||
// Copyright 2008 Google Inc.
|
||||
// All Rights Reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: mheule@google.com (Markus Heule)
|
||||
//
|
||||
|
||||
#include "gtest/gtest-test-part.h"
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
using testing::Message;
|
||||
using testing::Test;
|
||||
using testing::TestPartResult;
|
||||
using testing::TestPartResultArray;
|
||||
|
||||
namespace {
|
||||
|
||||
// Tests the TestPartResult class.
|
||||
|
||||
// The test fixture for testing TestPartResult.
|
||||
class TestPartResultTest : public Test {
|
||||
protected:
|
||||
TestPartResultTest()
|
||||
: r1_(TestPartResult::kSuccess, "foo/bar.cc", 10, "Success!"),
|
||||
r2_(TestPartResult::kNonFatalFailure, "foo/bar.cc", -1, "Failure!"),
|
||||
r3_(TestPartResult::kFatalFailure, NULL, -1, "Failure!") {}
|
||||
|
||||
TestPartResult r1_, r2_, r3_;
|
||||
};
|
||||
|
||||
|
||||
TEST_F(TestPartResultTest, ConstructorWorks) {
|
||||
Message message;
|
||||
message << "something is terribly wrong";
|
||||
message << static_cast<const char*>(testing::internal::kStackTraceMarker);
|
||||
message << "some unimportant stack trace";
|
||||
|
||||
const TestPartResult result(TestPartResult::kNonFatalFailure,
|
||||
"some_file.cc",
|
||||
42,
|
||||
message.GetString().c_str());
|
||||
|
||||
EXPECT_EQ(TestPartResult::kNonFatalFailure, result.type());
|
||||
EXPECT_STREQ("some_file.cc", result.file_name());
|
||||
EXPECT_EQ(42, result.line_number());
|
||||
EXPECT_STREQ(message.GetString().c_str(), result.message());
|
||||
EXPECT_STREQ("something is terribly wrong", result.summary());
|
||||
}
|
||||
|
||||
TEST_F(TestPartResultTest, ResultAccessorsWork) {
|
||||
const TestPartResult success(TestPartResult::kSuccess,
|
||||
"file.cc",
|
||||
42,
|
||||
"message");
|
||||
EXPECT_TRUE(success.passed());
|
||||
EXPECT_FALSE(success.failed());
|
||||
EXPECT_FALSE(success.nonfatally_failed());
|
||||
EXPECT_FALSE(success.fatally_failed());
|
||||
|
||||
const TestPartResult nonfatal_failure(TestPartResult::kNonFatalFailure,
|
||||
"file.cc",
|
||||
42,
|
||||
"message");
|
||||
EXPECT_FALSE(nonfatal_failure.passed());
|
||||
EXPECT_TRUE(nonfatal_failure.failed());
|
||||
EXPECT_TRUE(nonfatal_failure.nonfatally_failed());
|
||||
EXPECT_FALSE(nonfatal_failure.fatally_failed());
|
||||
|
||||
const TestPartResult fatal_failure(TestPartResult::kFatalFailure,
|
||||
"file.cc",
|
||||
42,
|
||||
"message");
|
||||
EXPECT_FALSE(fatal_failure.passed());
|
||||
EXPECT_TRUE(fatal_failure.failed());
|
||||
EXPECT_FALSE(fatal_failure.nonfatally_failed());
|
||||
EXPECT_TRUE(fatal_failure.fatally_failed());
|
||||
}
|
||||
|
||||
// Tests TestPartResult::type().
|
||||
TEST_F(TestPartResultTest, type) {
|
||||
EXPECT_EQ(TestPartResult::kSuccess, r1_.type());
|
||||
EXPECT_EQ(TestPartResult::kNonFatalFailure, r2_.type());
|
||||
EXPECT_EQ(TestPartResult::kFatalFailure, r3_.type());
|
||||
}
|
||||
|
||||
// Tests TestPartResult::file_name().
|
||||
TEST_F(TestPartResultTest, file_name) {
|
||||
EXPECT_STREQ("foo/bar.cc", r1_.file_name());
|
||||
EXPECT_STREQ(NULL, r3_.file_name());
|
||||
}
|
||||
|
||||
// Tests TestPartResult::line_number().
|
||||
TEST_F(TestPartResultTest, line_number) {
|
||||
EXPECT_EQ(10, r1_.line_number());
|
||||
EXPECT_EQ(-1, r2_.line_number());
|
||||
}
|
||||
|
||||
// Tests TestPartResult::message().
|
||||
TEST_F(TestPartResultTest, message) {
|
||||
EXPECT_STREQ("Success!", r1_.message());
|
||||
}
|
||||
|
||||
// Tests TestPartResult::passed().
|
||||
TEST_F(TestPartResultTest, Passed) {
|
||||
EXPECT_TRUE(r1_.passed());
|
||||
EXPECT_FALSE(r2_.passed());
|
||||
EXPECT_FALSE(r3_.passed());
|
||||
}
|
||||
|
||||
// Tests TestPartResult::failed().
|
||||
TEST_F(TestPartResultTest, Failed) {
|
||||
EXPECT_FALSE(r1_.failed());
|
||||
EXPECT_TRUE(r2_.failed());
|
||||
EXPECT_TRUE(r3_.failed());
|
||||
}
|
||||
|
||||
// Tests TestPartResult::fatally_failed().
|
||||
TEST_F(TestPartResultTest, FatallyFailed) {
|
||||
EXPECT_FALSE(r1_.fatally_failed());
|
||||
EXPECT_FALSE(r2_.fatally_failed());
|
||||
EXPECT_TRUE(r3_.fatally_failed());
|
||||
}
|
||||
|
||||
// Tests TestPartResult::nonfatally_failed().
|
||||
TEST_F(TestPartResultTest, NonfatallyFailed) {
|
||||
EXPECT_FALSE(r1_.nonfatally_failed());
|
||||
EXPECT_TRUE(r2_.nonfatally_failed());
|
||||
EXPECT_FALSE(r3_.nonfatally_failed());
|
||||
}
|
||||
|
||||
// Tests the TestPartResultArray class.
|
||||
|
||||
class TestPartResultArrayTest : public Test {
|
||||
protected:
|
||||
TestPartResultArrayTest()
|
||||
: r1_(TestPartResult::kNonFatalFailure, "foo/bar.cc", -1, "Failure 1"),
|
||||
r2_(TestPartResult::kFatalFailure, "foo/bar.cc", -1, "Failure 2") {}
|
||||
|
||||
const TestPartResult r1_, r2_;
|
||||
};
|
||||
|
||||
// Tests that TestPartResultArray initially has size 0.
|
||||
TEST_F(TestPartResultArrayTest, InitialSizeIsZero) {
|
||||
TestPartResultArray results;
|
||||
EXPECT_EQ(0, results.size());
|
||||
}
|
||||
|
||||
// Tests that TestPartResultArray contains the given TestPartResult
|
||||
// after one Append() operation.
|
||||
TEST_F(TestPartResultArrayTest, ContainsGivenResultAfterAppend) {
|
||||
TestPartResultArray results;
|
||||
results.Append(r1_);
|
||||
EXPECT_EQ(1, results.size());
|
||||
EXPECT_STREQ("Failure 1", results.GetTestPartResult(0).message());
|
||||
}
|
||||
|
||||
// Tests that TestPartResultArray contains the given TestPartResults
|
||||
// after two Append() operations.
|
||||
TEST_F(TestPartResultArrayTest, ContainsGivenResultsAfterTwoAppends) {
|
||||
TestPartResultArray results;
|
||||
results.Append(r1_);
|
||||
results.Append(r2_);
|
||||
EXPECT_EQ(2, results.size());
|
||||
EXPECT_STREQ("Failure 1", results.GetTestPartResult(0).message());
|
||||
EXPECT_STREQ("Failure 2", results.GetTestPartResult(1).message());
|
||||
}
|
||||
|
||||
typedef TestPartResultArrayTest TestPartResultArrayDeathTest;
|
||||
|
||||
// Tests that the program dies when GetTestPartResult() is called with
|
||||
// an invalid index.
|
||||
TEST_F(TestPartResultArrayDeathTest, DiesWhenIndexIsOutOfBound) {
|
||||
TestPartResultArray results;
|
||||
results.Append(r1_);
|
||||
|
||||
EXPECT_DEATH_IF_SUPPORTED(results.GetTestPartResult(-1), "");
|
||||
EXPECT_DEATH_IF_SUPPORTED(results.GetTestPartResult(1), "");
|
||||
}
|
||||
|
||||
// TODO(mheule@google.com): Add a test for the class HasNewFatalFailureHelper.
|
||||
|
||||
} // namespace
|
320
gtest/test/gtest-tuple_test.cc
Normal file
320
gtest/test/gtest-tuple_test.cc
Normal file
@ -0,0 +1,320 @@
|
||||
// Copyright 2007, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
#include "gtest/internal/gtest-tuple.h"
|
||||
#include <utility>
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
namespace {
|
||||
|
||||
using ::std::tr1::get;
|
||||
using ::std::tr1::make_tuple;
|
||||
using ::std::tr1::tuple;
|
||||
using ::std::tr1::tuple_element;
|
||||
using ::std::tr1::tuple_size;
|
||||
using ::testing::StaticAssertTypeEq;
|
||||
|
||||
// Tests that tuple_element<K, tuple<T0, T1, ..., TN> >::type returns TK.
|
||||
TEST(tuple_element_Test, ReturnsElementType) {
|
||||
StaticAssertTypeEq<int, tuple_element<0, tuple<int, char> >::type>();
|
||||
StaticAssertTypeEq<int&, tuple_element<1, tuple<double, int&> >::type>();
|
||||
StaticAssertTypeEq<bool, tuple_element<2, tuple<double, int, bool> >::type>();
|
||||
}
|
||||
|
||||
// Tests that tuple_size<T>::value gives the number of fields in tuple
|
||||
// type T.
|
||||
TEST(tuple_size_Test, ReturnsNumberOfFields) {
|
||||
EXPECT_EQ(0, +tuple_size<tuple<> >::value);
|
||||
EXPECT_EQ(1, +tuple_size<tuple<void*> >::value);
|
||||
EXPECT_EQ(1, +tuple_size<tuple<char> >::value);
|
||||
EXPECT_EQ(1, +(tuple_size<tuple<tuple<int, double> > >::value));
|
||||
EXPECT_EQ(2, +(tuple_size<tuple<int&, const char> >::value));
|
||||
EXPECT_EQ(3, +(tuple_size<tuple<char*, void, const bool&> >::value));
|
||||
}
|
||||
|
||||
// Tests comparing a tuple with itself.
|
||||
TEST(ComparisonTest, ComparesWithSelf) {
|
||||
const tuple<int, char, bool> a(5, 'a', false);
|
||||
|
||||
EXPECT_TRUE(a == a);
|
||||
EXPECT_FALSE(a != a);
|
||||
}
|
||||
|
||||
// Tests comparing two tuples with the same value.
|
||||
TEST(ComparisonTest, ComparesEqualTuples) {
|
||||
const tuple<int, bool> a(5, true), b(5, true);
|
||||
|
||||
EXPECT_TRUE(a == b);
|
||||
EXPECT_FALSE(a != b);
|
||||
}
|
||||
|
||||
// Tests comparing two different tuples that have no reference fields.
|
||||
TEST(ComparisonTest, ComparesUnequalTuplesWithoutReferenceFields) {
|
||||
typedef tuple<const int, char> FooTuple;
|
||||
|
||||
const FooTuple a(0, 'x');
|
||||
const FooTuple b(1, 'a');
|
||||
|
||||
EXPECT_TRUE(a != b);
|
||||
EXPECT_FALSE(a == b);
|
||||
|
||||
const FooTuple c(1, 'b');
|
||||
|
||||
EXPECT_TRUE(b != c);
|
||||
EXPECT_FALSE(b == c);
|
||||
}
|
||||
|
||||
// Tests comparing two different tuples that have reference fields.
|
||||
TEST(ComparisonTest, ComparesUnequalTuplesWithReferenceFields) {
|
||||
typedef tuple<int&, const char&> FooTuple;
|
||||
|
||||
int i = 5;
|
||||
const char ch = 'a';
|
||||
const FooTuple a(i, ch);
|
||||
|
||||
int j = 6;
|
||||
const FooTuple b(j, ch);
|
||||
|
||||
EXPECT_TRUE(a != b);
|
||||
EXPECT_FALSE(a == b);
|
||||
|
||||
j = 5;
|
||||
const char ch2 = 'b';
|
||||
const FooTuple c(j, ch2);
|
||||
|
||||
EXPECT_TRUE(b != c);
|
||||
EXPECT_FALSE(b == c);
|
||||
}
|
||||
|
||||
// Tests that a tuple field with a reference type is an alias of the
|
||||
// variable it's supposed to reference.
|
||||
TEST(ReferenceFieldTest, IsAliasOfReferencedVariable) {
|
||||
int n = 0;
|
||||
tuple<bool, int&> t(true, n);
|
||||
|
||||
n = 1;
|
||||
EXPECT_EQ(n, get<1>(t))
|
||||
<< "Changing a underlying variable should update the reference field.";
|
||||
|
||||
// Makes sure that the implementation doesn't do anything funny with
|
||||
// the & operator for the return type of get<>().
|
||||
EXPECT_EQ(&n, &(get<1>(t)))
|
||||
<< "The address of a reference field should equal the address of "
|
||||
<< "the underlying variable.";
|
||||
|
||||
get<1>(t) = 2;
|
||||
EXPECT_EQ(2, n)
|
||||
<< "Changing a reference field should update the underlying variable.";
|
||||
}
|
||||
|
||||
// Tests that tuple's default constructor default initializes each field.
|
||||
// This test needs to compile without generating warnings.
|
||||
TEST(TupleConstructorTest, DefaultConstructorDefaultInitializesEachField) {
|
||||
// The TR1 report requires that tuple's default constructor default
|
||||
// initializes each field, even if it's a primitive type. If the
|
||||
// implementation forgets to do this, this test will catch it by
|
||||
// generating warnings about using uninitialized variables (assuming
|
||||
// a decent compiler).
|
||||
|
||||
tuple<> empty;
|
||||
|
||||
tuple<int> a1, b1;
|
||||
b1 = a1;
|
||||
EXPECT_EQ(0, get<0>(b1));
|
||||
|
||||
tuple<int, double> a2, b2;
|
||||
b2 = a2;
|
||||
EXPECT_EQ(0, get<0>(b2));
|
||||
EXPECT_EQ(0.0, get<1>(b2));
|
||||
|
||||
tuple<double, char, bool*> a3, b3;
|
||||
b3 = a3;
|
||||
EXPECT_EQ(0.0, get<0>(b3));
|
||||
EXPECT_EQ('\0', get<1>(b3));
|
||||
EXPECT_TRUE(get<2>(b3) == NULL);
|
||||
|
||||
tuple<int, int, int, int, int, int, int, int, int, int> a10, b10;
|
||||
b10 = a10;
|
||||
EXPECT_EQ(0, get<0>(b10));
|
||||
EXPECT_EQ(0, get<1>(b10));
|
||||
EXPECT_EQ(0, get<2>(b10));
|
||||
EXPECT_EQ(0, get<3>(b10));
|
||||
EXPECT_EQ(0, get<4>(b10));
|
||||
EXPECT_EQ(0, get<5>(b10));
|
||||
EXPECT_EQ(0, get<6>(b10));
|
||||
EXPECT_EQ(0, get<7>(b10));
|
||||
EXPECT_EQ(0, get<8>(b10));
|
||||
EXPECT_EQ(0, get<9>(b10));
|
||||
}
|
||||
|
||||
// Tests constructing a tuple from its fields.
|
||||
TEST(TupleConstructorTest, ConstructsFromFields) {
|
||||
int n = 1;
|
||||
// Reference field.
|
||||
tuple<int&> a(n);
|
||||
EXPECT_EQ(&n, &(get<0>(a)));
|
||||
|
||||
// Non-reference fields.
|
||||
tuple<int, char> b(5, 'a');
|
||||
EXPECT_EQ(5, get<0>(b));
|
||||
EXPECT_EQ('a', get<1>(b));
|
||||
|
||||
// Const reference field.
|
||||
const int m = 2;
|
||||
tuple<bool, const int&> c(true, m);
|
||||
EXPECT_TRUE(get<0>(c));
|
||||
EXPECT_EQ(&m, &(get<1>(c)));
|
||||
}
|
||||
|
||||
// Tests tuple's copy constructor.
|
||||
TEST(TupleConstructorTest, CopyConstructor) {
|
||||
tuple<double, bool> a(0.0, true);
|
||||
tuple<double, bool> b(a);
|
||||
|
||||
EXPECT_DOUBLE_EQ(0.0, get<0>(b));
|
||||
EXPECT_TRUE(get<1>(b));
|
||||
}
|
||||
|
||||
// Tests constructing a tuple from another tuple that has a compatible
|
||||
// but different type.
|
||||
TEST(TupleConstructorTest, ConstructsFromDifferentTupleType) {
|
||||
tuple<int, int, char> a(0, 1, 'a');
|
||||
tuple<double, long, int> b(a);
|
||||
|
||||
EXPECT_DOUBLE_EQ(0.0, get<0>(b));
|
||||
EXPECT_EQ(1, get<1>(b));
|
||||
EXPECT_EQ('a', get<2>(b));
|
||||
}
|
||||
|
||||
// Tests constructing a 2-tuple from an std::pair.
|
||||
TEST(TupleConstructorTest, ConstructsFromPair) {
|
||||
::std::pair<int, char> a(1, 'a');
|
||||
tuple<int, char> b(a);
|
||||
tuple<int, const char&> c(a);
|
||||
}
|
||||
|
||||
// Tests assigning a tuple to another tuple with the same type.
|
||||
TEST(TupleAssignmentTest, AssignsToSameTupleType) {
|
||||
const tuple<int, long> a(5, 7L);
|
||||
tuple<int, long> b;
|
||||
b = a;
|
||||
EXPECT_EQ(5, get<0>(b));
|
||||
EXPECT_EQ(7L, get<1>(b));
|
||||
}
|
||||
|
||||
// Tests assigning a tuple to another tuple with a different but
|
||||
// compatible type.
|
||||
TEST(TupleAssignmentTest, AssignsToDifferentTupleType) {
|
||||
const tuple<int, long, bool> a(1, 7L, true);
|
||||
tuple<long, int, bool> b;
|
||||
b = a;
|
||||
EXPECT_EQ(1L, get<0>(b));
|
||||
EXPECT_EQ(7, get<1>(b));
|
||||
EXPECT_TRUE(get<2>(b));
|
||||
}
|
||||
|
||||
// Tests assigning an std::pair to a 2-tuple.
|
||||
TEST(TupleAssignmentTest, AssignsFromPair) {
|
||||
const ::std::pair<int, bool> a(5, true);
|
||||
tuple<int, bool> b;
|
||||
b = a;
|
||||
EXPECT_EQ(5, get<0>(b));
|
||||
EXPECT_TRUE(get<1>(b));
|
||||
|
||||
tuple<long, bool> c;
|
||||
c = a;
|
||||
EXPECT_EQ(5L, get<0>(c));
|
||||
EXPECT_TRUE(get<1>(c));
|
||||
}
|
||||
|
||||
// A fixture for testing big tuples.
|
||||
class BigTupleTest : public testing::Test {
|
||||
protected:
|
||||
typedef tuple<int, int, int, int, int, int, int, int, int, int> BigTuple;
|
||||
|
||||
BigTupleTest() :
|
||||
a_(1, 0, 0, 0, 0, 0, 0, 0, 0, 2),
|
||||
b_(1, 0, 0, 0, 0, 0, 0, 0, 0, 3) {}
|
||||
|
||||
BigTuple a_, b_;
|
||||
};
|
||||
|
||||
// Tests constructing big tuples.
|
||||
TEST_F(BigTupleTest, Construction) {
|
||||
BigTuple a;
|
||||
BigTuple b(b_);
|
||||
}
|
||||
|
||||
// Tests that get<N>(t) returns the N-th (0-based) field of tuple t.
|
||||
TEST_F(BigTupleTest, get) {
|
||||
EXPECT_EQ(1, get<0>(a_));
|
||||
EXPECT_EQ(2, get<9>(a_));
|
||||
|
||||
// Tests that get() works on a const tuple too.
|
||||
const BigTuple a(a_);
|
||||
EXPECT_EQ(1, get<0>(a));
|
||||
EXPECT_EQ(2, get<9>(a));
|
||||
}
|
||||
|
||||
// Tests comparing big tuples.
|
||||
TEST_F(BigTupleTest, Comparisons) {
|
||||
EXPECT_TRUE(a_ == a_);
|
||||
EXPECT_FALSE(a_ != a_);
|
||||
|
||||
EXPECT_TRUE(a_ != b_);
|
||||
EXPECT_FALSE(a_ == b_);
|
||||
}
|
||||
|
||||
TEST(MakeTupleTest, WorksForScalarTypes) {
|
||||
tuple<bool, int> a;
|
||||
a = make_tuple(true, 5);
|
||||
EXPECT_TRUE(get<0>(a));
|
||||
EXPECT_EQ(5, get<1>(a));
|
||||
|
||||
tuple<char, int, long> b;
|
||||
b = make_tuple('a', 'b', 5);
|
||||
EXPECT_EQ('a', get<0>(b));
|
||||
EXPECT_EQ('b', get<1>(b));
|
||||
EXPECT_EQ(5, get<2>(b));
|
||||
}
|
||||
|
||||
TEST(MakeTupleTest, WorksForPointers) {
|
||||
int a[] = { 1, 2, 3, 4 };
|
||||
const char* const str = "hi";
|
||||
int* const p = a;
|
||||
|
||||
tuple<const char*, int*> t;
|
||||
t = make_tuple(str, p);
|
||||
EXPECT_EQ(str, get<0>(t));
|
||||
EXPECT_EQ(p, get<1>(t));
|
||||
}
|
||||
|
||||
} // namespace
|
45
gtest/test/gtest-typed-test2_test.cc
Normal file
45
gtest/test/gtest-typed-test2_test.cc
Normal file
@ -0,0 +1,45 @@
|
||||
// Copyright 2008 Google Inc.
|
||||
// All Rights Reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include "test/gtest-typed-test_test.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#if GTEST_HAS_TYPED_TEST_P
|
||||
|
||||
// Tests that the same type-parameterized test case can be
|
||||
// instantiated in different translation units linked together.
|
||||
// (ContainerTest is also instantiated in gtest-typed-test_test.cc.)
|
||||
INSTANTIATE_TYPED_TEST_CASE_P(Vector, ContainerTest,
|
||||
testing::Types<std::vector<int> >);
|
||||
|
||||
#endif // GTEST_HAS_TYPED_TEST_P
|
360
gtest/test/gtest-typed-test_test.cc
Normal file
360
gtest/test/gtest-typed-test_test.cc
Normal file
@ -0,0 +1,360 @@
|
||||
// Copyright 2008 Google Inc.
|
||||
// All Rights Reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
#include <set>
|
||||
#include <vector>
|
||||
|
||||
#include "test/gtest-typed-test_test.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
using testing::Test;
|
||||
|
||||
// Used for testing that SetUpTestCase()/TearDownTestCase(), fixture
|
||||
// ctor/dtor, and SetUp()/TearDown() work correctly in typed tests and
|
||||
// type-parameterized test.
|
||||
template <typename T>
|
||||
class CommonTest : public Test {
|
||||
// For some technical reason, SetUpTestCase() and TearDownTestCase()
|
||||
// must be public.
|
||||
public:
|
||||
static void SetUpTestCase() {
|
||||
shared_ = new T(5);
|
||||
}
|
||||
|
||||
static void TearDownTestCase() {
|
||||
delete shared_;
|
||||
shared_ = NULL;
|
||||
}
|
||||
|
||||
// This 'protected:' is optional. There's no harm in making all
|
||||
// members of this fixture class template public.
|
||||
protected:
|
||||
// We used to use std::list here, but switched to std::vector since
|
||||
// MSVC's <list> doesn't compile cleanly with /W4.
|
||||
typedef std::vector<T> Vector;
|
||||
typedef std::set<int> IntSet;
|
||||
|
||||
CommonTest() : value_(1) {}
|
||||
|
||||
virtual ~CommonTest() { EXPECT_EQ(3, value_); }
|
||||
|
||||
virtual void SetUp() {
|
||||
EXPECT_EQ(1, value_);
|
||||
value_++;
|
||||
}
|
||||
|
||||
virtual void TearDown() {
|
||||
EXPECT_EQ(2, value_);
|
||||
value_++;
|
||||
}
|
||||
|
||||
T value_;
|
||||
static T* shared_;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
T* CommonTest<T>::shared_ = NULL;
|
||||
|
||||
// This #ifdef block tests typed tests.
|
||||
#if GTEST_HAS_TYPED_TEST
|
||||
|
||||
using testing::Types;
|
||||
|
||||
// Tests that SetUpTestCase()/TearDownTestCase(), fixture ctor/dtor,
|
||||
// and SetUp()/TearDown() work correctly in typed tests
|
||||
|
||||
typedef Types<char, int> TwoTypes;
|
||||
TYPED_TEST_CASE(CommonTest, TwoTypes);
|
||||
|
||||
TYPED_TEST(CommonTest, ValuesAreCorrect) {
|
||||
// Static members of the fixture class template can be visited via
|
||||
// the TestFixture:: prefix.
|
||||
EXPECT_EQ(5, *TestFixture::shared_);
|
||||
|
||||
// Typedefs in the fixture class template can be visited via the
|
||||
// "typename TestFixture::" prefix.
|
||||
typename TestFixture::Vector empty;
|
||||
EXPECT_EQ(0U, empty.size());
|
||||
|
||||
typename TestFixture::IntSet empty2;
|
||||
EXPECT_EQ(0U, empty2.size());
|
||||
|
||||
// Non-static members of the fixture class must be visited via
|
||||
// 'this', as required by C++ for class templates.
|
||||
EXPECT_EQ(2, this->value_);
|
||||
}
|
||||
|
||||
// The second test makes sure shared_ is not deleted after the first
|
||||
// test.
|
||||
TYPED_TEST(CommonTest, ValuesAreStillCorrect) {
|
||||
// Static members of the fixture class template can also be visited
|
||||
// via 'this'.
|
||||
ASSERT_TRUE(this->shared_ != NULL);
|
||||
EXPECT_EQ(5, *this->shared_);
|
||||
|
||||
// TypeParam can be used to refer to the type parameter.
|
||||
EXPECT_EQ(static_cast<TypeParam>(2), this->value_);
|
||||
}
|
||||
|
||||
// Tests that multiple TYPED_TEST_CASE's can be defined in the same
|
||||
// translation unit.
|
||||
|
||||
template <typename T>
|
||||
class TypedTest1 : public Test {
|
||||
};
|
||||
|
||||
// Verifies that the second argument of TYPED_TEST_CASE can be a
|
||||
// single type.
|
||||
TYPED_TEST_CASE(TypedTest1, int);
|
||||
TYPED_TEST(TypedTest1, A) {}
|
||||
|
||||
template <typename T>
|
||||
class TypedTest2 : public Test {
|
||||
};
|
||||
|
||||
// Verifies that the second argument of TYPED_TEST_CASE can be a
|
||||
// Types<...> type list.
|
||||
TYPED_TEST_CASE(TypedTest2, Types<int>);
|
||||
|
||||
// This also verifies that tests from different typed test cases can
|
||||
// share the same name.
|
||||
TYPED_TEST(TypedTest2, A) {}
|
||||
|
||||
// Tests that a typed test case can be defined in a namespace.
|
||||
|
||||
namespace library1 {
|
||||
|
||||
template <typename T>
|
||||
class NumericTest : public Test {
|
||||
};
|
||||
|
||||
typedef Types<int, long> NumericTypes;
|
||||
TYPED_TEST_CASE(NumericTest, NumericTypes);
|
||||
|
||||
TYPED_TEST(NumericTest, DefaultIsZero) {
|
||||
EXPECT_EQ(0, TypeParam());
|
||||
}
|
||||
|
||||
} // namespace library1
|
||||
|
||||
#endif // GTEST_HAS_TYPED_TEST
|
||||
|
||||
// This #ifdef block tests type-parameterized tests.
|
||||
#if GTEST_HAS_TYPED_TEST_P
|
||||
|
||||
using testing::Types;
|
||||
using testing::internal::TypedTestCasePState;
|
||||
|
||||
// Tests TypedTestCasePState.
|
||||
|
||||
class TypedTestCasePStateTest : public Test {
|
||||
protected:
|
||||
virtual void SetUp() {
|
||||
state_.AddTestName("foo.cc", 0, "FooTest", "A");
|
||||
state_.AddTestName("foo.cc", 0, "FooTest", "B");
|
||||
state_.AddTestName("foo.cc", 0, "FooTest", "C");
|
||||
}
|
||||
|
||||
TypedTestCasePState state_;
|
||||
};
|
||||
|
||||
TEST_F(TypedTestCasePStateTest, SucceedsForMatchingList) {
|
||||
const char* tests = "A, B, C";
|
||||
EXPECT_EQ(tests,
|
||||
state_.VerifyRegisteredTestNames("foo.cc", 1, tests));
|
||||
}
|
||||
|
||||
// Makes sure that the order of the tests and spaces around the names
|
||||
// don't matter.
|
||||
TEST_F(TypedTestCasePStateTest, IgnoresOrderAndSpaces) {
|
||||
const char* tests = "A,C, B";
|
||||
EXPECT_EQ(tests,
|
||||
state_.VerifyRegisteredTestNames("foo.cc", 1, tests));
|
||||
}
|
||||
|
||||
typedef TypedTestCasePStateTest TypedTestCasePStateDeathTest;
|
||||
|
||||
TEST_F(TypedTestCasePStateDeathTest, DetectsDuplicates) {
|
||||
EXPECT_DEATH_IF_SUPPORTED(
|
||||
state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, A, C"),
|
||||
"foo\\.cc.1.?: Test A is listed more than once\\.");
|
||||
}
|
||||
|
||||
TEST_F(TypedTestCasePStateDeathTest, DetectsExtraTest) {
|
||||
EXPECT_DEATH_IF_SUPPORTED(
|
||||
state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, C, D"),
|
||||
"foo\\.cc.1.?: No test named D can be found in this test case\\.");
|
||||
}
|
||||
|
||||
TEST_F(TypedTestCasePStateDeathTest, DetectsMissedTest) {
|
||||
EXPECT_DEATH_IF_SUPPORTED(
|
||||
state_.VerifyRegisteredTestNames("foo.cc", 1, "A, C"),
|
||||
"foo\\.cc.1.?: You forgot to list test B\\.");
|
||||
}
|
||||
|
||||
// Tests that defining a test for a parameterized test case generates
|
||||
// a run-time error if the test case has been registered.
|
||||
TEST_F(TypedTestCasePStateDeathTest, DetectsTestAfterRegistration) {
|
||||
state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, C");
|
||||
EXPECT_DEATH_IF_SUPPORTED(
|
||||
state_.AddTestName("foo.cc", 2, "FooTest", "D"),
|
||||
"foo\\.cc.2.?: Test D must be defined before REGISTER_TYPED_TEST_CASE_P"
|
||||
"\\(FooTest, \\.\\.\\.\\)\\.");
|
||||
}
|
||||
|
||||
// Tests that SetUpTestCase()/TearDownTestCase(), fixture ctor/dtor,
|
||||
// and SetUp()/TearDown() work correctly in type-parameterized tests.
|
||||
|
||||
template <typename T>
|
||||
class DerivedTest : public CommonTest<T> {
|
||||
};
|
||||
|
||||
TYPED_TEST_CASE_P(DerivedTest);
|
||||
|
||||
TYPED_TEST_P(DerivedTest, ValuesAreCorrect) {
|
||||
// Static members of the fixture class template can be visited via
|
||||
// the TestFixture:: prefix.
|
||||
EXPECT_EQ(5, *TestFixture::shared_);
|
||||
|
||||
// Non-static members of the fixture class must be visited via
|
||||
// 'this', as required by C++ for class templates.
|
||||
EXPECT_EQ(2, this->value_);
|
||||
}
|
||||
|
||||
// The second test makes sure shared_ is not deleted after the first
|
||||
// test.
|
||||
TYPED_TEST_P(DerivedTest, ValuesAreStillCorrect) {
|
||||
// Static members of the fixture class template can also be visited
|
||||
// via 'this'.
|
||||
ASSERT_TRUE(this->shared_ != NULL);
|
||||
EXPECT_EQ(5, *this->shared_);
|
||||
EXPECT_EQ(2, this->value_);
|
||||
}
|
||||
|
||||
REGISTER_TYPED_TEST_CASE_P(DerivedTest,
|
||||
ValuesAreCorrect, ValuesAreStillCorrect);
|
||||
|
||||
typedef Types<short, long> MyTwoTypes;
|
||||
INSTANTIATE_TYPED_TEST_CASE_P(My, DerivedTest, MyTwoTypes);
|
||||
|
||||
// Tests that multiple TYPED_TEST_CASE_P's can be defined in the same
|
||||
// translation unit.
|
||||
|
||||
template <typename T>
|
||||
class TypedTestP1 : public Test {
|
||||
};
|
||||
|
||||
TYPED_TEST_CASE_P(TypedTestP1);
|
||||
|
||||
// For testing that the code between TYPED_TEST_CASE_P() and
|
||||
// TYPED_TEST_P() is not enclosed in a namespace.
|
||||
typedef int IntAfterTypedTestCaseP;
|
||||
|
||||
TYPED_TEST_P(TypedTestP1, A) {}
|
||||
TYPED_TEST_P(TypedTestP1, B) {}
|
||||
|
||||
// For testing that the code between TYPED_TEST_P() and
|
||||
// REGISTER_TYPED_TEST_CASE_P() is not enclosed in a namespace.
|
||||
typedef int IntBeforeRegisterTypedTestCaseP;
|
||||
|
||||
REGISTER_TYPED_TEST_CASE_P(TypedTestP1, A, B);
|
||||
|
||||
template <typename T>
|
||||
class TypedTestP2 : public Test {
|
||||
};
|
||||
|
||||
TYPED_TEST_CASE_P(TypedTestP2);
|
||||
|
||||
// This also verifies that tests from different type-parameterized
|
||||
// test cases can share the same name.
|
||||
TYPED_TEST_P(TypedTestP2, A) {}
|
||||
|
||||
REGISTER_TYPED_TEST_CASE_P(TypedTestP2, A);
|
||||
|
||||
// Verifies that the code between TYPED_TEST_CASE_P() and
|
||||
// REGISTER_TYPED_TEST_CASE_P() is not enclosed in a namespace.
|
||||
IntAfterTypedTestCaseP after = 0;
|
||||
IntBeforeRegisterTypedTestCaseP before = 0;
|
||||
|
||||
// Verifies that the last argument of INSTANTIATE_TYPED_TEST_CASE_P()
|
||||
// can be either a single type or a Types<...> type list.
|
||||
INSTANTIATE_TYPED_TEST_CASE_P(Int, TypedTestP1, int);
|
||||
INSTANTIATE_TYPED_TEST_CASE_P(Int, TypedTestP2, Types<int>);
|
||||
|
||||
// Tests that the same type-parameterized test case can be
|
||||
// instantiated more than once in the same translation unit.
|
||||
INSTANTIATE_TYPED_TEST_CASE_P(Double, TypedTestP2, Types<double>);
|
||||
|
||||
// Tests that the same type-parameterized test case can be
|
||||
// instantiated in different translation units linked together.
|
||||
// (ContainerTest is also instantiated in gtest-typed-test_test.cc.)
|
||||
typedef Types<std::vector<double>, std::set<char> > MyContainers;
|
||||
INSTANTIATE_TYPED_TEST_CASE_P(My, ContainerTest, MyContainers);
|
||||
|
||||
// Tests that a type-parameterized test case can be defined and
|
||||
// instantiated in a namespace.
|
||||
|
||||
namespace library2 {
|
||||
|
||||
template <typename T>
|
||||
class NumericTest : public Test {
|
||||
};
|
||||
|
||||
TYPED_TEST_CASE_P(NumericTest);
|
||||
|
||||
TYPED_TEST_P(NumericTest, DefaultIsZero) {
|
||||
EXPECT_EQ(0, TypeParam());
|
||||
}
|
||||
|
||||
TYPED_TEST_P(NumericTest, ZeroIsLessThanOne) {
|
||||
EXPECT_LT(TypeParam(0), TypeParam(1));
|
||||
}
|
||||
|
||||
REGISTER_TYPED_TEST_CASE_P(NumericTest,
|
||||
DefaultIsZero, ZeroIsLessThanOne);
|
||||
typedef Types<int, double> NumericTypes;
|
||||
INSTANTIATE_TYPED_TEST_CASE_P(My, NumericTest, NumericTypes);
|
||||
|
||||
} // namespace library2
|
||||
|
||||
#endif // GTEST_HAS_TYPED_TEST_P
|
||||
|
||||
#if !defined(GTEST_HAS_TYPED_TEST) && !defined(GTEST_HAS_TYPED_TEST_P)
|
||||
|
||||
// Google Test may not support type-parameterized tests with some
|
||||
// compilers. If we use conditional compilation to compile out all
|
||||
// code referring to the gtest_main library, MSVC linker will not link
|
||||
// that library at all and consequently complain about missing entry
|
||||
// point defined in that library (fatal error LNK1561: entry point
|
||||
// must be defined). This dummy test keeps gtest_main linked in.
|
||||
TEST(DummyTest, TypedTestsAreNotSupportedOnThisPlatform) {}
|
||||
|
||||
#endif // #if !defined(GTEST_HAS_TYPED_TEST) && !defined(GTEST_HAS_TYPED_TEST_P)
|
66
gtest/test/gtest-typed-test_test.h
Normal file
66
gtest/test/gtest-typed-test_test.h
Normal file
@ -0,0 +1,66 @@
|
||||
// Copyright 2008 Google Inc.
|
||||
// All Rights Reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
#ifndef GTEST_TEST_GTEST_TYPED_TEST_TEST_H_
|
||||
#define GTEST_TEST_GTEST_TYPED_TEST_TEST_H_
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#if GTEST_HAS_TYPED_TEST_P
|
||||
|
||||
using testing::Test;
|
||||
|
||||
// For testing that the same type-parameterized test case can be
|
||||
// instantiated in different translation units linked together.
|
||||
// ContainerTest will be instantiated in both gtest-typed-test_test.cc
|
||||
// and gtest-typed-test2_test.cc.
|
||||
|
||||
template <typename T>
|
||||
class ContainerTest : public Test {
|
||||
};
|
||||
|
||||
TYPED_TEST_CASE_P(ContainerTest);
|
||||
|
||||
TYPED_TEST_P(ContainerTest, CanBeDefaultConstructed) {
|
||||
TypeParam container;
|
||||
}
|
||||
|
||||
TYPED_TEST_P(ContainerTest, InitialSizeIsZero) {
|
||||
TypeParam container;
|
||||
EXPECT_EQ(0U, container.size());
|
||||
}
|
||||
|
||||
REGISTER_TYPED_TEST_CASE_P(ContainerTest,
|
||||
CanBeDefaultConstructed, InitialSizeIsZero);
|
||||
|
||||
#endif // GTEST_HAS_TYPED_TEST_P
|
||||
|
||||
#endif // GTEST_TEST_GTEST_TYPED_TEST_TEST_H_
|
341
gtest/test/gtest-unittest-api_test.cc
Normal file
341
gtest/test/gtest-unittest-api_test.cc
Normal file
@ -0,0 +1,341 @@
|
||||
// Copyright 2009 Google Inc. All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: vladl@google.com (Vlad Losev)
|
||||
//
|
||||
// The Google C++ Testing Framework (Google Test)
|
||||
//
|
||||
// This file contains tests verifying correctness of data provided via
|
||||
// UnitTest's public methods.
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#include <string.h> // For strcmp.
|
||||
#include <algorithm>
|
||||
|
||||
using ::testing::InitGoogleTest;
|
||||
|
||||
namespace testing {
|
||||
namespace internal {
|
||||
|
||||
template <typename T>
|
||||
struct LessByName {
|
||||
bool operator()(const T* a, const T* b) {
|
||||
return strcmp(a->name(), b->name()) < 0;
|
||||
}
|
||||
};
|
||||
|
||||
class UnitTestHelper {
|
||||
public:
|
||||
// Returns the array of pointers to all test cases sorted by the test case
|
||||
// name. The caller is responsible for deleting the array.
|
||||
static TestCase const** const GetSortedTestCases() {
|
||||
UnitTest& unit_test = *UnitTest::GetInstance();
|
||||
TestCase const** const test_cases =
|
||||
new const TestCase*[unit_test.total_test_case_count()];
|
||||
|
||||
for (int i = 0; i < unit_test.total_test_case_count(); ++i)
|
||||
test_cases[i] = unit_test.GetTestCase(i);
|
||||
|
||||
std::sort(test_cases,
|
||||
test_cases + unit_test.total_test_case_count(),
|
||||
LessByName<TestCase>());
|
||||
return test_cases;
|
||||
}
|
||||
|
||||
// Returns the test case by its name. The caller doesn't own the returned
|
||||
// pointer.
|
||||
static const TestCase* FindTestCase(const char* name) {
|
||||
UnitTest& unit_test = *UnitTest::GetInstance();
|
||||
for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
|
||||
const TestCase* test_case = unit_test.GetTestCase(i);
|
||||
if (0 == strcmp(test_case->name(), name))
|
||||
return test_case;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Returns the array of pointers to all tests in a particular test case
|
||||
// sorted by the test name. The caller is responsible for deleting the
|
||||
// array.
|
||||
static TestInfo const** const GetSortedTests(const TestCase* test_case) {
|
||||
TestInfo const** const tests =
|
||||
new const TestInfo*[test_case->total_test_count()];
|
||||
|
||||
for (int i = 0; i < test_case->total_test_count(); ++i)
|
||||
tests[i] = test_case->GetTestInfo(i);
|
||||
|
||||
std::sort(tests, tests + test_case->total_test_count(),
|
||||
LessByName<TestInfo>());
|
||||
return tests;
|
||||
}
|
||||
};
|
||||
|
||||
#if GTEST_HAS_TYPED_TEST
|
||||
template <typename T> class TestCaseWithCommentTest : public Test {};
|
||||
TYPED_TEST_CASE(TestCaseWithCommentTest, Types<int>);
|
||||
TYPED_TEST(TestCaseWithCommentTest, Dummy) {}
|
||||
|
||||
const int kTypedTestCases = 1;
|
||||
const int kTypedTests = 1;
|
||||
#else
|
||||
const int kTypedTestCases = 0;
|
||||
const int kTypedTests = 0;
|
||||
#endif // GTEST_HAS_TYPED_TEST
|
||||
|
||||
// We can only test the accessors that do not change value while tests run.
|
||||
// Since tests can be run in any order, the values the accessors that track
|
||||
// test execution (such as failed_test_count) can not be predicted.
|
||||
TEST(ApiTest, UnitTestImmutableAccessorsWork) {
|
||||
UnitTest* unit_test = UnitTest::GetInstance();
|
||||
|
||||
ASSERT_EQ(2 + kTypedTestCases, unit_test->total_test_case_count());
|
||||
EXPECT_EQ(1 + kTypedTestCases, unit_test->test_case_to_run_count());
|
||||
EXPECT_EQ(2, unit_test->disabled_test_count());
|
||||
EXPECT_EQ(5 + kTypedTests, unit_test->total_test_count());
|
||||
EXPECT_EQ(3 + kTypedTests, unit_test->test_to_run_count());
|
||||
|
||||
const TestCase** const test_cases = UnitTestHelper::GetSortedTestCases();
|
||||
|
||||
EXPECT_STREQ("ApiTest", test_cases[0]->name());
|
||||
EXPECT_STREQ("DISABLED_Test", test_cases[1]->name());
|
||||
#if GTEST_HAS_TYPED_TEST
|
||||
EXPECT_STREQ("TestCaseWithCommentTest/0", test_cases[2]->name());
|
||||
#endif // GTEST_HAS_TYPED_TEST
|
||||
|
||||
delete[] test_cases;
|
||||
|
||||
// The following lines initiate actions to verify certain methods in
|
||||
// FinalSuccessChecker::TearDown.
|
||||
|
||||
// Records a test property to verify TestResult::GetTestProperty().
|
||||
RecordProperty("key", "value");
|
||||
}
|
||||
|
||||
AssertionResult IsNull(const char* str) {
|
||||
if (str != NULL) {
|
||||
return testing::AssertionFailure() << "argument is " << str;
|
||||
}
|
||||
return AssertionSuccess();
|
||||
}
|
||||
|
||||
TEST(ApiTest, TestCaseImmutableAccessorsWork) {
|
||||
const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest");
|
||||
ASSERT_TRUE(test_case != NULL);
|
||||
|
||||
EXPECT_STREQ("ApiTest", test_case->name());
|
||||
EXPECT_TRUE(IsNull(test_case->type_param()));
|
||||
EXPECT_TRUE(test_case->should_run());
|
||||
EXPECT_EQ(1, test_case->disabled_test_count());
|
||||
EXPECT_EQ(3, test_case->test_to_run_count());
|
||||
ASSERT_EQ(4, test_case->total_test_count());
|
||||
|
||||
const TestInfo** tests = UnitTestHelper::GetSortedTests(test_case);
|
||||
|
||||
EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());
|
||||
EXPECT_STREQ("ApiTest", tests[0]->test_case_name());
|
||||
EXPECT_TRUE(IsNull(tests[0]->value_param()));
|
||||
EXPECT_TRUE(IsNull(tests[0]->type_param()));
|
||||
EXPECT_FALSE(tests[0]->should_run());
|
||||
|
||||
EXPECT_STREQ("TestCaseDisabledAccessorsWork", tests[1]->name());
|
||||
EXPECT_STREQ("ApiTest", tests[1]->test_case_name());
|
||||
EXPECT_TRUE(IsNull(tests[1]->value_param()));
|
||||
EXPECT_TRUE(IsNull(tests[1]->type_param()));
|
||||
EXPECT_TRUE(tests[1]->should_run());
|
||||
|
||||
EXPECT_STREQ("TestCaseImmutableAccessorsWork", tests[2]->name());
|
||||
EXPECT_STREQ("ApiTest", tests[2]->test_case_name());
|
||||
EXPECT_TRUE(IsNull(tests[2]->value_param()));
|
||||
EXPECT_TRUE(IsNull(tests[2]->type_param()));
|
||||
EXPECT_TRUE(tests[2]->should_run());
|
||||
|
||||
EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());
|
||||
EXPECT_STREQ("ApiTest", tests[3]->test_case_name());
|
||||
EXPECT_TRUE(IsNull(tests[3]->value_param()));
|
||||
EXPECT_TRUE(IsNull(tests[3]->type_param()));
|
||||
EXPECT_TRUE(tests[3]->should_run());
|
||||
|
||||
delete[] tests;
|
||||
tests = NULL;
|
||||
|
||||
#if GTEST_HAS_TYPED_TEST
|
||||
test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0");
|
||||
ASSERT_TRUE(test_case != NULL);
|
||||
|
||||
EXPECT_STREQ("TestCaseWithCommentTest/0", test_case->name());
|
||||
EXPECT_STREQ(GetTypeName<int>().c_str(), test_case->type_param());
|
||||
EXPECT_TRUE(test_case->should_run());
|
||||
EXPECT_EQ(0, test_case->disabled_test_count());
|
||||
EXPECT_EQ(1, test_case->test_to_run_count());
|
||||
ASSERT_EQ(1, test_case->total_test_count());
|
||||
|
||||
tests = UnitTestHelper::GetSortedTests(test_case);
|
||||
|
||||
EXPECT_STREQ("Dummy", tests[0]->name());
|
||||
EXPECT_STREQ("TestCaseWithCommentTest/0", tests[0]->test_case_name());
|
||||
EXPECT_TRUE(IsNull(tests[0]->value_param()));
|
||||
EXPECT_STREQ(GetTypeName<int>().c_str(), tests[0]->type_param());
|
||||
EXPECT_TRUE(tests[0]->should_run());
|
||||
|
||||
delete[] tests;
|
||||
#endif // GTEST_HAS_TYPED_TEST
|
||||
}
|
||||
|
||||
TEST(ApiTest, TestCaseDisabledAccessorsWork) {
|
||||
const TestCase* test_case = UnitTestHelper::FindTestCase("DISABLED_Test");
|
||||
ASSERT_TRUE(test_case != NULL);
|
||||
|
||||
EXPECT_STREQ("DISABLED_Test", test_case->name());
|
||||
EXPECT_TRUE(IsNull(test_case->type_param()));
|
||||
EXPECT_FALSE(test_case->should_run());
|
||||
EXPECT_EQ(1, test_case->disabled_test_count());
|
||||
EXPECT_EQ(0, test_case->test_to_run_count());
|
||||
ASSERT_EQ(1, test_case->total_test_count());
|
||||
|
||||
const TestInfo* const test_info = test_case->GetTestInfo(0);
|
||||
EXPECT_STREQ("Dummy2", test_info->name());
|
||||
EXPECT_STREQ("DISABLED_Test", test_info->test_case_name());
|
||||
EXPECT_TRUE(IsNull(test_info->value_param()));
|
||||
EXPECT_TRUE(IsNull(test_info->type_param()));
|
||||
EXPECT_FALSE(test_info->should_run());
|
||||
}
|
||||
|
||||
// These two tests are here to provide support for testing
|
||||
// test_case_to_run_count, disabled_test_count, and test_to_run_count.
|
||||
TEST(ApiTest, DISABLED_Dummy1) {}
|
||||
TEST(DISABLED_Test, Dummy2) {}
|
||||
|
||||
class FinalSuccessChecker : public Environment {
|
||||
protected:
|
||||
virtual void TearDown() {
|
||||
UnitTest* unit_test = UnitTest::GetInstance();
|
||||
|
||||
EXPECT_EQ(1 + kTypedTestCases, unit_test->successful_test_case_count());
|
||||
EXPECT_EQ(3 + kTypedTests, unit_test->successful_test_count());
|
||||
EXPECT_EQ(0, unit_test->failed_test_case_count());
|
||||
EXPECT_EQ(0, unit_test->failed_test_count());
|
||||
EXPECT_TRUE(unit_test->Passed());
|
||||
EXPECT_FALSE(unit_test->Failed());
|
||||
ASSERT_EQ(2 + kTypedTestCases, unit_test->total_test_case_count());
|
||||
|
||||
const TestCase** const test_cases = UnitTestHelper::GetSortedTestCases();
|
||||
|
||||
EXPECT_STREQ("ApiTest", test_cases[0]->name());
|
||||
EXPECT_TRUE(IsNull(test_cases[0]->type_param()));
|
||||
EXPECT_TRUE(test_cases[0]->should_run());
|
||||
EXPECT_EQ(1, test_cases[0]->disabled_test_count());
|
||||
ASSERT_EQ(4, test_cases[0]->total_test_count());
|
||||
EXPECT_EQ(3, test_cases[0]->successful_test_count());
|
||||
EXPECT_EQ(0, test_cases[0]->failed_test_count());
|
||||
EXPECT_TRUE(test_cases[0]->Passed());
|
||||
EXPECT_FALSE(test_cases[0]->Failed());
|
||||
|
||||
EXPECT_STREQ("DISABLED_Test", test_cases[1]->name());
|
||||
EXPECT_TRUE(IsNull(test_cases[1]->type_param()));
|
||||
EXPECT_FALSE(test_cases[1]->should_run());
|
||||
EXPECT_EQ(1, test_cases[1]->disabled_test_count());
|
||||
ASSERT_EQ(1, test_cases[1]->total_test_count());
|
||||
EXPECT_EQ(0, test_cases[1]->successful_test_count());
|
||||
EXPECT_EQ(0, test_cases[1]->failed_test_count());
|
||||
|
||||
#if GTEST_HAS_TYPED_TEST
|
||||
EXPECT_STREQ("TestCaseWithCommentTest/0", test_cases[2]->name());
|
||||
EXPECT_STREQ(GetTypeName<int>().c_str(), test_cases[2]->type_param());
|
||||
EXPECT_TRUE(test_cases[2]->should_run());
|
||||
EXPECT_EQ(0, test_cases[2]->disabled_test_count());
|
||||
ASSERT_EQ(1, test_cases[2]->total_test_count());
|
||||
EXPECT_EQ(1, test_cases[2]->successful_test_count());
|
||||
EXPECT_EQ(0, test_cases[2]->failed_test_count());
|
||||
EXPECT_TRUE(test_cases[2]->Passed());
|
||||
EXPECT_FALSE(test_cases[2]->Failed());
|
||||
#endif // GTEST_HAS_TYPED_TEST
|
||||
|
||||
const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest");
|
||||
const TestInfo** tests = UnitTestHelper::GetSortedTests(test_case);
|
||||
EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());
|
||||
EXPECT_STREQ("ApiTest", tests[0]->test_case_name());
|
||||
EXPECT_FALSE(tests[0]->should_run());
|
||||
|
||||
EXPECT_STREQ("TestCaseDisabledAccessorsWork", tests[1]->name());
|
||||
EXPECT_STREQ("ApiTest", tests[1]->test_case_name());
|
||||
EXPECT_TRUE(IsNull(tests[1]->value_param()));
|
||||
EXPECT_TRUE(IsNull(tests[1]->type_param()));
|
||||
EXPECT_TRUE(tests[1]->should_run());
|
||||
EXPECT_TRUE(tests[1]->result()->Passed());
|
||||
EXPECT_EQ(0, tests[1]->result()->test_property_count());
|
||||
|
||||
EXPECT_STREQ("TestCaseImmutableAccessorsWork", tests[2]->name());
|
||||
EXPECT_STREQ("ApiTest", tests[2]->test_case_name());
|
||||
EXPECT_TRUE(IsNull(tests[2]->value_param()));
|
||||
EXPECT_TRUE(IsNull(tests[2]->type_param()));
|
||||
EXPECT_TRUE(tests[2]->should_run());
|
||||
EXPECT_TRUE(tests[2]->result()->Passed());
|
||||
EXPECT_EQ(0, tests[2]->result()->test_property_count());
|
||||
|
||||
EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());
|
||||
EXPECT_STREQ("ApiTest", tests[3]->test_case_name());
|
||||
EXPECT_TRUE(IsNull(tests[3]->value_param()));
|
||||
EXPECT_TRUE(IsNull(tests[3]->type_param()));
|
||||
EXPECT_TRUE(tests[3]->should_run());
|
||||
EXPECT_TRUE(tests[3]->result()->Passed());
|
||||
EXPECT_EQ(1, tests[3]->result()->test_property_count());
|
||||
const TestProperty& property = tests[3]->result()->GetTestProperty(0);
|
||||
EXPECT_STREQ("key", property.key());
|
||||
EXPECT_STREQ("value", property.value());
|
||||
|
||||
delete[] tests;
|
||||
|
||||
#if GTEST_HAS_TYPED_TEST
|
||||
test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0");
|
||||
tests = UnitTestHelper::GetSortedTests(test_case);
|
||||
|
||||
EXPECT_STREQ("Dummy", tests[0]->name());
|
||||
EXPECT_STREQ("TestCaseWithCommentTest/0", tests[0]->test_case_name());
|
||||
EXPECT_TRUE(IsNull(tests[0]->value_param()));
|
||||
EXPECT_STREQ(GetTypeName<int>().c_str(), tests[0]->type_param());
|
||||
EXPECT_TRUE(tests[0]->should_run());
|
||||
EXPECT_TRUE(tests[0]->result()->Passed());
|
||||
EXPECT_EQ(0, tests[0]->result()->test_property_count());
|
||||
|
||||
delete[] tests;
|
||||
#endif // GTEST_HAS_TYPED_TEST
|
||||
delete[] test_cases;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace internal
|
||||
} // namespace testing
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
InitGoogleTest(&argc, argv);
|
||||
|
||||
AddGlobalTestEnvironment(new testing::internal::FinalSuccessChecker());
|
||||
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
47
gtest/test/gtest_all_test.cc
Normal file
47
gtest/test/gtest_all_test.cc
Normal file
@ -0,0 +1,47 @@
|
||||
// Copyright 2009, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
//
|
||||
// Tests for Google C++ Testing Framework (Google Test)
|
||||
//
|
||||
// Sometimes it's desirable to build most of Google Test's own tests
|
||||
// by compiling a single file. This file serves this purpose.
|
||||
#include "test/gtest-filepath_test.cc"
|
||||
#include "test/gtest-linked_ptr_test.cc"
|
||||
#include "test/gtest-message_test.cc"
|
||||
#include "test/gtest-options_test.cc"
|
||||
#include "test/gtest-port_test.cc"
|
||||
#include "test/gtest_pred_impl_unittest.cc"
|
||||
#include "test/gtest_prod_test.cc"
|
||||
#include "test/gtest-test-part_test.cc"
|
||||
#include "test/gtest-typed-test_test.cc"
|
||||
#include "test/gtest-typed-test2_test.cc"
|
||||
#include "test/gtest_unittest.cc"
|
||||
#include "test/production.cc"
|
218
gtest/test/gtest_break_on_failure_unittest.py
Executable file
218
gtest/test/gtest_break_on_failure_unittest.py
Executable file
@ -0,0 +1,218 @@
|
||||
#!/usr/bin/env python
|
||||
#
|
||||
# Copyright 2006, Google Inc.
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are
|
||||
# met:
|
||||
#
|
||||
# * Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# * Redistributions in binary form must reproduce the above
|
||||
# copyright notice, this list of conditions and the following disclaimer
|
||||
# in the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
# * Neither the name of Google Inc. nor the names of its
|
||||
# contributors may be used to endorse or promote products derived from
|
||||
# this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
"""Unit test for Google Test's break-on-failure mode.
|
||||
|
||||
A user can ask Google Test to seg-fault when an assertion fails, using
|
||||
either the GTEST_BREAK_ON_FAILURE environment variable or the
|
||||
--gtest_break_on_failure flag. This script tests such functionality
|
||||
by invoking gtest_break_on_failure_unittest_ (a program written with
|
||||
Google Test) with different environments and command line flags.
|
||||
"""
|
||||
|
||||
__author__ = 'wan@google.com (Zhanyong Wan)'
|
||||
|
||||
import gtest_test_utils
|
||||
import os
|
||||
import sys
|
||||
|
||||
|
||||
# Constants.
|
||||
|
||||
IS_WINDOWS = os.name == 'nt'
|
||||
|
||||
# The environment variable for enabling/disabling the break-on-failure mode.
|
||||
BREAK_ON_FAILURE_ENV_VAR = 'GTEST_BREAK_ON_FAILURE'
|
||||
|
||||
# The command line flag for enabling/disabling the break-on-failure mode.
|
||||
BREAK_ON_FAILURE_FLAG = 'gtest_break_on_failure'
|
||||
|
||||
# The environment variable for enabling/disabling the throw-on-failure mode.
|
||||
THROW_ON_FAILURE_ENV_VAR = 'GTEST_THROW_ON_FAILURE'
|
||||
|
||||
# The environment variable for enabling/disabling the catch-exceptions mode.
|
||||
CATCH_EXCEPTIONS_ENV_VAR = 'GTEST_CATCH_EXCEPTIONS'
|
||||
|
||||
# Path to the gtest_break_on_failure_unittest_ program.
|
||||
EXE_PATH = gtest_test_utils.GetTestExecutablePath(
|
||||
'gtest_break_on_failure_unittest_')
|
||||
|
||||
|
||||
# Utilities.
|
||||
|
||||
|
||||
environ = os.environ.copy()
|
||||
|
||||
|
||||
def SetEnvVar(env_var, value):
|
||||
"""Sets an environment variable to a given value; unsets it when the
|
||||
given value is None.
|
||||
"""
|
||||
|
||||
if value is not None:
|
||||
environ[env_var] = value
|
||||
elif env_var in environ:
|
||||
del environ[env_var]
|
||||
|
||||
|
||||
def Run(command):
|
||||
"""Runs a command; returns 1 if it was killed by a signal, or 0 otherwise."""
|
||||
|
||||
p = gtest_test_utils.Subprocess(command, env=environ)
|
||||
if p.terminated_by_signal:
|
||||
return 1
|
||||
else:
|
||||
return 0
|
||||
|
||||
|
||||
# The tests.
|
||||
|
||||
|
||||
class GTestBreakOnFailureUnitTest(gtest_test_utils.TestCase):
|
||||
"""Tests using the GTEST_BREAK_ON_FAILURE environment variable or
|
||||
the --gtest_break_on_failure flag to turn assertion failures into
|
||||
segmentation faults.
|
||||
"""
|
||||
|
||||
def RunAndVerify(self, env_var_value, flag_value, expect_seg_fault):
|
||||
"""Runs gtest_break_on_failure_unittest_ and verifies that it does
|
||||
(or does not) have a seg-fault.
|
||||
|
||||
Args:
|
||||
env_var_value: value of the GTEST_BREAK_ON_FAILURE environment
|
||||
variable; None if the variable should be unset.
|
||||
flag_value: value of the --gtest_break_on_failure flag;
|
||||
None if the flag should not be present.
|
||||
expect_seg_fault: 1 if the program is expected to generate a seg-fault;
|
||||
0 otherwise.
|
||||
"""
|
||||
|
||||
SetEnvVar(BREAK_ON_FAILURE_ENV_VAR, env_var_value)
|
||||
|
||||
if env_var_value is None:
|
||||
env_var_value_msg = ' is not set'
|
||||
else:
|
||||
env_var_value_msg = '=' + env_var_value
|
||||
|
||||
if flag_value is None:
|
||||
flag = ''
|
||||
elif flag_value == '0':
|
||||
flag = '--%s=0' % BREAK_ON_FAILURE_FLAG
|
||||
else:
|
||||
flag = '--%s' % BREAK_ON_FAILURE_FLAG
|
||||
|
||||
command = [EXE_PATH]
|
||||
if flag:
|
||||
command.append(flag)
|
||||
|
||||
if expect_seg_fault:
|
||||
should_or_not = 'should'
|
||||
else:
|
||||
should_or_not = 'should not'
|
||||
|
||||
has_seg_fault = Run(command)
|
||||
|
||||
SetEnvVar(BREAK_ON_FAILURE_ENV_VAR, None)
|
||||
|
||||
msg = ('when %s%s, an assertion failure in "%s" %s cause a seg-fault.' %
|
||||
(BREAK_ON_FAILURE_ENV_VAR, env_var_value_msg, ' '.join(command),
|
||||
should_or_not))
|
||||
self.assert_(has_seg_fault == expect_seg_fault, msg)
|
||||
|
||||
def testDefaultBehavior(self):
|
||||
"""Tests the behavior of the default mode."""
|
||||
|
||||
self.RunAndVerify(env_var_value=None,
|
||||
flag_value=None,
|
||||
expect_seg_fault=0)
|
||||
|
||||
def testEnvVar(self):
|
||||
"""Tests using the GTEST_BREAK_ON_FAILURE environment variable."""
|
||||
|
||||
self.RunAndVerify(env_var_value='0',
|
||||
flag_value=None,
|
||||
expect_seg_fault=0)
|
||||
self.RunAndVerify(env_var_value='1',
|
||||
flag_value=None,
|
||||
expect_seg_fault=1)
|
||||
|
||||
def testFlag(self):
|
||||
"""Tests using the --gtest_break_on_failure flag."""
|
||||
|
||||
self.RunAndVerify(env_var_value=None,
|
||||
flag_value='0',
|
||||
expect_seg_fault=0)
|
||||
self.RunAndVerify(env_var_value=None,
|
||||
flag_value='1',
|
||||
expect_seg_fault=1)
|
||||
|
||||
def testFlagOverridesEnvVar(self):
|
||||
"""Tests that the flag overrides the environment variable."""
|
||||
|
||||
self.RunAndVerify(env_var_value='0',
|
||||
flag_value='0',
|
||||
expect_seg_fault=0)
|
||||
self.RunAndVerify(env_var_value='0',
|
||||
flag_value='1',
|
||||
expect_seg_fault=1)
|
||||
self.RunAndVerify(env_var_value='1',
|
||||
flag_value='0',
|
||||
expect_seg_fault=0)
|
||||
self.RunAndVerify(env_var_value='1',
|
||||
flag_value='1',
|
||||
expect_seg_fault=1)
|
||||
|
||||
def testBreakOnFailureOverridesThrowOnFailure(self):
|
||||
"""Tests that gtest_break_on_failure overrides gtest_throw_on_failure."""
|
||||
|
||||
SetEnvVar(THROW_ON_FAILURE_ENV_VAR, '1')
|
||||
try:
|
||||
self.RunAndVerify(env_var_value=None,
|
||||
flag_value='1',
|
||||
expect_seg_fault=1)
|
||||
finally:
|
||||
SetEnvVar(THROW_ON_FAILURE_ENV_VAR, None)
|
||||
|
||||
if IS_WINDOWS:
|
||||
def testCatchExceptionsDoesNotInterfere(self):
|
||||
"""Tests that gtest_catch_exceptions doesn't interfere."""
|
||||
|
||||
SetEnvVar(CATCH_EXCEPTIONS_ENV_VAR, '1')
|
||||
try:
|
||||
self.RunAndVerify(env_var_value='1',
|
||||
flag_value='1',
|
||||
expect_seg_fault=1)
|
||||
finally:
|
||||
SetEnvVar(CATCH_EXCEPTIONS_ENV_VAR, None)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
gtest_test_utils.Main()
|
88
gtest/test/gtest_break_on_failure_unittest_.cc
Normal file
88
gtest/test/gtest_break_on_failure_unittest_.cc
Normal file
@ -0,0 +1,88 @@
|
||||
// Copyright 2006, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
// Unit test for Google Test's break-on-failure mode.
|
||||
//
|
||||
// A user can ask Google Test to seg-fault when an assertion fails, using
|
||||
// either the GTEST_BREAK_ON_FAILURE environment variable or the
|
||||
// --gtest_break_on_failure flag. This file is used for testing such
|
||||
// functionality.
|
||||
//
|
||||
// This program will be invoked from a Python unit test. It is
|
||||
// expected to fail. Don't run it directly.
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#if GTEST_OS_WINDOWS
|
||||
# include <windows.h>
|
||||
# include <stdlib.h>
|
||||
#endif
|
||||
|
||||
namespace {
|
||||
|
||||
// A test that's expected to fail.
|
||||
TEST(Foo, Bar) {
|
||||
EXPECT_EQ(2, 3);
|
||||
}
|
||||
|
||||
#if GTEST_HAS_SEH && !GTEST_OS_WINDOWS_MOBILE
|
||||
// On Windows Mobile global exception handlers are not supported.
|
||||
LONG WINAPI ExitWithExceptionCode(
|
||||
struct _EXCEPTION_POINTERS* exception_pointers) {
|
||||
exit(exception_pointers->ExceptionRecord->ExceptionCode);
|
||||
}
|
||||
#endif
|
||||
|
||||
} // namespace
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
#if GTEST_OS_WINDOWS
|
||||
// Suppresses display of the Windows error dialog upon encountering
|
||||
// a general protection fault (segment violation).
|
||||
SetErrorMode(SEM_NOGPFAULTERRORBOX | SEM_FAILCRITICALERRORS);
|
||||
|
||||
# if GTEST_HAS_SEH && !GTEST_OS_WINDOWS_MOBILE
|
||||
|
||||
// The default unhandled exception filter does not always exit
|
||||
// with the exception code as exit code - for example it exits with
|
||||
// 0 for EXCEPTION_ACCESS_VIOLATION and 1 for EXCEPTION_BREAKPOINT
|
||||
// if the application is compiled in debug mode. Thus we use our own
|
||||
// filter which always exits with the exception code for unhandled
|
||||
// exceptions.
|
||||
SetUnhandledExceptionFilter(ExitWithExceptionCode);
|
||||
|
||||
# endif
|
||||
#endif
|
||||
|
||||
testing::InitGoogleTest(&argc, argv);
|
||||
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
220
gtest/test/gtest_catch_exceptions_test.py
Executable file
220
gtest/test/gtest_catch_exceptions_test.py
Executable file
@ -0,0 +1,220 @@
|
||||
#!/usr/bin/env python
|
||||
#
|
||||
# Copyright 2010 Google Inc. All Rights Reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are
|
||||
# met:
|
||||
#
|
||||
# * Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# * Redistributions in binary form must reproduce the above
|
||||
# copyright notice, this list of conditions and the following disclaimer
|
||||
# in the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
# * Neither the name of Google Inc. nor the names of its
|
||||
# contributors may be used to endorse or promote products derived from
|
||||
# this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
"""Tests Google Test's exception catching behavior.
|
||||
|
||||
This script invokes gtest_catch_exceptions_test_ and
|
||||
gtest_catch_exceptions_ex_test_ (programs written with
|
||||
Google Test) and verifies their output.
|
||||
"""
|
||||
|
||||
__author__ = 'vladl@google.com (Vlad Losev)'
|
||||
|
||||
import os
|
||||
|
||||
import gtest_test_utils
|
||||
|
||||
# Constants.
|
||||
FLAG_PREFIX = '--gtest_'
|
||||
LIST_TESTS_FLAG = FLAG_PREFIX + 'list_tests'
|
||||
NO_CATCH_EXCEPTIONS_FLAG = FLAG_PREFIX + 'catch_exceptions=0'
|
||||
FILTER_FLAG = FLAG_PREFIX + 'filter'
|
||||
|
||||
# Path to the gtest_catch_exceptions_ex_test_ binary, compiled with
|
||||
# exceptions enabled.
|
||||
EX_EXE_PATH = gtest_test_utils.GetTestExecutablePath(
|
||||
'gtest_catch_exceptions_ex_test_')
|
||||
|
||||
# Path to the gtest_catch_exceptions_test_ binary, compiled with
|
||||
# exceptions disabled.
|
||||
EXE_PATH = gtest_test_utils.GetTestExecutablePath(
|
||||
'gtest_catch_exceptions_no_ex_test_')
|
||||
|
||||
TEST_LIST = gtest_test_utils.Subprocess([EXE_PATH, LIST_TESTS_FLAG]).output
|
||||
|
||||
SUPPORTS_SEH_EXCEPTIONS = 'ThrowsSehException' in TEST_LIST
|
||||
|
||||
if SUPPORTS_SEH_EXCEPTIONS:
|
||||
BINARY_OUTPUT = gtest_test_utils.Subprocess([EXE_PATH]).output
|
||||
|
||||
EX_BINARY_OUTPUT = gtest_test_utils.Subprocess([EX_EXE_PATH]).output
|
||||
|
||||
# The tests.
|
||||
if SUPPORTS_SEH_EXCEPTIONS:
|
||||
# pylint:disable-msg=C6302
|
||||
class CatchSehExceptionsTest(gtest_test_utils.TestCase):
|
||||
"""Tests exception-catching behavior."""
|
||||
|
||||
|
||||
def TestSehExceptions(self, test_output):
|
||||
self.assert_('SEH exception with code 0x2a thrown '
|
||||
'in the test fixture\'s constructor'
|
||||
in test_output)
|
||||
self.assert_('SEH exception with code 0x2a thrown '
|
||||
'in the test fixture\'s destructor'
|
||||
in test_output)
|
||||
self.assert_('SEH exception with code 0x2a thrown in SetUpTestCase()'
|
||||
in test_output)
|
||||
self.assert_('SEH exception with code 0x2a thrown in TearDownTestCase()'
|
||||
in test_output)
|
||||
self.assert_('SEH exception with code 0x2a thrown in SetUp()'
|
||||
in test_output)
|
||||
self.assert_('SEH exception with code 0x2a thrown in TearDown()'
|
||||
in test_output)
|
||||
self.assert_('SEH exception with code 0x2a thrown in the test body'
|
||||
in test_output)
|
||||
|
||||
def testCatchesSehExceptionsWithCxxExceptionsEnabled(self):
|
||||
self.TestSehExceptions(EX_BINARY_OUTPUT)
|
||||
|
||||
def testCatchesSehExceptionsWithCxxExceptionsDisabled(self):
|
||||
self.TestSehExceptions(BINARY_OUTPUT)
|
||||
|
||||
|
||||
class CatchCxxExceptionsTest(gtest_test_utils.TestCase):
|
||||
"""Tests C++ exception-catching behavior.
|
||||
|
||||
Tests in this test case verify that:
|
||||
* C++ exceptions are caught and logged as C++ (not SEH) exceptions
|
||||
* Exception thrown affect the remainder of the test work flow in the
|
||||
expected manner.
|
||||
"""
|
||||
|
||||
def testCatchesCxxExceptionsInFixtureConstructor(self):
|
||||
self.assert_('C++ exception with description '
|
||||
'"Standard C++ exception" thrown '
|
||||
'in the test fixture\'s constructor'
|
||||
in EX_BINARY_OUTPUT)
|
||||
self.assert_('unexpected' not in EX_BINARY_OUTPUT,
|
||||
'This failure belongs in this test only if '
|
||||
'"CxxExceptionInConstructorTest" (no quotes) '
|
||||
'appears on the same line as words "called unexpectedly"')
|
||||
|
||||
def testCatchesCxxExceptionsInFixtureDestructor(self):
|
||||
self.assert_('C++ exception with description '
|
||||
'"Standard C++ exception" thrown '
|
||||
'in the test fixture\'s destructor'
|
||||
in EX_BINARY_OUTPUT)
|
||||
self.assert_('CxxExceptionInDestructorTest::TearDownTestCase() '
|
||||
'called as expected.'
|
||||
in EX_BINARY_OUTPUT)
|
||||
|
||||
def testCatchesCxxExceptionsInSetUpTestCase(self):
|
||||
self.assert_('C++ exception with description "Standard C++ exception"'
|
||||
' thrown in SetUpTestCase()'
|
||||
in EX_BINARY_OUTPUT)
|
||||
self.assert_('CxxExceptionInConstructorTest::TearDownTestCase() '
|
||||
'called as expected.'
|
||||
in EX_BINARY_OUTPUT)
|
||||
self.assert_('CxxExceptionInSetUpTestCaseTest constructor '
|
||||
'called as expected.'
|
||||
in EX_BINARY_OUTPUT)
|
||||
self.assert_('CxxExceptionInSetUpTestCaseTest destructor '
|
||||
'called as expected.'
|
||||
in EX_BINARY_OUTPUT)
|
||||
self.assert_('CxxExceptionInSetUpTestCaseTest::SetUp() '
|
||||
'called as expected.'
|
||||
in EX_BINARY_OUTPUT)
|
||||
self.assert_('CxxExceptionInSetUpTestCaseTest::TearDown() '
|
||||
'called as expected.'
|
||||
in EX_BINARY_OUTPUT)
|
||||
self.assert_('CxxExceptionInSetUpTestCaseTest test body '
|
||||
'called as expected.'
|
||||
in EX_BINARY_OUTPUT)
|
||||
|
||||
def testCatchesCxxExceptionsInTearDownTestCase(self):
|
||||
self.assert_('C++ exception with description "Standard C++ exception"'
|
||||
' thrown in TearDownTestCase()'
|
||||
in EX_BINARY_OUTPUT)
|
||||
|
||||
def testCatchesCxxExceptionsInSetUp(self):
|
||||
self.assert_('C++ exception with description "Standard C++ exception"'
|
||||
' thrown in SetUp()'
|
||||
in EX_BINARY_OUTPUT)
|
||||
self.assert_('CxxExceptionInSetUpTest::TearDownTestCase() '
|
||||
'called as expected.'
|
||||
in EX_BINARY_OUTPUT)
|
||||
self.assert_('CxxExceptionInSetUpTest destructor '
|
||||
'called as expected.'
|
||||
in EX_BINARY_OUTPUT)
|
||||
self.assert_('CxxExceptionInSetUpTest::TearDown() '
|
||||
'called as expected.'
|
||||
in EX_BINARY_OUTPUT)
|
||||
self.assert_('unexpected' not in EX_BINARY_OUTPUT,
|
||||
'This failure belongs in this test only if '
|
||||
'"CxxExceptionInSetUpTest" (no quotes) '
|
||||
'appears on the same line as words "called unexpectedly"')
|
||||
|
||||
def testCatchesCxxExceptionsInTearDown(self):
|
||||
self.assert_('C++ exception with description "Standard C++ exception"'
|
||||
' thrown in TearDown()'
|
||||
in EX_BINARY_OUTPUT)
|
||||
self.assert_('CxxExceptionInTearDownTest::TearDownTestCase() '
|
||||
'called as expected.'
|
||||
in EX_BINARY_OUTPUT)
|
||||
self.assert_('CxxExceptionInTearDownTest destructor '
|
||||
'called as expected.'
|
||||
in EX_BINARY_OUTPUT)
|
||||
|
||||
def testCatchesCxxExceptionsInTestBody(self):
|
||||
self.assert_('C++ exception with description "Standard C++ exception"'
|
||||
' thrown in the test body'
|
||||
in EX_BINARY_OUTPUT)
|
||||
self.assert_('CxxExceptionInTestBodyTest::TearDownTestCase() '
|
||||
'called as expected.'
|
||||
in EX_BINARY_OUTPUT)
|
||||
self.assert_('CxxExceptionInTestBodyTest destructor '
|
||||
'called as expected.'
|
||||
in EX_BINARY_OUTPUT)
|
||||
self.assert_('CxxExceptionInTestBodyTest::TearDown() '
|
||||
'called as expected.'
|
||||
in EX_BINARY_OUTPUT)
|
||||
|
||||
def testCatchesNonStdCxxExceptions(self):
|
||||
self.assert_('Unknown C++ exception thrown in the test body'
|
||||
in EX_BINARY_OUTPUT)
|
||||
|
||||
def testUnhandledCxxExceptionsAbortTheProgram(self):
|
||||
# Filters out SEH exception tests on Windows. Unhandled SEH exceptions
|
||||
# cause tests to show pop-up windows there.
|
||||
FITLER_OUT_SEH_TESTS_FLAG = FILTER_FLAG + '=-*Seh*'
|
||||
# By default, Google Test doesn't catch the exceptions.
|
||||
uncaught_exceptions_ex_binary_output = gtest_test_utils.Subprocess(
|
||||
[EX_EXE_PATH,
|
||||
NO_CATCH_EXCEPTIONS_FLAG,
|
||||
FITLER_OUT_SEH_TESTS_FLAG]).output
|
||||
|
||||
self.assert_('Unhandled C++ exception terminating the program'
|
||||
in uncaught_exceptions_ex_binary_output)
|
||||
self.assert_('unexpected' not in uncaught_exceptions_ex_binary_output)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
gtest_test_utils.Main()
|
308
gtest/test/gtest_catch_exceptions_test_.cc
Normal file
308
gtest/test/gtest_catch_exceptions_test_.cc
Normal file
@ -0,0 +1,308 @@
|
||||
// Copyright 2010, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: vladl@google.com (Vlad Losev)
|
||||
//
|
||||
// Tests for Google Test itself. Tests in this file throw C++ or SEH
|
||||
// exceptions, and the output is verified by gtest_catch_exceptions_test.py.
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#include <stdio.h> // NOLINT
|
||||
#include <stdlib.h> // For exit().
|
||||
|
||||
#if GTEST_HAS_SEH
|
||||
# include <windows.h>
|
||||
#endif
|
||||
|
||||
#if GTEST_HAS_EXCEPTIONS
|
||||
# include <exception> // For set_terminate().
|
||||
# include <stdexcept>
|
||||
#endif
|
||||
|
||||
using testing::Test;
|
||||
|
||||
#if GTEST_HAS_SEH
|
||||
|
||||
class SehExceptionInConstructorTest : public Test {
|
||||
public:
|
||||
SehExceptionInConstructorTest() { RaiseException(42, 0, 0, NULL); }
|
||||
};
|
||||
|
||||
TEST_F(SehExceptionInConstructorTest, ThrowsExceptionInConstructor) {}
|
||||
|
||||
class SehExceptionInDestructorTest : public Test {
|
||||
public:
|
||||
~SehExceptionInDestructorTest() { RaiseException(42, 0, 0, NULL); }
|
||||
};
|
||||
|
||||
TEST_F(SehExceptionInDestructorTest, ThrowsExceptionInDestructor) {}
|
||||
|
||||
class SehExceptionInSetUpTestCaseTest : public Test {
|
||||
public:
|
||||
static void SetUpTestCase() { RaiseException(42, 0, 0, NULL); }
|
||||
};
|
||||
|
||||
TEST_F(SehExceptionInSetUpTestCaseTest, ThrowsExceptionInSetUpTestCase) {}
|
||||
|
||||
class SehExceptionInTearDownTestCaseTest : public Test {
|
||||
public:
|
||||
static void TearDownTestCase() { RaiseException(42, 0, 0, NULL); }
|
||||
};
|
||||
|
||||
TEST_F(SehExceptionInTearDownTestCaseTest, ThrowsExceptionInTearDownTestCase) {}
|
||||
|
||||
class SehExceptionInSetUpTest : public Test {
|
||||
protected:
|
||||
virtual void SetUp() { RaiseException(42, 0, 0, NULL); }
|
||||
};
|
||||
|
||||
TEST_F(SehExceptionInSetUpTest, ThrowsExceptionInSetUp) {}
|
||||
|
||||
class SehExceptionInTearDownTest : public Test {
|
||||
protected:
|
||||
virtual void TearDown() { RaiseException(42, 0, 0, NULL); }
|
||||
};
|
||||
|
||||
TEST_F(SehExceptionInTearDownTest, ThrowsExceptionInTearDown) {}
|
||||
|
||||
TEST(SehExceptionTest, ThrowsSehException) {
|
||||
RaiseException(42, 0, 0, NULL);
|
||||
}
|
||||
|
||||
#endif // GTEST_HAS_SEH
|
||||
|
||||
#if GTEST_HAS_EXCEPTIONS
|
||||
|
||||
class CxxExceptionInConstructorTest : public Test {
|
||||
public:
|
||||
CxxExceptionInConstructorTest() {
|
||||
// Without this macro VC++ complains about unreachable code at the end of
|
||||
// the constructor.
|
||||
GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(
|
||||
throw std::runtime_error("Standard C++ exception"));
|
||||
}
|
||||
|
||||
static void TearDownTestCase() {
|
||||
printf("%s",
|
||||
"CxxExceptionInConstructorTest::TearDownTestCase() "
|
||||
"called as expected.\n");
|
||||
}
|
||||
|
||||
protected:
|
||||
~CxxExceptionInConstructorTest() {
|
||||
ADD_FAILURE() << "CxxExceptionInConstructorTest destructor "
|
||||
<< "called unexpectedly.";
|
||||
}
|
||||
|
||||
virtual void SetUp() {
|
||||
ADD_FAILURE() << "CxxExceptionInConstructorTest::SetUp() "
|
||||
<< "called unexpectedly.";
|
||||
}
|
||||
|
||||
virtual void TearDown() {
|
||||
ADD_FAILURE() << "CxxExceptionInConstructorTest::TearDown() "
|
||||
<< "called unexpectedly.";
|
||||
}
|
||||
};
|
||||
|
||||
TEST_F(CxxExceptionInConstructorTest, ThrowsExceptionInConstructor) {
|
||||
ADD_FAILURE() << "CxxExceptionInConstructorTest test body "
|
||||
<< "called unexpectedly.";
|
||||
}
|
||||
|
||||
class CxxExceptionInDestructorTest : public Test {
|
||||
public:
|
||||
static void TearDownTestCase() {
|
||||
printf("%s",
|
||||
"CxxExceptionInDestructorTest::TearDownTestCase() "
|
||||
"called as expected.\n");
|
||||
}
|
||||
|
||||
protected:
|
||||
~CxxExceptionInDestructorTest() {
|
||||
GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(
|
||||
throw std::runtime_error("Standard C++ exception"));
|
||||
}
|
||||
};
|
||||
|
||||
TEST_F(CxxExceptionInDestructorTest, ThrowsExceptionInDestructor) {}
|
||||
|
||||
class CxxExceptionInSetUpTestCaseTest : public Test {
|
||||
public:
|
||||
CxxExceptionInSetUpTestCaseTest() {
|
||||
printf("%s",
|
||||
"CxxExceptionInSetUpTestCaseTest constructor "
|
||||
"called as expected.\n");
|
||||
}
|
||||
|
||||
static void SetUpTestCase() {
|
||||
throw std::runtime_error("Standard C++ exception");
|
||||
}
|
||||
|
||||
static void TearDownTestCase() {
|
||||
printf("%s",
|
||||
"CxxExceptionInSetUpTestCaseTest::TearDownTestCase() "
|
||||
"called as expected.\n");
|
||||
}
|
||||
|
||||
protected:
|
||||
~CxxExceptionInSetUpTestCaseTest() {
|
||||
printf("%s",
|
||||
"CxxExceptionInSetUpTestCaseTest destructor "
|
||||
"called as expected.\n");
|
||||
}
|
||||
|
||||
virtual void SetUp() {
|
||||
printf("%s",
|
||||
"CxxExceptionInSetUpTestCaseTest::SetUp() "
|
||||
"called as expected.\n");
|
||||
}
|
||||
|
||||
virtual void TearDown() {
|
||||
printf("%s",
|
||||
"CxxExceptionInSetUpTestCaseTest::TearDown() "
|
||||
"called as expected.\n");
|
||||
}
|
||||
};
|
||||
|
||||
TEST_F(CxxExceptionInSetUpTestCaseTest, ThrowsExceptionInSetUpTestCase) {
|
||||
printf("%s",
|
||||
"CxxExceptionInSetUpTestCaseTest test body "
|
||||
"called as expected.\n");
|
||||
}
|
||||
|
||||
class CxxExceptionInTearDownTestCaseTest : public Test {
|
||||
public:
|
||||
static void TearDownTestCase() {
|
||||
throw std::runtime_error("Standard C++ exception");
|
||||
}
|
||||
};
|
||||
|
||||
TEST_F(CxxExceptionInTearDownTestCaseTest, ThrowsExceptionInTearDownTestCase) {}
|
||||
|
||||
class CxxExceptionInSetUpTest : public Test {
|
||||
public:
|
||||
static void TearDownTestCase() {
|
||||
printf("%s",
|
||||
"CxxExceptionInSetUpTest::TearDownTestCase() "
|
||||
"called as expected.\n");
|
||||
}
|
||||
|
||||
protected:
|
||||
~CxxExceptionInSetUpTest() {
|
||||
printf("%s",
|
||||
"CxxExceptionInSetUpTest destructor "
|
||||
"called as expected.\n");
|
||||
}
|
||||
|
||||
virtual void SetUp() { throw std::runtime_error("Standard C++ exception"); }
|
||||
|
||||
virtual void TearDown() {
|
||||
printf("%s",
|
||||
"CxxExceptionInSetUpTest::TearDown() "
|
||||
"called as expected.\n");
|
||||
}
|
||||
};
|
||||
|
||||
TEST_F(CxxExceptionInSetUpTest, ThrowsExceptionInSetUp) {
|
||||
ADD_FAILURE() << "CxxExceptionInSetUpTest test body "
|
||||
<< "called unexpectedly.";
|
||||
}
|
||||
|
||||
class CxxExceptionInTearDownTest : public Test {
|
||||
public:
|
||||
static void TearDownTestCase() {
|
||||
printf("%s",
|
||||
"CxxExceptionInTearDownTest::TearDownTestCase() "
|
||||
"called as expected.\n");
|
||||
}
|
||||
|
||||
protected:
|
||||
~CxxExceptionInTearDownTest() {
|
||||
printf("%s",
|
||||
"CxxExceptionInTearDownTest destructor "
|
||||
"called as expected.\n");
|
||||
}
|
||||
|
||||
virtual void TearDown() {
|
||||
throw std::runtime_error("Standard C++ exception");
|
||||
}
|
||||
};
|
||||
|
||||
TEST_F(CxxExceptionInTearDownTest, ThrowsExceptionInTearDown) {}
|
||||
|
||||
class CxxExceptionInTestBodyTest : public Test {
|
||||
public:
|
||||
static void TearDownTestCase() {
|
||||
printf("%s",
|
||||
"CxxExceptionInTestBodyTest::TearDownTestCase() "
|
||||
"called as expected.\n");
|
||||
}
|
||||
|
||||
protected:
|
||||
~CxxExceptionInTestBodyTest() {
|
||||
printf("%s",
|
||||
"CxxExceptionInTestBodyTest destructor "
|
||||
"called as expected.\n");
|
||||
}
|
||||
|
||||
virtual void TearDown() {
|
||||
printf("%s",
|
||||
"CxxExceptionInTestBodyTest::TearDown() "
|
||||
"called as expected.\n");
|
||||
}
|
||||
};
|
||||
|
||||
TEST_F(CxxExceptionInTestBodyTest, ThrowsStdCxxException) {
|
||||
throw std::runtime_error("Standard C++ exception");
|
||||
}
|
||||
|
||||
TEST(CxxExceptionTest, ThrowsNonStdCxxException) {
|
||||
throw "C-string";
|
||||
}
|
||||
|
||||
// This terminate handler aborts the program using exit() rather than abort().
|
||||
// This avoids showing pop-ups on Windows systems and core dumps on Unix-like
|
||||
// ones.
|
||||
void TerminateHandler() {
|
||||
fprintf(stderr, "%s\n", "Unhandled C++ exception terminating the program.");
|
||||
fflush(NULL);
|
||||
exit(3);
|
||||
}
|
||||
|
||||
#endif // GTEST_HAS_EXCEPTIONS
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
#if GTEST_HAS_EXCEPTIONS
|
||||
std::set_terminate(&TerminateHandler);
|
||||
#endif
|
||||
testing::InitGoogleTest(&argc, argv);
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
130
gtest/test/gtest_color_test.py
Executable file
130
gtest/test/gtest_color_test.py
Executable file
@ -0,0 +1,130 @@
|
||||
#!/usr/bin/env python
|
||||
#
|
||||
# Copyright 2008, Google Inc.
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are
|
||||
# met:
|
||||
#
|
||||
# * Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# * Redistributions in binary form must reproduce the above
|
||||
# copyright notice, this list of conditions and the following disclaimer
|
||||
# in the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
# * Neither the name of Google Inc. nor the names of its
|
||||
# contributors may be used to endorse or promote products derived from
|
||||
# this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
"""Verifies that Google Test correctly determines whether to use colors."""
|
||||
|
||||
__author__ = 'wan@google.com (Zhanyong Wan)'
|
||||
|
||||
import os
|
||||
import gtest_test_utils
|
||||
|
||||
|
||||
IS_WINDOWS = os.name = 'nt'
|
||||
|
||||
COLOR_ENV_VAR = 'GTEST_COLOR'
|
||||
COLOR_FLAG = 'gtest_color'
|
||||
COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_color_test_')
|
||||
|
||||
|
||||
def SetEnvVar(env_var, value):
|
||||
"""Sets the env variable to 'value'; unsets it when 'value' is None."""
|
||||
|
||||
if value is not None:
|
||||
os.environ[env_var] = value
|
||||
elif env_var in os.environ:
|
||||
del os.environ[env_var]
|
||||
|
||||
|
||||
def UsesColor(term, color_env_var, color_flag):
|
||||
"""Runs gtest_color_test_ and returns its exit code."""
|
||||
|
||||
SetEnvVar('TERM', term)
|
||||
SetEnvVar(COLOR_ENV_VAR, color_env_var)
|
||||
|
||||
if color_flag is None:
|
||||
args = []
|
||||
else:
|
||||
args = ['--%s=%s' % (COLOR_FLAG, color_flag)]
|
||||
p = gtest_test_utils.Subprocess([COMMAND] + args)
|
||||
return not p.exited or p.exit_code
|
||||
|
||||
|
||||
class GTestColorTest(gtest_test_utils.TestCase):
|
||||
def testNoEnvVarNoFlag(self):
|
||||
"""Tests the case when there's neither GTEST_COLOR nor --gtest_color."""
|
||||
|
||||
if not IS_WINDOWS:
|
||||
self.assert_(not UsesColor('dumb', None, None))
|
||||
self.assert_(not UsesColor('emacs', None, None))
|
||||
self.assert_(not UsesColor('xterm-mono', None, None))
|
||||
self.assert_(not UsesColor('unknown', None, None))
|
||||
self.assert_(not UsesColor(None, None, None))
|
||||
self.assert_(UsesColor('linux', None, None))
|
||||
self.assert_(UsesColor('cygwin', None, None))
|
||||
self.assert_(UsesColor('xterm', None, None))
|
||||
self.assert_(UsesColor('xterm-color', None, None))
|
||||
self.assert_(UsesColor('xterm-256color', None, None))
|
||||
|
||||
def testFlagOnly(self):
|
||||
"""Tests the case when there's --gtest_color but not GTEST_COLOR."""
|
||||
|
||||
self.assert_(not UsesColor('dumb', None, 'no'))
|
||||
self.assert_(not UsesColor('xterm-color', None, 'no'))
|
||||
if not IS_WINDOWS:
|
||||
self.assert_(not UsesColor('emacs', None, 'auto'))
|
||||
self.assert_(UsesColor('xterm', None, 'auto'))
|
||||
self.assert_(UsesColor('dumb', None, 'yes'))
|
||||
self.assert_(UsesColor('xterm', None, 'yes'))
|
||||
|
||||
def testEnvVarOnly(self):
|
||||
"""Tests the case when there's GTEST_COLOR but not --gtest_color."""
|
||||
|
||||
self.assert_(not UsesColor('dumb', 'no', None))
|
||||
self.assert_(not UsesColor('xterm-color', 'no', None))
|
||||
if not IS_WINDOWS:
|
||||
self.assert_(not UsesColor('dumb', 'auto', None))
|
||||
self.assert_(UsesColor('xterm-color', 'auto', None))
|
||||
self.assert_(UsesColor('dumb', 'yes', None))
|
||||
self.assert_(UsesColor('xterm-color', 'yes', None))
|
||||
|
||||
def testEnvVarAndFlag(self):
|
||||
"""Tests the case when there are both GTEST_COLOR and --gtest_color."""
|
||||
|
||||
self.assert_(not UsesColor('xterm-color', 'no', 'no'))
|
||||
self.assert_(UsesColor('dumb', 'no', 'yes'))
|
||||
self.assert_(UsesColor('xterm-color', 'no', 'auto'))
|
||||
|
||||
def testAliasesOfYesAndNo(self):
|
||||
"""Tests using aliases in specifying --gtest_color."""
|
||||
|
||||
self.assert_(UsesColor('dumb', None, 'true'))
|
||||
self.assert_(UsesColor('dumb', None, 'YES'))
|
||||
self.assert_(UsesColor('dumb', None, 'T'))
|
||||
self.assert_(UsesColor('dumb', None, '1'))
|
||||
|
||||
self.assert_(not UsesColor('xterm', None, 'f'))
|
||||
self.assert_(not UsesColor('xterm', None, 'false'))
|
||||
self.assert_(not UsesColor('xterm', None, '0'))
|
||||
self.assert_(not UsesColor('xterm', None, 'unknown'))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
gtest_test_utils.Main()
|
71
gtest/test/gtest_color_test_.cc
Normal file
71
gtest/test/gtest_color_test_.cc
Normal file
@ -0,0 +1,71 @@
|
||||
// Copyright 2008, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
// A helper program for testing how Google Test determines whether to use
|
||||
// colors in the output. It prints "YES" and returns 1 if Google Test
|
||||
// decides to use colors, and prints "NO" and returns 0 otherwise.
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
// Indicates that this translation unit is part of Google Test's
|
||||
// implementation. It must come before gtest-internal-inl.h is
|
||||
// included, or there will be a compiler error. This trick is to
|
||||
// prevent a user from accidentally including gtest-internal-inl.h in
|
||||
// his code.
|
||||
#define GTEST_IMPLEMENTATION_ 1
|
||||
#include "src/gtest-internal-inl.h"
|
||||
#undef GTEST_IMPLEMENTATION_
|
||||
|
||||
using testing::internal::ShouldUseColor;
|
||||
|
||||
// The purpose of this is to ensure that the UnitTest singleton is
|
||||
// created before main() is entered, and thus that ShouldUseColor()
|
||||
// works the same way as in a real Google-Test-based test. We don't actual
|
||||
// run the TEST itself.
|
||||
TEST(GTestColorTest, Dummy) {
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
testing::InitGoogleTest(&argc, argv);
|
||||
|
||||
if (ShouldUseColor(true)) {
|
||||
// Google Test decides to use colors in the output (assuming it
|
||||
// goes to a TTY).
|
||||
printf("YES\n");
|
||||
return 1;
|
||||
} else {
|
||||
// Google Test decides not to use colors in the output.
|
||||
printf("NO\n");
|
||||
return 0;
|
||||
}
|
||||
}
|
103
gtest/test/gtest_env_var_test.py
Executable file
103
gtest/test/gtest_env_var_test.py
Executable file
@ -0,0 +1,103 @@
|
||||
#!/usr/bin/env python
|
||||
#
|
||||
# Copyright 2008, Google Inc.
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are
|
||||
# met:
|
||||
#
|
||||
# * Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# * Redistributions in binary form must reproduce the above
|
||||
# copyright notice, this list of conditions and the following disclaimer
|
||||
# in the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
# * Neither the name of Google Inc. nor the names of its
|
||||
# contributors may be used to endorse or promote products derived from
|
||||
# this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
"""Verifies that Google Test correctly parses environment variables."""
|
||||
|
||||
__author__ = 'wan@google.com (Zhanyong Wan)'
|
||||
|
||||
import os
|
||||
import gtest_test_utils
|
||||
|
||||
|
||||
IS_WINDOWS = os.name == 'nt'
|
||||
IS_LINUX = os.name == 'posix' and os.uname()[0] == 'Linux'
|
||||
|
||||
COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_env_var_test_')
|
||||
|
||||
environ = os.environ.copy()
|
||||
|
||||
|
||||
def AssertEq(expected, actual):
|
||||
if expected != actual:
|
||||
print 'Expected: %s' % (expected,)
|
||||
print ' Actual: %s' % (actual,)
|
||||
raise AssertionError
|
||||
|
||||
|
||||
def SetEnvVar(env_var, value):
|
||||
"""Sets the env variable to 'value'; unsets it when 'value' is None."""
|
||||
|
||||
if value is not None:
|
||||
environ[env_var] = value
|
||||
elif env_var in environ:
|
||||
del environ[env_var]
|
||||
|
||||
|
||||
def GetFlag(flag):
|
||||
"""Runs gtest_env_var_test_ and returns its output."""
|
||||
|
||||
args = [COMMAND]
|
||||
if flag is not None:
|
||||
args += [flag]
|
||||
return gtest_test_utils.Subprocess(args, env=environ).output
|
||||
|
||||
|
||||
def TestFlag(flag, test_val, default_val):
|
||||
"""Verifies that the given flag is affected by the corresponding env var."""
|
||||
|
||||
env_var = 'GTEST_' + flag.upper()
|
||||
SetEnvVar(env_var, test_val)
|
||||
AssertEq(test_val, GetFlag(flag))
|
||||
SetEnvVar(env_var, None)
|
||||
AssertEq(default_val, GetFlag(flag))
|
||||
|
||||
|
||||
class GTestEnvVarTest(gtest_test_utils.TestCase):
|
||||
def testEnvVarAffectsFlag(self):
|
||||
"""Tests that environment variable should affect the corresponding flag."""
|
||||
|
||||
TestFlag('break_on_failure', '1', '0')
|
||||
TestFlag('color', 'yes', 'auto')
|
||||
TestFlag('filter', 'FooTest.Bar', '*')
|
||||
TestFlag('output', 'xml:tmp/foo.xml', '')
|
||||
TestFlag('print_time', '0', '1')
|
||||
TestFlag('repeat', '999', '1')
|
||||
TestFlag('throw_on_failure', '1', '0')
|
||||
TestFlag('death_test_style', 'threadsafe', 'fast')
|
||||
TestFlag('catch_exceptions', '0', '1')
|
||||
|
||||
if IS_LINUX:
|
||||
TestFlag('death_test_use_fork', '1', '0')
|
||||
TestFlag('stack_trace_depth', '0', '100')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
gtest_test_utils.Main()
|
126
gtest/test/gtest_env_var_test_.cc
Normal file
126
gtest/test/gtest_env_var_test_.cc
Normal file
@ -0,0 +1,126 @@
|
||||
// Copyright 2008, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
// A helper program for testing that Google Test parses the environment
|
||||
// variables correctly.
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#define GTEST_IMPLEMENTATION_ 1
|
||||
#include "src/gtest-internal-inl.h"
|
||||
#undef GTEST_IMPLEMENTATION_
|
||||
|
||||
using ::std::cout;
|
||||
|
||||
namespace testing {
|
||||
|
||||
// The purpose of this is to make the test more realistic by ensuring
|
||||
// that the UnitTest singleton is created before main() is entered.
|
||||
// We don't actual run the TEST itself.
|
||||
TEST(GTestEnvVarTest, Dummy) {
|
||||
}
|
||||
|
||||
void PrintFlag(const char* flag) {
|
||||
if (strcmp(flag, "break_on_failure") == 0) {
|
||||
cout << GTEST_FLAG(break_on_failure);
|
||||
return;
|
||||
}
|
||||
|
||||
if (strcmp(flag, "catch_exceptions") == 0) {
|
||||
cout << GTEST_FLAG(catch_exceptions);
|
||||
return;
|
||||
}
|
||||
|
||||
if (strcmp(flag, "color") == 0) {
|
||||
cout << GTEST_FLAG(color);
|
||||
return;
|
||||
}
|
||||
|
||||
if (strcmp(flag, "death_test_style") == 0) {
|
||||
cout << GTEST_FLAG(death_test_style);
|
||||
return;
|
||||
}
|
||||
|
||||
if (strcmp(flag, "death_test_use_fork") == 0) {
|
||||
cout << GTEST_FLAG(death_test_use_fork);
|
||||
return;
|
||||
}
|
||||
|
||||
if (strcmp(flag, "filter") == 0) {
|
||||
cout << GTEST_FLAG(filter);
|
||||
return;
|
||||
}
|
||||
|
||||
if (strcmp(flag, "output") == 0) {
|
||||
cout << GTEST_FLAG(output);
|
||||
return;
|
||||
}
|
||||
|
||||
if (strcmp(flag, "print_time") == 0) {
|
||||
cout << GTEST_FLAG(print_time);
|
||||
return;
|
||||
}
|
||||
|
||||
if (strcmp(flag, "repeat") == 0) {
|
||||
cout << GTEST_FLAG(repeat);
|
||||
return;
|
||||
}
|
||||
|
||||
if (strcmp(flag, "stack_trace_depth") == 0) {
|
||||
cout << GTEST_FLAG(stack_trace_depth);
|
||||
return;
|
||||
}
|
||||
|
||||
if (strcmp(flag, "throw_on_failure") == 0) {
|
||||
cout << GTEST_FLAG(throw_on_failure);
|
||||
return;
|
||||
}
|
||||
|
||||
cout << "Invalid flag name " << flag
|
||||
<< ". Valid names are break_on_failure, color, filter, etc.\n";
|
||||
exit(1);
|
||||
}
|
||||
|
||||
} // namespace testing
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
testing::InitGoogleTest(&argc, argv);
|
||||
|
||||
if (argc != 2) {
|
||||
cout << "Usage: gtest_env_var_test_ NAME_OF_FLAG\n";
|
||||
return 1;
|
||||
}
|
||||
|
||||
testing::PrintFlag(argv[1]);
|
||||
return 0;
|
||||
}
|
191
gtest/test/gtest_environment_test.cc
Normal file
191
gtest/test/gtest_environment_test.cc
Normal file
@ -0,0 +1,191 @@
|
||||
// Copyright 2007, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
//
|
||||
// Tests using global test environments.
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#define GTEST_IMPLEMENTATION_ 1 // Required for the next #include.
|
||||
#include "src/gtest-internal-inl.h"
|
||||
#undef GTEST_IMPLEMENTATION_
|
||||
|
||||
namespace testing {
|
||||
GTEST_DECLARE_string_(filter);
|
||||
}
|
||||
|
||||
namespace {
|
||||
|
||||
enum FailureType {
|
||||
NO_FAILURE, NON_FATAL_FAILURE, FATAL_FAILURE
|
||||
};
|
||||
|
||||
// For testing using global test environments.
|
||||
class MyEnvironment : public testing::Environment {
|
||||
public:
|
||||
MyEnvironment() { Reset(); }
|
||||
|
||||
// Depending on the value of failure_in_set_up_, SetUp() will
|
||||
// generate a non-fatal failure, generate a fatal failure, or
|
||||
// succeed.
|
||||
virtual void SetUp() {
|
||||
set_up_was_run_ = true;
|
||||
|
||||
switch (failure_in_set_up_) {
|
||||
case NON_FATAL_FAILURE:
|
||||
ADD_FAILURE() << "Expected non-fatal failure in global set-up.";
|
||||
break;
|
||||
case FATAL_FAILURE:
|
||||
FAIL() << "Expected fatal failure in global set-up.";
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Generates a non-fatal failure.
|
||||
virtual void TearDown() {
|
||||
tear_down_was_run_ = true;
|
||||
ADD_FAILURE() << "Expected non-fatal failure in global tear-down.";
|
||||
}
|
||||
|
||||
// Resets the state of the environment s.t. it can be reused.
|
||||
void Reset() {
|
||||
failure_in_set_up_ = NO_FAILURE;
|
||||
set_up_was_run_ = false;
|
||||
tear_down_was_run_ = false;
|
||||
}
|
||||
|
||||
// We call this function to set the type of failure SetUp() should
|
||||
// generate.
|
||||
void set_failure_in_set_up(FailureType type) {
|
||||
failure_in_set_up_ = type;
|
||||
}
|
||||
|
||||
// Was SetUp() run?
|
||||
bool set_up_was_run() const { return set_up_was_run_; }
|
||||
|
||||
// Was TearDown() run?
|
||||
bool tear_down_was_run() const { return tear_down_was_run_; }
|
||||
private:
|
||||
FailureType failure_in_set_up_;
|
||||
bool set_up_was_run_;
|
||||
bool tear_down_was_run_;
|
||||
};
|
||||
|
||||
// Was the TEST run?
|
||||
bool test_was_run;
|
||||
|
||||
// The sole purpose of this TEST is to enable us to check whether it
|
||||
// was run.
|
||||
TEST(FooTest, Bar) {
|
||||
test_was_run = true;
|
||||
}
|
||||
|
||||
// Prints the message and aborts the program if condition is false.
|
||||
void Check(bool condition, const char* msg) {
|
||||
if (!condition) {
|
||||
printf("FAILED: %s\n", msg);
|
||||
testing::internal::posix::Abort();
|
||||
}
|
||||
}
|
||||
|
||||
// Runs the tests. Return true iff successful.
|
||||
//
|
||||
// The 'failure' parameter specifies the type of failure that should
|
||||
// be generated by the global set-up.
|
||||
int RunAllTests(MyEnvironment* env, FailureType failure) {
|
||||
env->Reset();
|
||||
env->set_failure_in_set_up(failure);
|
||||
test_was_run = false;
|
||||
testing::internal::GetUnitTestImpl()->ClearAdHocTestResult();
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
testing::InitGoogleTest(&argc, argv);
|
||||
|
||||
// Registers a global test environment, and verifies that the
|
||||
// registration function returns its argument.
|
||||
MyEnvironment* const env = new MyEnvironment;
|
||||
Check(testing::AddGlobalTestEnvironment(env) == env,
|
||||
"AddGlobalTestEnvironment() should return its argument.");
|
||||
|
||||
// Verifies that RUN_ALL_TESTS() runs the tests when the global
|
||||
// set-up is successful.
|
||||
Check(RunAllTests(env, NO_FAILURE) != 0,
|
||||
"RUN_ALL_TESTS() should return non-zero, as the global tear-down "
|
||||
"should generate a failure.");
|
||||
Check(test_was_run,
|
||||
"The tests should run, as the global set-up should generate no "
|
||||
"failure");
|
||||
Check(env->tear_down_was_run(),
|
||||
"The global tear-down should run, as the global set-up was run.");
|
||||
|
||||
// Verifies that RUN_ALL_TESTS() runs the tests when the global
|
||||
// set-up generates no fatal failure.
|
||||
Check(RunAllTests(env, NON_FATAL_FAILURE) != 0,
|
||||
"RUN_ALL_TESTS() should return non-zero, as both the global set-up "
|
||||
"and the global tear-down should generate a non-fatal failure.");
|
||||
Check(test_was_run,
|
||||
"The tests should run, as the global set-up should generate no "
|
||||
"fatal failure.");
|
||||
Check(env->tear_down_was_run(),
|
||||
"The global tear-down should run, as the global set-up was run.");
|
||||
|
||||
// Verifies that RUN_ALL_TESTS() runs no test when the global set-up
|
||||
// generates a fatal failure.
|
||||
Check(RunAllTests(env, FATAL_FAILURE) != 0,
|
||||
"RUN_ALL_TESTS() should return non-zero, as the global set-up "
|
||||
"should generate a fatal failure.");
|
||||
Check(!test_was_run,
|
||||
"The tests should not run, as the global set-up should generate "
|
||||
"a fatal failure.");
|
||||
Check(env->tear_down_was_run(),
|
||||
"The global tear-down should run, as the global set-up was run.");
|
||||
|
||||
// Verifies that RUN_ALL_TESTS() doesn't do global set-up or
|
||||
// tear-down when there is no test to run.
|
||||
testing::GTEST_FLAG(filter) = "-*";
|
||||
Check(RunAllTests(env, NO_FAILURE) == 0,
|
||||
"RUN_ALL_TESTS() should return zero, as there is no test to run.");
|
||||
Check(!env->set_up_was_run(),
|
||||
"The global set-up should not run, as there is no test to run.");
|
||||
Check(!env->tear_down_was_run(),
|
||||
"The global tear-down should not run, "
|
||||
"as the global set-up was not run.");
|
||||
|
||||
printf("PASS\n");
|
||||
return 0;
|
||||
}
|
633
gtest/test/gtest_filter_unittest.py
Executable file
633
gtest/test/gtest_filter_unittest.py
Executable file
@ -0,0 +1,633 @@
|
||||
#!/usr/bin/env python
|
||||
#
|
||||
# Copyright 2005 Google Inc. All Rights Reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are
|
||||
# met:
|
||||
#
|
||||
# * Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# * Redistributions in binary form must reproduce the above
|
||||
# copyright notice, this list of conditions and the following disclaimer
|
||||
# in the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
# * Neither the name of Google Inc. nor the names of its
|
||||
# contributors may be used to endorse or promote products derived from
|
||||
# this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
"""Unit test for Google Test test filters.
|
||||
|
||||
A user can specify which test(s) in a Google Test program to run via either
|
||||
the GTEST_FILTER environment variable or the --gtest_filter flag.
|
||||
This script tests such functionality by invoking
|
||||
gtest_filter_unittest_ (a program written with Google Test) with different
|
||||
environments and command line flags.
|
||||
|
||||
Note that test sharding may also influence which tests are filtered. Therefore,
|
||||
we test that here also.
|
||||
"""
|
||||
|
||||
__author__ = 'wan@google.com (Zhanyong Wan)'
|
||||
|
||||
import os
|
||||
import re
|
||||
import sets
|
||||
import sys
|
||||
|
||||
import gtest_test_utils
|
||||
|
||||
# Constants.
|
||||
|
||||
# Checks if this platform can pass empty environment variables to child
|
||||
# processes. We set an env variable to an empty string and invoke a python
|
||||
# script in a subprocess to print whether the variable is STILL in
|
||||
# os.environ. We then use 'eval' to parse the child's output so that an
|
||||
# exception is thrown if the input is anything other than 'True' nor 'False'.
|
||||
os.environ['EMPTY_VAR'] = ''
|
||||
child = gtest_test_utils.Subprocess(
|
||||
[sys.executable, '-c', 'import os; print \'EMPTY_VAR\' in os.environ'])
|
||||
CAN_PASS_EMPTY_ENV = eval(child.output)
|
||||
|
||||
|
||||
# Check if this platform can unset environment variables in child processes.
|
||||
# We set an env variable to a non-empty string, unset it, and invoke
|
||||
# a python script in a subprocess to print whether the variable
|
||||
# is NO LONGER in os.environ.
|
||||
# We use 'eval' to parse the child's output so that an exception
|
||||
# is thrown if the input is neither 'True' nor 'False'.
|
||||
os.environ['UNSET_VAR'] = 'X'
|
||||
del os.environ['UNSET_VAR']
|
||||
child = gtest_test_utils.Subprocess(
|
||||
[sys.executable, '-c', 'import os; print \'UNSET_VAR\' not in os.environ'])
|
||||
CAN_UNSET_ENV = eval(child.output)
|
||||
|
||||
|
||||
# Checks if we should test with an empty filter. This doesn't
|
||||
# make sense on platforms that cannot pass empty env variables (Win32)
|
||||
# and on platforms that cannot unset variables (since we cannot tell
|
||||
# the difference between "" and NULL -- Borland and Solaris < 5.10)
|
||||
CAN_TEST_EMPTY_FILTER = (CAN_PASS_EMPTY_ENV and CAN_UNSET_ENV)
|
||||
|
||||
|
||||
# The environment variable for specifying the test filters.
|
||||
FILTER_ENV_VAR = 'GTEST_FILTER'
|
||||
|
||||
# The environment variables for test sharding.
|
||||
TOTAL_SHARDS_ENV_VAR = 'GTEST_TOTAL_SHARDS'
|
||||
SHARD_INDEX_ENV_VAR = 'GTEST_SHARD_INDEX'
|
||||
SHARD_STATUS_FILE_ENV_VAR = 'GTEST_SHARD_STATUS_FILE'
|
||||
|
||||
# The command line flag for specifying the test filters.
|
||||
FILTER_FLAG = 'gtest_filter'
|
||||
|
||||
# The command line flag for including disabled tests.
|
||||
ALSO_RUN_DISABED_TESTS_FLAG = 'gtest_also_run_disabled_tests'
|
||||
|
||||
# Command to run the gtest_filter_unittest_ program.
|
||||
COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_filter_unittest_')
|
||||
|
||||
# Regex for determining whether parameterized tests are enabled in the binary.
|
||||
PARAM_TEST_REGEX = re.compile(r'/ParamTest')
|
||||
|
||||
# Regex for parsing test case names from Google Test's output.
|
||||
TEST_CASE_REGEX = re.compile(r'^\[\-+\] \d+ tests? from (\w+(/\w+)?)')
|
||||
|
||||
# Regex for parsing test names from Google Test's output.
|
||||
TEST_REGEX = re.compile(r'^\[\s*RUN\s*\].*\.(\w+(/\w+)?)')
|
||||
|
||||
# The command line flag to tell Google Test to output the list of tests it
|
||||
# will run.
|
||||
LIST_TESTS_FLAG = '--gtest_list_tests'
|
||||
|
||||
# Indicates whether Google Test supports death tests.
|
||||
SUPPORTS_DEATH_TESTS = 'HasDeathTest' in gtest_test_utils.Subprocess(
|
||||
[COMMAND, LIST_TESTS_FLAG]).output
|
||||
|
||||
# Full names of all tests in gtest_filter_unittests_.
|
||||
PARAM_TESTS = [
|
||||
'SeqP/ParamTest.TestX/0',
|
||||
'SeqP/ParamTest.TestX/1',
|
||||
'SeqP/ParamTest.TestY/0',
|
||||
'SeqP/ParamTest.TestY/1',
|
||||
'SeqQ/ParamTest.TestX/0',
|
||||
'SeqQ/ParamTest.TestX/1',
|
||||
'SeqQ/ParamTest.TestY/0',
|
||||
'SeqQ/ParamTest.TestY/1',
|
||||
]
|
||||
|
||||
DISABLED_TESTS = [
|
||||
'BarTest.DISABLED_TestFour',
|
||||
'BarTest.DISABLED_TestFive',
|
||||
'BazTest.DISABLED_TestC',
|
||||
'DISABLED_FoobarTest.Test1',
|
||||
'DISABLED_FoobarTest.DISABLED_Test2',
|
||||
'DISABLED_FoobarbazTest.TestA',
|
||||
]
|
||||
|
||||
if SUPPORTS_DEATH_TESTS:
|
||||
DEATH_TESTS = [
|
||||
'HasDeathTest.Test1',
|
||||
'HasDeathTest.Test2',
|
||||
]
|
||||
else:
|
||||
DEATH_TESTS = []
|
||||
|
||||
# All the non-disabled tests.
|
||||
ACTIVE_TESTS = [
|
||||
'FooTest.Abc',
|
||||
'FooTest.Xyz',
|
||||
|
||||
'BarTest.TestOne',
|
||||
'BarTest.TestTwo',
|
||||
'BarTest.TestThree',
|
||||
|
||||
'BazTest.TestOne',
|
||||
'BazTest.TestA',
|
||||
'BazTest.TestB',
|
||||
] + DEATH_TESTS + PARAM_TESTS
|
||||
|
||||
param_tests_present = None
|
||||
|
||||
# Utilities.
|
||||
|
||||
environ = os.environ.copy()
|
||||
|
||||
|
||||
def SetEnvVar(env_var, value):
|
||||
"""Sets the env variable to 'value'; unsets it when 'value' is None."""
|
||||
|
||||
if value is not None:
|
||||
environ[env_var] = value
|
||||
elif env_var in environ:
|
||||
del environ[env_var]
|
||||
|
||||
|
||||
def RunAndReturnOutput(args = None):
|
||||
"""Runs the test program and returns its output."""
|
||||
|
||||
return gtest_test_utils.Subprocess([COMMAND] + (args or []),
|
||||
env=environ).output
|
||||
|
||||
|
||||
def RunAndExtractTestList(args = None):
|
||||
"""Runs the test program and returns its exit code and a list of tests run."""
|
||||
|
||||
p = gtest_test_utils.Subprocess([COMMAND] + (args or []), env=environ)
|
||||
tests_run = []
|
||||
test_case = ''
|
||||
test = ''
|
||||
for line in p.output.split('\n'):
|
||||
match = TEST_CASE_REGEX.match(line)
|
||||
if match is not None:
|
||||
test_case = match.group(1)
|
||||
else:
|
||||
match = TEST_REGEX.match(line)
|
||||
if match is not None:
|
||||
test = match.group(1)
|
||||
tests_run.append(test_case + '.' + test)
|
||||
return (tests_run, p.exit_code)
|
||||
|
||||
|
||||
def InvokeWithModifiedEnv(extra_env, function, *args, **kwargs):
|
||||
"""Runs the given function and arguments in a modified environment."""
|
||||
try:
|
||||
original_env = environ.copy()
|
||||
environ.update(extra_env)
|
||||
return function(*args, **kwargs)
|
||||
finally:
|
||||
environ.clear()
|
||||
environ.update(original_env)
|
||||
|
||||
|
||||
def RunWithSharding(total_shards, shard_index, command):
|
||||
"""Runs a test program shard and returns exit code and a list of tests run."""
|
||||
|
||||
extra_env = {SHARD_INDEX_ENV_VAR: str(shard_index),
|
||||
TOTAL_SHARDS_ENV_VAR: str(total_shards)}
|
||||
return InvokeWithModifiedEnv(extra_env, RunAndExtractTestList, command)
|
||||
|
||||
# The unit test.
|
||||
|
||||
|
||||
class GTestFilterUnitTest(gtest_test_utils.TestCase):
|
||||
"""Tests the env variable or the command line flag to filter tests."""
|
||||
|
||||
# Utilities.
|
||||
|
||||
def AssertSetEqual(self, lhs, rhs):
|
||||
"""Asserts that two sets are equal."""
|
||||
|
||||
for elem in lhs:
|
||||
self.assert_(elem in rhs, '%s in %s' % (elem, rhs))
|
||||
|
||||
for elem in rhs:
|
||||
self.assert_(elem in lhs, '%s in %s' % (elem, lhs))
|
||||
|
||||
def AssertPartitionIsValid(self, set_var, list_of_sets):
|
||||
"""Asserts that list_of_sets is a valid partition of set_var."""
|
||||
|
||||
full_partition = []
|
||||
for slice_var in list_of_sets:
|
||||
full_partition.extend(slice_var)
|
||||
self.assertEqual(len(set_var), len(full_partition))
|
||||
self.assertEqual(sets.Set(set_var), sets.Set(full_partition))
|
||||
|
||||
def AdjustForParameterizedTests(self, tests_to_run):
|
||||
"""Adjust tests_to_run in case value parameterized tests are disabled."""
|
||||
|
||||
global param_tests_present
|
||||
if not param_tests_present:
|
||||
return list(sets.Set(tests_to_run) - sets.Set(PARAM_TESTS))
|
||||
else:
|
||||
return tests_to_run
|
||||
|
||||
def RunAndVerify(self, gtest_filter, tests_to_run):
|
||||
"""Checks that the binary runs correct set of tests for a given filter."""
|
||||
|
||||
tests_to_run = self.AdjustForParameterizedTests(tests_to_run)
|
||||
|
||||
# First, tests using the environment variable.
|
||||
|
||||
# Windows removes empty variables from the environment when passing it
|
||||
# to a new process. This means it is impossible to pass an empty filter
|
||||
# into a process using the environment variable. However, we can still
|
||||
# test the case when the variable is not supplied (i.e., gtest_filter is
|
||||
# None).
|
||||
# pylint: disable-msg=C6403
|
||||
if CAN_TEST_EMPTY_FILTER or gtest_filter != '':
|
||||
SetEnvVar(FILTER_ENV_VAR, gtest_filter)
|
||||
tests_run = RunAndExtractTestList()[0]
|
||||
SetEnvVar(FILTER_ENV_VAR, None)
|
||||
self.AssertSetEqual(tests_run, tests_to_run)
|
||||
# pylint: enable-msg=C6403
|
||||
|
||||
# Next, tests using the command line flag.
|
||||
|
||||
if gtest_filter is None:
|
||||
args = []
|
||||
else:
|
||||
args = ['--%s=%s' % (FILTER_FLAG, gtest_filter)]
|
||||
|
||||
tests_run = RunAndExtractTestList(args)[0]
|
||||
self.AssertSetEqual(tests_run, tests_to_run)
|
||||
|
||||
def RunAndVerifyWithSharding(self, gtest_filter, total_shards, tests_to_run,
|
||||
args=None, check_exit_0=False):
|
||||
"""Checks that binary runs correct tests for the given filter and shard.
|
||||
|
||||
Runs all shards of gtest_filter_unittest_ with the given filter, and
|
||||
verifies that the right set of tests were run. The union of tests run
|
||||
on each shard should be identical to tests_to_run, without duplicates.
|
||||
|
||||
Args:
|
||||
gtest_filter: A filter to apply to the tests.
|
||||
total_shards: A total number of shards to split test run into.
|
||||
tests_to_run: A set of tests expected to run.
|
||||
args : Arguments to pass to the to the test binary.
|
||||
check_exit_0: When set to a true value, make sure that all shards
|
||||
return 0.
|
||||
"""
|
||||
|
||||
tests_to_run = self.AdjustForParameterizedTests(tests_to_run)
|
||||
|
||||
# Windows removes empty variables from the environment when passing it
|
||||
# to a new process. This means it is impossible to pass an empty filter
|
||||
# into a process using the environment variable. However, we can still
|
||||
# test the case when the variable is not supplied (i.e., gtest_filter is
|
||||
# None).
|
||||
# pylint: disable-msg=C6403
|
||||
if CAN_TEST_EMPTY_FILTER or gtest_filter != '':
|
||||
SetEnvVar(FILTER_ENV_VAR, gtest_filter)
|
||||
partition = []
|
||||
for i in range(0, total_shards):
|
||||
(tests_run, exit_code) = RunWithSharding(total_shards, i, args)
|
||||
if check_exit_0:
|
||||
self.assertEqual(0, exit_code)
|
||||
partition.append(tests_run)
|
||||
|
||||
self.AssertPartitionIsValid(tests_to_run, partition)
|
||||
SetEnvVar(FILTER_ENV_VAR, None)
|
||||
# pylint: enable-msg=C6403
|
||||
|
||||
def RunAndVerifyAllowingDisabled(self, gtest_filter, tests_to_run):
|
||||
"""Checks that the binary runs correct set of tests for the given filter.
|
||||
|
||||
Runs gtest_filter_unittest_ with the given filter, and enables
|
||||
disabled tests. Verifies that the right set of tests were run.
|
||||
|
||||
Args:
|
||||
gtest_filter: A filter to apply to the tests.
|
||||
tests_to_run: A set of tests expected to run.
|
||||
"""
|
||||
|
||||
tests_to_run = self.AdjustForParameterizedTests(tests_to_run)
|
||||
|
||||
# Construct the command line.
|
||||
args = ['--%s' % ALSO_RUN_DISABED_TESTS_FLAG]
|
||||
if gtest_filter is not None:
|
||||
args.append('--%s=%s' % (FILTER_FLAG, gtest_filter))
|
||||
|
||||
tests_run = RunAndExtractTestList(args)[0]
|
||||
self.AssertSetEqual(tests_run, tests_to_run)
|
||||
|
||||
def setUp(self):
|
||||
"""Sets up test case.
|
||||
|
||||
Determines whether value-parameterized tests are enabled in the binary and
|
||||
sets the flags accordingly.
|
||||
"""
|
||||
|
||||
global param_tests_present
|
||||
if param_tests_present is None:
|
||||
param_tests_present = PARAM_TEST_REGEX.search(
|
||||
RunAndReturnOutput()) is not None
|
||||
|
||||
def testDefaultBehavior(self):
|
||||
"""Tests the behavior of not specifying the filter."""
|
||||
|
||||
self.RunAndVerify(None, ACTIVE_TESTS)
|
||||
|
||||
def testDefaultBehaviorWithShards(self):
|
||||
"""Tests the behavior without the filter, with sharding enabled."""
|
||||
|
||||
self.RunAndVerifyWithSharding(None, 1, ACTIVE_TESTS)
|
||||
self.RunAndVerifyWithSharding(None, 2, ACTIVE_TESTS)
|
||||
self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS) - 1, ACTIVE_TESTS)
|
||||
self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS), ACTIVE_TESTS)
|
||||
self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS) + 1, ACTIVE_TESTS)
|
||||
|
||||
def testEmptyFilter(self):
|
||||
"""Tests an empty filter."""
|
||||
|
||||
self.RunAndVerify('', [])
|
||||
self.RunAndVerifyWithSharding('', 1, [])
|
||||
self.RunAndVerifyWithSharding('', 2, [])
|
||||
|
||||
def testBadFilter(self):
|
||||
"""Tests a filter that matches nothing."""
|
||||
|
||||
self.RunAndVerify('BadFilter', [])
|
||||
self.RunAndVerifyAllowingDisabled('BadFilter', [])
|
||||
|
||||
def testFullName(self):
|
||||
"""Tests filtering by full name."""
|
||||
|
||||
self.RunAndVerify('FooTest.Xyz', ['FooTest.Xyz'])
|
||||
self.RunAndVerifyAllowingDisabled('FooTest.Xyz', ['FooTest.Xyz'])
|
||||
self.RunAndVerifyWithSharding('FooTest.Xyz', 5, ['FooTest.Xyz'])
|
||||
|
||||
def testUniversalFilters(self):
|
||||
"""Tests filters that match everything."""
|
||||
|
||||
self.RunAndVerify('*', ACTIVE_TESTS)
|
||||
self.RunAndVerify('*.*', ACTIVE_TESTS)
|
||||
self.RunAndVerifyWithSharding('*.*', len(ACTIVE_TESTS) - 3, ACTIVE_TESTS)
|
||||
self.RunAndVerifyAllowingDisabled('*', ACTIVE_TESTS + DISABLED_TESTS)
|
||||
self.RunAndVerifyAllowingDisabled('*.*', ACTIVE_TESTS + DISABLED_TESTS)
|
||||
|
||||
def testFilterByTestCase(self):
|
||||
"""Tests filtering by test case name."""
|
||||
|
||||
self.RunAndVerify('FooTest.*', ['FooTest.Abc', 'FooTest.Xyz'])
|
||||
|
||||
BAZ_TESTS = ['BazTest.TestOne', 'BazTest.TestA', 'BazTest.TestB']
|
||||
self.RunAndVerify('BazTest.*', BAZ_TESTS)
|
||||
self.RunAndVerifyAllowingDisabled('BazTest.*',
|
||||
BAZ_TESTS + ['BazTest.DISABLED_TestC'])
|
||||
|
||||
def testFilterByTest(self):
|
||||
"""Tests filtering by test name."""
|
||||
|
||||
self.RunAndVerify('*.TestOne', ['BarTest.TestOne', 'BazTest.TestOne'])
|
||||
|
||||
def testFilterDisabledTests(self):
|
||||
"""Select only the disabled tests to run."""
|
||||
|
||||
self.RunAndVerify('DISABLED_FoobarTest.Test1', [])
|
||||
self.RunAndVerifyAllowingDisabled('DISABLED_FoobarTest.Test1',
|
||||
['DISABLED_FoobarTest.Test1'])
|
||||
|
||||
self.RunAndVerify('*DISABLED_*', [])
|
||||
self.RunAndVerifyAllowingDisabled('*DISABLED_*', DISABLED_TESTS)
|
||||
|
||||
self.RunAndVerify('*.DISABLED_*', [])
|
||||
self.RunAndVerifyAllowingDisabled('*.DISABLED_*', [
|
||||
'BarTest.DISABLED_TestFour',
|
||||
'BarTest.DISABLED_TestFive',
|
||||
'BazTest.DISABLED_TestC',
|
||||
'DISABLED_FoobarTest.DISABLED_Test2',
|
||||
])
|
||||
|
||||
self.RunAndVerify('DISABLED_*', [])
|
||||
self.RunAndVerifyAllowingDisabled('DISABLED_*', [
|
||||
'DISABLED_FoobarTest.Test1',
|
||||
'DISABLED_FoobarTest.DISABLED_Test2',
|
||||
'DISABLED_FoobarbazTest.TestA',
|
||||
])
|
||||
|
||||
def testWildcardInTestCaseName(self):
|
||||
"""Tests using wildcard in the test case name."""
|
||||
|
||||
self.RunAndVerify('*a*.*', [
|
||||
'BarTest.TestOne',
|
||||
'BarTest.TestTwo',
|
||||
'BarTest.TestThree',
|
||||
|
||||
'BazTest.TestOne',
|
||||
'BazTest.TestA',
|
||||
'BazTest.TestB', ] + DEATH_TESTS + PARAM_TESTS)
|
||||
|
||||
def testWildcardInTestName(self):
|
||||
"""Tests using wildcard in the test name."""
|
||||
|
||||
self.RunAndVerify('*.*A*', ['FooTest.Abc', 'BazTest.TestA'])
|
||||
|
||||
def testFilterWithoutDot(self):
|
||||
"""Tests a filter that has no '.' in it."""
|
||||
|
||||
self.RunAndVerify('*z*', [
|
||||
'FooTest.Xyz',
|
||||
|
||||
'BazTest.TestOne',
|
||||
'BazTest.TestA',
|
||||
'BazTest.TestB',
|
||||
])
|
||||
|
||||
def testTwoPatterns(self):
|
||||
"""Tests filters that consist of two patterns."""
|
||||
|
||||
self.RunAndVerify('Foo*.*:*A*', [
|
||||
'FooTest.Abc',
|
||||
'FooTest.Xyz',
|
||||
|
||||
'BazTest.TestA',
|
||||
])
|
||||
|
||||
# An empty pattern + a non-empty one
|
||||
self.RunAndVerify(':*A*', ['FooTest.Abc', 'BazTest.TestA'])
|
||||
|
||||
def testThreePatterns(self):
|
||||
"""Tests filters that consist of three patterns."""
|
||||
|
||||
self.RunAndVerify('*oo*:*A*:*One', [
|
||||
'FooTest.Abc',
|
||||
'FooTest.Xyz',
|
||||
|
||||
'BarTest.TestOne',
|
||||
|
||||
'BazTest.TestOne',
|
||||
'BazTest.TestA',
|
||||
])
|
||||
|
||||
# The 2nd pattern is empty.
|
||||
self.RunAndVerify('*oo*::*One', [
|
||||
'FooTest.Abc',
|
||||
'FooTest.Xyz',
|
||||
|
||||
'BarTest.TestOne',
|
||||
|
||||
'BazTest.TestOne',
|
||||
])
|
||||
|
||||
# The last 2 patterns are empty.
|
||||
self.RunAndVerify('*oo*::', [
|
||||
'FooTest.Abc',
|
||||
'FooTest.Xyz',
|
||||
])
|
||||
|
||||
def testNegativeFilters(self):
|
||||
self.RunAndVerify('*-BazTest.TestOne', [
|
||||
'FooTest.Abc',
|
||||
'FooTest.Xyz',
|
||||
|
||||
'BarTest.TestOne',
|
||||
'BarTest.TestTwo',
|
||||
'BarTest.TestThree',
|
||||
|
||||
'BazTest.TestA',
|
||||
'BazTest.TestB',
|
||||
] + DEATH_TESTS + PARAM_TESTS)
|
||||
|
||||
self.RunAndVerify('*-FooTest.Abc:BazTest.*', [
|
||||
'FooTest.Xyz',
|
||||
|
||||
'BarTest.TestOne',
|
||||
'BarTest.TestTwo',
|
||||
'BarTest.TestThree',
|
||||
] + DEATH_TESTS + PARAM_TESTS)
|
||||
|
||||
self.RunAndVerify('BarTest.*-BarTest.TestOne', [
|
||||
'BarTest.TestTwo',
|
||||
'BarTest.TestThree',
|
||||
])
|
||||
|
||||
# Tests without leading '*'.
|
||||
self.RunAndVerify('-FooTest.Abc:FooTest.Xyz:BazTest.*', [
|
||||
'BarTest.TestOne',
|
||||
'BarTest.TestTwo',
|
||||
'BarTest.TestThree',
|
||||
] + DEATH_TESTS + PARAM_TESTS)
|
||||
|
||||
# Value parameterized tests.
|
||||
self.RunAndVerify('*/*', PARAM_TESTS)
|
||||
|
||||
# Value parameterized tests filtering by the sequence name.
|
||||
self.RunAndVerify('SeqP/*', [
|
||||
'SeqP/ParamTest.TestX/0',
|
||||
'SeqP/ParamTest.TestX/1',
|
||||
'SeqP/ParamTest.TestY/0',
|
||||
'SeqP/ParamTest.TestY/1',
|
||||
])
|
||||
|
||||
# Value parameterized tests filtering by the test name.
|
||||
self.RunAndVerify('*/0', [
|
||||
'SeqP/ParamTest.TestX/0',
|
||||
'SeqP/ParamTest.TestY/0',
|
||||
'SeqQ/ParamTest.TestX/0',
|
||||
'SeqQ/ParamTest.TestY/0',
|
||||
])
|
||||
|
||||
def testFlagOverridesEnvVar(self):
|
||||
"""Tests that the filter flag overrides the filtering env. variable."""
|
||||
|
||||
SetEnvVar(FILTER_ENV_VAR, 'Foo*')
|
||||
args = ['--%s=%s' % (FILTER_FLAG, '*One')]
|
||||
tests_run = RunAndExtractTestList(args)[0]
|
||||
SetEnvVar(FILTER_ENV_VAR, None)
|
||||
|
||||
self.AssertSetEqual(tests_run, ['BarTest.TestOne', 'BazTest.TestOne'])
|
||||
|
||||
def testShardStatusFileIsCreated(self):
|
||||
"""Tests that the shard file is created if specified in the environment."""
|
||||
|
||||
shard_status_file = os.path.join(gtest_test_utils.GetTempDir(),
|
||||
'shard_status_file')
|
||||
self.assert_(not os.path.exists(shard_status_file))
|
||||
|
||||
extra_env = {SHARD_STATUS_FILE_ENV_VAR: shard_status_file}
|
||||
try:
|
||||
InvokeWithModifiedEnv(extra_env, RunAndReturnOutput)
|
||||
finally:
|
||||
self.assert_(os.path.exists(shard_status_file))
|
||||
os.remove(shard_status_file)
|
||||
|
||||
def testShardStatusFileIsCreatedWithListTests(self):
|
||||
"""Tests that the shard file is created with the "list_tests" flag."""
|
||||
|
||||
shard_status_file = os.path.join(gtest_test_utils.GetTempDir(),
|
||||
'shard_status_file2')
|
||||
self.assert_(not os.path.exists(shard_status_file))
|
||||
|
||||
extra_env = {SHARD_STATUS_FILE_ENV_VAR: shard_status_file}
|
||||
try:
|
||||
output = InvokeWithModifiedEnv(extra_env,
|
||||
RunAndReturnOutput,
|
||||
[LIST_TESTS_FLAG])
|
||||
finally:
|
||||
# This assertion ensures that Google Test enumerated the tests as
|
||||
# opposed to running them.
|
||||
self.assert_('[==========]' not in output,
|
||||
'Unexpected output during test enumeration.\n'
|
||||
'Please ensure that LIST_TESTS_FLAG is assigned the\n'
|
||||
'correct flag value for listing Google Test tests.')
|
||||
|
||||
self.assert_(os.path.exists(shard_status_file))
|
||||
os.remove(shard_status_file)
|
||||
|
||||
if SUPPORTS_DEATH_TESTS:
|
||||
def testShardingWorksWithDeathTests(self):
|
||||
"""Tests integration with death tests and sharding."""
|
||||
|
||||
gtest_filter = 'HasDeathTest.*:SeqP/*'
|
||||
expected_tests = [
|
||||
'HasDeathTest.Test1',
|
||||
'HasDeathTest.Test2',
|
||||
|
||||
'SeqP/ParamTest.TestX/0',
|
||||
'SeqP/ParamTest.TestX/1',
|
||||
'SeqP/ParamTest.TestY/0',
|
||||
'SeqP/ParamTest.TestY/1',
|
||||
]
|
||||
|
||||
for flag in ['--gtest_death_test_style=threadsafe',
|
||||
'--gtest_death_test_style=fast']:
|
||||
self.RunAndVerifyWithSharding(gtest_filter, 3, expected_tests,
|
||||
check_exit_0=True, args=[flag])
|
||||
self.RunAndVerifyWithSharding(gtest_filter, 5, expected_tests,
|
||||
check_exit_0=True, args=[flag])
|
||||
|
||||
if __name__ == '__main__':
|
||||
gtest_test_utils.Main()
|
140
gtest/test/gtest_filter_unittest_.cc
Normal file
140
gtest/test/gtest_filter_unittest_.cc
Normal file
@ -0,0 +1,140 @@
|
||||
// Copyright 2005, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
// Unit test for Google Test test filters.
|
||||
//
|
||||
// A user can specify which test(s) in a Google Test program to run via
|
||||
// either the GTEST_FILTER environment variable or the --gtest_filter
|
||||
// flag. This is used for testing such functionality.
|
||||
//
|
||||
// The program will be invoked from a Python unit test. Don't run it
|
||||
// directly.
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
namespace {
|
||||
|
||||
// Test case FooTest.
|
||||
|
||||
class FooTest : public testing::Test {
|
||||
};
|
||||
|
||||
TEST_F(FooTest, Abc) {
|
||||
}
|
||||
|
||||
TEST_F(FooTest, Xyz) {
|
||||
FAIL() << "Expected failure.";
|
||||
}
|
||||
|
||||
// Test case BarTest.
|
||||
|
||||
TEST(BarTest, TestOne) {
|
||||
}
|
||||
|
||||
TEST(BarTest, TestTwo) {
|
||||
}
|
||||
|
||||
TEST(BarTest, TestThree) {
|
||||
}
|
||||
|
||||
TEST(BarTest, DISABLED_TestFour) {
|
||||
FAIL() << "Expected failure.";
|
||||
}
|
||||
|
||||
TEST(BarTest, DISABLED_TestFive) {
|
||||
FAIL() << "Expected failure.";
|
||||
}
|
||||
|
||||
// Test case BazTest.
|
||||
|
||||
TEST(BazTest, TestOne) {
|
||||
FAIL() << "Expected failure.";
|
||||
}
|
||||
|
||||
TEST(BazTest, TestA) {
|
||||
}
|
||||
|
||||
TEST(BazTest, TestB) {
|
||||
}
|
||||
|
||||
TEST(BazTest, DISABLED_TestC) {
|
||||
FAIL() << "Expected failure.";
|
||||
}
|
||||
|
||||
// Test case HasDeathTest
|
||||
|
||||
TEST(HasDeathTest, Test1) {
|
||||
EXPECT_DEATH_IF_SUPPORTED(exit(1), ".*");
|
||||
}
|
||||
|
||||
// We need at least two death tests to make sure that the all death tests
|
||||
// aren't on the first shard.
|
||||
TEST(HasDeathTest, Test2) {
|
||||
EXPECT_DEATH_IF_SUPPORTED(exit(1), ".*");
|
||||
}
|
||||
|
||||
// Test case FoobarTest
|
||||
|
||||
TEST(DISABLED_FoobarTest, Test1) {
|
||||
FAIL() << "Expected failure.";
|
||||
}
|
||||
|
||||
TEST(DISABLED_FoobarTest, DISABLED_Test2) {
|
||||
FAIL() << "Expected failure.";
|
||||
}
|
||||
|
||||
// Test case FoobarbazTest
|
||||
|
||||
TEST(DISABLED_FoobarbazTest, TestA) {
|
||||
FAIL() << "Expected failure.";
|
||||
}
|
||||
|
||||
#if GTEST_HAS_PARAM_TEST
|
||||
class ParamTest : public testing::TestWithParam<int> {
|
||||
};
|
||||
|
||||
TEST_P(ParamTest, TestX) {
|
||||
}
|
||||
|
||||
TEST_P(ParamTest, TestY) {
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SeqP, ParamTest, testing::Values(1, 2));
|
||||
INSTANTIATE_TEST_CASE_P(SeqQ, ParamTest, testing::Values(5, 6));
|
||||
#endif // GTEST_HAS_PARAM_TEST
|
||||
|
||||
} // namespace
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
172
gtest/test/gtest_help_test.py
Executable file
172
gtest/test/gtest_help_test.py
Executable file
@ -0,0 +1,172 @@
|
||||
#!/usr/bin/env python
|
||||
#
|
||||
# Copyright 2009, Google Inc.
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are
|
||||
# met:
|
||||
#
|
||||
# * Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# * Redistributions in binary form must reproduce the above
|
||||
# copyright notice, this list of conditions and the following disclaimer
|
||||
# in the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
# * Neither the name of Google Inc. nor the names of its
|
||||
# contributors may be used to endorse or promote products derived from
|
||||
# this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
"""Tests the --help flag of Google C++ Testing Framework.
|
||||
|
||||
SYNOPSIS
|
||||
gtest_help_test.py --build_dir=BUILD/DIR
|
||||
# where BUILD/DIR contains the built gtest_help_test_ file.
|
||||
gtest_help_test.py
|
||||
"""
|
||||
|
||||
__author__ = 'wan@google.com (Zhanyong Wan)'
|
||||
|
||||
import os
|
||||
import re
|
||||
import gtest_test_utils
|
||||
|
||||
|
||||
IS_LINUX = os.name == 'posix' and os.uname()[0] == 'Linux'
|
||||
IS_WINDOWS = os.name == 'nt'
|
||||
|
||||
PROGRAM_PATH = gtest_test_utils.GetTestExecutablePath('gtest_help_test_')
|
||||
FLAG_PREFIX = '--gtest_'
|
||||
DEATH_TEST_STYLE_FLAG = FLAG_PREFIX + 'death_test_style'
|
||||
STREAM_RESULT_TO_FLAG = FLAG_PREFIX + 'stream_result_to'
|
||||
UNKNOWN_FLAG = FLAG_PREFIX + 'unknown_flag_for_testing'
|
||||
LIST_TESTS_FLAG = FLAG_PREFIX + 'list_tests'
|
||||
INCORRECT_FLAG_VARIANTS = [re.sub('^--', '-', LIST_TESTS_FLAG),
|
||||
re.sub('^--', '/', LIST_TESTS_FLAG),
|
||||
re.sub('_', '-', LIST_TESTS_FLAG)]
|
||||
INTERNAL_FLAG_FOR_TESTING = FLAG_PREFIX + 'internal_flag_for_testing'
|
||||
|
||||
SUPPORTS_DEATH_TESTS = "DeathTest" in gtest_test_utils.Subprocess(
|
||||
[PROGRAM_PATH, LIST_TESTS_FLAG]).output
|
||||
|
||||
# The help message must match this regex.
|
||||
HELP_REGEX = re.compile(
|
||||
FLAG_PREFIX + r'list_tests.*' +
|
||||
FLAG_PREFIX + r'filter=.*' +
|
||||
FLAG_PREFIX + r'also_run_disabled_tests.*' +
|
||||
FLAG_PREFIX + r'repeat=.*' +
|
||||
FLAG_PREFIX + r'shuffle.*' +
|
||||
FLAG_PREFIX + r'random_seed=.*' +
|
||||
FLAG_PREFIX + r'color=.*' +
|
||||
FLAG_PREFIX + r'print_time.*' +
|
||||
FLAG_PREFIX + r'output=.*' +
|
||||
FLAG_PREFIX + r'break_on_failure.*' +
|
||||
FLAG_PREFIX + r'throw_on_failure.*' +
|
||||
FLAG_PREFIX + r'catch_exceptions=0.*',
|
||||
re.DOTALL)
|
||||
|
||||
|
||||
def RunWithFlag(flag):
|
||||
"""Runs gtest_help_test_ with the given flag.
|
||||
|
||||
Returns:
|
||||
the exit code and the text output as a tuple.
|
||||
Args:
|
||||
flag: the command-line flag to pass to gtest_help_test_, or None.
|
||||
"""
|
||||
|
||||
if flag is None:
|
||||
command = [PROGRAM_PATH]
|
||||
else:
|
||||
command = [PROGRAM_PATH, flag]
|
||||
child = gtest_test_utils.Subprocess(command)
|
||||
return child.exit_code, child.output
|
||||
|
||||
|
||||
class GTestHelpTest(gtest_test_utils.TestCase):
|
||||
"""Tests the --help flag and its equivalent forms."""
|
||||
|
||||
def TestHelpFlag(self, flag):
|
||||
"""Verifies correct behavior when help flag is specified.
|
||||
|
||||
The right message must be printed and the tests must
|
||||
skipped when the given flag is specified.
|
||||
|
||||
Args:
|
||||
flag: A flag to pass to the binary or None.
|
||||
"""
|
||||
|
||||
exit_code, output = RunWithFlag(flag)
|
||||
self.assertEquals(0, exit_code)
|
||||
self.assert_(HELP_REGEX.search(output), output)
|
||||
|
||||
if IS_LINUX:
|
||||
self.assert_(STREAM_RESULT_TO_FLAG in output, output)
|
||||
else:
|
||||
self.assert_(STREAM_RESULT_TO_FLAG not in output, output)
|
||||
|
||||
if SUPPORTS_DEATH_TESTS and not IS_WINDOWS:
|
||||
self.assert_(DEATH_TEST_STYLE_FLAG in output, output)
|
||||
else:
|
||||
self.assert_(DEATH_TEST_STYLE_FLAG not in output, output)
|
||||
|
||||
def TestNonHelpFlag(self, flag):
|
||||
"""Verifies correct behavior when no help flag is specified.
|
||||
|
||||
Verifies that when no help flag is specified, the tests are run
|
||||
and the help message is not printed.
|
||||
|
||||
Args:
|
||||
flag: A flag to pass to the binary or None.
|
||||
"""
|
||||
|
||||
exit_code, output = RunWithFlag(flag)
|
||||
self.assert_(exit_code != 0)
|
||||
self.assert_(not HELP_REGEX.search(output), output)
|
||||
|
||||
def testPrintsHelpWithFullFlag(self):
|
||||
self.TestHelpFlag('--help')
|
||||
|
||||
def testPrintsHelpWithShortFlag(self):
|
||||
self.TestHelpFlag('-h')
|
||||
|
||||
def testPrintsHelpWithQuestionFlag(self):
|
||||
self.TestHelpFlag('-?')
|
||||
|
||||
def testPrintsHelpWithWindowsStyleQuestionFlag(self):
|
||||
self.TestHelpFlag('/?')
|
||||
|
||||
def testPrintsHelpWithUnrecognizedGoogleTestFlag(self):
|
||||
self.TestHelpFlag(UNKNOWN_FLAG)
|
||||
|
||||
def testPrintsHelpWithIncorrectFlagStyle(self):
|
||||
for incorrect_flag in INCORRECT_FLAG_VARIANTS:
|
||||
self.TestHelpFlag(incorrect_flag)
|
||||
|
||||
def testRunsTestsWithoutHelpFlag(self):
|
||||
"""Verifies that when no help flag is specified, the tests are run
|
||||
and the help message is not printed."""
|
||||
|
||||
self.TestNonHelpFlag(None)
|
||||
|
||||
def testRunsTestsWithGtestInternalFlag(self):
|
||||
"""Verifies that the tests are run and no help message is printed when
|
||||
a flag starting with Google Test prefix and 'internal_' is supplied."""
|
||||
|
||||
self.TestNonHelpFlag(INTERNAL_FLAG_FOR_TESTING)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
gtest_test_utils.Main()
|
46
gtest/test/gtest_help_test_.cc
Normal file
46
gtest/test/gtest_help_test_.cc
Normal file
@ -0,0 +1,46 @@
|
||||
// Copyright 2009, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
// This program is meant to be run by gtest_help_test.py. Do not run
|
||||
// it directly.
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
// When a help flag is specified, this program should skip the tests
|
||||
// and exit with 0; otherwise the following test will be executed,
|
||||
// causing this program to exit with a non-zero code.
|
||||
TEST(HelpFlagTest, ShouldNotBeRun) {
|
||||
ASSERT_TRUE(false) << "Tests shouldn't be run when --help is specified.";
|
||||
}
|
||||
|
||||
#if GTEST_HAS_DEATH_TEST
|
||||
TEST(DeathTest, UsedByPythonScriptToDetectSupportForDeathTestsInThisBinary) {}
|
||||
#endif
|
177
gtest/test/gtest_list_tests_unittest.py
Executable file
177
gtest/test/gtest_list_tests_unittest.py
Executable file
@ -0,0 +1,177 @@
|
||||
#!/usr/bin/env python
|
||||
#
|
||||
# Copyright 2006, Google Inc.
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are
|
||||
# met:
|
||||
#
|
||||
# * Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# * Redistributions in binary form must reproduce the above
|
||||
# copyright notice, this list of conditions and the following disclaimer
|
||||
# in the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
# * Neither the name of Google Inc. nor the names of its
|
||||
# contributors may be used to endorse or promote products derived from
|
||||
# this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
"""Unit test for Google Test's --gtest_list_tests flag.
|
||||
|
||||
A user can ask Google Test to list all tests by specifying the
|
||||
--gtest_list_tests flag. This script tests such functionality
|
||||
by invoking gtest_list_tests_unittest_ (a program written with
|
||||
Google Test) the command line flags.
|
||||
"""
|
||||
|
||||
__author__ = 'phanna@google.com (Patrick Hanna)'
|
||||
|
||||
import gtest_test_utils
|
||||
|
||||
|
||||
# Constants.
|
||||
|
||||
# The command line flag for enabling/disabling listing all tests.
|
||||
LIST_TESTS_FLAG = 'gtest_list_tests'
|
||||
|
||||
# Path to the gtest_list_tests_unittest_ program.
|
||||
EXE_PATH = gtest_test_utils.GetTestExecutablePath('gtest_list_tests_unittest_')
|
||||
|
||||
# The expected output when running gtest_list_tests_unittest_ with
|
||||
# --gtest_list_tests
|
||||
EXPECTED_OUTPUT_NO_FILTER = """FooDeathTest.
|
||||
Test1
|
||||
Foo.
|
||||
Bar1
|
||||
Bar2
|
||||
DISABLED_Bar3
|
||||
Abc.
|
||||
Xyz
|
||||
Def
|
||||
FooBar.
|
||||
Baz
|
||||
FooTest.
|
||||
Test1
|
||||
DISABLED_Test2
|
||||
Test3
|
||||
"""
|
||||
|
||||
# The expected output when running gtest_list_tests_unittest_ with
|
||||
# --gtest_list_tests and --gtest_filter=Foo*.
|
||||
EXPECTED_OUTPUT_FILTER_FOO = """FooDeathTest.
|
||||
Test1
|
||||
Foo.
|
||||
Bar1
|
||||
Bar2
|
||||
DISABLED_Bar3
|
||||
FooBar.
|
||||
Baz
|
||||
FooTest.
|
||||
Test1
|
||||
DISABLED_Test2
|
||||
Test3
|
||||
"""
|
||||
|
||||
# Utilities.
|
||||
|
||||
|
||||
def Run(args):
|
||||
"""Runs gtest_list_tests_unittest_ and returns the list of tests printed."""
|
||||
|
||||
return gtest_test_utils.Subprocess([EXE_PATH] + args,
|
||||
capture_stderr=False).output
|
||||
|
||||
|
||||
# The unit test.
|
||||
|
||||
class GTestListTestsUnitTest(gtest_test_utils.TestCase):
|
||||
"""Tests using the --gtest_list_tests flag to list all tests."""
|
||||
|
||||
def RunAndVerify(self, flag_value, expected_output, other_flag):
|
||||
"""Runs gtest_list_tests_unittest_ and verifies that it prints
|
||||
the correct tests.
|
||||
|
||||
Args:
|
||||
flag_value: value of the --gtest_list_tests flag;
|
||||
None if the flag should not be present.
|
||||
|
||||
expected_output: the expected output after running command;
|
||||
|
||||
other_flag: a different flag to be passed to command
|
||||
along with gtest_list_tests;
|
||||
None if the flag should not be present.
|
||||
"""
|
||||
|
||||
if flag_value is None:
|
||||
flag = ''
|
||||
flag_expression = 'not set'
|
||||
elif flag_value == '0':
|
||||
flag = '--%s=0' % LIST_TESTS_FLAG
|
||||
flag_expression = '0'
|
||||
else:
|
||||
flag = '--%s' % LIST_TESTS_FLAG
|
||||
flag_expression = '1'
|
||||
|
||||
args = [flag]
|
||||
|
||||
if other_flag is not None:
|
||||
args += [other_flag]
|
||||
|
||||
output = Run(args)
|
||||
|
||||
msg = ('when %s is %s, the output of "%s" is "%s".' %
|
||||
(LIST_TESTS_FLAG, flag_expression, ' '.join(args), output))
|
||||
|
||||
if expected_output is not None:
|
||||
self.assert_(output == expected_output, msg)
|
||||
else:
|
||||
self.assert_(output != EXPECTED_OUTPUT_NO_FILTER, msg)
|
||||
|
||||
def testDefaultBehavior(self):
|
||||
"""Tests the behavior of the default mode."""
|
||||
|
||||
self.RunAndVerify(flag_value=None,
|
||||
expected_output=None,
|
||||
other_flag=None)
|
||||
|
||||
def testFlag(self):
|
||||
"""Tests using the --gtest_list_tests flag."""
|
||||
|
||||
self.RunAndVerify(flag_value='0',
|
||||
expected_output=None,
|
||||
other_flag=None)
|
||||
self.RunAndVerify(flag_value='1',
|
||||
expected_output=EXPECTED_OUTPUT_NO_FILTER,
|
||||
other_flag=None)
|
||||
|
||||
def testOverrideNonFilterFlags(self):
|
||||
"""Tests that --gtest_list_tests overrides the non-filter flags."""
|
||||
|
||||
self.RunAndVerify(flag_value='1',
|
||||
expected_output=EXPECTED_OUTPUT_NO_FILTER,
|
||||
other_flag='--gtest_break_on_failure')
|
||||
|
||||
def testWithFilterFlags(self):
|
||||
"""Tests that --gtest_list_tests takes into account the
|
||||
--gtest_filter flag."""
|
||||
|
||||
self.RunAndVerify(flag_value='1',
|
||||
expected_output=EXPECTED_OUTPUT_FILTER_FOO,
|
||||
other_flag='--gtest_filter=Foo*')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
gtest_test_utils.Main()
|
85
gtest/test/gtest_list_tests_unittest_.cc
Normal file
85
gtest/test/gtest_list_tests_unittest_.cc
Normal file
@ -0,0 +1,85 @@
|
||||
// Copyright 2006, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: phanna@google.com (Patrick Hanna)
|
||||
|
||||
// Unit test for Google Test's --gtest_list_tests flag.
|
||||
//
|
||||
// A user can ask Google Test to list all tests that will run
|
||||
// so that when using a filter, a user will know what
|
||||
// tests to look for. The tests will not be run after listing.
|
||||
//
|
||||
// This program will be invoked from a Python unit test.
|
||||
// Don't run it directly.
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
namespace {
|
||||
|
||||
// Several different test cases and tests that will be listed.
|
||||
TEST(Foo, Bar1) {
|
||||
}
|
||||
|
||||
TEST(Foo, Bar2) {
|
||||
}
|
||||
|
||||
TEST(Foo, DISABLED_Bar3) {
|
||||
}
|
||||
|
||||
TEST(Abc, Xyz) {
|
||||
}
|
||||
|
||||
TEST(Abc, Def) {
|
||||
}
|
||||
|
||||
TEST(FooBar, Baz) {
|
||||
}
|
||||
|
||||
class FooTest : public testing::Test {
|
||||
};
|
||||
|
||||
TEST_F(FooTest, Test1) {
|
||||
}
|
||||
|
||||
TEST_F(FooTest, DISABLED_Test2) {
|
||||
}
|
||||
|
||||
TEST_F(FooTest, Test3) {
|
||||
}
|
||||
|
||||
TEST(FooDeathTest, Test1) {
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
45
gtest/test/gtest_main_unittest.cc
Normal file
45
gtest/test/gtest_main_unittest.cc
Normal file
@ -0,0 +1,45 @@
|
||||
// Copyright 2006, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
// Tests that we don't have to define main() when we link to
|
||||
// gtest_main instead of gtest.
|
||||
|
||||
namespace {
|
||||
|
||||
TEST(GTestMainTest, ShouldSucceed) {
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
// We are using the main() function defined in src/gtest_main.cc, so
|
||||
// we don't define it here.
|
57
gtest/test/gtest_no_test_unittest.cc
Normal file
57
gtest/test/gtest_no_test_unittest.cc
Normal file
@ -0,0 +1,57 @@
|
||||
// Copyright 2006, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
// Tests that a Google Test program that has no test defined can run
|
||||
// successfully.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
testing::InitGoogleTest(&argc, argv);
|
||||
|
||||
// An ad-hoc assertion outside of all tests.
|
||||
//
|
||||
// This serves three purposes:
|
||||
//
|
||||
// 1. It verifies that an ad-hoc assertion can be executed even if
|
||||
// no test is defined.
|
||||
// 2. It verifies that a failed ad-hoc assertion causes the test
|
||||
// program to fail.
|
||||
// 3. We had a bug where the XML output won't be generated if an
|
||||
// assertion is executed before RUN_ALL_TESTS() is called, even
|
||||
// though --gtest_output=xml is specified. This makes sure the
|
||||
// bug is fixed and doesn't regress.
|
||||
EXPECT_EQ(1, 2);
|
||||
|
||||
// The above EXPECT_EQ() should cause RUN_ALL_TESTS() to return non-zero.
|
||||
return RUN_ALL_TESTS() ? 0 : 1;
|
||||
}
|
335
gtest/test/gtest_output_test.py
Executable file
335
gtest/test/gtest_output_test.py
Executable file
@ -0,0 +1,335 @@
|
||||
#!/usr/bin/env python
|
||||
#
|
||||
# Copyright 2008, Google Inc.
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are
|
||||
# met:
|
||||
#
|
||||
# * Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# * Redistributions in binary form must reproduce the above
|
||||
# copyright notice, this list of conditions and the following disclaimer
|
||||
# in the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
# * Neither the name of Google Inc. nor the names of its
|
||||
# contributors may be used to endorse or promote products derived from
|
||||
# this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
"""Tests the text output of Google C++ Testing Framework.
|
||||
|
||||
SYNOPSIS
|
||||
gtest_output_test.py --build_dir=BUILD/DIR --gengolden
|
||||
# where BUILD/DIR contains the built gtest_output_test_ file.
|
||||
gtest_output_test.py --gengolden
|
||||
gtest_output_test.py
|
||||
"""
|
||||
|
||||
__author__ = 'wan@google.com (Zhanyong Wan)'
|
||||
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
import gtest_test_utils
|
||||
|
||||
|
||||
# The flag for generating the golden file
|
||||
GENGOLDEN_FLAG = '--gengolden'
|
||||
CATCH_EXCEPTIONS_ENV_VAR_NAME = 'GTEST_CATCH_EXCEPTIONS'
|
||||
|
||||
IS_WINDOWS = os.name == 'nt'
|
||||
|
||||
# TODO(vladl@google.com): remove the _lin suffix.
|
||||
GOLDEN_NAME = 'gtest_output_test_golden_lin.txt'
|
||||
|
||||
PROGRAM_PATH = gtest_test_utils.GetTestExecutablePath('gtest_output_test_')
|
||||
|
||||
# At least one command we exercise must not have the
|
||||
# --gtest_internal_skip_environment_and_ad_hoc_tests flag.
|
||||
COMMAND_LIST_TESTS = ({}, [PROGRAM_PATH, '--gtest_list_tests'])
|
||||
COMMAND_WITH_COLOR = ({}, [PROGRAM_PATH, '--gtest_color=yes'])
|
||||
COMMAND_WITH_TIME = ({}, [PROGRAM_PATH,
|
||||
'--gtest_print_time',
|
||||
'--gtest_internal_skip_environment_and_ad_hoc_tests',
|
||||
'--gtest_filter=FatalFailureTest.*:LoggingTest.*'])
|
||||
COMMAND_WITH_DISABLED = (
|
||||
{}, [PROGRAM_PATH,
|
||||
'--gtest_also_run_disabled_tests',
|
||||
'--gtest_internal_skip_environment_and_ad_hoc_tests',
|
||||
'--gtest_filter=*DISABLED_*'])
|
||||
COMMAND_WITH_SHARDING = (
|
||||
{'GTEST_SHARD_INDEX': '1', 'GTEST_TOTAL_SHARDS': '2'},
|
||||
[PROGRAM_PATH,
|
||||
'--gtest_internal_skip_environment_and_ad_hoc_tests',
|
||||
'--gtest_filter=PassingTest.*'])
|
||||
|
||||
GOLDEN_PATH = os.path.join(gtest_test_utils.GetSourceDir(), GOLDEN_NAME)
|
||||
|
||||
|
||||
def ToUnixLineEnding(s):
|
||||
"""Changes all Windows/Mac line endings in s to UNIX line endings."""
|
||||
|
||||
return s.replace('\r\n', '\n').replace('\r', '\n')
|
||||
|
||||
|
||||
def RemoveLocations(test_output):
|
||||
"""Removes all file location info from a Google Test program's output.
|
||||
|
||||
Args:
|
||||
test_output: the output of a Google Test program.
|
||||
|
||||
Returns:
|
||||
output with all file location info (in the form of
|
||||
'DIRECTORY/FILE_NAME:LINE_NUMBER: 'or
|
||||
'DIRECTORY\\FILE_NAME(LINE_NUMBER): ') replaced by
|
||||
'FILE_NAME:#: '.
|
||||
"""
|
||||
|
||||
return re.sub(r'.*[/\\](.+)(\:\d+|\(\d+\))\: ', r'\1:#: ', test_output)
|
||||
|
||||
|
||||
def RemoveStackTraceDetails(output):
|
||||
"""Removes all stack traces from a Google Test program's output."""
|
||||
|
||||
# *? means "find the shortest string that matches".
|
||||
return re.sub(r'Stack trace:(.|\n)*?\n\n',
|
||||
'Stack trace: (omitted)\n\n', output)
|
||||
|
||||
|
||||
def RemoveStackTraces(output):
|
||||
"""Removes all traces of stack traces from a Google Test program's output."""
|
||||
|
||||
# *? means "find the shortest string that matches".
|
||||
return re.sub(r'Stack trace:(.|\n)*?\n\n', '', output)
|
||||
|
||||
|
||||
def RemoveTime(output):
|
||||
"""Removes all time information from a Google Test program's output."""
|
||||
|
||||
return re.sub(r'\(\d+ ms', '(? ms', output)
|
||||
|
||||
|
||||
def RemoveTypeInfoDetails(test_output):
|
||||
"""Removes compiler-specific type info from Google Test program's output.
|
||||
|
||||
Args:
|
||||
test_output: the output of a Google Test program.
|
||||
|
||||
Returns:
|
||||
output with type information normalized to canonical form.
|
||||
"""
|
||||
|
||||
# some compilers output the name of type 'unsigned int' as 'unsigned'
|
||||
return re.sub(r'unsigned int', 'unsigned', test_output)
|
||||
|
||||
|
||||
def NormalizeToCurrentPlatform(test_output):
|
||||
"""Normalizes platform specific output details for easier comparison."""
|
||||
|
||||
if IS_WINDOWS:
|
||||
# Removes the color information that is not present on Windows.
|
||||
test_output = re.sub('\x1b\\[(0;3\d)?m', '', test_output)
|
||||
# Changes failure message headers into the Windows format.
|
||||
test_output = re.sub(r': Failure\n', r': error: ', test_output)
|
||||
# Changes file(line_number) to file:line_number.
|
||||
test_output = re.sub(r'((\w|\.)+)\((\d+)\):', r'\1:\3:', test_output)
|
||||
|
||||
return test_output
|
||||
|
||||
|
||||
def RemoveTestCounts(output):
|
||||
"""Removes test counts from a Google Test program's output."""
|
||||
|
||||
output = re.sub(r'\d+ tests?, listed below',
|
||||
'? tests, listed below', output)
|
||||
output = re.sub(r'\d+ FAILED TESTS',
|
||||
'? FAILED TESTS', output)
|
||||
output = re.sub(r'\d+ tests? from \d+ test cases?',
|
||||
'? tests from ? test cases', output)
|
||||
output = re.sub(r'\d+ tests? from ([a-zA-Z_])',
|
||||
r'? tests from \1', output)
|
||||
return re.sub(r'\d+ tests?\.', '? tests.', output)
|
||||
|
||||
|
||||
def RemoveMatchingTests(test_output, pattern):
|
||||
"""Removes output of specified tests from a Google Test program's output.
|
||||
|
||||
This function strips not only the beginning and the end of a test but also
|
||||
all output in between.
|
||||
|
||||
Args:
|
||||
test_output: A string containing the test output.
|
||||
pattern: A regex string that matches names of test cases or
|
||||
tests to remove.
|
||||
|
||||
Returns:
|
||||
Contents of test_output with tests whose names match pattern removed.
|
||||
"""
|
||||
|
||||
test_output = re.sub(
|
||||
r'.*\[ RUN \] .*%s(.|\n)*?\[( FAILED | OK )\] .*%s.*\n' % (
|
||||
pattern, pattern),
|
||||
'',
|
||||
test_output)
|
||||
return re.sub(r'.*%s.*\n' % pattern, '', test_output)
|
||||
|
||||
|
||||
def NormalizeOutput(output):
|
||||
"""Normalizes output (the output of gtest_output_test_.exe)."""
|
||||
|
||||
output = ToUnixLineEnding(output)
|
||||
output = RemoveLocations(output)
|
||||
output = RemoveStackTraceDetails(output)
|
||||
output = RemoveTime(output)
|
||||
return output
|
||||
|
||||
|
||||
def GetShellCommandOutput(env_cmd):
|
||||
"""Runs a command in a sub-process, and returns its output in a string.
|
||||
|
||||
Args:
|
||||
env_cmd: The shell command. A 2-tuple where element 0 is a dict of extra
|
||||
environment variables to set, and element 1 is a string with
|
||||
the command and any flags.
|
||||
|
||||
Returns:
|
||||
A string with the command's combined standard and diagnostic output.
|
||||
"""
|
||||
|
||||
# Spawns cmd in a sub-process, and gets its standard I/O file objects.
|
||||
# Set and save the environment properly.
|
||||
environ = os.environ.copy()
|
||||
environ.update(env_cmd[0])
|
||||
p = gtest_test_utils.Subprocess(env_cmd[1], env=environ)
|
||||
|
||||
return p.output
|
||||
|
||||
|
||||
def GetCommandOutput(env_cmd):
|
||||
"""Runs a command and returns its output with all file location
|
||||
info stripped off.
|
||||
|
||||
Args:
|
||||
env_cmd: The shell command. A 2-tuple where element 0 is a dict of extra
|
||||
environment variables to set, and element 1 is a string with
|
||||
the command and any flags.
|
||||
"""
|
||||
|
||||
# Disables exception pop-ups on Windows.
|
||||
environ, cmdline = env_cmd
|
||||
environ = dict(environ) # Ensures we are modifying a copy.
|
||||
environ[CATCH_EXCEPTIONS_ENV_VAR_NAME] = '1'
|
||||
return NormalizeOutput(GetShellCommandOutput((environ, cmdline)))
|
||||
|
||||
|
||||
def GetOutputOfAllCommands():
|
||||
"""Returns concatenated output from several representative commands."""
|
||||
|
||||
return (GetCommandOutput(COMMAND_WITH_COLOR) +
|
||||
GetCommandOutput(COMMAND_WITH_TIME) +
|
||||
GetCommandOutput(COMMAND_WITH_DISABLED) +
|
||||
GetCommandOutput(COMMAND_WITH_SHARDING))
|
||||
|
||||
|
||||
test_list = GetShellCommandOutput(COMMAND_LIST_TESTS)
|
||||
SUPPORTS_DEATH_TESTS = 'DeathTest' in test_list
|
||||
SUPPORTS_TYPED_TESTS = 'TypedTest' in test_list
|
||||
SUPPORTS_THREADS = 'ExpectFailureWithThreadsTest' in test_list
|
||||
SUPPORTS_STACK_TRACES = False
|
||||
|
||||
CAN_GENERATE_GOLDEN_FILE = (SUPPORTS_DEATH_TESTS and
|
||||
SUPPORTS_TYPED_TESTS and
|
||||
SUPPORTS_THREADS)
|
||||
|
||||
|
||||
class GTestOutputTest(gtest_test_utils.TestCase):
|
||||
def RemoveUnsupportedTests(self, test_output):
|
||||
if not SUPPORTS_DEATH_TESTS:
|
||||
test_output = RemoveMatchingTests(test_output, 'DeathTest')
|
||||
if not SUPPORTS_TYPED_TESTS:
|
||||
test_output = RemoveMatchingTests(test_output, 'TypedTest')
|
||||
test_output = RemoveMatchingTests(test_output, 'TypedDeathTest')
|
||||
test_output = RemoveMatchingTests(test_output, 'TypeParamDeathTest')
|
||||
if not SUPPORTS_THREADS:
|
||||
test_output = RemoveMatchingTests(test_output,
|
||||
'ExpectFailureWithThreadsTest')
|
||||
test_output = RemoveMatchingTests(test_output,
|
||||
'ScopedFakeTestPartResultReporterTest')
|
||||
test_output = RemoveMatchingTests(test_output,
|
||||
'WorksConcurrently')
|
||||
if not SUPPORTS_STACK_TRACES:
|
||||
test_output = RemoveStackTraces(test_output)
|
||||
|
||||
return test_output
|
||||
|
||||
def testOutput(self):
|
||||
output = GetOutputOfAllCommands()
|
||||
|
||||
golden_file = open(GOLDEN_PATH, 'rb')
|
||||
# A mis-configured source control system can cause \r appear in EOL
|
||||
# sequences when we read the golden file irrespective of an operating
|
||||
# system used. Therefore, we need to strip those \r's from newlines
|
||||
# unconditionally.
|
||||
golden = ToUnixLineEnding(golden_file.read())
|
||||
golden_file.close()
|
||||
|
||||
# We want the test to pass regardless of certain features being
|
||||
# supported or not.
|
||||
|
||||
# We still have to remove type name specifics in all cases.
|
||||
normalized_actual = RemoveTypeInfoDetails(output)
|
||||
normalized_golden = RemoveTypeInfoDetails(golden)
|
||||
|
||||
if CAN_GENERATE_GOLDEN_FILE:
|
||||
self.assertEqual(normalized_golden, normalized_actual)
|
||||
else:
|
||||
normalized_actual = NormalizeToCurrentPlatform(
|
||||
RemoveTestCounts(normalized_actual))
|
||||
normalized_golden = NormalizeToCurrentPlatform(
|
||||
RemoveTestCounts(self.RemoveUnsupportedTests(normalized_golden)))
|
||||
|
||||
# This code is very handy when debugging golden file differences:
|
||||
if os.getenv('DEBUG_GTEST_OUTPUT_TEST'):
|
||||
open(os.path.join(
|
||||
gtest_test_utils.GetSourceDir(),
|
||||
'_gtest_output_test_normalized_actual.txt'), 'wb').write(
|
||||
normalized_actual)
|
||||
open(os.path.join(
|
||||
gtest_test_utils.GetSourceDir(),
|
||||
'_gtest_output_test_normalized_golden.txt'), 'wb').write(
|
||||
normalized_golden)
|
||||
|
||||
self.assertEqual(normalized_golden, normalized_actual)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
if sys.argv[1:] == [GENGOLDEN_FLAG]:
|
||||
if CAN_GENERATE_GOLDEN_FILE:
|
||||
output = GetOutputOfAllCommands()
|
||||
golden_file = open(GOLDEN_PATH, 'wb')
|
||||
golden_file.write(output)
|
||||
golden_file.close()
|
||||
else:
|
||||
message = (
|
||||
"""Unable to write a golden file when compiled in an environment
|
||||
that does not support all the required features (death tests, typed tests,
|
||||
and multiple threads). Please generate the golden file using a binary built
|
||||
with those features enabled.""")
|
||||
|
||||
sys.stderr.write(message)
|
||||
sys.exit(1)
|
||||
else:
|
||||
gtest_test_utils.Main()
|
1020
gtest/test/gtest_output_test_.cc
Normal file
1020
gtest/test/gtest_output_test_.cc
Normal file
File diff suppressed because it is too large
Load Diff
711
gtest/test/gtest_output_test_golden_lin.txt
Normal file
711
gtest/test/gtest_output_test_golden_lin.txt
Normal file
@ -0,0 +1,711 @@
|
||||
The non-test part of the code is expected to have 2 failures.
|
||||
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Value of: false
|
||||
Actual: false
|
||||
Expected: true
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Value of: 3
|
||||
Expected: 2
|
||||
[0;32m[==========] [mRunning 62 tests from 27 test cases.
|
||||
[0;32m[----------] [mGlobal test environment set-up.
|
||||
FooEnvironment::SetUp() called.
|
||||
BarEnvironment::SetUp() called.
|
||||
[0;32m[----------] [m1 test from ADeathTest
|
||||
[0;32m[ RUN ] [mADeathTest.ShouldRunFirst
|
||||
[0;32m[ OK ] [mADeathTest.ShouldRunFirst
|
||||
[0;32m[----------] [m1 test from ATypedDeathTest/0, where TypeParam = int
|
||||
[0;32m[ RUN ] [mATypedDeathTest/0.ShouldRunFirst
|
||||
[0;32m[ OK ] [mATypedDeathTest/0.ShouldRunFirst
|
||||
[0;32m[----------] [m1 test from ATypedDeathTest/1, where TypeParam = double
|
||||
[0;32m[ RUN ] [mATypedDeathTest/1.ShouldRunFirst
|
||||
[0;32m[ OK ] [mATypedDeathTest/1.ShouldRunFirst
|
||||
[0;32m[----------] [m1 test from My/ATypeParamDeathTest/0, where TypeParam = int
|
||||
[0;32m[ RUN ] [mMy/ATypeParamDeathTest/0.ShouldRunFirst
|
||||
[0;32m[ OK ] [mMy/ATypeParamDeathTest/0.ShouldRunFirst
|
||||
[0;32m[----------] [m1 test from My/ATypeParamDeathTest/1, where TypeParam = double
|
||||
[0;32m[ RUN ] [mMy/ATypeParamDeathTest/1.ShouldRunFirst
|
||||
[0;32m[ OK ] [mMy/ATypeParamDeathTest/1.ShouldRunFirst
|
||||
[0;32m[----------] [m2 tests from PassingTest
|
||||
[0;32m[ RUN ] [mPassingTest.PassingTest1
|
||||
[0;32m[ OK ] [mPassingTest.PassingTest1
|
||||
[0;32m[ RUN ] [mPassingTest.PassingTest2
|
||||
[0;32m[ OK ] [mPassingTest.PassingTest2
|
||||
[0;32m[----------] [m3 tests from FatalFailureTest
|
||||
[0;32m[ RUN ] [mFatalFailureTest.FatalFailureInSubroutine
|
||||
(expecting a failure that x should be 1)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Value of: x
|
||||
Actual: 2
|
||||
Expected: 1
|
||||
[0;31m[ FAILED ] [mFatalFailureTest.FatalFailureInSubroutine
|
||||
[0;32m[ RUN ] [mFatalFailureTest.FatalFailureInNestedSubroutine
|
||||
(expecting a failure that x should be 1)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Value of: x
|
||||
Actual: 2
|
||||
Expected: 1
|
||||
[0;31m[ FAILED ] [mFatalFailureTest.FatalFailureInNestedSubroutine
|
||||
[0;32m[ RUN ] [mFatalFailureTest.NonfatalFailureInSubroutine
|
||||
(expecting a failure on false)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Value of: false
|
||||
Actual: false
|
||||
Expected: true
|
||||
[0;31m[ FAILED ] [mFatalFailureTest.NonfatalFailureInSubroutine
|
||||
[0;32m[----------] [m1 test from LoggingTest
|
||||
[0;32m[ RUN ] [mLoggingTest.InterleavingLoggingAndAssertions
|
||||
(expecting 2 failures on (3) >= (a[i]))
|
||||
i == 0
|
||||
i == 1
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: (3) >= (a[i]), actual: 3 vs 9
|
||||
i == 2
|
||||
i == 3
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: (3) >= (a[i]), actual: 3 vs 6
|
||||
[0;31m[ FAILED ] [mLoggingTest.InterleavingLoggingAndAssertions
|
||||
[0;32m[----------] [m6 tests from SCOPED_TRACETest
|
||||
[0;32m[ RUN ] [mSCOPED_TRACETest.ObeysScopes
|
||||
(expected to fail)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
This failure is expected, and shouldn't have a trace.
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
This failure is expected, and should have a trace.
|
||||
Google Test trace:
|
||||
gtest_output_test_.cc:#: Expected trace
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
This failure is expected, and shouldn't have a trace.
|
||||
[0;31m[ FAILED ] [mSCOPED_TRACETest.ObeysScopes
|
||||
[0;32m[ RUN ] [mSCOPED_TRACETest.WorksInLoop
|
||||
(expected to fail)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Value of: n
|
||||
Actual: 1
|
||||
Expected: 2
|
||||
Google Test trace:
|
||||
gtest_output_test_.cc:#: i = 1
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Value of: n
|
||||
Actual: 2
|
||||
Expected: 1
|
||||
Google Test trace:
|
||||
gtest_output_test_.cc:#: i = 2
|
||||
[0;31m[ FAILED ] [mSCOPED_TRACETest.WorksInLoop
|
||||
[0;32m[ RUN ] [mSCOPED_TRACETest.WorksInSubroutine
|
||||
(expected to fail)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Value of: n
|
||||
Actual: 1
|
||||
Expected: 2
|
||||
Google Test trace:
|
||||
gtest_output_test_.cc:#: n = 1
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Value of: n
|
||||
Actual: 2
|
||||
Expected: 1
|
||||
Google Test trace:
|
||||
gtest_output_test_.cc:#: n = 2
|
||||
[0;31m[ FAILED ] [mSCOPED_TRACETest.WorksInSubroutine
|
||||
[0;32m[ RUN ] [mSCOPED_TRACETest.CanBeNested
|
||||
(expected to fail)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Value of: n
|
||||
Actual: 2
|
||||
Expected: 1
|
||||
Google Test trace:
|
||||
gtest_output_test_.cc:#: n = 2
|
||||
gtest_output_test_.cc:#:
|
||||
[0;31m[ FAILED ] [mSCOPED_TRACETest.CanBeNested
|
||||
[0;32m[ RUN ] [mSCOPED_TRACETest.CanBeRepeated
|
||||
(expected to fail)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
This failure is expected, and should contain trace point A.
|
||||
Google Test trace:
|
||||
gtest_output_test_.cc:#: A
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
This failure is expected, and should contain trace point A and B.
|
||||
Google Test trace:
|
||||
gtest_output_test_.cc:#: B
|
||||
gtest_output_test_.cc:#: A
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
This failure is expected, and should contain trace point A, B, and C.
|
||||
Google Test trace:
|
||||
gtest_output_test_.cc:#: C
|
||||
gtest_output_test_.cc:#: B
|
||||
gtest_output_test_.cc:#: A
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
This failure is expected, and should contain trace point A, B, and D.
|
||||
Google Test trace:
|
||||
gtest_output_test_.cc:#: D
|
||||
gtest_output_test_.cc:#: B
|
||||
gtest_output_test_.cc:#: A
|
||||
[0;31m[ FAILED ] [mSCOPED_TRACETest.CanBeRepeated
|
||||
[0;32m[ RUN ] [mSCOPED_TRACETest.WorksConcurrently
|
||||
(expecting 6 failures)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected failure #1 (in thread B, only trace B alive).
|
||||
Google Test trace:
|
||||
gtest_output_test_.cc:#: Trace B
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected failure #2 (in thread A, trace A & B both alive).
|
||||
Google Test trace:
|
||||
gtest_output_test_.cc:#: Trace A
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected failure #3 (in thread B, trace A & B both alive).
|
||||
Google Test trace:
|
||||
gtest_output_test_.cc:#: Trace B
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected failure #4 (in thread B, only trace A alive).
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected failure #5 (in thread A, only trace A alive).
|
||||
Google Test trace:
|
||||
gtest_output_test_.cc:#: Trace A
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected failure #6 (in thread A, no trace alive).
|
||||
[0;31m[ FAILED ] [mSCOPED_TRACETest.WorksConcurrently
|
||||
[0;32m[----------] [m1 test from NonFatalFailureInFixtureConstructorTest
|
||||
[0;32m[ RUN ] [mNonFatalFailureInFixtureConstructorTest.FailureInConstructor
|
||||
(expecting 5 failures)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected failure #1, in the test fixture c'tor.
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected failure #2, in SetUp().
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected failure #3, in the test body.
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected failure #4, in TearDown.
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected failure #5, in the test fixture d'tor.
|
||||
[0;31m[ FAILED ] [mNonFatalFailureInFixtureConstructorTest.FailureInConstructor
|
||||
[0;32m[----------] [m1 test from FatalFailureInFixtureConstructorTest
|
||||
[0;32m[ RUN ] [mFatalFailureInFixtureConstructorTest.FailureInConstructor
|
||||
(expecting 2 failures)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected failure #1, in the test fixture c'tor.
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected failure #2, in the test fixture d'tor.
|
||||
[0;31m[ FAILED ] [mFatalFailureInFixtureConstructorTest.FailureInConstructor
|
||||
[0;32m[----------] [m1 test from NonFatalFailureInSetUpTest
|
||||
[0;32m[ RUN ] [mNonFatalFailureInSetUpTest.FailureInSetUp
|
||||
(expecting 4 failures)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected failure #1, in SetUp().
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected failure #2, in the test function.
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected failure #3, in TearDown().
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected failure #4, in the test fixture d'tor.
|
||||
[0;31m[ FAILED ] [mNonFatalFailureInSetUpTest.FailureInSetUp
|
||||
[0;32m[----------] [m1 test from FatalFailureInSetUpTest
|
||||
[0;32m[ RUN ] [mFatalFailureInSetUpTest.FailureInSetUp
|
||||
(expecting 3 failures)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected failure #1, in SetUp().
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected failure #2, in TearDown().
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected failure #3, in the test fixture d'tor.
|
||||
[0;31m[ FAILED ] [mFatalFailureInSetUpTest.FailureInSetUp
|
||||
[0;32m[----------] [m1 test from AddFailureAtTest
|
||||
[0;32m[ RUN ] [mAddFailureAtTest.MessageContainsSpecifiedFileAndLineNumber
|
||||
foo.cc:42: Failure
|
||||
Failed
|
||||
Expected failure in foo.cc
|
||||
[0;31m[ FAILED ] [mAddFailureAtTest.MessageContainsSpecifiedFileAndLineNumber
|
||||
[0;32m[----------] [m4 tests from MixedUpTestCaseTest
|
||||
[0;32m[ RUN ] [mMixedUpTestCaseTest.FirstTestFromNamespaceFoo
|
||||
[0;32m[ OK ] [mMixedUpTestCaseTest.FirstTestFromNamespaceFoo
|
||||
[0;32m[ RUN ] [mMixedUpTestCaseTest.SecondTestFromNamespaceFoo
|
||||
[0;32m[ OK ] [mMixedUpTestCaseTest.SecondTestFromNamespaceFoo
|
||||
[0;32m[ RUN ] [mMixedUpTestCaseTest.ThisShouldFail
|
||||
gtest.cc:#: Failure
|
||||
Failed
|
||||
All tests in the same test case must use the same test fixture
|
||||
class. However, in test case MixedUpTestCaseTest,
|
||||
you defined test FirstTestFromNamespaceFoo and test ThisShouldFail
|
||||
using two different test fixture classes. This can happen if
|
||||
the two classes are from different namespaces or translation
|
||||
units and have the same name. You should probably rename one
|
||||
of the classes to put the tests into different test cases.
|
||||
[0;31m[ FAILED ] [mMixedUpTestCaseTest.ThisShouldFail
|
||||
[0;32m[ RUN ] [mMixedUpTestCaseTest.ThisShouldFailToo
|
||||
gtest.cc:#: Failure
|
||||
Failed
|
||||
All tests in the same test case must use the same test fixture
|
||||
class. However, in test case MixedUpTestCaseTest,
|
||||
you defined test FirstTestFromNamespaceFoo and test ThisShouldFailToo
|
||||
using two different test fixture classes. This can happen if
|
||||
the two classes are from different namespaces or translation
|
||||
units and have the same name. You should probably rename one
|
||||
of the classes to put the tests into different test cases.
|
||||
[0;31m[ FAILED ] [mMixedUpTestCaseTest.ThisShouldFailToo
|
||||
[0;32m[----------] [m2 tests from MixedUpTestCaseWithSameTestNameTest
|
||||
[0;32m[ RUN ] [mMixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
|
||||
[0;32m[ OK ] [mMixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
|
||||
[0;32m[ RUN ] [mMixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
|
||||
gtest.cc:#: Failure
|
||||
Failed
|
||||
All tests in the same test case must use the same test fixture
|
||||
class. However, in test case MixedUpTestCaseWithSameTestNameTest,
|
||||
you defined test TheSecondTestWithThisNameShouldFail and test TheSecondTestWithThisNameShouldFail
|
||||
using two different test fixture classes. This can happen if
|
||||
the two classes are from different namespaces or translation
|
||||
units and have the same name. You should probably rename one
|
||||
of the classes to put the tests into different test cases.
|
||||
[0;31m[ FAILED ] [mMixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
|
||||
[0;32m[----------] [m2 tests from TEST_F_before_TEST_in_same_test_case
|
||||
[0;32m[ RUN ] [mTEST_F_before_TEST_in_same_test_case.DefinedUsingTEST_F
|
||||
[0;32m[ OK ] [mTEST_F_before_TEST_in_same_test_case.DefinedUsingTEST_F
|
||||
[0;32m[ RUN ] [mTEST_F_before_TEST_in_same_test_case.DefinedUsingTESTAndShouldFail
|
||||
gtest.cc:#: Failure
|
||||
Failed
|
||||
All tests in the same test case must use the same test fixture
|
||||
class, so mixing TEST_F and TEST in the same test case is
|
||||
illegal. In test case TEST_F_before_TEST_in_same_test_case,
|
||||
test DefinedUsingTEST_F is defined using TEST_F but
|
||||
test DefinedUsingTESTAndShouldFail is defined using TEST. You probably
|
||||
want to change the TEST to TEST_F or move it to another test
|
||||
case.
|
||||
[0;31m[ FAILED ] [mTEST_F_before_TEST_in_same_test_case.DefinedUsingTESTAndShouldFail
|
||||
[0;32m[----------] [m2 tests from TEST_before_TEST_F_in_same_test_case
|
||||
[0;32m[ RUN ] [mTEST_before_TEST_F_in_same_test_case.DefinedUsingTEST
|
||||
[0;32m[ OK ] [mTEST_before_TEST_F_in_same_test_case.DefinedUsingTEST
|
||||
[0;32m[ RUN ] [mTEST_before_TEST_F_in_same_test_case.DefinedUsingTEST_FAndShouldFail
|
||||
gtest.cc:#: Failure
|
||||
Failed
|
||||
All tests in the same test case must use the same test fixture
|
||||
class, so mixing TEST_F and TEST in the same test case is
|
||||
illegal. In test case TEST_before_TEST_F_in_same_test_case,
|
||||
test DefinedUsingTEST_FAndShouldFail is defined using TEST_F but
|
||||
test DefinedUsingTEST is defined using TEST. You probably
|
||||
want to change the TEST to TEST_F or move it to another test
|
||||
case.
|
||||
[0;31m[ FAILED ] [mTEST_before_TEST_F_in_same_test_case.DefinedUsingTEST_FAndShouldFail
|
||||
[0;32m[----------] [m8 tests from ExpectNonfatalFailureTest
|
||||
[0;32m[ RUN ] [mExpectNonfatalFailureTest.CanReferenceGlobalVariables
|
||||
[0;32m[ OK ] [mExpectNonfatalFailureTest.CanReferenceGlobalVariables
|
||||
[0;32m[ RUN ] [mExpectNonfatalFailureTest.CanReferenceLocalVariables
|
||||
[0;32m[ OK ] [mExpectNonfatalFailureTest.CanReferenceLocalVariables
|
||||
[0;32m[ RUN ] [mExpectNonfatalFailureTest.SucceedsWhenThereIsOneNonfatalFailure
|
||||
[0;32m[ OK ] [mExpectNonfatalFailureTest.SucceedsWhenThereIsOneNonfatalFailure
|
||||
[0;32m[ RUN ] [mExpectNonfatalFailureTest.FailsWhenThereIsNoNonfatalFailure
|
||||
(expecting a failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 non-fatal failure
|
||||
Actual: 0 failures
|
||||
[0;31m[ FAILED ] [mExpectNonfatalFailureTest.FailsWhenThereIsNoNonfatalFailure
|
||||
[0;32m[ RUN ] [mExpectNonfatalFailureTest.FailsWhenThereAreTwoNonfatalFailures
|
||||
(expecting a failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 non-fatal failure
|
||||
Actual: 2 failures
|
||||
gtest_output_test_.cc:#: Non-fatal failure:
|
||||
Failed
|
||||
Expected non-fatal failure 1.
|
||||
|
||||
gtest_output_test_.cc:#: Non-fatal failure:
|
||||
Failed
|
||||
Expected non-fatal failure 2.
|
||||
|
||||
[0;31m[ FAILED ] [mExpectNonfatalFailureTest.FailsWhenThereAreTwoNonfatalFailures
|
||||
[0;32m[ RUN ] [mExpectNonfatalFailureTest.FailsWhenThereIsOneFatalFailure
|
||||
(expecting a failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 non-fatal failure
|
||||
Actual:
|
||||
gtest_output_test_.cc:#: Fatal failure:
|
||||
Failed
|
||||
Expected fatal failure.
|
||||
|
||||
[0;31m[ FAILED ] [mExpectNonfatalFailureTest.FailsWhenThereIsOneFatalFailure
|
||||
[0;32m[ RUN ] [mExpectNonfatalFailureTest.FailsWhenStatementReturns
|
||||
(expecting a failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 non-fatal failure
|
||||
Actual: 0 failures
|
||||
[0;31m[ FAILED ] [mExpectNonfatalFailureTest.FailsWhenStatementReturns
|
||||
[0;32m[ RUN ] [mExpectNonfatalFailureTest.FailsWhenStatementThrows
|
||||
(expecting a failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 non-fatal failure
|
||||
Actual: 0 failures
|
||||
[0;31m[ FAILED ] [mExpectNonfatalFailureTest.FailsWhenStatementThrows
|
||||
[0;32m[----------] [m8 tests from ExpectFatalFailureTest
|
||||
[0;32m[ RUN ] [mExpectFatalFailureTest.CanReferenceGlobalVariables
|
||||
[0;32m[ OK ] [mExpectFatalFailureTest.CanReferenceGlobalVariables
|
||||
[0;32m[ RUN ] [mExpectFatalFailureTest.CanReferenceLocalStaticVariables
|
||||
[0;32m[ OK ] [mExpectFatalFailureTest.CanReferenceLocalStaticVariables
|
||||
[0;32m[ RUN ] [mExpectFatalFailureTest.SucceedsWhenThereIsOneFatalFailure
|
||||
[0;32m[ OK ] [mExpectFatalFailureTest.SucceedsWhenThereIsOneFatalFailure
|
||||
[0;32m[ RUN ] [mExpectFatalFailureTest.FailsWhenThereIsNoFatalFailure
|
||||
(expecting a failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 fatal failure
|
||||
Actual: 0 failures
|
||||
[0;31m[ FAILED ] [mExpectFatalFailureTest.FailsWhenThereIsNoFatalFailure
|
||||
[0;32m[ RUN ] [mExpectFatalFailureTest.FailsWhenThereAreTwoFatalFailures
|
||||
(expecting a failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 fatal failure
|
||||
Actual: 2 failures
|
||||
gtest_output_test_.cc:#: Fatal failure:
|
||||
Failed
|
||||
Expected fatal failure.
|
||||
|
||||
gtest_output_test_.cc:#: Fatal failure:
|
||||
Failed
|
||||
Expected fatal failure.
|
||||
|
||||
[0;31m[ FAILED ] [mExpectFatalFailureTest.FailsWhenThereAreTwoFatalFailures
|
||||
[0;32m[ RUN ] [mExpectFatalFailureTest.FailsWhenThereIsOneNonfatalFailure
|
||||
(expecting a failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 fatal failure
|
||||
Actual:
|
||||
gtest_output_test_.cc:#: Non-fatal failure:
|
||||
Failed
|
||||
Expected non-fatal failure.
|
||||
|
||||
[0;31m[ FAILED ] [mExpectFatalFailureTest.FailsWhenThereIsOneNonfatalFailure
|
||||
[0;32m[ RUN ] [mExpectFatalFailureTest.FailsWhenStatementReturns
|
||||
(expecting a failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 fatal failure
|
||||
Actual: 0 failures
|
||||
[0;31m[ FAILED ] [mExpectFatalFailureTest.FailsWhenStatementReturns
|
||||
[0;32m[ RUN ] [mExpectFatalFailureTest.FailsWhenStatementThrows
|
||||
(expecting a failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 fatal failure
|
||||
Actual: 0 failures
|
||||
[0;31m[ FAILED ] [mExpectFatalFailureTest.FailsWhenStatementThrows
|
||||
[0;32m[----------] [m2 tests from TypedTest/0, where TypeParam = int
|
||||
[0;32m[ RUN ] [mTypedTest/0.Success
|
||||
[0;32m[ OK ] [mTypedTest/0.Success
|
||||
[0;32m[ RUN ] [mTypedTest/0.Failure
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Value of: TypeParam()
|
||||
Actual: 0
|
||||
Expected: 1
|
||||
Expected failure
|
||||
[0;31m[ FAILED ] [mTypedTest/0.Failure, where TypeParam = int
|
||||
[0;32m[----------] [m2 tests from Unsigned/TypedTestP/0, where TypeParam = unsigned char
|
||||
[0;32m[ RUN ] [mUnsigned/TypedTestP/0.Success
|
||||
[0;32m[ OK ] [mUnsigned/TypedTestP/0.Success
|
||||
[0;32m[ RUN ] [mUnsigned/TypedTestP/0.Failure
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Value of: TypeParam()
|
||||
Actual: '\0'
|
||||
Expected: 1U
|
||||
Which is: 1
|
||||
Expected failure
|
||||
[0;31m[ FAILED ] [mUnsigned/TypedTestP/0.Failure, where TypeParam = unsigned char
|
||||
[0;32m[----------] [m2 tests from Unsigned/TypedTestP/1, where TypeParam = unsigned int
|
||||
[0;32m[ RUN ] [mUnsigned/TypedTestP/1.Success
|
||||
[0;32m[ OK ] [mUnsigned/TypedTestP/1.Success
|
||||
[0;32m[ RUN ] [mUnsigned/TypedTestP/1.Failure
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Value of: TypeParam()
|
||||
Actual: 0
|
||||
Expected: 1U
|
||||
Which is: 1
|
||||
Expected failure
|
||||
[0;31m[ FAILED ] [mUnsigned/TypedTestP/1.Failure, where TypeParam = unsigned int
|
||||
[0;32m[----------] [m4 tests from ExpectFailureTest
|
||||
[0;32m[ RUN ] [mExpectFailureTest.ExpectFatalFailure
|
||||
(expecting 1 failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 fatal failure
|
||||
Actual:
|
||||
gtest_output_test_.cc:#: Success:
|
||||
Succeeded
|
||||
|
||||
(expecting 1 failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 fatal failure
|
||||
Actual:
|
||||
gtest_output_test_.cc:#: Non-fatal failure:
|
||||
Failed
|
||||
Expected non-fatal failure.
|
||||
|
||||
(expecting 1 failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 fatal failure containing "Some other fatal failure expected."
|
||||
Actual:
|
||||
gtest_output_test_.cc:#: Fatal failure:
|
||||
Failed
|
||||
Expected fatal failure.
|
||||
|
||||
[0;31m[ FAILED ] [mExpectFailureTest.ExpectFatalFailure
|
||||
[0;32m[ RUN ] [mExpectFailureTest.ExpectNonFatalFailure
|
||||
(expecting 1 failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 non-fatal failure
|
||||
Actual:
|
||||
gtest_output_test_.cc:#: Success:
|
||||
Succeeded
|
||||
|
||||
(expecting 1 failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 non-fatal failure
|
||||
Actual:
|
||||
gtest_output_test_.cc:#: Fatal failure:
|
||||
Failed
|
||||
Expected fatal failure.
|
||||
|
||||
(expecting 1 failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 non-fatal failure containing "Some other non-fatal failure."
|
||||
Actual:
|
||||
gtest_output_test_.cc:#: Non-fatal failure:
|
||||
Failed
|
||||
Expected non-fatal failure.
|
||||
|
||||
[0;31m[ FAILED ] [mExpectFailureTest.ExpectNonFatalFailure
|
||||
[0;32m[ RUN ] [mExpectFailureTest.ExpectFatalFailureOnAllThreads
|
||||
(expecting 1 failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 fatal failure
|
||||
Actual:
|
||||
gtest_output_test_.cc:#: Success:
|
||||
Succeeded
|
||||
|
||||
(expecting 1 failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 fatal failure
|
||||
Actual:
|
||||
gtest_output_test_.cc:#: Non-fatal failure:
|
||||
Failed
|
||||
Expected non-fatal failure.
|
||||
|
||||
(expecting 1 failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 fatal failure containing "Some other fatal failure expected."
|
||||
Actual:
|
||||
gtest_output_test_.cc:#: Fatal failure:
|
||||
Failed
|
||||
Expected fatal failure.
|
||||
|
||||
[0;31m[ FAILED ] [mExpectFailureTest.ExpectFatalFailureOnAllThreads
|
||||
[0;32m[ RUN ] [mExpectFailureTest.ExpectNonFatalFailureOnAllThreads
|
||||
(expecting 1 failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 non-fatal failure
|
||||
Actual:
|
||||
gtest_output_test_.cc:#: Success:
|
||||
Succeeded
|
||||
|
||||
(expecting 1 failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 non-fatal failure
|
||||
Actual:
|
||||
gtest_output_test_.cc:#: Fatal failure:
|
||||
Failed
|
||||
Expected fatal failure.
|
||||
|
||||
(expecting 1 failure)
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 non-fatal failure containing "Some other non-fatal failure."
|
||||
Actual:
|
||||
gtest_output_test_.cc:#: Non-fatal failure:
|
||||
Failed
|
||||
Expected non-fatal failure.
|
||||
|
||||
[0;31m[ FAILED ] [mExpectFailureTest.ExpectNonFatalFailureOnAllThreads
|
||||
[0;32m[----------] [m2 tests from ExpectFailureWithThreadsTest
|
||||
[0;32m[ RUN ] [mExpectFailureWithThreadsTest.ExpectFatalFailure
|
||||
(expecting 2 failures)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected fatal failure.
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 fatal failure
|
||||
Actual: 0 failures
|
||||
[0;31m[ FAILED ] [mExpectFailureWithThreadsTest.ExpectFatalFailure
|
||||
[0;32m[ RUN ] [mExpectFailureWithThreadsTest.ExpectNonFatalFailure
|
||||
(expecting 2 failures)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected non-fatal failure.
|
||||
gtest.cc:#: Failure
|
||||
Expected: 1 non-fatal failure
|
||||
Actual: 0 failures
|
||||
[0;31m[ FAILED ] [mExpectFailureWithThreadsTest.ExpectNonFatalFailure
|
||||
[0;32m[----------] [m1 test from ScopedFakeTestPartResultReporterTest
|
||||
[0;32m[ RUN ] [mScopedFakeTestPartResultReporterTest.InterceptOnlyCurrentThread
|
||||
(expecting 2 failures)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected fatal failure.
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected non-fatal failure.
|
||||
[0;31m[ FAILED ] [mScopedFakeTestPartResultReporterTest.InterceptOnlyCurrentThread
|
||||
[0;32m[----------] [m1 test from PrintingFailingParams/FailingParamTest
|
||||
[0;32m[ RUN ] [mPrintingFailingParams/FailingParamTest.Fails/0
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Value of: GetParam()
|
||||
Actual: 2
|
||||
Expected: 1
|
||||
[0;31m[ FAILED ] [mPrintingFailingParams/FailingParamTest.Fails/0, where GetParam() = 2
|
||||
[0;32m[----------] [mGlobal test environment tear-down
|
||||
BarEnvironment::TearDown() called.
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected non-fatal failure.
|
||||
FooEnvironment::TearDown() called.
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Failed
|
||||
Expected fatal failure.
|
||||
[0;32m[==========] [m62 tests from 27 test cases ran.
|
||||
[0;32m[ PASSED ] [m21 tests.
|
||||
[0;31m[ FAILED ] [m41 tests, listed below:
|
||||
[0;31m[ FAILED ] [mFatalFailureTest.FatalFailureInSubroutine
|
||||
[0;31m[ FAILED ] [mFatalFailureTest.FatalFailureInNestedSubroutine
|
||||
[0;31m[ FAILED ] [mFatalFailureTest.NonfatalFailureInSubroutine
|
||||
[0;31m[ FAILED ] [mLoggingTest.InterleavingLoggingAndAssertions
|
||||
[0;31m[ FAILED ] [mSCOPED_TRACETest.ObeysScopes
|
||||
[0;31m[ FAILED ] [mSCOPED_TRACETest.WorksInLoop
|
||||
[0;31m[ FAILED ] [mSCOPED_TRACETest.WorksInSubroutine
|
||||
[0;31m[ FAILED ] [mSCOPED_TRACETest.CanBeNested
|
||||
[0;31m[ FAILED ] [mSCOPED_TRACETest.CanBeRepeated
|
||||
[0;31m[ FAILED ] [mSCOPED_TRACETest.WorksConcurrently
|
||||
[0;31m[ FAILED ] [mNonFatalFailureInFixtureConstructorTest.FailureInConstructor
|
||||
[0;31m[ FAILED ] [mFatalFailureInFixtureConstructorTest.FailureInConstructor
|
||||
[0;31m[ FAILED ] [mNonFatalFailureInSetUpTest.FailureInSetUp
|
||||
[0;31m[ FAILED ] [mFatalFailureInSetUpTest.FailureInSetUp
|
||||
[0;31m[ FAILED ] [mAddFailureAtTest.MessageContainsSpecifiedFileAndLineNumber
|
||||
[0;31m[ FAILED ] [mMixedUpTestCaseTest.ThisShouldFail
|
||||
[0;31m[ FAILED ] [mMixedUpTestCaseTest.ThisShouldFailToo
|
||||
[0;31m[ FAILED ] [mMixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
|
||||
[0;31m[ FAILED ] [mTEST_F_before_TEST_in_same_test_case.DefinedUsingTESTAndShouldFail
|
||||
[0;31m[ FAILED ] [mTEST_before_TEST_F_in_same_test_case.DefinedUsingTEST_FAndShouldFail
|
||||
[0;31m[ FAILED ] [mExpectNonfatalFailureTest.FailsWhenThereIsNoNonfatalFailure
|
||||
[0;31m[ FAILED ] [mExpectNonfatalFailureTest.FailsWhenThereAreTwoNonfatalFailures
|
||||
[0;31m[ FAILED ] [mExpectNonfatalFailureTest.FailsWhenThereIsOneFatalFailure
|
||||
[0;31m[ FAILED ] [mExpectNonfatalFailureTest.FailsWhenStatementReturns
|
||||
[0;31m[ FAILED ] [mExpectNonfatalFailureTest.FailsWhenStatementThrows
|
||||
[0;31m[ FAILED ] [mExpectFatalFailureTest.FailsWhenThereIsNoFatalFailure
|
||||
[0;31m[ FAILED ] [mExpectFatalFailureTest.FailsWhenThereAreTwoFatalFailures
|
||||
[0;31m[ FAILED ] [mExpectFatalFailureTest.FailsWhenThereIsOneNonfatalFailure
|
||||
[0;31m[ FAILED ] [mExpectFatalFailureTest.FailsWhenStatementReturns
|
||||
[0;31m[ FAILED ] [mExpectFatalFailureTest.FailsWhenStatementThrows
|
||||
[0;31m[ FAILED ] [mTypedTest/0.Failure, where TypeParam = int
|
||||
[0;31m[ FAILED ] [mUnsigned/TypedTestP/0.Failure, where TypeParam = unsigned char
|
||||
[0;31m[ FAILED ] [mUnsigned/TypedTestP/1.Failure, where TypeParam = unsigned int
|
||||
[0;31m[ FAILED ] [mExpectFailureTest.ExpectFatalFailure
|
||||
[0;31m[ FAILED ] [mExpectFailureTest.ExpectNonFatalFailure
|
||||
[0;31m[ FAILED ] [mExpectFailureTest.ExpectFatalFailureOnAllThreads
|
||||
[0;31m[ FAILED ] [mExpectFailureTest.ExpectNonFatalFailureOnAllThreads
|
||||
[0;31m[ FAILED ] [mExpectFailureWithThreadsTest.ExpectFatalFailure
|
||||
[0;31m[ FAILED ] [mExpectFailureWithThreadsTest.ExpectNonFatalFailure
|
||||
[0;31m[ FAILED ] [mScopedFakeTestPartResultReporterTest.InterceptOnlyCurrentThread
|
||||
[0;31m[ FAILED ] [mPrintingFailingParams/FailingParamTest.Fails/0, where GetParam() = 2
|
||||
|
||||
41 FAILED TESTS
|
||||
[0;33m YOU HAVE 1 DISABLED TEST
|
||||
|
||||
[mNote: Google Test filter = FatalFailureTest.*:LoggingTest.*
|
||||
[==========] Running 4 tests from 2 test cases.
|
||||
[----------] Global test environment set-up.
|
||||
[----------] 3 tests from FatalFailureTest
|
||||
[ RUN ] FatalFailureTest.FatalFailureInSubroutine
|
||||
(expecting a failure that x should be 1)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Value of: x
|
||||
Actual: 2
|
||||
Expected: 1
|
||||
[ FAILED ] FatalFailureTest.FatalFailureInSubroutine (? ms)
|
||||
[ RUN ] FatalFailureTest.FatalFailureInNestedSubroutine
|
||||
(expecting a failure that x should be 1)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Value of: x
|
||||
Actual: 2
|
||||
Expected: 1
|
||||
[ FAILED ] FatalFailureTest.FatalFailureInNestedSubroutine (? ms)
|
||||
[ RUN ] FatalFailureTest.NonfatalFailureInSubroutine
|
||||
(expecting a failure on false)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Value of: false
|
||||
Actual: false
|
||||
Expected: true
|
||||
[ FAILED ] FatalFailureTest.NonfatalFailureInSubroutine (? ms)
|
||||
[----------] 3 tests from FatalFailureTest (? ms total)
|
||||
|
||||
[----------] 1 test from LoggingTest
|
||||
[ RUN ] LoggingTest.InterleavingLoggingAndAssertions
|
||||
(expecting 2 failures on (3) >= (a[i]))
|
||||
i == 0
|
||||
i == 1
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: (3) >= (a[i]), actual: 3 vs 9
|
||||
i == 2
|
||||
i == 3
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: (3) >= (a[i]), actual: 3 vs 6
|
||||
[ FAILED ] LoggingTest.InterleavingLoggingAndAssertions (? ms)
|
||||
[----------] 1 test from LoggingTest (? ms total)
|
||||
|
||||
[----------] Global test environment tear-down
|
||||
[==========] 4 tests from 2 test cases ran. (? ms total)
|
||||
[ PASSED ] 0 tests.
|
||||
[ FAILED ] 4 tests, listed below:
|
||||
[ FAILED ] FatalFailureTest.FatalFailureInSubroutine
|
||||
[ FAILED ] FatalFailureTest.FatalFailureInNestedSubroutine
|
||||
[ FAILED ] FatalFailureTest.NonfatalFailureInSubroutine
|
||||
[ FAILED ] LoggingTest.InterleavingLoggingAndAssertions
|
||||
|
||||
4 FAILED TESTS
|
||||
YOU HAVE 1 DISABLED TEST
|
||||
|
||||
Note: Google Test filter = *DISABLED_*
|
||||
[==========] Running 1 test from 1 test case.
|
||||
[----------] Global test environment set-up.
|
||||
[----------] 1 test from DisabledTestsWarningTest
|
||||
[ RUN ] DisabledTestsWarningTest.DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning
|
||||
[ OK ] DisabledTestsWarningTest.DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning
|
||||
[----------] Global test environment tear-down
|
||||
[==========] 1 test from 1 test case ran.
|
||||
[ PASSED ] 1 test.
|
||||
Note: Google Test filter = PassingTest.*
|
||||
Note: This is test shard 2 of 2.
|
||||
[==========] Running 1 test from 1 test case.
|
||||
[----------] Global test environment set-up.
|
||||
[----------] 1 test from PassingTest
|
||||
[ RUN ] PassingTest.PassingTest2
|
||||
[ OK ] PassingTest.PassingTest2
|
||||
[----------] Global test environment tear-down
|
||||
[==========] 1 test from 1 test case ran.
|
||||
[ PASSED ] 1 test.
|
||||
|
||||
YOU HAVE 1 DISABLED TEST
|
||||
|
2427
gtest/test/gtest_pred_impl_unittest.cc
Normal file
2427
gtest/test/gtest_pred_impl_unittest.cc
Normal file
File diff suppressed because it is too large
Load Diff
57
gtest/test/gtest_prod_test.cc
Normal file
57
gtest/test/gtest_prod_test.cc
Normal file
@ -0,0 +1,57 @@
|
||||
// Copyright 2006, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
//
|
||||
// Unit test for include/gtest/gtest_prod.h.
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
#include "test/production.h"
|
||||
|
||||
// Tests that private members can be accessed from a TEST declared as
|
||||
// a friend of the class.
|
||||
TEST(PrivateCodeTest, CanAccessPrivateMembers) {
|
||||
PrivateCode a;
|
||||
EXPECT_EQ(0, a.x_);
|
||||
|
||||
a.set_x(1);
|
||||
EXPECT_EQ(1, a.x_);
|
||||
}
|
||||
|
||||
typedef testing::Test PrivateCodeFixtureTest;
|
||||
|
||||
// Tests that private members can be accessed from a TEST_F declared
|
||||
// as a friend of the class.
|
||||
TEST_F(PrivateCodeFixtureTest, CanAccessPrivateMembers) {
|
||||
PrivateCode a;
|
||||
EXPECT_EQ(0, a.x_);
|
||||
|
||||
a.set_x(2);
|
||||
EXPECT_EQ(2, a.x_);
|
||||
}
|
253
gtest/test/gtest_repeat_test.cc
Normal file
253
gtest/test/gtest_repeat_test.cc
Normal file
@ -0,0 +1,253 @@
|
||||
// Copyright 2008, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
// Tests the --gtest_repeat=number flag.
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <iostream>
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
// Indicates that this translation unit is part of Google Test's
|
||||
// implementation. It must come before gtest-internal-inl.h is
|
||||
// included, or there will be a compiler error. This trick is to
|
||||
// prevent a user from accidentally including gtest-internal-inl.h in
|
||||
// his code.
|
||||
#define GTEST_IMPLEMENTATION_ 1
|
||||
#include "src/gtest-internal-inl.h"
|
||||
#undef GTEST_IMPLEMENTATION_
|
||||
|
||||
namespace testing {
|
||||
|
||||
GTEST_DECLARE_string_(death_test_style);
|
||||
GTEST_DECLARE_string_(filter);
|
||||
GTEST_DECLARE_int32_(repeat);
|
||||
|
||||
} // namespace testing
|
||||
|
||||
using testing::GTEST_FLAG(death_test_style);
|
||||
using testing::GTEST_FLAG(filter);
|
||||
using testing::GTEST_FLAG(repeat);
|
||||
|
||||
namespace {
|
||||
|
||||
// We need this when we are testing Google Test itself and therefore
|
||||
// cannot use Google Test assertions.
|
||||
#define GTEST_CHECK_INT_EQ_(expected, actual) \
|
||||
do {\
|
||||
const int expected_val = (expected);\
|
||||
const int actual_val = (actual);\
|
||||
if (::testing::internal::IsTrue(expected_val != actual_val)) {\
|
||||
::std::cout << "Value of: " #actual "\n"\
|
||||
<< " Actual: " << actual_val << "\n"\
|
||||
<< "Expected: " #expected "\n"\
|
||||
<< "Which is: " << expected_val << "\n";\
|
||||
::testing::internal::posix::Abort();\
|
||||
}\
|
||||
} while(::testing::internal::AlwaysFalse())
|
||||
|
||||
|
||||
// Used for verifying that global environment set-up and tear-down are
|
||||
// inside the gtest_repeat loop.
|
||||
|
||||
int g_environment_set_up_count = 0;
|
||||
int g_environment_tear_down_count = 0;
|
||||
|
||||
class MyEnvironment : public testing::Environment {
|
||||
public:
|
||||
MyEnvironment() {}
|
||||
virtual void SetUp() { g_environment_set_up_count++; }
|
||||
virtual void TearDown() { g_environment_tear_down_count++; }
|
||||
};
|
||||
|
||||
// A test that should fail.
|
||||
|
||||
int g_should_fail_count = 0;
|
||||
|
||||
TEST(FooTest, ShouldFail) {
|
||||
g_should_fail_count++;
|
||||
EXPECT_EQ(0, 1) << "Expected failure.";
|
||||
}
|
||||
|
||||
// A test that should pass.
|
||||
|
||||
int g_should_pass_count = 0;
|
||||
|
||||
TEST(FooTest, ShouldPass) {
|
||||
g_should_pass_count++;
|
||||
}
|
||||
|
||||
// A test that contains a thread-safe death test and a fast death
|
||||
// test. It should pass.
|
||||
|
||||
int g_death_test_count = 0;
|
||||
|
||||
TEST(BarDeathTest, ThreadSafeAndFast) {
|
||||
g_death_test_count++;
|
||||
|
||||
GTEST_FLAG(death_test_style) = "threadsafe";
|
||||
EXPECT_DEATH_IF_SUPPORTED(::testing::internal::posix::Abort(), "");
|
||||
|
||||
GTEST_FLAG(death_test_style) = "fast";
|
||||
EXPECT_DEATH_IF_SUPPORTED(::testing::internal::posix::Abort(), "");
|
||||
}
|
||||
|
||||
#if GTEST_HAS_PARAM_TEST
|
||||
int g_param_test_count = 0;
|
||||
|
||||
const int kNumberOfParamTests = 10;
|
||||
|
||||
class MyParamTest : public testing::TestWithParam<int> {};
|
||||
|
||||
TEST_P(MyParamTest, ShouldPass) {
|
||||
// TODO(vladl@google.com): Make parameter value checking robust
|
||||
// WRT order of tests.
|
||||
GTEST_CHECK_INT_EQ_(g_param_test_count % kNumberOfParamTests, GetParam());
|
||||
g_param_test_count++;
|
||||
}
|
||||
INSTANTIATE_TEST_CASE_P(MyParamSequence,
|
||||
MyParamTest,
|
||||
testing::Range(0, kNumberOfParamTests));
|
||||
#endif // GTEST_HAS_PARAM_TEST
|
||||
|
||||
// Resets the count for each test.
|
||||
void ResetCounts() {
|
||||
g_environment_set_up_count = 0;
|
||||
g_environment_tear_down_count = 0;
|
||||
g_should_fail_count = 0;
|
||||
g_should_pass_count = 0;
|
||||
g_death_test_count = 0;
|
||||
#if GTEST_HAS_PARAM_TEST
|
||||
g_param_test_count = 0;
|
||||
#endif // GTEST_HAS_PARAM_TEST
|
||||
}
|
||||
|
||||
// Checks that the count for each test is expected.
|
||||
void CheckCounts(int expected) {
|
||||
GTEST_CHECK_INT_EQ_(expected, g_environment_set_up_count);
|
||||
GTEST_CHECK_INT_EQ_(expected, g_environment_tear_down_count);
|
||||
GTEST_CHECK_INT_EQ_(expected, g_should_fail_count);
|
||||
GTEST_CHECK_INT_EQ_(expected, g_should_pass_count);
|
||||
GTEST_CHECK_INT_EQ_(expected, g_death_test_count);
|
||||
#if GTEST_HAS_PARAM_TEST
|
||||
GTEST_CHECK_INT_EQ_(expected * kNumberOfParamTests, g_param_test_count);
|
||||
#endif // GTEST_HAS_PARAM_TEST
|
||||
}
|
||||
|
||||
// Tests the behavior of Google Test when --gtest_repeat is not specified.
|
||||
void TestRepeatUnspecified() {
|
||||
ResetCounts();
|
||||
GTEST_CHECK_INT_EQ_(1, RUN_ALL_TESTS());
|
||||
CheckCounts(1);
|
||||
}
|
||||
|
||||
// Tests the behavior of Google Test when --gtest_repeat has the given value.
|
||||
void TestRepeat(int repeat) {
|
||||
GTEST_FLAG(repeat) = repeat;
|
||||
|
||||
ResetCounts();
|
||||
GTEST_CHECK_INT_EQ_(repeat > 0 ? 1 : 0, RUN_ALL_TESTS());
|
||||
CheckCounts(repeat);
|
||||
}
|
||||
|
||||
// Tests using --gtest_repeat when --gtest_filter specifies an empty
|
||||
// set of tests.
|
||||
void TestRepeatWithEmptyFilter(int repeat) {
|
||||
GTEST_FLAG(repeat) = repeat;
|
||||
GTEST_FLAG(filter) = "None";
|
||||
|
||||
ResetCounts();
|
||||
GTEST_CHECK_INT_EQ_(0, RUN_ALL_TESTS());
|
||||
CheckCounts(0);
|
||||
}
|
||||
|
||||
// Tests using --gtest_repeat when --gtest_filter specifies a set of
|
||||
// successful tests.
|
||||
void TestRepeatWithFilterForSuccessfulTests(int repeat) {
|
||||
GTEST_FLAG(repeat) = repeat;
|
||||
GTEST_FLAG(filter) = "*-*ShouldFail";
|
||||
|
||||
ResetCounts();
|
||||
GTEST_CHECK_INT_EQ_(0, RUN_ALL_TESTS());
|
||||
GTEST_CHECK_INT_EQ_(repeat, g_environment_set_up_count);
|
||||
GTEST_CHECK_INT_EQ_(repeat, g_environment_tear_down_count);
|
||||
GTEST_CHECK_INT_EQ_(0, g_should_fail_count);
|
||||
GTEST_CHECK_INT_EQ_(repeat, g_should_pass_count);
|
||||
GTEST_CHECK_INT_EQ_(repeat, g_death_test_count);
|
||||
#if GTEST_HAS_PARAM_TEST
|
||||
GTEST_CHECK_INT_EQ_(repeat * kNumberOfParamTests, g_param_test_count);
|
||||
#endif // GTEST_HAS_PARAM_TEST
|
||||
}
|
||||
|
||||
// Tests using --gtest_repeat when --gtest_filter specifies a set of
|
||||
// failed tests.
|
||||
void TestRepeatWithFilterForFailedTests(int repeat) {
|
||||
GTEST_FLAG(repeat) = repeat;
|
||||
GTEST_FLAG(filter) = "*ShouldFail";
|
||||
|
||||
ResetCounts();
|
||||
GTEST_CHECK_INT_EQ_(1, RUN_ALL_TESTS());
|
||||
GTEST_CHECK_INT_EQ_(repeat, g_environment_set_up_count);
|
||||
GTEST_CHECK_INT_EQ_(repeat, g_environment_tear_down_count);
|
||||
GTEST_CHECK_INT_EQ_(repeat, g_should_fail_count);
|
||||
GTEST_CHECK_INT_EQ_(0, g_should_pass_count);
|
||||
GTEST_CHECK_INT_EQ_(0, g_death_test_count);
|
||||
#if GTEST_HAS_PARAM_TEST
|
||||
GTEST_CHECK_INT_EQ_(0, g_param_test_count);
|
||||
#endif // GTEST_HAS_PARAM_TEST
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
testing::InitGoogleTest(&argc, argv);
|
||||
testing::AddGlobalTestEnvironment(new MyEnvironment);
|
||||
|
||||
TestRepeatUnspecified();
|
||||
TestRepeat(0);
|
||||
TestRepeat(1);
|
||||
TestRepeat(5);
|
||||
|
||||
TestRepeatWithEmptyFilter(2);
|
||||
TestRepeatWithEmptyFilter(3);
|
||||
|
||||
TestRepeatWithFilterForSuccessfulTests(3);
|
||||
|
||||
TestRepeatWithFilterForFailedTests(4);
|
||||
|
||||
// It would be nice to verify that the tests indeed loop forever
|
||||
// when GTEST_FLAG(repeat) is negative, but this test will be quite
|
||||
// complicated to write. Since this flag is for interactive
|
||||
// debugging only and doesn't affect the normal test result, such a
|
||||
// test would be an overkill.
|
||||
|
||||
printf("PASS\n");
|
||||
return 0;
|
||||
}
|
325
gtest/test/gtest_shuffle_test.py
Executable file
325
gtest/test/gtest_shuffle_test.py
Executable file
@ -0,0 +1,325 @@
|
||||
#!/usr/bin/env python
|
||||
#
|
||||
# Copyright 2009 Google Inc. All Rights Reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are
|
||||
# met:
|
||||
#
|
||||
# * Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# * Redistributions in binary form must reproduce the above
|
||||
# copyright notice, this list of conditions and the following disclaimer
|
||||
# in the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
# * Neither the name of Google Inc. nor the names of its
|
||||
# contributors may be used to endorse or promote products derived from
|
||||
# this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
"""Verifies that test shuffling works."""
|
||||
|
||||
__author__ = 'wan@google.com (Zhanyong Wan)'
|
||||
|
||||
import os
|
||||
import gtest_test_utils
|
||||
|
||||
# Command to run the gtest_shuffle_test_ program.
|
||||
COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_shuffle_test_')
|
||||
|
||||
# The environment variables for test sharding.
|
||||
TOTAL_SHARDS_ENV_VAR = 'GTEST_TOTAL_SHARDS'
|
||||
SHARD_INDEX_ENV_VAR = 'GTEST_SHARD_INDEX'
|
||||
|
||||
TEST_FILTER = 'A*.A:A*.B:C*'
|
||||
|
||||
ALL_TESTS = []
|
||||
ACTIVE_TESTS = []
|
||||
FILTERED_TESTS = []
|
||||
SHARDED_TESTS = []
|
||||
|
||||
SHUFFLED_ALL_TESTS = []
|
||||
SHUFFLED_ACTIVE_TESTS = []
|
||||
SHUFFLED_FILTERED_TESTS = []
|
||||
SHUFFLED_SHARDED_TESTS = []
|
||||
|
||||
|
||||
def AlsoRunDisabledTestsFlag():
|
||||
return '--gtest_also_run_disabled_tests'
|
||||
|
||||
|
||||
def FilterFlag(test_filter):
|
||||
return '--gtest_filter=%s' % (test_filter,)
|
||||
|
||||
|
||||
def RepeatFlag(n):
|
||||
return '--gtest_repeat=%s' % (n,)
|
||||
|
||||
|
||||
def ShuffleFlag():
|
||||
return '--gtest_shuffle'
|
||||
|
||||
|
||||
def RandomSeedFlag(n):
|
||||
return '--gtest_random_seed=%s' % (n,)
|
||||
|
||||
|
||||
def RunAndReturnOutput(extra_env, args):
|
||||
"""Runs the test program and returns its output."""
|
||||
|
||||
environ_copy = os.environ.copy()
|
||||
environ_copy.update(extra_env)
|
||||
|
||||
return gtest_test_utils.Subprocess([COMMAND] + args, env=environ_copy).output
|
||||
|
||||
|
||||
def GetTestsForAllIterations(extra_env, args):
|
||||
"""Runs the test program and returns a list of test lists.
|
||||
|
||||
Args:
|
||||
extra_env: a map from environment variables to their values
|
||||
args: command line flags to pass to gtest_shuffle_test_
|
||||
|
||||
Returns:
|
||||
A list where the i-th element is the list of tests run in the i-th
|
||||
test iteration.
|
||||
"""
|
||||
|
||||
test_iterations = []
|
||||
for line in RunAndReturnOutput(extra_env, args).split('\n'):
|
||||
if line.startswith('----'):
|
||||
tests = []
|
||||
test_iterations.append(tests)
|
||||
elif line.strip():
|
||||
tests.append(line.strip()) # 'TestCaseName.TestName'
|
||||
|
||||
return test_iterations
|
||||
|
||||
|
||||
def GetTestCases(tests):
|
||||
"""Returns a list of test cases in the given full test names.
|
||||
|
||||
Args:
|
||||
tests: a list of full test names
|
||||
|
||||
Returns:
|
||||
A list of test cases from 'tests', in their original order.
|
||||
Consecutive duplicates are removed.
|
||||
"""
|
||||
|
||||
test_cases = []
|
||||
for test in tests:
|
||||
test_case = test.split('.')[0]
|
||||
if not test_case in test_cases:
|
||||
test_cases.append(test_case)
|
||||
|
||||
return test_cases
|
||||
|
||||
|
||||
def CalculateTestLists():
|
||||
"""Calculates the list of tests run under different flags."""
|
||||
|
||||
if not ALL_TESTS:
|
||||
ALL_TESTS.extend(
|
||||
GetTestsForAllIterations({}, [AlsoRunDisabledTestsFlag()])[0])
|
||||
|
||||
if not ACTIVE_TESTS:
|
||||
ACTIVE_TESTS.extend(GetTestsForAllIterations({}, [])[0])
|
||||
|
||||
if not FILTERED_TESTS:
|
||||
FILTERED_TESTS.extend(
|
||||
GetTestsForAllIterations({}, [FilterFlag(TEST_FILTER)])[0])
|
||||
|
||||
if not SHARDED_TESTS:
|
||||
SHARDED_TESTS.extend(
|
||||
GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
|
||||
SHARD_INDEX_ENV_VAR: '1'},
|
||||
[])[0])
|
||||
|
||||
if not SHUFFLED_ALL_TESTS:
|
||||
SHUFFLED_ALL_TESTS.extend(GetTestsForAllIterations(
|
||||
{}, [AlsoRunDisabledTestsFlag(), ShuffleFlag(), RandomSeedFlag(1)])[0])
|
||||
|
||||
if not SHUFFLED_ACTIVE_TESTS:
|
||||
SHUFFLED_ACTIVE_TESTS.extend(GetTestsForAllIterations(
|
||||
{}, [ShuffleFlag(), RandomSeedFlag(1)])[0])
|
||||
|
||||
if not SHUFFLED_FILTERED_TESTS:
|
||||
SHUFFLED_FILTERED_TESTS.extend(GetTestsForAllIterations(
|
||||
{}, [ShuffleFlag(), RandomSeedFlag(1), FilterFlag(TEST_FILTER)])[0])
|
||||
|
||||
if not SHUFFLED_SHARDED_TESTS:
|
||||
SHUFFLED_SHARDED_TESTS.extend(
|
||||
GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
|
||||
SHARD_INDEX_ENV_VAR: '1'},
|
||||
[ShuffleFlag(), RandomSeedFlag(1)])[0])
|
||||
|
||||
|
||||
class GTestShuffleUnitTest(gtest_test_utils.TestCase):
|
||||
"""Tests test shuffling."""
|
||||
|
||||
def setUp(self):
|
||||
CalculateTestLists()
|
||||
|
||||
def testShufflePreservesNumberOfTests(self):
|
||||
self.assertEqual(len(ALL_TESTS), len(SHUFFLED_ALL_TESTS))
|
||||
self.assertEqual(len(ACTIVE_TESTS), len(SHUFFLED_ACTIVE_TESTS))
|
||||
self.assertEqual(len(FILTERED_TESTS), len(SHUFFLED_FILTERED_TESTS))
|
||||
self.assertEqual(len(SHARDED_TESTS), len(SHUFFLED_SHARDED_TESTS))
|
||||
|
||||
def testShuffleChangesTestOrder(self):
|
||||
self.assert_(SHUFFLED_ALL_TESTS != ALL_TESTS, SHUFFLED_ALL_TESTS)
|
||||
self.assert_(SHUFFLED_ACTIVE_TESTS != ACTIVE_TESTS, SHUFFLED_ACTIVE_TESTS)
|
||||
self.assert_(SHUFFLED_FILTERED_TESTS != FILTERED_TESTS,
|
||||
SHUFFLED_FILTERED_TESTS)
|
||||
self.assert_(SHUFFLED_SHARDED_TESTS != SHARDED_TESTS,
|
||||
SHUFFLED_SHARDED_TESTS)
|
||||
|
||||
def testShuffleChangesTestCaseOrder(self):
|
||||
self.assert_(GetTestCases(SHUFFLED_ALL_TESTS) != GetTestCases(ALL_TESTS),
|
||||
GetTestCases(SHUFFLED_ALL_TESTS))
|
||||
self.assert_(
|
||||
GetTestCases(SHUFFLED_ACTIVE_TESTS) != GetTestCases(ACTIVE_TESTS),
|
||||
GetTestCases(SHUFFLED_ACTIVE_TESTS))
|
||||
self.assert_(
|
||||
GetTestCases(SHUFFLED_FILTERED_TESTS) != GetTestCases(FILTERED_TESTS),
|
||||
GetTestCases(SHUFFLED_FILTERED_TESTS))
|
||||
self.assert_(
|
||||
GetTestCases(SHUFFLED_SHARDED_TESTS) != GetTestCases(SHARDED_TESTS),
|
||||
GetTestCases(SHUFFLED_SHARDED_TESTS))
|
||||
|
||||
def testShuffleDoesNotRepeatTest(self):
|
||||
for test in SHUFFLED_ALL_TESTS:
|
||||
self.assertEqual(1, SHUFFLED_ALL_TESTS.count(test),
|
||||
'%s appears more than once' % (test,))
|
||||
for test in SHUFFLED_ACTIVE_TESTS:
|
||||
self.assertEqual(1, SHUFFLED_ACTIVE_TESTS.count(test),
|
||||
'%s appears more than once' % (test,))
|
||||
for test in SHUFFLED_FILTERED_TESTS:
|
||||
self.assertEqual(1, SHUFFLED_FILTERED_TESTS.count(test),
|
||||
'%s appears more than once' % (test,))
|
||||
for test in SHUFFLED_SHARDED_TESTS:
|
||||
self.assertEqual(1, SHUFFLED_SHARDED_TESTS.count(test),
|
||||
'%s appears more than once' % (test,))
|
||||
|
||||
def testShuffleDoesNotCreateNewTest(self):
|
||||
for test in SHUFFLED_ALL_TESTS:
|
||||
self.assert_(test in ALL_TESTS, '%s is an invalid test' % (test,))
|
||||
for test in SHUFFLED_ACTIVE_TESTS:
|
||||
self.assert_(test in ACTIVE_TESTS, '%s is an invalid test' % (test,))
|
||||
for test in SHUFFLED_FILTERED_TESTS:
|
||||
self.assert_(test in FILTERED_TESTS, '%s is an invalid test' % (test,))
|
||||
for test in SHUFFLED_SHARDED_TESTS:
|
||||
self.assert_(test in SHARDED_TESTS, '%s is an invalid test' % (test,))
|
||||
|
||||
def testShuffleIncludesAllTests(self):
|
||||
for test in ALL_TESTS:
|
||||
self.assert_(test in SHUFFLED_ALL_TESTS, '%s is missing' % (test,))
|
||||
for test in ACTIVE_TESTS:
|
||||
self.assert_(test in SHUFFLED_ACTIVE_TESTS, '%s is missing' % (test,))
|
||||
for test in FILTERED_TESTS:
|
||||
self.assert_(test in SHUFFLED_FILTERED_TESTS, '%s is missing' % (test,))
|
||||
for test in SHARDED_TESTS:
|
||||
self.assert_(test in SHUFFLED_SHARDED_TESTS, '%s is missing' % (test,))
|
||||
|
||||
def testShuffleLeavesDeathTestsAtFront(self):
|
||||
non_death_test_found = False
|
||||
for test in SHUFFLED_ACTIVE_TESTS:
|
||||
if 'DeathTest.' in test:
|
||||
self.assert_(not non_death_test_found,
|
||||
'%s appears after a non-death test' % (test,))
|
||||
else:
|
||||
non_death_test_found = True
|
||||
|
||||
def _VerifyTestCasesDoNotInterleave(self, tests):
|
||||
test_cases = []
|
||||
for test in tests:
|
||||
[test_case, _] = test.split('.')
|
||||
if test_cases and test_cases[-1] != test_case:
|
||||
test_cases.append(test_case)
|
||||
self.assertEqual(1, test_cases.count(test_case),
|
||||
'Test case %s is not grouped together in %s' %
|
||||
(test_case, tests))
|
||||
|
||||
def testShuffleDoesNotInterleaveTestCases(self):
|
||||
self._VerifyTestCasesDoNotInterleave(SHUFFLED_ALL_TESTS)
|
||||
self._VerifyTestCasesDoNotInterleave(SHUFFLED_ACTIVE_TESTS)
|
||||
self._VerifyTestCasesDoNotInterleave(SHUFFLED_FILTERED_TESTS)
|
||||
self._VerifyTestCasesDoNotInterleave(SHUFFLED_SHARDED_TESTS)
|
||||
|
||||
def testShuffleRestoresOrderAfterEachIteration(self):
|
||||
# Get the test lists in all 3 iterations, using random seed 1, 2,
|
||||
# and 3 respectively. Google Test picks a different seed in each
|
||||
# iteration, and this test depends on the current implementation
|
||||
# picking successive numbers. This dependency is not ideal, but
|
||||
# makes the test much easier to write.
|
||||
[tests_in_iteration1, tests_in_iteration2, tests_in_iteration3] = (
|
||||
GetTestsForAllIterations(
|
||||
{}, [ShuffleFlag(), RandomSeedFlag(1), RepeatFlag(3)]))
|
||||
|
||||
# Make sure running the tests with random seed 1 gets the same
|
||||
# order as in iteration 1 above.
|
||||
[tests_with_seed1] = GetTestsForAllIterations(
|
||||
{}, [ShuffleFlag(), RandomSeedFlag(1)])
|
||||
self.assertEqual(tests_in_iteration1, tests_with_seed1)
|
||||
|
||||
# Make sure running the tests with random seed 2 gets the same
|
||||
# order as in iteration 2 above. Success means that Google Test
|
||||
# correctly restores the test order before re-shuffling at the
|
||||
# beginning of iteration 2.
|
||||
[tests_with_seed2] = GetTestsForAllIterations(
|
||||
{}, [ShuffleFlag(), RandomSeedFlag(2)])
|
||||
self.assertEqual(tests_in_iteration2, tests_with_seed2)
|
||||
|
||||
# Make sure running the tests with random seed 3 gets the same
|
||||
# order as in iteration 3 above. Success means that Google Test
|
||||
# correctly restores the test order before re-shuffling at the
|
||||
# beginning of iteration 3.
|
||||
[tests_with_seed3] = GetTestsForAllIterations(
|
||||
{}, [ShuffleFlag(), RandomSeedFlag(3)])
|
||||
self.assertEqual(tests_in_iteration3, tests_with_seed3)
|
||||
|
||||
def testShuffleGeneratesNewOrderInEachIteration(self):
|
||||
[tests_in_iteration1, tests_in_iteration2, tests_in_iteration3] = (
|
||||
GetTestsForAllIterations(
|
||||
{}, [ShuffleFlag(), RandomSeedFlag(1), RepeatFlag(3)]))
|
||||
|
||||
self.assert_(tests_in_iteration1 != tests_in_iteration2,
|
||||
tests_in_iteration1)
|
||||
self.assert_(tests_in_iteration1 != tests_in_iteration3,
|
||||
tests_in_iteration1)
|
||||
self.assert_(tests_in_iteration2 != tests_in_iteration3,
|
||||
tests_in_iteration2)
|
||||
|
||||
def testShuffleShardedTestsPreservesPartition(self):
|
||||
# If we run M tests on N shards, the same M tests should be run in
|
||||
# total, regardless of the random seeds used by the shards.
|
||||
[tests1] = GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
|
||||
SHARD_INDEX_ENV_VAR: '0'},
|
||||
[ShuffleFlag(), RandomSeedFlag(1)])
|
||||
[tests2] = GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
|
||||
SHARD_INDEX_ENV_VAR: '1'},
|
||||
[ShuffleFlag(), RandomSeedFlag(20)])
|
||||
[tests3] = GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
|
||||
SHARD_INDEX_ENV_VAR: '2'},
|
||||
[ShuffleFlag(), RandomSeedFlag(25)])
|
||||
sorted_sharded_tests = tests1 + tests2 + tests3
|
||||
sorted_sharded_tests.sort()
|
||||
sorted_active_tests = []
|
||||
sorted_active_tests.extend(ACTIVE_TESTS)
|
||||
sorted_active_tests.sort()
|
||||
self.assertEqual(sorted_active_tests, sorted_sharded_tests)
|
||||
|
||||
if __name__ == '__main__':
|
||||
gtest_test_utils.Main()
|
104
gtest/test/gtest_shuffle_test_.cc
Normal file
104
gtest/test/gtest_shuffle_test_.cc
Normal file
@ -0,0 +1,104 @@
|
||||
// Copyright 2009, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
// Verifies that test shuffling works.
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
namespace {
|
||||
|
||||
using ::testing::EmptyTestEventListener;
|
||||
using ::testing::InitGoogleTest;
|
||||
using ::testing::Message;
|
||||
using ::testing::Test;
|
||||
using ::testing::TestEventListeners;
|
||||
using ::testing::TestInfo;
|
||||
using ::testing::UnitTest;
|
||||
using ::testing::internal::String;
|
||||
using ::testing::internal::scoped_ptr;
|
||||
|
||||
// The test methods are empty, as the sole purpose of this program is
|
||||
// to print the test names before/after shuffling.
|
||||
|
||||
class A : public Test {};
|
||||
TEST_F(A, A) {}
|
||||
TEST_F(A, B) {}
|
||||
|
||||
TEST(ADeathTest, A) {}
|
||||
TEST(ADeathTest, B) {}
|
||||
TEST(ADeathTest, C) {}
|
||||
|
||||
TEST(B, A) {}
|
||||
TEST(B, B) {}
|
||||
TEST(B, C) {}
|
||||
TEST(B, DISABLED_D) {}
|
||||
TEST(B, DISABLED_E) {}
|
||||
|
||||
TEST(BDeathTest, A) {}
|
||||
TEST(BDeathTest, B) {}
|
||||
|
||||
TEST(C, A) {}
|
||||
TEST(C, B) {}
|
||||
TEST(C, C) {}
|
||||
TEST(C, DISABLED_D) {}
|
||||
|
||||
TEST(CDeathTest, A) {}
|
||||
|
||||
TEST(DISABLED_D, A) {}
|
||||
TEST(DISABLED_D, DISABLED_B) {}
|
||||
|
||||
// This printer prints the full test names only, starting each test
|
||||
// iteration with a "----" marker.
|
||||
class TestNamePrinter : public EmptyTestEventListener {
|
||||
public:
|
||||
virtual void OnTestIterationStart(const UnitTest& /* unit_test */,
|
||||
int /* iteration */) {
|
||||
printf("----\n");
|
||||
}
|
||||
|
||||
virtual void OnTestStart(const TestInfo& test_info) {
|
||||
printf("%s.%s\n", test_info.test_case_name(), test_info.name());
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
InitGoogleTest(&argc, argv);
|
||||
|
||||
// Replaces the default printer with TestNamePrinter, which prints
|
||||
// the test name only.
|
||||
TestEventListeners& listeners = UnitTest::GetInstance()->listeners();
|
||||
delete listeners.Release(listeners.default_result_printer());
|
||||
listeners.Append(new TestNamePrinter);
|
||||
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
57
gtest/test/gtest_sole_header_test.cc
Normal file
57
gtest/test/gtest_sole_header_test.cc
Normal file
@ -0,0 +1,57 @@
|
||||
// Copyright 2008, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: mheule@google.com (Markus Heule)
|
||||
//
|
||||
// This test verifies that it's possible to use Google Test by including
|
||||
// the gtest.h header file alone.
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
namespace {
|
||||
|
||||
void Subroutine() {
|
||||
EXPECT_EQ(42, 42);
|
||||
}
|
||||
|
||||
TEST(NoFatalFailureTest, ExpectNoFatalFailure) {
|
||||
EXPECT_NO_FATAL_FAILURE(;);
|
||||
EXPECT_NO_FATAL_FAILURE(SUCCEED());
|
||||
EXPECT_NO_FATAL_FAILURE(Subroutine());
|
||||
EXPECT_NO_FATAL_FAILURE({ SUCCEED(); });
|
||||
}
|
||||
|
||||
TEST(NoFatalFailureTest, AssertNoFatalFailure) {
|
||||
ASSERT_NO_FATAL_FAILURE(;);
|
||||
ASSERT_NO_FATAL_FAILURE(SUCCEED());
|
||||
ASSERT_NO_FATAL_FAILURE(Subroutine());
|
||||
ASSERT_NO_FATAL_FAILURE({ SUCCEED(); });
|
||||
}
|
||||
|
||||
} // namespace
|
257
gtest/test/gtest_stress_test.cc
Normal file
257
gtest/test/gtest_stress_test.cc
Normal file
@ -0,0 +1,257 @@
|
||||
// Copyright 2007, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
// Tests that SCOPED_TRACE() and various Google Test assertions can be
|
||||
// used in a large number of threads concurrently.
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
|
||||
// We must define this macro in order to #include
|
||||
// gtest-internal-inl.h. This is how Google Test prevents a user from
|
||||
// accidentally depending on its internal implementation.
|
||||
#define GTEST_IMPLEMENTATION_ 1
|
||||
#include "src/gtest-internal-inl.h"
|
||||
#undef GTEST_IMPLEMENTATION_
|
||||
|
||||
#if GTEST_IS_THREADSAFE
|
||||
|
||||
namespace testing {
|
||||
namespace {
|
||||
|
||||
using internal::Notification;
|
||||
using internal::String;
|
||||
using internal::TestPropertyKeyIs;
|
||||
using internal::ThreadWithParam;
|
||||
using internal::scoped_ptr;
|
||||
|
||||
// In order to run tests in this file, for platforms where Google Test is
|
||||
// thread safe, implement ThreadWithParam. See the description of its API
|
||||
// in gtest-port.h, where it is defined for already supported platforms.
|
||||
|
||||
// How many threads to create?
|
||||
const int kThreadCount = 50;
|
||||
|
||||
String IdToKey(int id, const char* suffix) {
|
||||
Message key;
|
||||
key << "key_" << id << "_" << suffix;
|
||||
return key.GetString();
|
||||
}
|
||||
|
||||
String IdToString(int id) {
|
||||
Message id_message;
|
||||
id_message << id;
|
||||
return id_message.GetString();
|
||||
}
|
||||
|
||||
void ExpectKeyAndValueWereRecordedForId(
|
||||
const std::vector<TestProperty>& properties,
|
||||
int id, const char* suffix) {
|
||||
TestPropertyKeyIs matches_key(IdToKey(id, suffix).c_str());
|
||||
const std::vector<TestProperty>::const_iterator property =
|
||||
std::find_if(properties.begin(), properties.end(), matches_key);
|
||||
ASSERT_TRUE(property != properties.end())
|
||||
<< "expecting " << suffix << " value for id " << id;
|
||||
EXPECT_STREQ(IdToString(id).c_str(), property->value());
|
||||
}
|
||||
|
||||
// Calls a large number of Google Test assertions, where exactly one of them
|
||||
// will fail.
|
||||
void ManyAsserts(int id) {
|
||||
GTEST_LOG_(INFO) << "Thread #" << id << " running...";
|
||||
|
||||
SCOPED_TRACE(Message() << "Thread #" << id);
|
||||
|
||||
for (int i = 0; i < kThreadCount; i++) {
|
||||
SCOPED_TRACE(Message() << "Iteration #" << i);
|
||||
|
||||
// A bunch of assertions that should succeed.
|
||||
EXPECT_TRUE(true);
|
||||
ASSERT_FALSE(false) << "This shouldn't fail.";
|
||||
EXPECT_STREQ("a", "a");
|
||||
ASSERT_LE(5, 6);
|
||||
EXPECT_EQ(i, i) << "This shouldn't fail.";
|
||||
|
||||
// RecordProperty() should interact safely with other threads as well.
|
||||
// The shared_key forces property updates.
|
||||
Test::RecordProperty(IdToKey(id, "string").c_str(), IdToString(id).c_str());
|
||||
Test::RecordProperty(IdToKey(id, "int").c_str(), id);
|
||||
Test::RecordProperty("shared_key", IdToString(id).c_str());
|
||||
|
||||
// This assertion should fail kThreadCount times per thread. It
|
||||
// is for testing whether Google Test can handle failed assertions in a
|
||||
// multi-threaded context.
|
||||
EXPECT_LT(i, 0) << "This should always fail.";
|
||||
}
|
||||
}
|
||||
|
||||
void CheckTestFailureCount(int expected_failures) {
|
||||
const TestInfo* const info = UnitTest::GetInstance()->current_test_info();
|
||||
const TestResult* const result = info->result();
|
||||
GTEST_CHECK_(expected_failures == result->total_part_count())
|
||||
<< "Logged " << result->total_part_count() << " failures "
|
||||
<< " vs. " << expected_failures << " expected";
|
||||
}
|
||||
|
||||
// Tests using SCOPED_TRACE() and Google Test assertions in many threads
|
||||
// concurrently.
|
||||
TEST(StressTest, CanUseScopedTraceAndAssertionsInManyThreads) {
|
||||
{
|
||||
scoped_ptr<ThreadWithParam<int> > threads[kThreadCount];
|
||||
Notification threads_can_start;
|
||||
for (int i = 0; i != kThreadCount; i++)
|
||||
threads[i].reset(new ThreadWithParam<int>(&ManyAsserts,
|
||||
i,
|
||||
&threads_can_start));
|
||||
|
||||
threads_can_start.Notify();
|
||||
|
||||
// Blocks until all the threads are done.
|
||||
for (int i = 0; i != kThreadCount; i++)
|
||||
threads[i]->Join();
|
||||
}
|
||||
|
||||
// Ensures that kThreadCount*kThreadCount failures have been reported.
|
||||
const TestInfo* const info = UnitTest::GetInstance()->current_test_info();
|
||||
const TestResult* const result = info->result();
|
||||
|
||||
std::vector<TestProperty> properties;
|
||||
// We have no access to the TestResult's list of properties but we can
|
||||
// copy them one by one.
|
||||
for (int i = 0; i < result->test_property_count(); ++i)
|
||||
properties.push_back(result->GetTestProperty(i));
|
||||
|
||||
EXPECT_EQ(kThreadCount * 2 + 1, result->test_property_count())
|
||||
<< "String and int values recorded on each thread, "
|
||||
<< "as well as one shared_key";
|
||||
for (int i = 0; i < kThreadCount; ++i) {
|
||||
ExpectKeyAndValueWereRecordedForId(properties, i, "string");
|
||||
ExpectKeyAndValueWereRecordedForId(properties, i, "int");
|
||||
}
|
||||
CheckTestFailureCount(kThreadCount*kThreadCount);
|
||||
}
|
||||
|
||||
void FailingThread(bool is_fatal) {
|
||||
if (is_fatal)
|
||||
FAIL() << "Fatal failure in some other thread. "
|
||||
<< "(This failure is expected.)";
|
||||
else
|
||||
ADD_FAILURE() << "Non-fatal failure in some other thread. "
|
||||
<< "(This failure is expected.)";
|
||||
}
|
||||
|
||||
void GenerateFatalFailureInAnotherThread(bool is_fatal) {
|
||||
ThreadWithParam<bool> thread(&FailingThread, is_fatal, NULL);
|
||||
thread.Join();
|
||||
}
|
||||
|
||||
TEST(NoFatalFailureTest, ExpectNoFatalFailureIgnoresFailuresInOtherThreads) {
|
||||
EXPECT_NO_FATAL_FAILURE(GenerateFatalFailureInAnotherThread(true));
|
||||
// We should only have one failure (the one from
|
||||
// GenerateFatalFailureInAnotherThread()), since the EXPECT_NO_FATAL_FAILURE
|
||||
// should succeed.
|
||||
CheckTestFailureCount(1);
|
||||
}
|
||||
|
||||
void AssertNoFatalFailureIgnoresFailuresInOtherThreads() {
|
||||
ASSERT_NO_FATAL_FAILURE(GenerateFatalFailureInAnotherThread(true));
|
||||
}
|
||||
TEST(NoFatalFailureTest, AssertNoFatalFailureIgnoresFailuresInOtherThreads) {
|
||||
// Using a subroutine, to make sure, that the test continues.
|
||||
AssertNoFatalFailureIgnoresFailuresInOtherThreads();
|
||||
// We should only have one failure (the one from
|
||||
// GenerateFatalFailureInAnotherThread()), since the EXPECT_NO_FATAL_FAILURE
|
||||
// should succeed.
|
||||
CheckTestFailureCount(1);
|
||||
}
|
||||
|
||||
TEST(FatalFailureTest, ExpectFatalFailureIgnoresFailuresInOtherThreads) {
|
||||
// This statement should fail, since the current thread doesn't generate a
|
||||
// fatal failure, only another one does.
|
||||
EXPECT_FATAL_FAILURE(GenerateFatalFailureInAnotherThread(true), "expected");
|
||||
CheckTestFailureCount(2);
|
||||
}
|
||||
|
||||
TEST(FatalFailureOnAllThreadsTest, ExpectFatalFailureOnAllThreads) {
|
||||
// This statement should succeed, because failures in all threads are
|
||||
// considered.
|
||||
EXPECT_FATAL_FAILURE_ON_ALL_THREADS(
|
||||
GenerateFatalFailureInAnotherThread(true), "expected");
|
||||
CheckTestFailureCount(0);
|
||||
// We need to add a failure, because main() checks that there are failures.
|
||||
// But when only this test is run, we shouldn't have any failures.
|
||||
ADD_FAILURE() << "This is an expected non-fatal failure.";
|
||||
}
|
||||
|
||||
TEST(NonFatalFailureTest, ExpectNonFatalFailureIgnoresFailuresInOtherThreads) {
|
||||
// This statement should fail, since the current thread doesn't generate a
|
||||
// fatal failure, only another one does.
|
||||
EXPECT_NONFATAL_FAILURE(GenerateFatalFailureInAnotherThread(false),
|
||||
"expected");
|
||||
CheckTestFailureCount(2);
|
||||
}
|
||||
|
||||
TEST(NonFatalFailureOnAllThreadsTest, ExpectNonFatalFailureOnAllThreads) {
|
||||
// This statement should succeed, because failures in all threads are
|
||||
// considered.
|
||||
EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(
|
||||
GenerateFatalFailureInAnotherThread(false), "expected");
|
||||
CheckTestFailureCount(0);
|
||||
// We need to add a failure, because main() checks that there are failures,
|
||||
// But when only this test is run, we shouldn't have any failures.
|
||||
ADD_FAILURE() << "This is an expected non-fatal failure.";
|
||||
}
|
||||
|
||||
} // namespace
|
||||
} // namespace testing
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
testing::InitGoogleTest(&argc, argv);
|
||||
|
||||
const int result = RUN_ALL_TESTS(); // Expected to fail.
|
||||
GTEST_CHECK_(result == 1) << "RUN_ALL_TESTS() did not fail as expected";
|
||||
|
||||
printf("\nPASS\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
#else
|
||||
TEST(StressTest,
|
||||
DISABLED_ThreadSafetyTestsAreSkippedWhenGoogleTestIsNotThreadSafe) {
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
testing::InitGoogleTest(&argc, argv);
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
#endif // GTEST_IS_THREADSAFE
|
305
gtest/test/gtest_test_utils.py
Executable file
305
gtest/test/gtest_test_utils.py
Executable file
@ -0,0 +1,305 @@
|
||||
#!/usr/bin/env python
|
||||
#
|
||||
# Copyright 2006, Google Inc.
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are
|
||||
# met:
|
||||
#
|
||||
# * Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# * Redistributions in binary form must reproduce the above
|
||||
# copyright notice, this list of conditions and the following disclaimer
|
||||
# in the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
# * Neither the name of Google Inc. nor the names of its
|
||||
# contributors may be used to endorse or promote products derived from
|
||||
# this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
"""Unit test utilities for Google C++ Testing Framework."""
|
||||
|
||||
__author__ = 'wan@google.com (Zhanyong Wan)'
|
||||
|
||||
import atexit
|
||||
import os
|
||||
import shutil
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
_test_module = unittest
|
||||
|
||||
# Suppresses the 'Import not at the top of the file' lint complaint.
|
||||
# pylint: disable-msg=C6204
|
||||
try:
|
||||
import subprocess
|
||||
_SUBPROCESS_MODULE_AVAILABLE = True
|
||||
except:
|
||||
import popen2
|
||||
_SUBPROCESS_MODULE_AVAILABLE = False
|
||||
# pylint: enable-msg=C6204
|
||||
|
||||
GTEST_OUTPUT_VAR_NAME = 'GTEST_OUTPUT'
|
||||
|
||||
IS_WINDOWS = os.name == 'nt'
|
||||
IS_CYGWIN = os.name == 'posix' and 'CYGWIN' in os.uname()[0]
|
||||
|
||||
# Here we expose a class from a particular module, depending on the
|
||||
# environment. The comment suppresses the 'Invalid variable name' lint
|
||||
# complaint.
|
||||
TestCase = _test_module.TestCase # pylint: disable-msg=C6409
|
||||
|
||||
# Initially maps a flag to its default value. After
|
||||
# _ParseAndStripGTestFlags() is called, maps a flag to its actual value.
|
||||
_flag_map = {'source_dir': os.path.dirname(sys.argv[0]),
|
||||
'build_dir': os.path.dirname(sys.argv[0])}
|
||||
_gtest_flags_are_parsed = False
|
||||
|
||||
|
||||
def _ParseAndStripGTestFlags(argv):
|
||||
"""Parses and strips Google Test flags from argv. This is idempotent."""
|
||||
|
||||
# Suppresses the lint complaint about a global variable since we need it
|
||||
# here to maintain module-wide state.
|
||||
global _gtest_flags_are_parsed # pylint: disable-msg=W0603
|
||||
if _gtest_flags_are_parsed:
|
||||
return
|
||||
|
||||
_gtest_flags_are_parsed = True
|
||||
for flag in _flag_map:
|
||||
# The environment variable overrides the default value.
|
||||
if flag.upper() in os.environ:
|
||||
_flag_map[flag] = os.environ[flag.upper()]
|
||||
|
||||
# The command line flag overrides the environment variable.
|
||||
i = 1 # Skips the program name.
|
||||
while i < len(argv):
|
||||
prefix = '--' + flag + '='
|
||||
if argv[i].startswith(prefix):
|
||||
_flag_map[flag] = argv[i][len(prefix):]
|
||||
del argv[i]
|
||||
break
|
||||
else:
|
||||
# We don't increment i in case we just found a --gtest_* flag
|
||||
# and removed it from argv.
|
||||
i += 1
|
||||
|
||||
|
||||
def GetFlag(flag):
|
||||
"""Returns the value of the given flag."""
|
||||
|
||||
# In case GetFlag() is called before Main(), we always call
|
||||
# _ParseAndStripGTestFlags() here to make sure the --gtest_* flags
|
||||
# are parsed.
|
||||
_ParseAndStripGTestFlags(sys.argv)
|
||||
|
||||
return _flag_map[flag]
|
||||
|
||||
|
||||
def GetSourceDir():
|
||||
"""Returns the absolute path of the directory where the .py files are."""
|
||||
|
||||
return os.path.abspath(GetFlag('source_dir'))
|
||||
|
||||
|
||||
def GetBuildDir():
|
||||
"""Returns the absolute path of the directory where the test binaries are."""
|
||||
|
||||
return os.path.abspath(GetFlag('build_dir'))
|
||||
|
||||
|
||||
_temp_dir = None
|
||||
|
||||
def _RemoveTempDir():
|
||||
if _temp_dir:
|
||||
shutil.rmtree(_temp_dir, ignore_errors=True)
|
||||
|
||||
atexit.register(_RemoveTempDir)
|
||||
|
||||
|
||||
def GetTempDir():
|
||||
"""Returns a directory for temporary files."""
|
||||
|
||||
global _temp_dir
|
||||
if not _temp_dir:
|
||||
_temp_dir = tempfile.mkdtemp()
|
||||
return _temp_dir
|
||||
|
||||
|
||||
def GetTestExecutablePath(executable_name, build_dir=None):
|
||||
"""Returns the absolute path of the test binary given its name.
|
||||
|
||||
The function will print a message and abort the program if the resulting file
|
||||
doesn't exist.
|
||||
|
||||
Args:
|
||||
executable_name: name of the test binary that the test script runs.
|
||||
build_dir: directory where to look for executables, by default
|
||||
the result of GetBuildDir().
|
||||
|
||||
Returns:
|
||||
The absolute path of the test binary.
|
||||
"""
|
||||
|
||||
path = os.path.abspath(os.path.join(build_dir or GetBuildDir(),
|
||||
executable_name))
|
||||
if (IS_WINDOWS or IS_CYGWIN) and not path.endswith('.exe'):
|
||||
path += '.exe'
|
||||
|
||||
if not os.path.exists(path):
|
||||
message = (
|
||||
'Unable to find the test binary. Please make sure to provide path\n'
|
||||
'to the binary via the --build_dir flag or the BUILD_DIR\n'
|
||||
'environment variable.')
|
||||
print >> sys.stderr, message
|
||||
sys.exit(1)
|
||||
|
||||
return path
|
||||
|
||||
|
||||
def GetExitStatus(exit_code):
|
||||
"""Returns the argument to exit(), or -1 if exit() wasn't called.
|
||||
|
||||
Args:
|
||||
exit_code: the result value of os.system(command).
|
||||
"""
|
||||
|
||||
if os.name == 'nt':
|
||||
# On Windows, os.WEXITSTATUS() doesn't work and os.system() returns
|
||||
# the argument to exit() directly.
|
||||
return exit_code
|
||||
else:
|
||||
# On Unix, os.WEXITSTATUS() must be used to extract the exit status
|
||||
# from the result of os.system().
|
||||
if os.WIFEXITED(exit_code):
|
||||
return os.WEXITSTATUS(exit_code)
|
||||
else:
|
||||
return -1
|
||||
|
||||
|
||||
class Subprocess:
|
||||
def __init__(self, command, working_dir=None, capture_stderr=True, env=None):
|
||||
"""Changes into a specified directory, if provided, and executes a command.
|
||||
|
||||
Restores the old directory afterwards.
|
||||
|
||||
Args:
|
||||
command: The command to run, in the form of sys.argv.
|
||||
working_dir: The directory to change into.
|
||||
capture_stderr: Determines whether to capture stderr in the output member
|
||||
or to discard it.
|
||||
env: Dictionary with environment to pass to the subprocess.
|
||||
|
||||
Returns:
|
||||
An object that represents outcome of the executed process. It has the
|
||||
following attributes:
|
||||
terminated_by_signal True iff the child process has been terminated
|
||||
by a signal.
|
||||
signal Sygnal that terminated the child process.
|
||||
exited True iff the child process exited normally.
|
||||
exit_code The code with which the child process exited.
|
||||
output Child process's stdout and stderr output
|
||||
combined in a string.
|
||||
"""
|
||||
|
||||
# The subprocess module is the preferrable way of running programs
|
||||
# since it is available and behaves consistently on all platforms,
|
||||
# including Windows. But it is only available starting in python 2.4.
|
||||
# In earlier python versions, we revert to the popen2 module, which is
|
||||
# available in python 2.0 and later but doesn't provide required
|
||||
# functionality (Popen4) under Windows. This allows us to support Mac
|
||||
# OS X 10.4 Tiger, which has python 2.3 installed.
|
||||
if _SUBPROCESS_MODULE_AVAILABLE:
|
||||
if capture_stderr:
|
||||
stderr = subprocess.STDOUT
|
||||
else:
|
||||
stderr = subprocess.PIPE
|
||||
|
||||
p = subprocess.Popen(command,
|
||||
stdout=subprocess.PIPE, stderr=stderr,
|
||||
cwd=working_dir, universal_newlines=True, env=env)
|
||||
# communicate returns a tuple with the file obect for the child's
|
||||
# output.
|
||||
self.output = p.communicate()[0]
|
||||
self._return_code = p.returncode
|
||||
else:
|
||||
old_dir = os.getcwd()
|
||||
|
||||
def _ReplaceEnvDict(dest, src):
|
||||
# Changes made by os.environ.clear are not inheritable by child
|
||||
# processes until Python 2.6. To produce inheritable changes we have
|
||||
# to delete environment items with the del statement.
|
||||
for key in dest:
|
||||
del dest[key]
|
||||
dest.update(src)
|
||||
|
||||
# When 'env' is not None, backup the environment variables and replace
|
||||
# them with the passed 'env'. When 'env' is None, we simply use the
|
||||
# current 'os.environ' for compatibility with the subprocess.Popen
|
||||
# semantics used above.
|
||||
if env is not None:
|
||||
old_environ = os.environ.copy()
|
||||
_ReplaceEnvDict(os.environ, env)
|
||||
|
||||
try:
|
||||
if working_dir is not None:
|
||||
os.chdir(working_dir)
|
||||
if capture_stderr:
|
||||
p = popen2.Popen4(command)
|
||||
else:
|
||||
p = popen2.Popen3(command)
|
||||
p.tochild.close()
|
||||
self.output = p.fromchild.read()
|
||||
ret_code = p.wait()
|
||||
finally:
|
||||
os.chdir(old_dir)
|
||||
|
||||
# Restore the old environment variables
|
||||
# if they were replaced.
|
||||
if env is not None:
|
||||
_ReplaceEnvDict(os.environ, old_environ)
|
||||
|
||||
# Converts ret_code to match the semantics of
|
||||
# subprocess.Popen.returncode.
|
||||
if os.WIFSIGNALED(ret_code):
|
||||
self._return_code = -os.WTERMSIG(ret_code)
|
||||
else: # os.WIFEXITED(ret_code) should return True here.
|
||||
self._return_code = os.WEXITSTATUS(ret_code)
|
||||
|
||||
if self._return_code < 0:
|
||||
self.terminated_by_signal = True
|
||||
self.exited = False
|
||||
self.signal = -self._return_code
|
||||
else:
|
||||
self.terminated_by_signal = False
|
||||
self.exited = True
|
||||
self.exit_code = self._return_code
|
||||
|
||||
|
||||
def Main():
|
||||
"""Runs the unit test."""
|
||||
|
||||
# We must call _ParseAndStripGTestFlags() before calling
|
||||
# unittest.main(). Otherwise the latter will be confused by the
|
||||
# --gtest_* flags.
|
||||
_ParseAndStripGTestFlags(sys.argv)
|
||||
# The tested binaries should not be writing XML output files unless the
|
||||
# script explicitly instructs them to.
|
||||
# TODO(vladl@google.com): Move this into Subprocess when we implement
|
||||
# passing environment into it as a parameter.
|
||||
if GTEST_OUTPUT_VAR_NAME in os.environ:
|
||||
del os.environ[GTEST_OUTPUT_VAR_NAME]
|
||||
|
||||
_test_module.main()
|
92
gtest/test/gtest_throw_on_failure_ex_test.cc
Normal file
92
gtest/test/gtest_throw_on_failure_ex_test.cc
Normal file
@ -0,0 +1,92 @@
|
||||
// Copyright 2009, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
// Tests Google Test's throw-on-failure mode with exceptions enabled.
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdexcept>
|
||||
|
||||
// Prints the given failure message and exits the program with
|
||||
// non-zero. We use this instead of a Google Test assertion to
|
||||
// indicate a failure, as the latter is been tested and cannot be
|
||||
// relied on.
|
||||
void Fail(const char* msg) {
|
||||
printf("FAILURE: %s\n", msg);
|
||||
fflush(stdout);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
// Tests that an assertion failure throws a subclass of
|
||||
// std::runtime_error.
|
||||
void TestFailureThrowsRuntimeError() {
|
||||
testing::GTEST_FLAG(throw_on_failure) = true;
|
||||
|
||||
// A successful assertion shouldn't throw.
|
||||
try {
|
||||
EXPECT_EQ(3, 3);
|
||||
} catch(...) {
|
||||
Fail("A successful assertion wrongfully threw.");
|
||||
}
|
||||
|
||||
// A failed assertion should throw a subclass of std::runtime_error.
|
||||
try {
|
||||
EXPECT_EQ(2, 3) << "Expected failure";
|
||||
} catch(const std::runtime_error& e) {
|
||||
if (strstr(e.what(), "Expected failure") != NULL)
|
||||
return;
|
||||
|
||||
printf("%s",
|
||||
"A failed assertion did throw an exception of the right type, "
|
||||
"but the message is incorrect. Instead of containing \"Expected "
|
||||
"failure\", it is:\n");
|
||||
Fail(e.what());
|
||||
} catch(...) {
|
||||
Fail("A failed assertion threw the wrong type of exception.");
|
||||
}
|
||||
Fail("A failed assertion should've thrown but didn't.");
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
testing::InitGoogleTest(&argc, argv);
|
||||
|
||||
// We want to ensure that people can use Google Test assertions in
|
||||
// other testing frameworks, as long as they initialize Google Test
|
||||
// properly and set the thrown-on-failure mode. Therefore, we don't
|
||||
// use Google Test's constructs for defining and running tests
|
||||
// (e.g. TEST and RUN_ALL_TESTS) here.
|
||||
|
||||
TestFailureThrowsRuntimeError();
|
||||
return 0;
|
||||
}
|
171
gtest/test/gtest_throw_on_failure_test.py
Executable file
171
gtest/test/gtest_throw_on_failure_test.py
Executable file
@ -0,0 +1,171 @@
|
||||
#!/usr/bin/env python
|
||||
#
|
||||
# Copyright 2009, Google Inc.
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are
|
||||
# met:
|
||||
#
|
||||
# * Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# * Redistributions in binary form must reproduce the above
|
||||
# copyright notice, this list of conditions and the following disclaimer
|
||||
# in the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
# * Neither the name of Google Inc. nor the names of its
|
||||
# contributors may be used to endorse or promote products derived from
|
||||
# this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
"""Tests Google Test's throw-on-failure mode with exceptions disabled.
|
||||
|
||||
This script invokes gtest_throw_on_failure_test_ (a program written with
|
||||
Google Test) with different environments and command line flags.
|
||||
"""
|
||||
|
||||
__author__ = 'wan@google.com (Zhanyong Wan)'
|
||||
|
||||
import os
|
||||
import gtest_test_utils
|
||||
|
||||
|
||||
# Constants.
|
||||
|
||||
# The command line flag for enabling/disabling the throw-on-failure mode.
|
||||
THROW_ON_FAILURE = 'gtest_throw_on_failure'
|
||||
|
||||
# Path to the gtest_throw_on_failure_test_ program, compiled with
|
||||
# exceptions disabled.
|
||||
EXE_PATH = gtest_test_utils.GetTestExecutablePath(
|
||||
'gtest_throw_on_failure_test_')
|
||||
|
||||
|
||||
# Utilities.
|
||||
|
||||
|
||||
def SetEnvVar(env_var, value):
|
||||
"""Sets an environment variable to a given value; unsets it when the
|
||||
given value is None.
|
||||
"""
|
||||
|
||||
env_var = env_var.upper()
|
||||
if value is not None:
|
||||
os.environ[env_var] = value
|
||||
elif env_var in os.environ:
|
||||
del os.environ[env_var]
|
||||
|
||||
|
||||
def Run(command):
|
||||
"""Runs a command; returns True/False if its exit code is/isn't 0."""
|
||||
|
||||
print 'Running "%s". . .' % ' '.join(command)
|
||||
p = gtest_test_utils.Subprocess(command)
|
||||
return p.exited and p.exit_code == 0
|
||||
|
||||
|
||||
# The tests. TODO(wan@google.com): refactor the class to share common
|
||||
# logic with code in gtest_break_on_failure_unittest.py.
|
||||
class ThrowOnFailureTest(gtest_test_utils.TestCase):
|
||||
"""Tests the throw-on-failure mode."""
|
||||
|
||||
def RunAndVerify(self, env_var_value, flag_value, should_fail):
|
||||
"""Runs gtest_throw_on_failure_test_ and verifies that it does
|
||||
(or does not) exit with a non-zero code.
|
||||
|
||||
Args:
|
||||
env_var_value: value of the GTEST_BREAK_ON_FAILURE environment
|
||||
variable; None if the variable should be unset.
|
||||
flag_value: value of the --gtest_break_on_failure flag;
|
||||
None if the flag should not be present.
|
||||
should_fail: True iff the program is expected to fail.
|
||||
"""
|
||||
|
||||
SetEnvVar(THROW_ON_FAILURE, env_var_value)
|
||||
|
||||
if env_var_value is None:
|
||||
env_var_value_msg = ' is not set'
|
||||
else:
|
||||
env_var_value_msg = '=' + env_var_value
|
||||
|
||||
if flag_value is None:
|
||||
flag = ''
|
||||
elif flag_value == '0':
|
||||
flag = '--%s=0' % THROW_ON_FAILURE
|
||||
else:
|
||||
flag = '--%s' % THROW_ON_FAILURE
|
||||
|
||||
command = [EXE_PATH]
|
||||
if flag:
|
||||
command.append(flag)
|
||||
|
||||
if should_fail:
|
||||
should_or_not = 'should'
|
||||
else:
|
||||
should_or_not = 'should not'
|
||||
|
||||
failed = not Run(command)
|
||||
|
||||
SetEnvVar(THROW_ON_FAILURE, None)
|
||||
|
||||
msg = ('when %s%s, an assertion failure in "%s" %s cause a non-zero '
|
||||
'exit code.' %
|
||||
(THROW_ON_FAILURE, env_var_value_msg, ' '.join(command),
|
||||
should_or_not))
|
||||
self.assert_(failed == should_fail, msg)
|
||||
|
||||
def testDefaultBehavior(self):
|
||||
"""Tests the behavior of the default mode."""
|
||||
|
||||
self.RunAndVerify(env_var_value=None, flag_value=None, should_fail=False)
|
||||
|
||||
def testThrowOnFailureEnvVar(self):
|
||||
"""Tests using the GTEST_THROW_ON_FAILURE environment variable."""
|
||||
|
||||
self.RunAndVerify(env_var_value='0',
|
||||
flag_value=None,
|
||||
should_fail=False)
|
||||
self.RunAndVerify(env_var_value='1',
|
||||
flag_value=None,
|
||||
should_fail=True)
|
||||
|
||||
def testThrowOnFailureFlag(self):
|
||||
"""Tests using the --gtest_throw_on_failure flag."""
|
||||
|
||||
self.RunAndVerify(env_var_value=None,
|
||||
flag_value='0',
|
||||
should_fail=False)
|
||||
self.RunAndVerify(env_var_value=None,
|
||||
flag_value='1',
|
||||
should_fail=True)
|
||||
|
||||
def testThrowOnFailureFlagOverridesEnvVar(self):
|
||||
"""Tests that --gtest_throw_on_failure overrides GTEST_THROW_ON_FAILURE."""
|
||||
|
||||
self.RunAndVerify(env_var_value='0',
|
||||
flag_value='0',
|
||||
should_fail=False)
|
||||
self.RunAndVerify(env_var_value='0',
|
||||
flag_value='1',
|
||||
should_fail=True)
|
||||
self.RunAndVerify(env_var_value='1',
|
||||
flag_value='0',
|
||||
should_fail=False)
|
||||
self.RunAndVerify(env_var_value='1',
|
||||
flag_value='1',
|
||||
should_fail=True)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
gtest_test_utils.Main()
|
56
gtest/test/gtest_throw_on_failure_test_.cc
Normal file
56
gtest/test/gtest_throw_on_failure_test_.cc
Normal file
@ -0,0 +1,56 @@
|
||||
// Copyright 2009, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
// Tests Google Test's throw-on-failure mode with exceptions disabled.
|
||||
//
|
||||
// This program must be compiled with exceptions disabled. It will be
|
||||
// invoked by gtest_throw_on_failure_test.py, and is expected to exit
|
||||
// with non-zero in the throw-on-failure mode or 0 otherwise.
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
testing::InitGoogleTest(&argc, argv);
|
||||
|
||||
// We want to ensure that people can use Google Test assertions in
|
||||
// other testing frameworks, as long as they initialize Google Test
|
||||
// properly and set the thrown-on-failure mode. Therefore, we don't
|
||||
// use Google Test's constructs for defining and running tests
|
||||
// (e.g. TEST and RUN_ALL_TESTS) here.
|
||||
|
||||
// In the throw-on-failure mode with exceptions disabled, this
|
||||
// assertion will cause the program to exit with a non-zero code.
|
||||
EXPECT_EQ(2, 3);
|
||||
|
||||
// When not in the throw-on-failure mode, the control will reach
|
||||
// here.
|
||||
return 0;
|
||||
}
|
70
gtest/test/gtest_uninitialized_test.py
Executable file
70
gtest/test/gtest_uninitialized_test.py
Executable file
@ -0,0 +1,70 @@
|
||||
#!/usr/bin/env python
|
||||
#
|
||||
# Copyright 2008, Google Inc.
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are
|
||||
# met:
|
||||
#
|
||||
# * Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# * Redistributions in binary form must reproduce the above
|
||||
# copyright notice, this list of conditions and the following disclaimer
|
||||
# in the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
# * Neither the name of Google Inc. nor the names of its
|
||||
# contributors may be used to endorse or promote products derived from
|
||||
# this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
"""Verifies that Google Test warns the user when not initialized properly."""
|
||||
|
||||
__author__ = 'wan@google.com (Zhanyong Wan)'
|
||||
|
||||
import gtest_test_utils
|
||||
|
||||
|
||||
COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_uninitialized_test_')
|
||||
|
||||
|
||||
def Assert(condition):
|
||||
if not condition:
|
||||
raise AssertionError
|
||||
|
||||
|
||||
def AssertEq(expected, actual):
|
||||
if expected != actual:
|
||||
print 'Expected: %s' % (expected,)
|
||||
print ' Actual: %s' % (actual,)
|
||||
raise AssertionError
|
||||
|
||||
|
||||
def TestExitCodeAndOutput(command):
|
||||
"""Runs the given command and verifies its exit code and output."""
|
||||
|
||||
# Verifies that 'command' exits with code 1.
|
||||
p = gtest_test_utils.Subprocess(command)
|
||||
Assert(p.exited)
|
||||
AssertEq(1, p.exit_code)
|
||||
Assert('InitGoogleTest' in p.output)
|
||||
|
||||
|
||||
class GTestUninitializedTest(gtest_test_utils.TestCase):
|
||||
def testExitCodeAndOutput(self):
|
||||
TestExitCodeAndOutput(COMMAND)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
gtest_test_utils.Main()
|
43
gtest/test/gtest_uninitialized_test_.cc
Normal file
43
gtest/test/gtest_uninitialized_test_.cc
Normal file
@ -0,0 +1,43 @@
|
||||
// Copyright 2008, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
TEST(DummyTest, Dummy) {
|
||||
// This test doesn't verify anything. We just need it to create a
|
||||
// realistic stage for testing the behavior of Google Test when
|
||||
// RUN_ALL_TESTS() is called without testing::InitGoogleTest() being
|
||||
// called first.
|
||||
}
|
||||
|
||||
int main() {
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
7337
gtest/test/gtest_unittest.cc
Normal file
7337
gtest/test/gtest_unittest.cc
Normal file
File diff suppressed because it is too large
Load Diff
49
gtest/test/gtest_xml_outfile1_test_.cc
Normal file
49
gtest/test/gtest_xml_outfile1_test_.cc
Normal file
@ -0,0 +1,49 @@
|
||||
// Copyright 2008, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: keith.ray@gmail.com (Keith Ray)
|
||||
//
|
||||
// gtest_xml_outfile1_test_ writes some xml via TestProperty used by
|
||||
// gtest_xml_outfiles_test.py
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
class PropertyOne : public testing::Test {
|
||||
protected:
|
||||
virtual void SetUp() {
|
||||
RecordProperty("SetUpProp", 1);
|
||||
}
|
||||
virtual void TearDown() {
|
||||
RecordProperty("TearDownProp", 1);
|
||||
}
|
||||
};
|
||||
|
||||
TEST_F(PropertyOne, TestSomeProperties) {
|
||||
RecordProperty("TestSomeProperty", 1);
|
||||
}
|
49
gtest/test/gtest_xml_outfile2_test_.cc
Normal file
49
gtest/test/gtest_xml_outfile2_test_.cc
Normal file
@ -0,0 +1,49 @@
|
||||
// Copyright 2008, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: keith.ray@gmail.com (Keith Ray)
|
||||
//
|
||||
// gtest_xml_outfile2_test_ writes some xml via TestProperty used by
|
||||
// gtest_xml_outfiles_test.py
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
class PropertyTwo : public testing::Test {
|
||||
protected:
|
||||
virtual void SetUp() {
|
||||
RecordProperty("SetUpProp", 2);
|
||||
}
|
||||
virtual void TearDown() {
|
||||
RecordProperty("TearDownProp", 2);
|
||||
}
|
||||
};
|
||||
|
||||
TEST_F(PropertyTwo, TestSomeProperties) {
|
||||
RecordProperty("TestSomeProperty", 2);
|
||||
}
|
132
gtest/test/gtest_xml_outfiles_test.py
Executable file
132
gtest/test/gtest_xml_outfiles_test.py
Executable file
@ -0,0 +1,132 @@
|
||||
#!/usr/bin/env python
|
||||
#
|
||||
# Copyright 2008, Google Inc.
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are
|
||||
# met:
|
||||
#
|
||||
# * Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# * Redistributions in binary form must reproduce the above
|
||||
# copyright notice, this list of conditions and the following disclaimer
|
||||
# in the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
# * Neither the name of Google Inc. nor the names of its
|
||||
# contributors may be used to endorse or promote products derived from
|
||||
# this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
"""Unit test for the gtest_xml_output module."""
|
||||
|
||||
__author__ = "keith.ray@gmail.com (Keith Ray)"
|
||||
|
||||
import os
|
||||
from xml.dom import minidom, Node
|
||||
|
||||
import gtest_test_utils
|
||||
import gtest_xml_test_utils
|
||||
|
||||
|
||||
GTEST_OUTPUT_SUBDIR = "xml_outfiles"
|
||||
GTEST_OUTPUT_1_TEST = "gtest_xml_outfile1_test_"
|
||||
GTEST_OUTPUT_2_TEST = "gtest_xml_outfile2_test_"
|
||||
|
||||
EXPECTED_XML_1 = """<?xml version="1.0" encoding="UTF-8"?>
|
||||
<testsuites tests="1" failures="0" disabled="0" errors="0" time="*" name="AllTests">
|
||||
<testsuite name="PropertyOne" tests="1" failures="0" disabled="0" errors="0" time="*">
|
||||
<testcase name="TestSomeProperties" status="run" time="*" classname="PropertyOne" SetUpProp="1" TestSomeProperty="1" TearDownProp="1" />
|
||||
</testsuite>
|
||||
</testsuites>
|
||||
"""
|
||||
|
||||
EXPECTED_XML_2 = """<?xml version="1.0" encoding="UTF-8"?>
|
||||
<testsuites tests="1" failures="0" disabled="0" errors="0" time="*" name="AllTests">
|
||||
<testsuite name="PropertyTwo" tests="1" failures="0" disabled="0" errors="0" time="*">
|
||||
<testcase name="TestSomeProperties" status="run" time="*" classname="PropertyTwo" SetUpProp="2" TestSomeProperty="2" TearDownProp="2" />
|
||||
</testsuite>
|
||||
</testsuites>
|
||||
"""
|
||||
|
||||
|
||||
class GTestXMLOutFilesTest(gtest_xml_test_utils.GTestXMLTestCase):
|
||||
"""Unit test for Google Test's XML output functionality."""
|
||||
|
||||
def setUp(self):
|
||||
# We want the trailing '/' that the last "" provides in os.path.join, for
|
||||
# telling Google Test to create an output directory instead of a single file
|
||||
# for xml output.
|
||||
self.output_dir_ = os.path.join(gtest_test_utils.GetTempDir(),
|
||||
GTEST_OUTPUT_SUBDIR, "")
|
||||
self.DeleteFilesAndDir()
|
||||
|
||||
def tearDown(self):
|
||||
self.DeleteFilesAndDir()
|
||||
|
||||
def DeleteFilesAndDir(self):
|
||||
try:
|
||||
os.remove(os.path.join(self.output_dir_, GTEST_OUTPUT_1_TEST + ".xml"))
|
||||
except os.error:
|
||||
pass
|
||||
try:
|
||||
os.remove(os.path.join(self.output_dir_, GTEST_OUTPUT_2_TEST + ".xml"))
|
||||
except os.error:
|
||||
pass
|
||||
try:
|
||||
os.rmdir(self.output_dir_)
|
||||
except os.error:
|
||||
pass
|
||||
|
||||
def testOutfile1(self):
|
||||
self._TestOutFile(GTEST_OUTPUT_1_TEST, EXPECTED_XML_1)
|
||||
|
||||
def testOutfile2(self):
|
||||
self._TestOutFile(GTEST_OUTPUT_2_TEST, EXPECTED_XML_2)
|
||||
|
||||
def _TestOutFile(self, test_name, expected_xml):
|
||||
gtest_prog_path = gtest_test_utils.GetTestExecutablePath(test_name)
|
||||
command = [gtest_prog_path, "--gtest_output=xml:%s" % self.output_dir_]
|
||||
p = gtest_test_utils.Subprocess(command,
|
||||
working_dir=gtest_test_utils.GetTempDir())
|
||||
self.assert_(p.exited)
|
||||
self.assertEquals(0, p.exit_code)
|
||||
|
||||
# TODO(wan@google.com): libtool causes the built test binary to be
|
||||
# named lt-gtest_xml_outfiles_test_ instead of
|
||||
# gtest_xml_outfiles_test_. To account for this possibillity, we
|
||||
# allow both names in the following code. We should remove this
|
||||
# hack when Chandler Carruth's libtool replacement tool is ready.
|
||||
output_file_name1 = test_name + ".xml"
|
||||
output_file1 = os.path.join(self.output_dir_, output_file_name1)
|
||||
output_file_name2 = 'lt-' + output_file_name1
|
||||
output_file2 = os.path.join(self.output_dir_, output_file_name2)
|
||||
self.assert_(os.path.isfile(output_file1) or os.path.isfile(output_file2),
|
||||
output_file1)
|
||||
|
||||
expected = minidom.parseString(expected_xml)
|
||||
if os.path.isfile(output_file1):
|
||||
actual = minidom.parse(output_file1)
|
||||
else:
|
||||
actual = minidom.parse(output_file2)
|
||||
self.NormalizeXml(actual.documentElement)
|
||||
self.AssertEquivalentNodes(expected.documentElement,
|
||||
actual.documentElement)
|
||||
expected.unlink()
|
||||
actual.unlink()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
os.environ["GTEST_STACK_TRACE_DEPTH"] = "0"
|
||||
gtest_test_utils.Main()
|
242
gtest/test/gtest_xml_output_unittest.py
Executable file
242
gtest/test/gtest_xml_output_unittest.py
Executable file
@ -0,0 +1,242 @@
|
||||
#!/usr/bin/env python
|
||||
#
|
||||
# Copyright 2006, Google Inc.
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are
|
||||
# met:
|
||||
#
|
||||
# * Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# * Redistributions in binary form must reproduce the above
|
||||
# copyright notice, this list of conditions and the following disclaimer
|
||||
# in the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
# * Neither the name of Google Inc. nor the names of its
|
||||
# contributors may be used to endorse or promote products derived from
|
||||
# this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
"""Unit test for the gtest_xml_output module"""
|
||||
|
||||
__author__ = 'eefacm@gmail.com (Sean Mcafee)'
|
||||
|
||||
import errno
|
||||
import os
|
||||
import sys
|
||||
from xml.dom import minidom, Node
|
||||
|
||||
import gtest_test_utils
|
||||
import gtest_xml_test_utils
|
||||
|
||||
|
||||
GTEST_OUTPUT_FLAG = "--gtest_output"
|
||||
GTEST_DEFAULT_OUTPUT_FILE = "test_detail.xml"
|
||||
GTEST_PROGRAM_NAME = "gtest_xml_output_unittest_"
|
||||
|
||||
SUPPORTS_STACK_TRACES = False
|
||||
|
||||
if SUPPORTS_STACK_TRACES:
|
||||
STACK_TRACE_TEMPLATE = "\nStack trace:\n*"
|
||||
else:
|
||||
STACK_TRACE_TEMPLATE = ""
|
||||
|
||||
EXPECTED_NON_EMPTY_XML = """<?xml version="1.0" encoding="UTF-8"?>
|
||||
<testsuites tests="23" failures="4" disabled="2" errors="0" time="*" name="AllTests">
|
||||
<testsuite name="SuccessfulTest" tests="1" failures="0" disabled="0" errors="0" time="*">
|
||||
<testcase name="Succeeds" status="run" time="*" classname="SuccessfulTest"/>
|
||||
</testsuite>
|
||||
<testsuite name="FailedTest" tests="1" failures="1" disabled="0" errors="0" time="*">
|
||||
<testcase name="Fails" status="run" time="*" classname="FailedTest">
|
||||
<failure message="Value of: 2
Expected: 1" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
|
||||
Value of: 2
|
||||
Expected: 1%(stack)s]]></failure>
|
||||
</testcase>
|
||||
</testsuite>
|
||||
<testsuite name="MixedResultTest" tests="3" failures="1" disabled="1" errors="0" time="*">
|
||||
<testcase name="Succeeds" status="run" time="*" classname="MixedResultTest"/>
|
||||
<testcase name="Fails" status="run" time="*" classname="MixedResultTest">
|
||||
<failure message="Value of: 2
Expected: 1" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
|
||||
Value of: 2
|
||||
Expected: 1%(stack)s]]></failure>
|
||||
<failure message="Value of: 3
Expected: 2" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
|
||||
Value of: 3
|
||||
Expected: 2%(stack)s]]></failure>
|
||||
</testcase>
|
||||
<testcase name="DISABLED_test" status="notrun" time="*" classname="MixedResultTest"/>
|
||||
</testsuite>
|
||||
<testsuite name="XmlQuotingTest" tests="1" failures="1" disabled="0" errors="0" time="*">
|
||||
<testcase name="OutputsCData" status="run" time="*" classname="XmlQuotingTest">
|
||||
<failure message="Failed
XML output: <?xml encoding="utf-8"><top><![CDATA[cdata text]]></top>" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
|
||||
Failed
|
||||
XML output: <?xml encoding="utf-8"><top><![CDATA[cdata text]]>]]><![CDATA[</top>%(stack)s]]></failure>
|
||||
</testcase>
|
||||
</testsuite>
|
||||
<testsuite name="InvalidCharactersTest" tests="1" failures="1" disabled="0" errors="0" time="*">
|
||||
<testcase name="InvalidCharactersInMessage" status="run" time="*" classname="InvalidCharactersTest">
|
||||
<failure message="Failed
Invalid characters in brackets []" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
|
||||
Failed
|
||||
Invalid characters in brackets []%(stack)s]]></failure>
|
||||
</testcase>
|
||||
</testsuite>
|
||||
<testsuite name="DisabledTest" tests="1" failures="0" disabled="1" errors="0" time="*">
|
||||
<testcase name="DISABLED_test_not_run" status="notrun" time="*" classname="DisabledTest"/>
|
||||
</testsuite>
|
||||
<testsuite name="PropertyRecordingTest" tests="4" failures="0" disabled="0" errors="0" time="*">
|
||||
<testcase name="OneProperty" status="run" time="*" classname="PropertyRecordingTest" key_1="1"/>
|
||||
<testcase name="IntValuedProperty" status="run" time="*" classname="PropertyRecordingTest" key_int="1"/>
|
||||
<testcase name="ThreeProperties" status="run" time="*" classname="PropertyRecordingTest" key_1="1" key_2="2" key_3="3"/>
|
||||
<testcase name="TwoValuesForOneKeyUsesLastValue" status="run" time="*" classname="PropertyRecordingTest" key_1="2"/>
|
||||
</testsuite>
|
||||
<testsuite name="NoFixtureTest" tests="3" failures="0" disabled="0" errors="0" time="*">
|
||||
<testcase name="RecordProperty" status="run" time="*" classname="NoFixtureTest" key="1"/>
|
||||
<testcase name="ExternalUtilityThatCallsRecordIntValuedProperty" status="run" time="*" classname="NoFixtureTest" key_for_utility_int="1"/>
|
||||
<testcase name="ExternalUtilityThatCallsRecordStringValuedProperty" status="run" time="*" classname="NoFixtureTest" key_for_utility_string="1"/>
|
||||
</testsuite>
|
||||
<testsuite name="Single/ValueParamTest" tests="4" failures="0" disabled="0" errors="0" time="*">
|
||||
<testcase name="HasValueParamAttribute/0" value_param="33" status="run" time="*" classname="Single/ValueParamTest" />
|
||||
<testcase name="HasValueParamAttribute/1" value_param="42" status="run" time="*" classname="Single/ValueParamTest" />
|
||||
<testcase name="AnotherTestThatHasValueParamAttribute/0" value_param="33" status="run" time="*" classname="Single/ValueParamTest" />
|
||||
<testcase name="AnotherTestThatHasValueParamAttribute/1" value_param="42" status="run" time="*" classname="Single/ValueParamTest" />
|
||||
</testsuite>
|
||||
<testsuite name="TypedTest/0" tests="1" failures="0" disabled="0" errors="0" time="*">
|
||||
<testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="TypedTest/0" />
|
||||
</testsuite>
|
||||
<testsuite name="TypedTest/1" tests="1" failures="0" disabled="0" errors="0" time="*">
|
||||
<testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="TypedTest/1" />
|
||||
</testsuite>
|
||||
<testsuite name="Single/TypeParameterizedTestCase/0" tests="1" failures="0" disabled="0" errors="0" time="*">
|
||||
<testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="Single/TypeParameterizedTestCase/0" />
|
||||
</testsuite>
|
||||
<testsuite name="Single/TypeParameterizedTestCase/1" tests="1" failures="0" disabled="0" errors="0" time="*">
|
||||
<testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="Single/TypeParameterizedTestCase/1" />
|
||||
</testsuite>
|
||||
</testsuites>""" % {'stack': STACK_TRACE_TEMPLATE}
|
||||
|
||||
|
||||
EXPECTED_EMPTY_XML = """<?xml version="1.0" encoding="UTF-8"?>
|
||||
<testsuites tests="0" failures="0" disabled="0" errors="0" time="*" name="AllTests">
|
||||
</testsuites>"""
|
||||
|
||||
|
||||
class GTestXMLOutputUnitTest(gtest_xml_test_utils.GTestXMLTestCase):
|
||||
"""
|
||||
Unit test for Google Test's XML output functionality.
|
||||
"""
|
||||
|
||||
def testNonEmptyXmlOutput(self):
|
||||
"""
|
||||
Runs a test program that generates a non-empty XML output, and
|
||||
tests that the XML output is expected.
|
||||
"""
|
||||
self._TestXmlOutput(GTEST_PROGRAM_NAME, EXPECTED_NON_EMPTY_XML, 1)
|
||||
|
||||
def testEmptyXmlOutput(self):
|
||||
"""
|
||||
Runs a test program that generates an empty XML output, and
|
||||
tests that the XML output is expected.
|
||||
"""
|
||||
|
||||
self._TestXmlOutput("gtest_no_test_unittest",
|
||||
EXPECTED_EMPTY_XML, 0)
|
||||
|
||||
def testDefaultOutputFile(self):
|
||||
"""
|
||||
Confirms that Google Test produces an XML output file with the expected
|
||||
default name if no name is explicitly specified.
|
||||
"""
|
||||
output_file = os.path.join(gtest_test_utils.GetTempDir(),
|
||||
GTEST_DEFAULT_OUTPUT_FILE)
|
||||
gtest_prog_path = gtest_test_utils.GetTestExecutablePath(
|
||||
"gtest_no_test_unittest")
|
||||
try:
|
||||
os.remove(output_file)
|
||||
except OSError, e:
|
||||
if e.errno != errno.ENOENT:
|
||||
raise
|
||||
|
||||
p = gtest_test_utils.Subprocess(
|
||||
[gtest_prog_path, "%s=xml" % GTEST_OUTPUT_FLAG],
|
||||
working_dir=gtest_test_utils.GetTempDir())
|
||||
self.assert_(p.exited)
|
||||
self.assertEquals(0, p.exit_code)
|
||||
self.assert_(os.path.isfile(output_file))
|
||||
|
||||
def testSuppressedXmlOutput(self):
|
||||
"""
|
||||
Tests that no XML file is generated if the default XML listener is
|
||||
shut down before RUN_ALL_TESTS is invoked.
|
||||
"""
|
||||
|
||||
xml_path = os.path.join(gtest_test_utils.GetTempDir(),
|
||||
GTEST_PROGRAM_NAME + "out.xml")
|
||||
if os.path.isfile(xml_path):
|
||||
os.remove(xml_path)
|
||||
|
||||
gtest_prog_path = gtest_test_utils.GetTestExecutablePath(GTEST_PROGRAM_NAME)
|
||||
|
||||
command = [gtest_prog_path,
|
||||
"%s=xml:%s" % (GTEST_OUTPUT_FLAG, xml_path),
|
||||
"--shut_down_xml"]
|
||||
p = gtest_test_utils.Subprocess(command)
|
||||
if p.terminated_by_signal:
|
||||
self.assert_(False,
|
||||
"%s was killed by signal %d" % (gtest_prog_name, p.signal))
|
||||
else:
|
||||
self.assert_(p.exited)
|
||||
self.assertEquals(1, p.exit_code,
|
||||
"'%s' exited with code %s, which doesn't match "
|
||||
"the expected exit code %s."
|
||||
% (command, p.exit_code, 1))
|
||||
|
||||
self.assert_(not os.path.isfile(xml_path))
|
||||
|
||||
|
||||
def _TestXmlOutput(self, gtest_prog_name, expected_xml, expected_exit_code):
|
||||
"""
|
||||
Asserts that the XML document generated by running the program
|
||||
gtest_prog_name matches expected_xml, a string containing another
|
||||
XML document. Furthermore, the program's exit code must be
|
||||
expected_exit_code.
|
||||
"""
|
||||
xml_path = os.path.join(gtest_test_utils.GetTempDir(),
|
||||
gtest_prog_name + "out.xml")
|
||||
gtest_prog_path = gtest_test_utils.GetTestExecutablePath(gtest_prog_name)
|
||||
|
||||
command = [gtest_prog_path, "%s=xml:%s" % (GTEST_OUTPUT_FLAG, xml_path)]
|
||||
p = gtest_test_utils.Subprocess(command)
|
||||
if p.terminated_by_signal:
|
||||
self.assert_(False,
|
||||
"%s was killed by signal %d" % (gtest_prog_name, p.signal))
|
||||
else:
|
||||
self.assert_(p.exited)
|
||||
self.assertEquals(expected_exit_code, p.exit_code,
|
||||
"'%s' exited with code %s, which doesn't match "
|
||||
"the expected exit code %s."
|
||||
% (command, p.exit_code, expected_exit_code))
|
||||
|
||||
expected = minidom.parseString(expected_xml)
|
||||
actual = minidom.parse(xml_path)
|
||||
self.NormalizeXml(actual.documentElement)
|
||||
self.AssertEquivalentNodes(expected.documentElement,
|
||||
actual.documentElement)
|
||||
expected.unlink()
|
||||
actual .unlink()
|
||||
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
os.environ['GTEST_STACK_TRACE_DEPTH'] = '1'
|
||||
gtest_test_utils.Main()
|
174
gtest/test/gtest_xml_output_unittest_.cc
Normal file
174
gtest/test/gtest_xml_output_unittest_.cc
Normal file
@ -0,0 +1,174 @@
|
||||
// Copyright 2006, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
// Author: eefacm@gmail.com (Sean Mcafee)
|
||||
|
||||
// Unit test for Google Test XML output.
|
||||
//
|
||||
// A user can specify XML output in a Google Test program to run via
|
||||
// either the GTEST_OUTPUT environment variable or the --gtest_output
|
||||
// flag. This is used for testing such functionality.
|
||||
//
|
||||
// This program will be invoked from a Python unit test. Don't run it
|
||||
// directly.
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
using ::testing::InitGoogleTest;
|
||||
using ::testing::TestEventListeners;
|
||||
using ::testing::TestWithParam;
|
||||
using ::testing::UnitTest;
|
||||
using ::testing::Test;
|
||||
using ::testing::Types;
|
||||
using ::testing::Values;
|
||||
|
||||
class SuccessfulTest : public Test {
|
||||
};
|
||||
|
||||
TEST_F(SuccessfulTest, Succeeds) {
|
||||
SUCCEED() << "This is a success.";
|
||||
ASSERT_EQ(1, 1);
|
||||
}
|
||||
|
||||
class FailedTest : public Test {
|
||||
};
|
||||
|
||||
TEST_F(FailedTest, Fails) {
|
||||
ASSERT_EQ(1, 2);
|
||||
}
|
||||
|
||||
class DisabledTest : public Test {
|
||||
};
|
||||
|
||||
TEST_F(DisabledTest, DISABLED_test_not_run) {
|
||||
FAIL() << "Unexpected failure: Disabled test should not be run";
|
||||
}
|
||||
|
||||
TEST(MixedResultTest, Succeeds) {
|
||||
EXPECT_EQ(1, 1);
|
||||
ASSERT_EQ(1, 1);
|
||||
}
|
||||
|
||||
TEST(MixedResultTest, Fails) {
|
||||
EXPECT_EQ(1, 2);
|
||||
ASSERT_EQ(2, 3);
|
||||
}
|
||||
|
||||
TEST(MixedResultTest, DISABLED_test) {
|
||||
FAIL() << "Unexpected failure: Disabled test should not be run";
|
||||
}
|
||||
|
||||
TEST(XmlQuotingTest, OutputsCData) {
|
||||
FAIL() << "XML output: "
|
||||
"<?xml encoding=\"utf-8\"><top><![CDATA[cdata text]]></top>";
|
||||
}
|
||||
|
||||
// Helps to test that invalid characters produced by test code do not make
|
||||
// it into the XML file.
|
||||
TEST(InvalidCharactersTest, InvalidCharactersInMessage) {
|
||||
FAIL() << "Invalid characters in brackets [\x1\x2]";
|
||||
}
|
||||
|
||||
class PropertyRecordingTest : public Test {
|
||||
};
|
||||
|
||||
TEST_F(PropertyRecordingTest, OneProperty) {
|
||||
RecordProperty("key_1", "1");
|
||||
}
|
||||
|
||||
TEST_F(PropertyRecordingTest, IntValuedProperty) {
|
||||
RecordProperty("key_int", 1);
|
||||
}
|
||||
|
||||
TEST_F(PropertyRecordingTest, ThreeProperties) {
|
||||
RecordProperty("key_1", "1");
|
||||
RecordProperty("key_2", "2");
|
||||
RecordProperty("key_3", "3");
|
||||
}
|
||||
|
||||
TEST_F(PropertyRecordingTest, TwoValuesForOneKeyUsesLastValue) {
|
||||
RecordProperty("key_1", "1");
|
||||
RecordProperty("key_1", "2");
|
||||
}
|
||||
|
||||
TEST(NoFixtureTest, RecordProperty) {
|
||||
RecordProperty("key", "1");
|
||||
}
|
||||
|
||||
void ExternalUtilityThatCallsRecordProperty(const char* key, int value) {
|
||||
testing::Test::RecordProperty(key, value);
|
||||
}
|
||||
|
||||
void ExternalUtilityThatCallsRecordProperty(const char* key,
|
||||
const char* value) {
|
||||
testing::Test::RecordProperty(key, value);
|
||||
}
|
||||
|
||||
TEST(NoFixtureTest, ExternalUtilityThatCallsRecordIntValuedProperty) {
|
||||
ExternalUtilityThatCallsRecordProperty("key_for_utility_int", 1);
|
||||
}
|
||||
|
||||
TEST(NoFixtureTest, ExternalUtilityThatCallsRecordStringValuedProperty) {
|
||||
ExternalUtilityThatCallsRecordProperty("key_for_utility_string", "1");
|
||||
}
|
||||
|
||||
// Verifies that the test parameter value is output in the 'value_param'
|
||||
// XML attribute for value-parameterized tests.
|
||||
class ValueParamTest : public TestWithParam<int> {};
|
||||
TEST_P(ValueParamTest, HasValueParamAttribute) {}
|
||||
TEST_P(ValueParamTest, AnotherTestThatHasValueParamAttribute) {}
|
||||
INSTANTIATE_TEST_CASE_P(Single, ValueParamTest, Values(33, 42));
|
||||
|
||||
// Verifies that the type parameter name is output in the 'type_param'
|
||||
// XML attribute for typed tests.
|
||||
template <typename T> class TypedTest : public Test {};
|
||||
typedef Types<int, long> TypedTestTypes;
|
||||
TYPED_TEST_CASE(TypedTest, TypedTestTypes);
|
||||
TYPED_TEST(TypedTest, HasTypeParamAttribute) {}
|
||||
|
||||
// Verifies that the type parameter name is output in the 'type_param'
|
||||
// XML attribute for type-parameterized tests.
|
||||
template <typename T> class TypeParameterizedTestCase : public Test {};
|
||||
TYPED_TEST_CASE_P(TypeParameterizedTestCase);
|
||||
TYPED_TEST_P(TypeParameterizedTestCase, HasTypeParamAttribute) {}
|
||||
REGISTER_TYPED_TEST_CASE_P(TypeParameterizedTestCase, HasTypeParamAttribute);
|
||||
typedef Types<int, long> TypeParameterizedTestCaseTypes;
|
||||
INSTANTIATE_TYPED_TEST_CASE_P(Single,
|
||||
TypeParameterizedTestCase,
|
||||
TypeParameterizedTestCaseTypes);
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
InitGoogleTest(&argc, argv);
|
||||
|
||||
if (argc > 1 && strcmp(argv[1], "--shut_down_xml") == 0) {
|
||||
TestEventListeners& listeners = UnitTest::GetInstance()->listeners();
|
||||
delete listeners.Release(listeners.default_xml_generator());
|
||||
}
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
179
gtest/test/gtest_xml_test_utils.py
Executable file
179
gtest/test/gtest_xml_test_utils.py
Executable file
@ -0,0 +1,179 @@
|
||||
#!/usr/bin/env python
|
||||
#
|
||||
# Copyright 2006, Google Inc.
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are
|
||||
# met:
|
||||
#
|
||||
# * Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# * Redistributions in binary form must reproduce the above
|
||||
# copyright notice, this list of conditions and the following disclaimer
|
||||
# in the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
# * Neither the name of Google Inc. nor the names of its
|
||||
# contributors may be used to endorse or promote products derived from
|
||||
# this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
"""Unit test utilities for gtest_xml_output"""
|
||||
|
||||
__author__ = 'eefacm@gmail.com (Sean Mcafee)'
|
||||
|
||||
import re
|
||||
from xml.dom import minidom, Node
|
||||
|
||||
import gtest_test_utils
|
||||
|
||||
|
||||
GTEST_OUTPUT_FLAG = "--gtest_output"
|
||||
GTEST_DEFAULT_OUTPUT_FILE = "test_detail.xml"
|
||||
|
||||
class GTestXMLTestCase(gtest_test_utils.TestCase):
|
||||
"""
|
||||
Base class for tests of Google Test's XML output functionality.
|
||||
"""
|
||||
|
||||
|
||||
def AssertEquivalentNodes(self, expected_node, actual_node):
|
||||
"""
|
||||
Asserts that actual_node (a DOM node object) is equivalent to
|
||||
expected_node (another DOM node object), in that either both of
|
||||
them are CDATA nodes and have the same value, or both are DOM
|
||||
elements and actual_node meets all of the following conditions:
|
||||
|
||||
* It has the same tag name as expected_node.
|
||||
* It has the same set of attributes as expected_node, each with
|
||||
the same value as the corresponding attribute of expected_node.
|
||||
Exceptions are any attribute named "time", which needs only be
|
||||
convertible to a floating-point number and any attribute named
|
||||
"type_param" which only has to be non-empty.
|
||||
* It has an equivalent set of child nodes (including elements and
|
||||
CDATA sections) as expected_node. Note that we ignore the
|
||||
order of the children as they are not guaranteed to be in any
|
||||
particular order.
|
||||
"""
|
||||
|
||||
if expected_node.nodeType == Node.CDATA_SECTION_NODE:
|
||||
self.assertEquals(Node.CDATA_SECTION_NODE, actual_node.nodeType)
|
||||
self.assertEquals(expected_node.nodeValue, actual_node.nodeValue)
|
||||
return
|
||||
|
||||
self.assertEquals(Node.ELEMENT_NODE, actual_node.nodeType)
|
||||
self.assertEquals(Node.ELEMENT_NODE, expected_node.nodeType)
|
||||
self.assertEquals(expected_node.tagName, actual_node.tagName)
|
||||
|
||||
expected_attributes = expected_node.attributes
|
||||
actual_attributes = actual_node .attributes
|
||||
self.assertEquals(
|
||||
expected_attributes.length, actual_attributes.length,
|
||||
"attribute numbers differ in element " + actual_node.tagName)
|
||||
for i in range(expected_attributes.length):
|
||||
expected_attr = expected_attributes.item(i)
|
||||
actual_attr = actual_attributes.get(expected_attr.name)
|
||||
self.assert_(
|
||||
actual_attr is not None,
|
||||
"expected attribute %s not found in element %s" %
|
||||
(expected_attr.name, actual_node.tagName))
|
||||
self.assertEquals(expected_attr.value, actual_attr.value,
|
||||
" values of attribute %s in element %s differ" %
|
||||
(expected_attr.name, actual_node.tagName))
|
||||
|
||||
expected_children = self._GetChildren(expected_node)
|
||||
actual_children = self._GetChildren(actual_node)
|
||||
self.assertEquals(
|
||||
len(expected_children), len(actual_children),
|
||||
"number of child elements differ in element " + actual_node.tagName)
|
||||
for child_id, child in expected_children.iteritems():
|
||||
self.assert_(child_id in actual_children,
|
||||
'<%s> is not in <%s> (in element %s)' %
|
||||
(child_id, actual_children, actual_node.tagName))
|
||||
self.AssertEquivalentNodes(child, actual_children[child_id])
|
||||
|
||||
identifying_attribute = {
|
||||
"testsuites": "name",
|
||||
"testsuite": "name",
|
||||
"testcase": "name",
|
||||
"failure": "message",
|
||||
}
|
||||
|
||||
def _GetChildren(self, element):
|
||||
"""
|
||||
Fetches all of the child nodes of element, a DOM Element object.
|
||||
Returns them as the values of a dictionary keyed by the IDs of the
|
||||
children. For <testsuites>, <testsuite> and <testcase> elements, the ID
|
||||
is the value of their "name" attribute; for <failure> elements, it is
|
||||
the value of the "message" attribute; CDATA sections and non-whitespace
|
||||
text nodes are concatenated into a single CDATA section with ID
|
||||
"detail". An exception is raised if any element other than the above
|
||||
four is encountered, if two child elements with the same identifying
|
||||
attributes are encountered, or if any other type of node is encountered.
|
||||
"""
|
||||
|
||||
children = {}
|
||||
for child in element.childNodes:
|
||||
if child.nodeType == Node.ELEMENT_NODE:
|
||||
self.assert_(child.tagName in self.identifying_attribute,
|
||||
"Encountered unknown element <%s>" % child.tagName)
|
||||
childID = child.getAttribute(self.identifying_attribute[child.tagName])
|
||||
self.assert_(childID not in children)
|
||||
children[childID] = child
|
||||
elif child.nodeType in [Node.TEXT_NODE, Node.CDATA_SECTION_NODE]:
|
||||
if "detail" not in children:
|
||||
if (child.nodeType == Node.CDATA_SECTION_NODE or
|
||||
not child.nodeValue.isspace()):
|
||||
children["detail"] = child.ownerDocument.createCDATASection(
|
||||
child.nodeValue)
|
||||
else:
|
||||
children["detail"].nodeValue += child.nodeValue
|
||||
else:
|
||||
self.fail("Encountered unexpected node type %d" % child.nodeType)
|
||||
return children
|
||||
|
||||
def NormalizeXml(self, element):
|
||||
"""
|
||||
Normalizes Google Test's XML output to eliminate references to transient
|
||||
information that may change from run to run.
|
||||
|
||||
* The "time" attribute of <testsuites>, <testsuite> and <testcase>
|
||||
elements is replaced with a single asterisk, if it contains
|
||||
only digit characters.
|
||||
* The "type_param" attribute of <testcase> elements is replaced with a
|
||||
single asterisk (if it sn non-empty) as it is the type name returned
|
||||
by the compiler and is platform dependent.
|
||||
* The line number reported in the first line of the "message"
|
||||
attribute of <failure> elements is replaced with a single asterisk.
|
||||
* The directory names in file paths are removed.
|
||||
* The stack traces are removed.
|
||||
"""
|
||||
|
||||
if element.tagName in ("testsuites", "testsuite", "testcase"):
|
||||
time = element.getAttributeNode("time")
|
||||
time.value = re.sub(r"^\d+(\.\d+)?$", "*", time.value)
|
||||
type_param = element.getAttributeNode("type_param")
|
||||
if type_param and type_param.value:
|
||||
type_param.value = "*"
|
||||
elif element.tagName == "failure":
|
||||
for child in element.childNodes:
|
||||
if child.nodeType == Node.CDATA_SECTION_NODE:
|
||||
# Removes the source line number.
|
||||
cdata = re.sub(r"^.*[/\\](.*:)\d+\n", "\\1*\n", child.nodeValue)
|
||||
# Removes the actual stack trace.
|
||||
child.nodeValue = re.sub(r"\nStack trace:\n(.|\n)*",
|
||||
"", cdata)
|
||||
for child in element.childNodes:
|
||||
if child.nodeType == Node.ELEMENT_NODE:
|
||||
self.NormalizeXml(child)
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user