Unzip GTest and GMock and remove zip handling code
This commit is contained in:
parent
72c394208f
commit
d37920364d
|
@ -10,8 +10,6 @@ config.h
|
||||||
/build
|
/build
|
||||||
/CMakeFiles
|
/CMakeFiles
|
||||||
/ext/cryptopp562
|
/ext/cryptopp562
|
||||||
/ext/gmock-1.6.0
|
|
||||||
/ext/gtest-1.6.0
|
|
||||||
/ext/openssl
|
/ext/openssl
|
||||||
/src/gui/Makefile*
|
/src/gui/Makefile*
|
||||||
/src/gui/object_script*
|
/src/gui/object_script*
|
||||||
|
|
Binary file not shown.
|
@ -0,0 +1,92 @@
|
||||||
|
Changes for 1.6.0:
|
||||||
|
|
||||||
|
* Compilation is much faster and uses much less memory, especially
|
||||||
|
when the constructor and destructor of a mock class are moved out of
|
||||||
|
the class body.
|
||||||
|
* New matchers: Pointwise(), Each().
|
||||||
|
* New actions: ReturnPointee() and ReturnRefOfCopy().
|
||||||
|
* CMake support.
|
||||||
|
* Project files for Visual Studio 2010.
|
||||||
|
* AllOf() and AnyOf() can handle up-to 10 arguments now.
|
||||||
|
* Google Mock doctor understands Clang error messages now.
|
||||||
|
* SetArgPointee<> now accepts string literals.
|
||||||
|
* gmock_gen.py handles storage specifier macros and template return
|
||||||
|
types now.
|
||||||
|
* Compatibility fixes.
|
||||||
|
* Bug fixes and implementation clean-ups.
|
||||||
|
* Potentially incompatible changes: disables the harmful 'make install'
|
||||||
|
command in autotools.
|
||||||
|
|
||||||
|
Potentially breaking changes:
|
||||||
|
|
||||||
|
* The description string for MATCHER*() changes from Python-style
|
||||||
|
interpolation to an ordinary C++ string expression.
|
||||||
|
* SetArgumentPointee is deprecated in favor of SetArgPointee.
|
||||||
|
* Some non-essential project files for Visual Studio 2005 are removed.
|
||||||
|
|
||||||
|
Changes for 1.5.0:
|
||||||
|
|
||||||
|
* New feature: Google Mock can be safely used in multi-threaded tests
|
||||||
|
on platforms having pthreads.
|
||||||
|
* New feature: function for printing a value of arbitrary type.
|
||||||
|
* New feature: function ExplainMatchResult() for easy definition of
|
||||||
|
composite matchers.
|
||||||
|
* The new matcher API lets user-defined matchers generate custom
|
||||||
|
explanations more directly and efficiently.
|
||||||
|
* Better failure messages all around.
|
||||||
|
* NotNull() and IsNull() now work with smart pointers.
|
||||||
|
* Field() and Property() now work when the matcher argument is a pointer
|
||||||
|
passed by reference.
|
||||||
|
* Regular expression matchers on all platforms.
|
||||||
|
* Added GCC 4.0 support for Google Mock Doctor.
|
||||||
|
* Added gmock_all_test.cc for compiling most Google Mock tests
|
||||||
|
in a single file.
|
||||||
|
* Significantly cleaned up compiler warnings.
|
||||||
|
* Bug fixes, better test coverage, and implementation clean-ups.
|
||||||
|
|
||||||
|
Potentially breaking changes:
|
||||||
|
|
||||||
|
* Custom matchers defined using MatcherInterface or MakePolymorphicMatcher()
|
||||||
|
need to be updated after upgrading to Google Mock 1.5.0; matchers defined
|
||||||
|
using MATCHER or MATCHER_P* aren't affected.
|
||||||
|
* Dropped support for 'make install'.
|
||||||
|
|
||||||
|
Changes for 1.4.0 (we skipped 1.2.* and 1.3.* to match the version of
|
||||||
|
Google Test):
|
||||||
|
|
||||||
|
* Works in more environments: Symbian and minGW, Visual C++ 7.1.
|
||||||
|
* Lighter weight: comes with our own implementation of TR1 tuple (no
|
||||||
|
more dependency on Boost!).
|
||||||
|
* New feature: --gmock_catch_leaked_mocks for detecting leaked mocks.
|
||||||
|
* New feature: ACTION_TEMPLATE for defining templatized actions.
|
||||||
|
* New feature: the .After() clause for specifying expectation order.
|
||||||
|
* New feature: the .With() clause for for specifying inter-argument
|
||||||
|
constraints.
|
||||||
|
* New feature: actions ReturnArg<k>(), ReturnNew<T>(...), and
|
||||||
|
DeleteArg<k>().
|
||||||
|
* New feature: matchers Key(), Pair(), Args<...>(), AllArgs(), IsNull(),
|
||||||
|
and Contains().
|
||||||
|
* New feature: utility class MockFunction<F>, useful for checkpoints, etc.
|
||||||
|
* New feature: functions Value(x, m) and SafeMatcherCast<T>(m).
|
||||||
|
* New feature: copying a mock object is rejected at compile time.
|
||||||
|
* New feature: a script for fusing all Google Mock and Google Test
|
||||||
|
source files for easy deployment.
|
||||||
|
* Improved the Google Mock doctor to diagnose more diseases.
|
||||||
|
* Improved the Google Mock generator script.
|
||||||
|
* Compatibility fixes for Mac OS X and gcc.
|
||||||
|
* Bug fixes and implementation clean-ups.
|
||||||
|
|
||||||
|
Changes for 1.1.0:
|
||||||
|
|
||||||
|
* New feature: ability to use Google Mock with any testing framework.
|
||||||
|
* New feature: macros for easily defining new matchers
|
||||||
|
* New feature: macros for easily defining new actions.
|
||||||
|
* New feature: more container matchers.
|
||||||
|
* New feature: actions for accessing function arguments and throwing
|
||||||
|
exceptions.
|
||||||
|
* Improved the Google Mock doctor script for diagnosing compiler errors.
|
||||||
|
* Bug fixes and implementation clean-ups.
|
||||||
|
|
||||||
|
Changes for 1.0.0:
|
||||||
|
|
||||||
|
* Initial Open Source release of Google Mock
|
|
@ -0,0 +1,151 @@
|
||||||
|
########################################################################
|
||||||
|
# CMake build script for Google Mock.
|
||||||
|
#
|
||||||
|
# To run the tests for Google Mock itself on Linux, use 'make test' or
|
||||||
|
# ctest. You can select which tests to run using 'ctest -R regex'.
|
||||||
|
# For more options, run 'ctest --help'.
|
||||||
|
|
||||||
|
# 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)
|
||||||
|
|
||||||
|
# Forces BUILD_SHARED_LIBS to OFF as Google Mock currently does not support
|
||||||
|
# working in a DLL.
|
||||||
|
# TODO(vladl@google.com): Implement building gMock as a DLL.
|
||||||
|
set(BUILD_SHARED_LIBS OFF)
|
||||||
|
|
||||||
|
option(gmock_build_tests "Build all of Google Mock's own tests." OFF)
|
||||||
|
|
||||||
|
# A directory to find Google Test sources.
|
||||||
|
if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/gtest/CMakeLists.txt")
|
||||||
|
set(gtest_dir gtest)
|
||||||
|
else()
|
||||||
|
set(gtest_dir ../gtest)
|
||||||
|
endif()
|
||||||
|
|
||||||
|
# Defines pre_project_set_up_hermetic_build() and set_up_hermetic_build().
|
||||||
|
include("${gtest_dir}/cmake/hermetic_build.cmake" OPTIONAL)
|
||||||
|
|
||||||
|
if (COMMAND pre_project_set_up_hermetic_build)
|
||||||
|
# Google Test also calls hermetic setup functions from add_subdirectory,
|
||||||
|
# although its changes will not affect things at the current scope.
|
||||||
|
pre_project_set_up_hermetic_build()
|
||||||
|
endif()
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
#
|
||||||
|
# Project-wide settings
|
||||||
|
|
||||||
|
# Name of the project.
|
||||||
|
#
|
||||||
|
# CMake files in this project can refer to the root source directory
|
||||||
|
# as ${gmock_SOURCE_DIR} and to the root binary directory as
|
||||||
|
# ${gmock_BINARY_DIR}.
|
||||||
|
# Language "C" is required for find_package(Threads).
|
||||||
|
project(gmock CXX C)
|
||||||
|
cmake_minimum_required(VERSION 2.6.2)
|
||||||
|
|
||||||
|
if (COMMAND set_up_hermetic_build)
|
||||||
|
set_up_hermetic_build()
|
||||||
|
endif()
|
||||||
|
|
||||||
|
# Instructs CMake to process Google Test's CMakeLists.txt and add its
|
||||||
|
# targets to the current scope. We are placing Google Test's binary
|
||||||
|
# directory in a subdirectory of our own as VC compilation may break
|
||||||
|
# if they are the same (the default).
|
||||||
|
add_subdirectory("${gtest_dir}" "${gmock_BINARY_DIR}/gtest")
|
||||||
|
|
||||||
|
# Although Google Test's CMakeLists.txt calls this function, the
|
||||||
|
# changes there don't affect the current scope. Therefore we have to
|
||||||
|
# call it again here.
|
||||||
|
config_compiler_and_linker() # from ${gtest_dir}/cmake/internal_utils.cmake
|
||||||
|
|
||||||
|
# Adds Google Mock's and Google Test's header directories to the search path.
|
||||||
|
include_directories("${gmock_SOURCE_DIR}/include"
|
||||||
|
"${gmock_SOURCE_DIR}"
|
||||||
|
"${gtest_SOURCE_DIR}/include"
|
||||||
|
# This directory is needed to build directly from Google
|
||||||
|
# Test sources.
|
||||||
|
"${gtest_SOURCE_DIR}")
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
#
|
||||||
|
# Defines the gmock & gmock_main libraries. User tests should link
|
||||||
|
# with one of them.
|
||||||
|
|
||||||
|
# Google Mock libraries. We build them using more strict warnings than what
|
||||||
|
# are used for other targets, to ensure that Google Mock can be compiled by
|
||||||
|
# a user aggressive about warnings.
|
||||||
|
cxx_library(gmock "${cxx_strict}" src/gmock-all.cc)
|
||||||
|
target_link_libraries(gmock gtest)
|
||||||
|
|
||||||
|
cxx_library(gmock_main "${cxx_strict}" src/gmock_main.cc)
|
||||||
|
target_link_libraries(gmock_main gmock)
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
#
|
||||||
|
# Google Mock's own tests.
|
||||||
|
#
|
||||||
|
# You can skip this section if you aren't interested in testing
|
||||||
|
# Google Mock itself.
|
||||||
|
#
|
||||||
|
# The tests are not built by default. To build them, set the
|
||||||
|
# gmock_build_tests option to ON. You can do it by running ccmake
|
||||||
|
# or specifying the -Dgmock_build_tests=ON flag when running cmake.
|
||||||
|
|
||||||
|
if (gmock_build_tests)
|
||||||
|
# This must be set in the root directory for the tests to be run by
|
||||||
|
# 'make test' or ctest.
|
||||||
|
enable_testing()
|
||||||
|
|
||||||
|
############################################################
|
||||||
|
# C++ tests built with standard compiler flags.
|
||||||
|
|
||||||
|
cxx_test(gmock-actions_test gmock_main)
|
||||||
|
cxx_test(gmock-cardinalities_test gmock_main)
|
||||||
|
cxx_test(gmock-generated-actions_test gmock_main)
|
||||||
|
cxx_test(gmock-generated-function-mockers_test gmock_main)
|
||||||
|
cxx_test(gmock-generated-internal-utils_test gmock_main)
|
||||||
|
cxx_test(gmock-generated-matchers_test gmock_main)
|
||||||
|
cxx_test(gmock-internal-utils_test gmock_main)
|
||||||
|
cxx_test(gmock-matchers_test gmock_main)
|
||||||
|
cxx_test(gmock-more-actions_test gmock_main)
|
||||||
|
cxx_test(gmock-nice-strict_test gmock_main)
|
||||||
|
cxx_test(gmock-port_test gmock_main)
|
||||||
|
cxx_test(gmock-spec-builders_test gmock_main)
|
||||||
|
cxx_test(gmock_link_test gmock_main test/gmock_link2_test.cc)
|
||||||
|
# cxx_test(gmock_stress_test gmock)
|
||||||
|
cxx_test(gmock_test gmock_main)
|
||||||
|
|
||||||
|
# gmock_all_test is commented to save time building and running tests.
|
||||||
|
# Uncomment if necessary.
|
||||||
|
# cxx_test(gmock_all_test gmock_main)
|
||||||
|
|
||||||
|
############################################################
|
||||||
|
# C++ tests built with non-standard compiler flags.
|
||||||
|
|
||||||
|
cxx_library(gmock_main_no_exception "${cxx_no_exception}"
|
||||||
|
"${gtest_dir}/src/gtest-all.cc" src/gmock-all.cc src/gmock_main.cc)
|
||||||
|
cxx_library(gmock_main_no_rtti "${cxx_no_rtti}"
|
||||||
|
"${gtest_dir}/src/gtest-all.cc" src/gmock-all.cc src/gmock_main.cc)
|
||||||
|
cxx_library(gmock_main_use_own_tuple "${cxx_use_own_tuple}"
|
||||||
|
"${gtest_dir}/src/gtest-all.cc" src/gmock-all.cc src/gmock_main.cc)
|
||||||
|
|
||||||
|
cxx_test_with_flags(gmock-more-actions_no_exception_test "${cxx_no_exception}"
|
||||||
|
gmock_main_no_exception test/gmock-more-actions_test.cc)
|
||||||
|
|
||||||
|
cxx_test_with_flags(gmock_no_rtti_test "${cxx_no_rtti}"
|
||||||
|
gmock_main_no_rtti test/gmock-spec-builders_test.cc)
|
||||||
|
|
||||||
|
cxx_test_with_flags(gmock_use_own_tuple_test "${cxx_use_own_tuple}"
|
||||||
|
gmock_main_use_own_tuple test/gmock-spec-builders_test.cc)
|
||||||
|
|
||||||
|
############################################################
|
||||||
|
# Python tests.
|
||||||
|
|
||||||
|
cxx_executable(gmock_leak_test_ test gmock_main)
|
||||||
|
py_test(gmock_leak_test)
|
||||||
|
|
||||||
|
cxx_executable(gmock_output_test_ test gmock)
|
||||||
|
py_test(gmock_output_test)
|
||||||
|
endif()
|
|
@ -0,0 +1,40 @@
|
||||||
|
# This file contains a list of people who've made non-trivial
|
||||||
|
# contribution to the Google C++ Mocking Framework project. People
|
||||||
|
# who commit code to the project are encouraged to add their names
|
||||||
|
# here. Please keep the list sorted by first names.
|
||||||
|
|
||||||
|
Benoit Sigoure <tsuna@google.com>
|
||||||
|
Bogdan Piloca <boo@google.com>
|
||||||
|
Chandler Carruth <chandlerc@google.com>
|
||||||
|
Dave MacLachlan <dmaclach@gmail.com>
|
||||||
|
David Anderson <danderson@google.com>
|
||||||
|
Dean Sturtevant
|
||||||
|
Gene Volovich <gv@cite.com>
|
||||||
|
Hal Burch <gmock@hburch.com>
|
||||||
|
Jeffrey Yasskin <jyasskin@google.com>
|
||||||
|
Jim Keller <jimkeller@google.com>
|
||||||
|
Joe Walnes <joe@truemesh.com>
|
||||||
|
Jon Wray <jwray@google.com>
|
||||||
|
Keir Mierle <mierle@gmail.com>
|
||||||
|
Keith Ray <keith.ray@gmail.com>
|
||||||
|
Kostya Serebryany <kcc@google.com>
|
||||||
|
Lev Makhlis
|
||||||
|
Manuel Klimek <klimek@google.com>
|
||||||
|
Mario Tanev <radix@google.com>
|
||||||
|
Mark Paskin
|
||||||
|
Markus Heule <markus.heule@gmail.com>
|
||||||
|
Matthew Simmons <simmonmt@acm.org>
|
||||||
|
Mike Bland <mbland@google.com>
|
||||||
|
Neal Norwitz <nnorwitz@gmail.com>
|
||||||
|
Nermin Ozkiranartli <nermin@google.com>
|
||||||
|
Owen Carlsen <ocarlsen@google.com>
|
||||||
|
Paneendra Ba <paneendra@google.com>
|
||||||
|
Paul Menage <menage@google.com>
|
||||||
|
Piotr Kaminski <piotrk@google.com>
|
||||||
|
Russ Rufer <russ@pentad.com>
|
||||||
|
Sverre Sundsdal <sundsdal@gmail.com>
|
||||||
|
Takeshi Yoshino <tyoshino@google.com>
|
||||||
|
Vadim Berman <vadimb@google.com>
|
||||||
|
Vlad Losev <vladl@google.com>
|
||||||
|
Wolfgang Klier <wklier@google.com>
|
||||||
|
Zhanyong Wan <wan@google.com>
|
|
@ -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.
|
|
@ -0,0 +1,209 @@
|
||||||
|
# Automake file
|
||||||
|
|
||||||
|
# Nonstandard package files for distribution.
|
||||||
|
EXTRA_DIST =
|
||||||
|
|
||||||
|
# We may need to build our internally packaged gtest. If so, it will be
|
||||||
|
# included in the 'subdirs' variable.
|
||||||
|
SUBDIRS = $(subdirs)
|
||||||
|
|
||||||
|
# This is generated by the configure script, so clean it for distribution.
|
||||||
|
DISTCLEANFILES = scripts/gmock-config
|
||||||
|
|
||||||
|
# We define the global AM_CPPFLAGS as everything we compile includes from these
|
||||||
|
# directories.
|
||||||
|
AM_CPPFLAGS = $(GTEST_CPPFLAGS) -I$(srcdir)/include
|
||||||
|
|
||||||
|
# Modifies compiler and linker flags for pthreads compatibility.
|
||||||
|
if HAVE_PTHREADS
|
||||||
|
AM_CXXFLAGS = @PTHREAD_CFLAGS@ -DGTEST_HAS_PTHREAD=1
|
||||||
|
AM_LIBS = @PTHREAD_LIBS@
|
||||||
|
endif
|
||||||
|
|
||||||
|
# Build rules for libraries.
|
||||||
|
lib_LTLIBRARIES = lib/libgmock.la lib/libgmock_main.la
|
||||||
|
|
||||||
|
lib_libgmock_la_SOURCES = src/gmock-all.cc
|
||||||
|
|
||||||
|
pkginclude_HEADERS = \
|
||||||
|
include/gmock/gmock-actions.h \
|
||||||
|
include/gmock/gmock-cardinalities.h \
|
||||||
|
include/gmock/gmock-generated-actions.h \
|
||||||
|
include/gmock/gmock-generated-function-mockers.h \
|
||||||
|
include/gmock/gmock-generated-matchers.h \
|
||||||
|
include/gmock/gmock-generated-nice-strict.h \
|
||||||
|
include/gmock/gmock-matchers.h \
|
||||||
|
include/gmock/gmock-more-actions.h \
|
||||||
|
include/gmock/gmock-spec-builders.h \
|
||||||
|
include/gmock/gmock.h
|
||||||
|
|
||||||
|
pkginclude_internaldir = $(pkgincludedir)/internal
|
||||||
|
pkginclude_internal_HEADERS = \
|
||||||
|
include/gmock/internal/gmock-generated-internal-utils.h \
|
||||||
|
include/gmock/internal/gmock-internal-utils.h \
|
||||||
|
include/gmock/internal/gmock-port.h
|
||||||
|
|
||||||
|
lib_libgmock_main_la_SOURCES = src/gmock_main.cc
|
||||||
|
lib_libgmock_main_la_LIBADD = lib/libgmock.la
|
||||||
|
|
||||||
|
# Build rules for tests. Automake's naming for some of these variables isn't
|
||||||
|
# terribly obvious, so this is a brief reference:
|
||||||
|
#
|
||||||
|
# TESTS -- Programs run automatically by "make check"
|
||||||
|
# check_PROGRAMS -- Programs built by "make check" but not necessarily run
|
||||||
|
|
||||||
|
TESTS=
|
||||||
|
check_PROGRAMS=
|
||||||
|
AM_LDFLAGS = $(GTEST_LDFLAGS)
|
||||||
|
|
||||||
|
# This exercises all major components of Google Mock. It also
|
||||||
|
# verifies that libgmock works.
|
||||||
|
TESTS += test/gmock-spec-builders_test
|
||||||
|
check_PROGRAMS += test/gmock-spec-builders_test
|
||||||
|
test_gmock_spec_builders_test_SOURCES = test/gmock-spec-builders_test.cc
|
||||||
|
test_gmock_spec_builders_test_LDADD = $(GTEST_LIBS) lib/libgmock.la
|
||||||
|
|
||||||
|
# This tests using Google Mock in multiple translation units. It also
|
||||||
|
# verifies that libgmock_main and libgmock work.
|
||||||
|
TESTS += test/gmock_link_test
|
||||||
|
check_PROGRAMS += test/gmock_link_test
|
||||||
|
test_gmock_link_test_SOURCES = \
|
||||||
|
test/gmock_link2_test.cc \
|
||||||
|
test/gmock_link_test.cc \
|
||||||
|
test/gmock_link_test.h
|
||||||
|
test_gmock_link_test_LDADD = $(GTEST_LIBS) lib/libgmock_main.la lib/libgmock.la
|
||||||
|
|
||||||
|
# Tests that fused gmock files compile and work.
|
||||||
|
TESTS += test/gmock_fused_test
|
||||||
|
check_PROGRAMS += test/gmock_fused_test
|
||||||
|
test_gmock_fused_test_SOURCES = \
|
||||||
|
fused-src/gmock-gtest-all.cc \
|
||||||
|
fused-src/gmock/gmock.h \
|
||||||
|
fused-src/gmock_main.cc \
|
||||||
|
fused-src/gtest/gtest.h \
|
||||||
|
test/gmock_test.cc
|
||||||
|
test_gmock_fused_test_CPPFLAGS = -I"$(srcdir)/fused-src"
|
||||||
|
|
||||||
|
# Google Mock source files that we don't compile directly.
|
||||||
|
GMOCK_SOURCE_INGLUDES = \
|
||||||
|
src/gmock-cardinalities.cc \
|
||||||
|
src/gmock-internal-utils.cc \
|
||||||
|
src/gmock-matchers.cc \
|
||||||
|
src/gmock-spec-builders.cc \
|
||||||
|
src/gmock.cc
|
||||||
|
|
||||||
|
EXTRA_DIST += $(GMOCK_SOURCE_INGLUDES)
|
||||||
|
|
||||||
|
# C++ tests that we don't compile using autotools.
|
||||||
|
EXTRA_DIST += \
|
||||||
|
test/gmock-actions_test.cc \
|
||||||
|
test/gmock-cardinalities_test.cc \
|
||||||
|
test/gmock-generated-actions_test.cc \
|
||||||
|
test/gmock-generated-function-mockers_test.cc \
|
||||||
|
test/gmock-generated-internal-utils_test.cc \
|
||||||
|
test/gmock-generated-matchers_test.cc \
|
||||||
|
test/gmock-internal-utils_test.cc \
|
||||||
|
test/gmock-matchers_test.cc \
|
||||||
|
test/gmock-more-actions_test.cc \
|
||||||
|
test/gmock-nice-strict_test.cc \
|
||||||
|
test/gmock-port_test.cc \
|
||||||
|
test/gmock_all_test.cc
|
||||||
|
|
||||||
|
# Python tests, which we don't run using autotools.
|
||||||
|
EXTRA_DIST += \
|
||||||
|
test/gmock_leak_test.py \
|
||||||
|
test/gmock_leak_test_.cc \
|
||||||
|
test/gmock_output_test.py \
|
||||||
|
test/gmock_output_test_.cc \
|
||||||
|
test/gmock_output_test_golden.txt \
|
||||||
|
test/gmock_test_utils.py
|
||||||
|
|
||||||
|
# Nonstandard package files for distribution.
|
||||||
|
EXTRA_DIST += \
|
||||||
|
CHANGES \
|
||||||
|
CONTRIBUTORS \
|
||||||
|
make/Makefile
|
||||||
|
|
||||||
|
# Pump scripts for generating Google Mock headers.
|
||||||
|
# TODO(chandlerc@google.com): automate the generation of *.h from *.h.pump.
|
||||||
|
EXTRA_DIST += \
|
||||||
|
include/gmock/gmock-generated-actions.h.pump \
|
||||||
|
include/gmock/gmock-generated-function-mockers.h.pump \
|
||||||
|
include/gmock/gmock-generated-matchers.h.pump \
|
||||||
|
include/gmock/gmock-generated-nice-strict.h.pump \
|
||||||
|
include/gmock/internal/gmock-generated-internal-utils.h.pump
|
||||||
|
|
||||||
|
# Script for fusing Google Mock and Google Test source files.
|
||||||
|
EXTRA_DIST += scripts/fuse_gmock_files.py
|
||||||
|
|
||||||
|
# The Google Mock Generator tool from the cppclean project.
|
||||||
|
EXTRA_DIST += \
|
||||||
|
scripts/generator/COPYING \
|
||||||
|
scripts/generator/README \
|
||||||
|
scripts/generator/README.cppclean \
|
||||||
|
scripts/generator/cpp/__init__.py \
|
||||||
|
scripts/generator/cpp/ast.py \
|
||||||
|
scripts/generator/cpp/gmock_class.py \
|
||||||
|
scripts/generator/cpp/keywords.py \
|
||||||
|
scripts/generator/cpp/tokenize.py \
|
||||||
|
scripts/generator/cpp/utils.py \
|
||||||
|
scripts/generator/gmock_gen.py
|
||||||
|
|
||||||
|
# CMake scripts.
|
||||||
|
EXTRA_DIST += \
|
||||||
|
CMakeLists.txt
|
||||||
|
|
||||||
|
# Microsoft Visual Studio 2005 projects.
|
||||||
|
EXTRA_DIST += \
|
||||||
|
msvc/2005/gmock.sln \
|
||||||
|
msvc/2005/gmock.vcproj \
|
||||||
|
msvc/2005/gmock_config.vsprops \
|
||||||
|
msvc/2005/gmock_main.vcproj \
|
||||||
|
msvc/2005/gmock_test.vcproj
|
||||||
|
|
||||||
|
# Microsoft Visual Studio 2010 projects.
|
||||||
|
EXTRA_DIST += \
|
||||||
|
msvc/2010/gmock.sln \
|
||||||
|
msvc/2010/gmock.vcxproj \
|
||||||
|
msvc/2010/gmock_config.props \
|
||||||
|
msvc/2010/gmock_main.vcxproj \
|
||||||
|
msvc/2010/gmock_test.vcxproj
|
||||||
|
|
||||||
|
# gmock_test.cc does not really depend on files generated by the
|
||||||
|
# fused-gmock-internal rule. However, gmock_test.o does, and it is
|
||||||
|
# important to include test/gmock_test.cc as part of this rule in order to
|
||||||
|
# prevent compiling gmock_test.o until all dependent files have been
|
||||||
|
# generated.
|
||||||
|
$(test_gmock_fused_test_SOURCES): fused-gmock-internal
|
||||||
|
|
||||||
|
# TODO(vladl@google.com): Find a way to add Google Tests's sources here.
|
||||||
|
fused-gmock-internal: $(pkginclude_HEADERS) $(pkginclude_internal_HEADERS) \
|
||||||
|
$(lib_libgmock_la_SOURCES) $(GMOCK_SOURCE_INGLUDES) \
|
||||||
|
$(lib_libgmock_main_la_SOURCES) \
|
||||||
|
scripts/fuse_gmock_files.py
|
||||||
|
mkdir -p "$(srcdir)/fused-src"
|
||||||
|
chmod -R u+w "$(srcdir)/fused-src"
|
||||||
|
rm -f "$(srcdir)/fused-src/gtest/gtest.h"
|
||||||
|
rm -f "$(srcdir)/fused-src/gmock/gmock.h"
|
||||||
|
rm -f "$(srcdir)/fused-src/gmock-gtest-all.cc"
|
||||||
|
"$(srcdir)/scripts/fuse_gmock_files.py" "$(srcdir)/fused-src"
|
||||||
|
cp -f "$(srcdir)/src/gmock_main.cc" "$(srcdir)/fused-src"
|
||||||
|
|
||||||
|
maintainer-clean-local:
|
||||||
|
rm -rf "$(srcdir)/fused-src"
|
||||||
|
|
||||||
|
# Death tests may produce core dumps in the build directory. In case
|
||||||
|
# this happens, clean them to keep distcleancheck happy.
|
||||||
|
CLEANFILES = core
|
||||||
|
|
||||||
|
# Disables 'make install' as installing a compiled version of Google
|
||||||
|
# Mock can lead to undefined behavior due to violation of the
|
||||||
|
# One-Definition Rule.
|
||||||
|
|
||||||
|
install-exec-local:
|
||||||
|
echo "'make install' is dangerous and not supported. Instead, see README for how to integrate Google Mock into your build system."
|
||||||
|
false
|
||||||
|
|
||||||
|
install-data-local:
|
||||||
|
echo "'make install' is dangerous and not supported. Instead, see README for how to integrate Google Mock into your build system."
|
||||||
|
false
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,354 @@
|
||||||
|
Google C++ Mocking Framework
|
||||||
|
============================
|
||||||
|
|
||||||
|
http://code.google.com/p/googlemock/
|
||||||
|
|
||||||
|
Overview
|
||||||
|
--------
|
||||||
|
|
||||||
|
Google's framework for writing and using C++ mock classes on a variety
|
||||||
|
of platforms (Linux, Mac OS X, Windows, Windows CE, Symbian, etc).
|
||||||
|
Inspired by jMock, EasyMock, and Hamcrest, and designed with C++'s
|
||||||
|
specifics in mind, it can help you derive better designs of your
|
||||||
|
system and write better tests.
|
||||||
|
|
||||||
|
Google Mock:
|
||||||
|
|
||||||
|
- provides a declarative syntax for defining mocks,
|
||||||
|
- can easily define partial (hybrid) mocks, which are a cross of real
|
||||||
|
and mock objects,
|
||||||
|
- handles functions of arbitrary types and overloaded functions,
|
||||||
|
- comes with a rich set of matchers for validating function arguments,
|
||||||
|
- uses an intuitive syntax for controlling the behavior of a mock,
|
||||||
|
- does automatic verification of expectations (no record-and-replay
|
||||||
|
needed),
|
||||||
|
- allows arbitrary (partial) ordering constraints on
|
||||||
|
function calls to be expressed,
|
||||||
|
- lets a user extend it by defining new matchers and actions.
|
||||||
|
- does not use exceptions, and
|
||||||
|
- is easy to learn and use.
|
||||||
|
|
||||||
|
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!
|
||||||
|
|
||||||
|
Please note that code under scripts/generator/ is from the cppclean
|
||||||
|
project (http://code.google.com/p/cppclean/) and under the Apache
|
||||||
|
License, which is different from Google Mock's license.
|
||||||
|
|
||||||
|
Requirements for End Users
|
||||||
|
--------------------------
|
||||||
|
|
||||||
|
Google Mock is implemented on top of the Google Test C++ testing
|
||||||
|
framework (http://code.google.com/p/googletest/), and includes the
|
||||||
|
latter as part of the SVN repositary and distribution package. You
|
||||||
|
must use the bundled version of Google Test when using Google Mock, or
|
||||||
|
you may get compiler/linker errors.
|
||||||
|
|
||||||
|
You can also easily configure Google Mock to work with another testing
|
||||||
|
framework of your choice; although it will still need Google Test as
|
||||||
|
an internal dependency. Please read
|
||||||
|
http://code.google.com/p/googlemock/wiki/ForDummies#Using_Google_Mock_with_Any_Testing_Framework
|
||||||
|
for how to do it.
|
||||||
|
|
||||||
|
Google Mock depends on advanced C++ features and thus requires a more
|
||||||
|
modern compiler. The following are needed to use Google Mock:
|
||||||
|
|
||||||
|
### Linux Requirements ###
|
||||||
|
|
||||||
|
These are the base requirements to build and use Google Mock from a source
|
||||||
|
package (as described below):
|
||||||
|
|
||||||
|
* GNU-compatible Make or "gmake"
|
||||||
|
* POSIX-standard shell
|
||||||
|
* POSIX(-2) Regular Expressions (regex.h)
|
||||||
|
* C++98-standard-compliant compiler (e.g. GCC 3.4 or newer)
|
||||||
|
|
||||||
|
### Windows Requirements ###
|
||||||
|
|
||||||
|
* Microsoft Visual C++ 8.0 SP1 or newer
|
||||||
|
|
||||||
|
### Mac OS X Requirements ###
|
||||||
|
|
||||||
|
* Mac OS X 10.4 Tiger or newer
|
||||||
|
* Developer Tools Installed
|
||||||
|
|
||||||
|
Requirements for Contributors
|
||||||
|
-----------------------------
|
||||||
|
|
||||||
|
We welcome patches. If you plan to contribute a patch, you need to
|
||||||
|
build Google Mock and its own tests from an SVN checkout (described
|
||||||
|
below), which has further requirements:
|
||||||
|
|
||||||
|
* Automake version 1.9 or newer
|
||||||
|
* Autoconf version 2.59 or newer
|
||||||
|
* Libtool / Libtoolize
|
||||||
|
* Python version 2.3 or newer (for running some of the tests and
|
||||||
|
re-generating certain source files from templates)
|
||||||
|
|
||||||
|
Getting the Source
|
||||||
|
------------------
|
||||||
|
|
||||||
|
There are two primary ways of getting Google Mock'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 development and make
|
||||||
|
patches much more easily, so we highly encourage it.
|
||||||
|
|
||||||
|
### Source Package ###
|
||||||
|
|
||||||
|
Google Mock 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 needed to
|
||||||
|
extract their contents, and the size of the resulting file. Download
|
||||||
|
whichever you are most comfortable with.
|
||||||
|
|
||||||
|
[1] http://code.google.com/p/googlemock/downloads/list
|
||||||
|
|
||||||
|
Once downloaded expand the archive using whichever tools you prefer
|
||||||
|
for that type. This will always result in a new directory with the
|
||||||
|
name "gmock-X.Y.Z" which contains all of the source code. Here are
|
||||||
|
some examples on Linux:
|
||||||
|
|
||||||
|
tar -xvzf gmock-X.Y.Z.tar.gz
|
||||||
|
tar -xvjf gmock-X.Y.Z.tar.bz2
|
||||||
|
unzip gmock-X.Y.Z.zip
|
||||||
|
|
||||||
|
### SVN Checkout ###
|
||||||
|
|
||||||
|
To check out the main branch (also known as the "trunk") of Google
|
||||||
|
Mock, run the following Subversion command:
|
||||||
|
|
||||||
|
svn checkout http://googlemock.googlecode.com/svn/trunk/ gmock-svn
|
||||||
|
|
||||||
|
If you are using a *nix system and plan to use the GNU Autotools build
|
||||||
|
system to build Google Mock (described below), you'll need to
|
||||||
|
configure it now. Otherwise you are done with getting the source
|
||||||
|
files.
|
||||||
|
|
||||||
|
To prepare the Autotools build system, enter the target directory of
|
||||||
|
the checkout command you used ('gmock-svn') and proceed with the
|
||||||
|
following command:
|
||||||
|
|
||||||
|
autoreconf -fvi
|
||||||
|
|
||||||
|
Once you have completed this step, you are ready to build the library.
|
||||||
|
Note that you should only need to complete this step once. The
|
||||||
|
subsequent 'make' invocations will automatically re-generate the bits
|
||||||
|
of the build system that need to be changed.
|
||||||
|
|
||||||
|
If your system uses older versions of the autotools, the above command
|
||||||
|
will fail. You may need to explicitly specify a version to use. For
|
||||||
|
instance, if you have both GNU Automake 1.4 and 1.9 installed and
|
||||||
|
'automake' would invoke the 1.4, use instead:
|
||||||
|
|
||||||
|
AUTOMAKE=automake-1.9 ACLOCAL=aclocal-1.9 autoreconf -fvi
|
||||||
|
|
||||||
|
Make sure you're using the same version of automake and aclocal.
|
||||||
|
|
||||||
|
Setting up the Build
|
||||||
|
--------------------
|
||||||
|
|
||||||
|
To build Google Mock 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 ###
|
||||||
|
|
||||||
|
This section shows how you can integrate Google Mock into your
|
||||||
|
existing build system.
|
||||||
|
|
||||||
|
Suppose you put Google Mock in directory ${GMOCK_DIR} and Google Test
|
||||||
|
in ${GTEST_DIR} (the latter is ${GMOCK_DIR}/gtest by default). To
|
||||||
|
build Google Mock, create a library build target (or a project as
|
||||||
|
called by Visual Studio and Xcode) to compile
|
||||||
|
|
||||||
|
${GTEST_DIR}/src/gtest-all.cc and ${GMOCK_DIR}/src/gmock-all.cc
|
||||||
|
|
||||||
|
with
|
||||||
|
|
||||||
|
${GTEST_DIR}/include, ${GTEST_DIR}, ${GMOCK_DIR}/include, and ${GMOCK_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} -I${GMOCK_DIR}/include \
|
||||||
|
-I${GMOCK_DIR} -c ${GTEST_DIR}/src/gtest-all.cc
|
||||||
|
g++ -I${GTEST_DIR}/include -I${GTEST_DIR} -I${GMOCK_DIR}/include \
|
||||||
|
-I${GMOCK_DIR} -c ${GMOCK_DIR}/src/gmock-all.cc
|
||||||
|
ar -rv libgmock.a gtest-all.o gmock-all.o
|
||||||
|
|
||||||
|
Next, you should compile your test source file with
|
||||||
|
${GTEST_DIR}/include and ${GMOCK_DIR}/include in the header search
|
||||||
|
path, and link it with gmock and any other necessary libraries:
|
||||||
|
|
||||||
|
g++ -I${GTEST_DIR}/include -I${GMOCK_DIR}/include \
|
||||||
|
path/to/your_test.cc libgmock.a -o your_test
|
||||||
|
|
||||||
|
As an example, the make/ directory contains a Makefile that you can
|
||||||
|
use to build Google Mock on systems where GNU make is available
|
||||||
|
(e.g. Linux, Mac OS X, and Cygwin). It doesn't try to build Google
|
||||||
|
Mock's own tests. Instead, it just builds the Google Mock 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 ${GMOCK_DIR}/make
|
||||||
|
make
|
||||||
|
./gmock_test
|
||||||
|
|
||||||
|
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.
|
||||||
|
|
||||||
|
### Windows ###
|
||||||
|
|
||||||
|
The msvc/2005 directory contains VC++ 2005 projects and the msvc/2010
|
||||||
|
directory contains VC++ 2010 projects for building Google Mock and
|
||||||
|
selected tests.
|
||||||
|
|
||||||
|
Change to the appropriate directory and run "msbuild gmock.sln" to
|
||||||
|
build the library and tests (or open the gmock.sln in the MSVC IDE).
|
||||||
|
If you want to create your own project to use with Google Mock, you'll
|
||||||
|
have to configure it to use the gmock_config propety sheet. For that:
|
||||||
|
|
||||||
|
* Open the Property Manager window (View | Other Windows | Property Manager)
|
||||||
|
* Right-click on your project and select "Add Existing Property Sheet..."
|
||||||
|
* Navigate to gmock_config.vsprops or gmock_config.props and select it.
|
||||||
|
* In Project Properties | Configuration Properties | General | Additional
|
||||||
|
Include Directories, type <path to Google Mock>/include.
|
||||||
|
|
||||||
|
Tweaking Google Mock
|
||||||
|
--------------------
|
||||||
|
|
||||||
|
Google Mock 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 Mock 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 ${GTEST_DIR}/include/gtest/internal/gtest-port.h.
|
||||||
|
|
||||||
|
### Choosing a TR1 Tuple Library ###
|
||||||
|
|
||||||
|
Google Mock uses the C++ Technical Report 1 (TR1) tuple library
|
||||||
|
heavily. Unfortunately TR1 tuple is not yet widely available with all
|
||||||
|
compilers. The good news is that Google Test 1.4.0+ implements a
|
||||||
|
subset of TR1 tuple that's enough for Google Mock's need. Google Mock
|
||||||
|
will automatically use that implementation when the compiler doesn't
|
||||||
|
provide TR1 tuple.
|
||||||
|
|
||||||
|
Usually you don't need to care about which tuple library Google Test
|
||||||
|
and Google Mock use. However, if your project already uses TR1 tuple,
|
||||||
|
you need to tell Google Test and Google Mock 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, Google Mock, and
|
||||||
|
your tests. If you want to force Google Test and Google Mock to use
|
||||||
|
their own tuple library, just add
|
||||||
|
|
||||||
|
-DGTEST_USE_OWN_TR1_TUPLE=1
|
||||||
|
|
||||||
|
to the compiler flags instead.
|
||||||
|
|
||||||
|
If you want to use Boost's TR1 tuple library with Google Mock, please
|
||||||
|
refer to the Boost website (http://www.boost.org/) for how to obtain
|
||||||
|
it and set it up.
|
||||||
|
|
||||||
|
### Tweaking Google Test ###
|
||||||
|
|
||||||
|
Most of Google Test's control macros apply to Google Mock as well.
|
||||||
|
Please see file ${GTEST_DIR}/README for how to tweak them.
|
||||||
|
|
||||||
|
Upgrading from an Earlier Version
|
||||||
|
---------------------------------
|
||||||
|
|
||||||
|
We strive to keep Google Mock 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 Mock.
|
||||||
|
|
||||||
|
### Upgrading from 1.1.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 ###
|
||||||
|
|
||||||
|
On platforms where the pthread library is available, Google Test and
|
||||||
|
Google Mock use it in order to be thread-safe. For this to work, you
|
||||||
|
may need to tweak your compiler and/or linker flags. Please see the
|
||||||
|
"Multi-threaded Tests" section in file ${GTEST_DIR}/README for what
|
||||||
|
you may need to do.
|
||||||
|
|
||||||
|
If you have custom matchers defined using MatcherInterface or
|
||||||
|
MakePolymorphicMatcher(), you'll need to update their definitions to
|
||||||
|
use the new matcher API [2]. Matchers defined using MATCHER() or
|
||||||
|
MATCHER_P*() aren't affected.
|
||||||
|
|
||||||
|
[2] http://code.google.com/p/googlemock/wiki/CookBook#Writing_New_Monomorphic_Matchers,
|
||||||
|
http://code.google.com/p/googlemock/wiki/CookBook#Writing_New_Polymorphic_Matchers
|
||||||
|
|
||||||
|
Developing Google Mock
|
||||||
|
----------------------
|
||||||
|
|
||||||
|
This section discusses how to make your own changes to Google Mock.
|
||||||
|
|
||||||
|
### Testing Google Mock 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'll need Autotools. First, make sure you have followed
|
||||||
|
the instructions in section "SVN Checkout" to configure Google Mock.
|
||||||
|
Then, create a build output directory and enter it. Next,
|
||||||
|
|
||||||
|
${GMOCK_DIR}/configure # Standard GNU configure script, --help for more info
|
||||||
|
|
||||||
|
Once you have successfully configured Google Mock, the build steps are
|
||||||
|
standard for GNU-style OSS packages.
|
||||||
|
|
||||||
|
make # Standard makefile following GNU conventions
|
||||||
|
make check # Builds and runs all tests - all should pass.
|
||||||
|
|
||||||
|
Note that when building your project against Google Mock, you are building
|
||||||
|
against Google Test as well. There is no need to configure Google Test
|
||||||
|
separately.
|
||||||
|
|
||||||
|
### Regenerating Source Files ###
|
||||||
|
|
||||||
|
Some of Google Mock'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/gmock/gmock-generated-actions.h.pump is used to generate
|
||||||
|
gmock-generated-actions.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' script (for Pump
|
||||||
|
is Useful for Meta Programming) to regenerate them. You can find
|
||||||
|
pump.py in the ${GTEST_DIR}/scripts/ directory. Read the Pump manual
|
||||||
|
[3] for how to use it.
|
||||||
|
|
||||||
|
[3] http://code.google.com/p/googletest/wiki/PumpManual.
|
||||||
|
|
||||||
|
### Contributing a Patch ###
|
||||||
|
|
||||||
|
We welcome patches. Please read the Google Mock developer's guide [4]
|
||||||
|
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.
|
||||||
|
|
||||||
|
[4] http://code.google.com/p/googlemock/wiki/DevGuide
|
||||||
|
|
||||||
|
Happy testing!
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,69 @@
|
||||||
|
/* build-aux/config.h.in. Generated from configure.ac by autoheader. */
|
||||||
|
|
||||||
|
/* Define to 1 if you have the <dlfcn.h> header file. */
|
||||||
|
#undef HAVE_DLFCN_H
|
||||||
|
|
||||||
|
/* Define to 1 if you have the <inttypes.h> header file. */
|
||||||
|
#undef HAVE_INTTYPES_H
|
||||||
|
|
||||||
|
/* Define to 1 if you have the <memory.h> header file. */
|
||||||
|
#undef HAVE_MEMORY_H
|
||||||
|
|
||||||
|
/* Define if you have POSIX threads libraries and header files. */
|
||||||
|
#undef HAVE_PTHREAD
|
||||||
|
|
||||||
|
/* Define to 1 if you have the <stdint.h> header file. */
|
||||||
|
#undef HAVE_STDINT_H
|
||||||
|
|
||||||
|
/* Define to 1 if you have the <stdlib.h> header file. */
|
||||||
|
#undef HAVE_STDLIB_H
|
||||||
|
|
||||||
|
/* Define to 1 if you have the <strings.h> header file. */
|
||||||
|
#undef HAVE_STRINGS_H
|
||||||
|
|
||||||
|
/* Define to 1 if you have the <string.h> header file. */
|
||||||
|
#undef HAVE_STRING_H
|
||||||
|
|
||||||
|
/* Define to 1 if you have the <sys/stat.h> header file. */
|
||||||
|
#undef HAVE_SYS_STAT_H
|
||||||
|
|
||||||
|
/* Define to 1 if you have the <sys/types.h> header file. */
|
||||||
|
#undef HAVE_SYS_TYPES_H
|
||||||
|
|
||||||
|
/* Define to 1 if you have the <unistd.h> header file. */
|
||||||
|
#undef HAVE_UNISTD_H
|
||||||
|
|
||||||
|
/* Define to the sub-directory in which libtool stores uninstalled libraries.
|
||||||
|
*/
|
||||||
|
#undef LT_OBJDIR
|
||||||
|
|
||||||
|
/* Name of package */
|
||||||
|
#undef PACKAGE
|
||||||
|
|
||||||
|
/* Define to the address where bug reports for this package should be sent. */
|
||||||
|
#undef PACKAGE_BUGREPORT
|
||||||
|
|
||||||
|
/* Define to the full name of this package. */
|
||||||
|
#undef PACKAGE_NAME
|
||||||
|
|
||||||
|
/* Define to the full name and version of this package. */
|
||||||
|
#undef PACKAGE_STRING
|
||||||
|
|
||||||
|
/* Define to the one symbol short name of this package. */
|
||||||
|
#undef PACKAGE_TARNAME
|
||||||
|
|
||||||
|
/* Define to the home page for this package. */
|
||||||
|
#undef PACKAGE_URL
|
||||||
|
|
||||||
|
/* Define to the version of this package. */
|
||||||
|
#undef PACKAGE_VERSION
|
||||||
|
|
||||||
|
/* Define to necessary symbol if this constant uses a non-standard name on
|
||||||
|
your system. */
|
||||||
|
#undef PTHREAD_CREATE_JOINABLE
|
||||||
|
|
||||||
|
/* Define to 1 if you have the ANSI C header files. */
|
||||||
|
#undef STDC_HEADERS
|
||||||
|
|
||||||
|
/* Version number of package */
|
||||||
|
#undef VERSION
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,630 @@
|
||||||
|
#! /bin/sh
|
||||||
|
# depcomp - compile a program generating dependencies as side-effects
|
||||||
|
|
||||||
|
scriptversion=2009-04-28.21; # UTC
|
||||||
|
|
||||||
|
# Copyright (C) 1999, 2000, 2003, 2004, 2005, 2006, 2007, 2009 Free
|
||||||
|
# Software Foundation, Inc.
|
||||||
|
|
||||||
|
# This program is free software; you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation; either version 2, or (at your option)
|
||||||
|
# any later version.
|
||||||
|
|
||||||
|
# This program is distributed in the hope that it will be useful,
|
||||||
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
# GNU General Public License for more details.
|
||||||
|
|
||||||
|
# You should have received a copy of the GNU General Public License
|
||||||
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
|
||||||
|
# As a special exception to the GNU General Public License, if you
|
||||||
|
# distribute this file as part of a program that contains a
|
||||||
|
# configuration script generated by Autoconf, you may include it under
|
||||||
|
# the same distribution terms that you use for the rest of that program.
|
||||||
|
|
||||||
|
# Originally written by Alexandre Oliva <oliva@dcc.unicamp.br>.
|
||||||
|
|
||||||
|
case $1 in
|
||||||
|
'')
|
||||||
|
echo "$0: No command. Try \`$0 --help' for more information." 1>&2
|
||||||
|
exit 1;
|
||||||
|
;;
|
||||||
|
-h | --h*)
|
||||||
|
cat <<\EOF
|
||||||
|
Usage: depcomp [--help] [--version] PROGRAM [ARGS]
|
||||||
|
|
||||||
|
Run PROGRAMS ARGS to compile a file, generating dependencies
|
||||||
|
as side-effects.
|
||||||
|
|
||||||
|
Environment variables:
|
||||||
|
depmode Dependency tracking mode.
|
||||||
|
source Source file read by `PROGRAMS ARGS'.
|
||||||
|
object Object file output by `PROGRAMS ARGS'.
|
||||||
|
DEPDIR directory where to store dependencies.
|
||||||
|
depfile Dependency file to output.
|
||||||
|
tmpdepfile Temporary file to use when outputing dependencies.
|
||||||
|
libtool Whether libtool is used (yes/no).
|
||||||
|
|
||||||
|
Report bugs to <bug-automake@gnu.org>.
|
||||||
|
EOF
|
||||||
|
exit $?
|
||||||
|
;;
|
||||||
|
-v | --v*)
|
||||||
|
echo "depcomp $scriptversion"
|
||||||
|
exit $?
|
||||||
|
;;
|
||||||
|
esac
|
||||||
|
|
||||||
|
if test -z "$depmode" || test -z "$source" || test -z "$object"; then
|
||||||
|
echo "depcomp: Variables source, object and depmode must be set" 1>&2
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
|
|
||||||
|
# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po.
|
||||||
|
depfile=${depfile-`echo "$object" |
|
||||||
|
sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`}
|
||||||
|
tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`}
|
||||||
|
|
||||||
|
rm -f "$tmpdepfile"
|
||||||
|
|
||||||
|
# Some modes work just like other modes, but use different flags. We
|
||||||
|
# parameterize here, but still list the modes in the big case below,
|
||||||
|
# to make depend.m4 easier to write. Note that we *cannot* use a case
|
||||||
|
# here, because this file can only contain one case statement.
|
||||||
|
if test "$depmode" = hp; then
|
||||||
|
# HP compiler uses -M and no extra arg.
|
||||||
|
gccflag=-M
|
||||||
|
depmode=gcc
|
||||||
|
fi
|
||||||
|
|
||||||
|
if test "$depmode" = dashXmstdout; then
|
||||||
|
# This is just like dashmstdout with a different argument.
|
||||||
|
dashmflag=-xM
|
||||||
|
depmode=dashmstdout
|
||||||
|
fi
|
||||||
|
|
||||||
|
cygpath_u="cygpath -u -f -"
|
||||||
|
if test "$depmode" = msvcmsys; then
|
||||||
|
# This is just like msvisualcpp but w/o cygpath translation.
|
||||||
|
# Just convert the backslash-escaped backslashes to single forward
|
||||||
|
# slashes to satisfy depend.m4
|
||||||
|
cygpath_u="sed s,\\\\\\\\,/,g"
|
||||||
|
depmode=msvisualcpp
|
||||||
|
fi
|
||||||
|
|
||||||
|
case "$depmode" in
|
||||||
|
gcc3)
|
||||||
|
## gcc 3 implements dependency tracking that does exactly what
|
||||||
|
## we want. Yay! Note: for some reason libtool 1.4 doesn't like
|
||||||
|
## it if -MD -MP comes after the -MF stuff. Hmm.
|
||||||
|
## Unfortunately, FreeBSD c89 acceptance of flags depends upon
|
||||||
|
## the command line argument order; so add the flags where they
|
||||||
|
## appear in depend2.am. Note that the slowdown incurred here
|
||||||
|
## affects only configure: in makefiles, %FASTDEP% shortcuts this.
|
||||||
|
for arg
|
||||||
|
do
|
||||||
|
case $arg in
|
||||||
|
-c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;;
|
||||||
|
*) set fnord "$@" "$arg" ;;
|
||||||
|
esac
|
||||||
|
shift # fnord
|
||||||
|
shift # $arg
|
||||||
|
done
|
||||||
|
"$@"
|
||||||
|
stat=$?
|
||||||
|
if test $stat -eq 0; then :
|
||||||
|
else
|
||||||
|
rm -f "$tmpdepfile"
|
||||||
|
exit $stat
|
||||||
|
fi
|
||||||
|
mv "$tmpdepfile" "$depfile"
|
||||||
|
;;
|
||||||
|
|
||||||
|
gcc)
|
||||||
|
## There are various ways to get dependency output from gcc. Here's
|
||||||
|
## why we pick this rather obscure method:
|
||||||
|
## - Don't want to use -MD because we'd like the dependencies to end
|
||||||
|
## up in a subdir. Having to rename by hand is ugly.
|
||||||
|
## (We might end up doing this anyway to support other compilers.)
|
||||||
|
## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
|
||||||
|
## -MM, not -M (despite what the docs say).
|
||||||
|
## - Using -M directly means running the compiler twice (even worse
|
||||||
|
## than renaming).
|
||||||
|
if test -z "$gccflag"; then
|
||||||
|
gccflag=-MD,
|
||||||
|
fi
|
||||||
|
"$@" -Wp,"$gccflag$tmpdepfile"
|
||||||
|
stat=$?
|
||||||
|
if test $stat -eq 0; then :
|
||||||
|
else
|
||||||
|
rm -f "$tmpdepfile"
|
||||||
|
exit $stat
|
||||||
|
fi
|
||||||
|
rm -f "$depfile"
|
||||||
|
echo "$object : \\" > "$depfile"
|
||||||
|
alpha=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
|
||||||
|
## The second -e expression handles DOS-style file names with drive letters.
|
||||||
|
sed -e 's/^[^:]*: / /' \
|
||||||
|
-e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"
|
||||||
|
## This next piece of magic avoids the `deleted header file' problem.
|
||||||
|
## The problem is that when a header file which appears in a .P file
|
||||||
|
## is deleted, the dependency causes make to die (because there is
|
||||||
|
## typically no way to rebuild the header). We avoid this by adding
|
||||||
|
## dummy dependencies for each header file. Too bad gcc doesn't do
|
||||||
|
## this for us directly.
|
||||||
|
tr ' ' '
|
||||||
|
' < "$tmpdepfile" |
|
||||||
|
## Some versions of gcc put a space before the `:'. On the theory
|
||||||
|
## that the space means something, we add a space to the output as
|
||||||
|
## well.
|
||||||
|
## Some versions of the HPUX 10.20 sed can't process this invocation
|
||||||
|
## correctly. Breaking it into two sed invocations is a workaround.
|
||||||
|
sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
|
||||||
|
rm -f "$tmpdepfile"
|
||||||
|
;;
|
||||||
|
|
||||||
|
hp)
|
||||||
|
# This case exists only to let depend.m4 do its work. It works by
|
||||||
|
# looking at the text of this script. This case will never be run,
|
||||||
|
# since it is checked for above.
|
||||||
|
exit 1
|
||||||
|
;;
|
||||||
|
|
||||||
|
sgi)
|
||||||
|
if test "$libtool" = yes; then
|
||||||
|
"$@" "-Wp,-MDupdate,$tmpdepfile"
|
||||||
|
else
|
||||||
|
"$@" -MDupdate "$tmpdepfile"
|
||||||
|
fi
|
||||||
|
stat=$?
|
||||||
|
if test $stat -eq 0; then :
|
||||||
|
else
|
||||||
|
rm -f "$tmpdepfile"
|
||||||
|
exit $stat
|
||||||
|
fi
|
||||||
|
rm -f "$depfile"
|
||||||
|
|
||||||
|
if test -f "$tmpdepfile"; then # yes, the sourcefile depend on other files
|
||||||
|
echo "$object : \\" > "$depfile"
|
||||||
|
|
||||||
|
# Clip off the initial element (the dependent). Don't try to be
|
||||||
|
# clever and replace this with sed code, as IRIX sed won't handle
|
||||||
|
# lines with more than a fixed number of characters (4096 in
|
||||||
|
# IRIX 6.2 sed, 8192 in IRIX 6.5). We also remove comment lines;
|
||||||
|
# the IRIX cc adds comments like `#:fec' to the end of the
|
||||||
|
# dependency line.
|
||||||
|
tr ' ' '
|
||||||
|
' < "$tmpdepfile" \
|
||||||
|
| sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' | \
|
||||||
|
tr '
|
||||||
|
' ' ' >> "$depfile"
|
||||||
|
echo >> "$depfile"
|
||||||
|
|
||||||
|
# The second pass generates a dummy entry for each header file.
|
||||||
|
tr ' ' '
|
||||||
|
' < "$tmpdepfile" \
|
||||||
|
| sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
|
||||||
|
>> "$depfile"
|
||||||
|
else
|
||||||
|
# The sourcefile does not contain any dependencies, so just
|
||||||
|
# store a dummy comment line, to avoid errors with the Makefile
|
||||||
|
# "include basename.Plo" scheme.
|
||||||
|
echo "#dummy" > "$depfile"
|
||||||
|
fi
|
||||||
|
rm -f "$tmpdepfile"
|
||||||
|
;;
|
||||||
|
|
||||||
|
aix)
|
||||||
|
# The C for AIX Compiler uses -M and outputs the dependencies
|
||||||
|
# in a .u file. In older versions, this file always lives in the
|
||||||
|
# current directory. Also, the AIX compiler puts `$object:' at the
|
||||||
|
# start of each line; $object doesn't have directory information.
|
||||||
|
# Version 6 uses the directory in both cases.
|
||||||
|
dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
|
||||||
|
test "x$dir" = "x$object" && dir=
|
||||||
|
base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
|
||||||
|
if test "$libtool" = yes; then
|
||||||
|
tmpdepfile1=$dir$base.u
|
||||||
|
tmpdepfile2=$base.u
|
||||||
|
tmpdepfile3=$dir.libs/$base.u
|
||||||
|
"$@" -Wc,-M
|
||||||
|
else
|
||||||
|
tmpdepfile1=$dir$base.u
|
||||||
|
tmpdepfile2=$dir$base.u
|
||||||
|
tmpdepfile3=$dir$base.u
|
||||||
|
"$@" -M
|
||||||
|
fi
|
||||||
|
stat=$?
|
||||||
|
|
||||||
|
if test $stat -eq 0; then :
|
||||||
|
else
|
||||||
|
rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
|
||||||
|
exit $stat
|
||||||
|
fi
|
||||||
|
|
||||||
|
for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
|
||||||
|
do
|
||||||
|
test -f "$tmpdepfile" && break
|
||||||
|
done
|
||||||
|
if test -f "$tmpdepfile"; then
|
||||||
|
# Each line is of the form `foo.o: dependent.h'.
|
||||||
|
# Do two passes, one to just change these to
|
||||||
|
# `$object: dependent.h' and one to simply `dependent.h:'.
|
||||||
|
sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
|
||||||
|
# That's a tab and a space in the [].
|
||||||
|
sed -e 's,^.*\.[a-z]*:[ ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
|
||||||
|
else
|
||||||
|
# The sourcefile does not contain any dependencies, so just
|
||||||
|
# store a dummy comment line, to avoid errors with the Makefile
|
||||||
|
# "include basename.Plo" scheme.
|
||||||
|
echo "#dummy" > "$depfile"
|
||||||
|
fi
|
||||||
|
rm -f "$tmpdepfile"
|
||||||
|
;;
|
||||||
|
|
||||||
|
icc)
|
||||||
|
# Intel's C compiler understands `-MD -MF file'. However on
|
||||||
|
# icc -MD -MF foo.d -c -o sub/foo.o sub/foo.c
|
||||||
|
# ICC 7.0 will fill foo.d with something like
|
||||||
|
# foo.o: sub/foo.c
|
||||||
|
# foo.o: sub/foo.h
|
||||||
|
# which is wrong. We want:
|
||||||
|
# sub/foo.o: sub/foo.c
|
||||||
|
# sub/foo.o: sub/foo.h
|
||||||
|
# sub/foo.c:
|
||||||
|
# sub/foo.h:
|
||||||
|
# ICC 7.1 will output
|
||||||
|
# foo.o: sub/foo.c sub/foo.h
|
||||||
|
# and will wrap long lines using \ :
|
||||||
|
# foo.o: sub/foo.c ... \
|
||||||
|
# sub/foo.h ... \
|
||||||
|
# ...
|
||||||
|
|
||||||
|
"$@" -MD -MF "$tmpdepfile"
|
||||||
|
stat=$?
|
||||||
|
if test $stat -eq 0; then :
|
||||||
|
else
|
||||||
|
rm -f "$tmpdepfile"
|
||||||
|
exit $stat
|
||||||
|
fi
|
||||||
|
rm -f "$depfile"
|
||||||
|
# Each line is of the form `foo.o: dependent.h',
|
||||||
|
# or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'.
|
||||||
|
# Do two passes, one to just change these to
|
||||||
|
# `$object: dependent.h' and one to simply `dependent.h:'.
|
||||||
|
sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile"
|
||||||
|
# Some versions of the HPUX 10.20 sed can't process this invocation
|
||||||
|
# correctly. Breaking it into two sed invocations is a workaround.
|
||||||
|
sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" |
|
||||||
|
sed -e 's/$/ :/' >> "$depfile"
|
||||||
|
rm -f "$tmpdepfile"
|
||||||
|
;;
|
||||||
|
|
||||||
|
hp2)
|
||||||
|
# The "hp" stanza above does not work with aCC (C++) and HP's ia64
|
||||||
|
# compilers, which have integrated preprocessors. The correct option
|
||||||
|
# to use with these is +Maked; it writes dependencies to a file named
|
||||||
|
# 'foo.d', which lands next to the object file, wherever that
|
||||||
|
# happens to be.
|
||||||
|
# Much of this is similar to the tru64 case; see comments there.
|
||||||
|
dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
|
||||||
|
test "x$dir" = "x$object" && dir=
|
||||||
|
base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
|
||||||
|
if test "$libtool" = yes; then
|
||||||
|
tmpdepfile1=$dir$base.d
|
||||||
|
tmpdepfile2=$dir.libs/$base.d
|
||||||
|
"$@" -Wc,+Maked
|
||||||
|
else
|
||||||
|
tmpdepfile1=$dir$base.d
|
||||||
|
tmpdepfile2=$dir$base.d
|
||||||
|
"$@" +Maked
|
||||||
|
fi
|
||||||
|
stat=$?
|
||||||
|
if test $stat -eq 0; then :
|
||||||
|
else
|
||||||
|
rm -f "$tmpdepfile1" "$tmpdepfile2"
|
||||||
|
exit $stat
|
||||||
|
fi
|
||||||
|
|
||||||
|
for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2"
|
||||||
|
do
|
||||||
|
test -f "$tmpdepfile" && break
|
||||||
|
done
|
||||||
|
if test -f "$tmpdepfile"; then
|
||||||
|
sed -e "s,^.*\.[a-z]*:,$object:," "$tmpdepfile" > "$depfile"
|
||||||
|
# Add `dependent.h:' lines.
|
||||||
|
sed -ne '2,${
|
||||||
|
s/^ *//
|
||||||
|
s/ \\*$//
|
||||||
|
s/$/:/
|
||||||
|
p
|
||||||
|
}' "$tmpdepfile" >> "$depfile"
|
||||||
|
else
|
||||||
|
echo "#dummy" > "$depfile"
|
||||||
|
fi
|
||||||
|
rm -f "$tmpdepfile" "$tmpdepfile2"
|
||||||
|
;;
|
||||||
|
|
||||||
|
tru64)
|
||||||
|
# The Tru64 compiler uses -MD to generate dependencies as a side
|
||||||
|
# effect. `cc -MD -o foo.o ...' puts the dependencies into `foo.o.d'.
|
||||||
|
# At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
|
||||||
|
# dependencies in `foo.d' instead, so we check for that too.
|
||||||
|
# Subdirectories are respected.
|
||||||
|
dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
|
||||||
|
test "x$dir" = "x$object" && dir=
|
||||||
|
base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
|
||||||
|
|
||||||
|
if test "$libtool" = yes; then
|
||||||
|
# With Tru64 cc, shared objects can also be used to make a
|
||||||
|
# static library. This mechanism is used in libtool 1.4 series to
|
||||||
|
# handle both shared and static libraries in a single compilation.
|
||||||
|
# With libtool 1.4, dependencies were output in $dir.libs/$base.lo.d.
|
||||||
|
#
|
||||||
|
# With libtool 1.5 this exception was removed, and libtool now
|
||||||
|
# generates 2 separate objects for the 2 libraries. These two
|
||||||
|
# compilations output dependencies in $dir.libs/$base.o.d and
|
||||||
|
# in $dir$base.o.d. We have to check for both files, because
|
||||||
|
# one of the two compilations can be disabled. We should prefer
|
||||||
|
# $dir$base.o.d over $dir.libs/$base.o.d because the latter is
|
||||||
|
# automatically cleaned when .libs/ is deleted, while ignoring
|
||||||
|
# the former would cause a distcleancheck panic.
|
||||||
|
tmpdepfile1=$dir.libs/$base.lo.d # libtool 1.4
|
||||||
|
tmpdepfile2=$dir$base.o.d # libtool 1.5
|
||||||
|
tmpdepfile3=$dir.libs/$base.o.d # libtool 1.5
|
||||||
|
tmpdepfile4=$dir.libs/$base.d # Compaq CCC V6.2-504
|
||||||
|
"$@" -Wc,-MD
|
||||||
|
else
|
||||||
|
tmpdepfile1=$dir$base.o.d
|
||||||
|
tmpdepfile2=$dir$base.d
|
||||||
|
tmpdepfile3=$dir$base.d
|
||||||
|
tmpdepfile4=$dir$base.d
|
||||||
|
"$@" -MD
|
||||||
|
fi
|
||||||
|
|
||||||
|
stat=$?
|
||||||
|
if test $stat -eq 0; then :
|
||||||
|
else
|
||||||
|
rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
|
||||||
|
exit $stat
|
||||||
|
fi
|
||||||
|
|
||||||
|
for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
|
||||||
|
do
|
||||||
|
test -f "$tmpdepfile" && break
|
||||||
|
done
|
||||||
|
if test -f "$tmpdepfile"; then
|
||||||
|
sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
|
||||||
|
# That's a tab and a space in the [].
|
||||||
|
sed -e 's,^.*\.[a-z]*:[ ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
|
||||||
|
else
|
||||||
|
echo "#dummy" > "$depfile"
|
||||||
|
fi
|
||||||
|
rm -f "$tmpdepfile"
|
||||||
|
;;
|
||||||
|
|
||||||
|
#nosideeffect)
|
||||||
|
# This comment above is used by automake to tell side-effect
|
||||||
|
# dependency tracking mechanisms from slower ones.
|
||||||
|
|
||||||
|
dashmstdout)
|
||||||
|
# Important note: in order to support this mode, a compiler *must*
|
||||||
|
# always write the preprocessed file to stdout, regardless of -o.
|
||||||
|
"$@" || exit $?
|
||||||
|
|
||||||
|
# Remove the call to Libtool.
|
||||||
|
if test "$libtool" = yes; then
|
||||||
|
while test "X$1" != 'X--mode=compile'; do
|
||||||
|
shift
|
||||||
|
done
|
||||||
|
shift
|
||||||
|
fi
|
||||||
|
|
||||||
|
# Remove `-o $object'.
|
||||||
|
IFS=" "
|
||||||
|
for arg
|
||||||
|
do
|
||||||
|
case $arg in
|
||||||
|
-o)
|
||||||
|
shift
|
||||||
|
;;
|
||||||
|
$object)
|
||||||
|
shift
|
||||||
|
;;
|
||||||
|
*)
|
||||||
|
set fnord "$@" "$arg"
|
||||||
|
shift # fnord
|
||||||
|
shift # $arg
|
||||||
|
;;
|
||||||
|
esac
|
||||||
|
done
|
||||||
|
|
||||||
|
test -z "$dashmflag" && dashmflag=-M
|
||||||
|
# Require at least two characters before searching for `:'
|
||||||
|
# in the target name. This is to cope with DOS-style filenames:
|
||||||
|
# a dependency such as `c:/foo/bar' could be seen as target `c' otherwise.
|
||||||
|
"$@" $dashmflag |
|
||||||
|
sed 's:^[ ]*[^: ][^:][^:]*\:[ ]*:'"$object"'\: :' > "$tmpdepfile"
|
||||||
|
rm -f "$depfile"
|
||||||
|
cat < "$tmpdepfile" > "$depfile"
|
||||||
|
tr ' ' '
|
||||||
|
' < "$tmpdepfile" | \
|
||||||
|
## Some versions of the HPUX 10.20 sed can't process this invocation
|
||||||
|
## correctly. Breaking it into two sed invocations is a workaround.
|
||||||
|
sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
|
||||||
|
rm -f "$tmpdepfile"
|
||||||
|
;;
|
||||||
|
|
||||||
|
dashXmstdout)
|
||||||
|
# This case only exists to satisfy depend.m4. It is never actually
|
||||||
|
# run, as this mode is specially recognized in the preamble.
|
||||||
|
exit 1
|
||||||
|
;;
|
||||||
|
|
||||||
|
makedepend)
|
||||||
|
"$@" || exit $?
|
||||||
|
# Remove any Libtool call
|
||||||
|
if test "$libtool" = yes; then
|
||||||
|
while test "X$1" != 'X--mode=compile'; do
|
||||||
|
shift
|
||||||
|
done
|
||||||
|
shift
|
||||||
|
fi
|
||||||
|
# X makedepend
|
||||||
|
shift
|
||||||
|
cleared=no eat=no
|
||||||
|
for arg
|
||||||
|
do
|
||||||
|
case $cleared in
|
||||||
|
no)
|
||||||
|
set ""; shift
|
||||||
|
cleared=yes ;;
|
||||||
|
esac
|
||||||
|
if test $eat = yes; then
|
||||||
|
eat=no
|
||||||
|
continue
|
||||||
|
fi
|
||||||
|
case "$arg" in
|
||||||
|
-D*|-I*)
|
||||||
|
set fnord "$@" "$arg"; shift ;;
|
||||||
|
# Strip any option that makedepend may not understand. Remove
|
||||||
|
# the object too, otherwise makedepend will parse it as a source file.
|
||||||
|
-arch)
|
||||||
|
eat=yes ;;
|
||||||
|
-*|$object)
|
||||||
|
;;
|
||||||
|
*)
|
||||||
|
set fnord "$@" "$arg"; shift ;;
|
||||||
|
esac
|
||||||
|
done
|
||||||
|
obj_suffix=`echo "$object" | sed 's/^.*\././'`
|
||||||
|
touch "$tmpdepfile"
|
||||||
|
${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@"
|
||||||
|
rm -f "$depfile"
|
||||||
|
cat < "$tmpdepfile" > "$depfile"
|
||||||
|
sed '1,2d' "$tmpdepfile" | tr ' ' '
|
||||||
|
' | \
|
||||||
|
## Some versions of the HPUX 10.20 sed can't process this invocation
|
||||||
|
## correctly. Breaking it into two sed invocations is a workaround.
|
||||||
|
sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
|
||||||
|
rm -f "$tmpdepfile" "$tmpdepfile".bak
|
||||||
|
;;
|
||||||
|
|
||||||
|
cpp)
|
||||||
|
# Important note: in order to support this mode, a compiler *must*
|
||||||
|
# always write the preprocessed file to stdout.
|
||||||
|
"$@" || exit $?
|
||||||
|
|
||||||
|
# Remove the call to Libtool.
|
||||||
|
if test "$libtool" = yes; then
|
||||||
|
while test "X$1" != 'X--mode=compile'; do
|
||||||
|
shift
|
||||||
|
done
|
||||||
|
shift
|
||||||
|
fi
|
||||||
|
|
||||||
|
# Remove `-o $object'.
|
||||||
|
IFS=" "
|
||||||
|
for arg
|
||||||
|
do
|
||||||
|
case $arg in
|
||||||
|
-o)
|
||||||
|
shift
|
||||||
|
;;
|
||||||
|
$object)
|
||||||
|
shift
|
||||||
|
;;
|
||||||
|
*)
|
||||||
|
set fnord "$@" "$arg"
|
||||||
|
shift # fnord
|
||||||
|
shift # $arg
|
||||||
|
;;
|
||||||
|
esac
|
||||||
|
done
|
||||||
|
|
||||||
|
"$@" -E |
|
||||||
|
sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
|
||||||
|
-e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' |
|
||||||
|
sed '$ s: \\$::' > "$tmpdepfile"
|
||||||
|
rm -f "$depfile"
|
||||||
|
echo "$object : \\" > "$depfile"
|
||||||
|
cat < "$tmpdepfile" >> "$depfile"
|
||||||
|
sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile"
|
||||||
|
rm -f "$tmpdepfile"
|
||||||
|
;;
|
||||||
|
|
||||||
|
msvisualcpp)
|
||||||
|
# Important note: in order to support this mode, a compiler *must*
|
||||||
|
# always write the preprocessed file to stdout.
|
||||||
|
"$@" || exit $?
|
||||||
|
|
||||||
|
# Remove the call to Libtool.
|
||||||
|
if test "$libtool" = yes; then
|
||||||
|
while test "X$1" != 'X--mode=compile'; do
|
||||||
|
shift
|
||||||
|
done
|
||||||
|
shift
|
||||||
|
fi
|
||||||
|
|
||||||
|
IFS=" "
|
||||||
|
for arg
|
||||||
|
do
|
||||||
|
case "$arg" in
|
||||||
|
-o)
|
||||||
|
shift
|
||||||
|
;;
|
||||||
|
$object)
|
||||||
|
shift
|
||||||
|
;;
|
||||||
|
"-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")
|
||||||
|
set fnord "$@"
|
||||||
|
shift
|
||||||
|
shift
|
||||||
|
;;
|
||||||
|
*)
|
||||||
|
set fnord "$@" "$arg"
|
||||||
|
shift
|
||||||
|
shift
|
||||||
|
;;
|
||||||
|
esac
|
||||||
|
done
|
||||||
|
"$@" -E 2>/dev/null |
|
||||||
|
sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile"
|
||||||
|
rm -f "$depfile"
|
||||||
|
echo "$object : \\" > "$depfile"
|
||||||
|
sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s:: \1 \\:p' >> "$depfile"
|
||||||
|
echo " " >> "$depfile"
|
||||||
|
sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile"
|
||||||
|
rm -f "$tmpdepfile"
|
||||||
|
;;
|
||||||
|
|
||||||
|
msvcmsys)
|
||||||
|
# This case exists only to let depend.m4 do its work. It works by
|
||||||
|
# looking at the text of this script. This case will never be run,
|
||||||
|
# since it is checked for above.
|
||||||
|
exit 1
|
||||||
|
;;
|
||||||
|
|
||||||
|
none)
|
||||||
|
exec "$@"
|
||||||
|
;;
|
||||||
|
|
||||||
|
*)
|
||||||
|
echo "Unknown depmode $depmode" 1>&2
|
||||||
|
exit 1
|
||||||
|
;;
|
||||||
|
esac
|
||||||
|
|
||||||
|
exit 0
|
||||||
|
|
||||||
|
# Local Variables:
|
||||||
|
# mode: shell-script
|
||||||
|
# sh-indentation: 2
|
||||||
|
# eval: (add-hook 'write-file-hooks 'time-stamp)
|
||||||
|
# time-stamp-start: "scriptversion="
|
||||||
|
# time-stamp-format: "%:y-%02m-%02d.%02H"
|
||||||
|
# time-stamp-time-zone: "UTC"
|
||||||
|
# time-stamp-end: "; # UTC"
|
||||||
|
# End:
|
|
@ -0,0 +1,520 @@
|
||||||
|
#!/bin/sh
|
||||||
|
# install - install a program, script, or datafile
|
||||||
|
|
||||||
|
scriptversion=2009-04-28.21; # UTC
|
||||||
|
|
||||||
|
# This originates from X11R5 (mit/util/scripts/install.sh), which was
|
||||||
|
# later released in X11R6 (xc/config/util/install.sh) with the
|
||||||
|
# following copyright and license.
|
||||||
|
#
|
||||||
|
# Copyright (C) 1994 X Consortium
|
||||||
|
#
|
||||||
|
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||||
|
# of this software and associated documentation files (the "Software"), to
|
||||||
|
# deal in the Software without restriction, including without limitation the
|
||||||
|
# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||||
|
# sell copies of the Software, and to permit persons to whom the Software is
|
||||||
|
# furnished to do so, subject to the following conditions:
|
||||||
|
#
|
||||||
|
# The above copyright notice and this permission notice shall be included in
|
||||||
|
# all copies or substantial portions of the Software.
|
||||||
|
#
|
||||||
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||||
|
# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
|
||||||
|
# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||||
|
#
|
||||||
|
# Except as contained in this notice, the name of the X Consortium shall not
|
||||||
|
# be used in advertising or otherwise to promote the sale, use or other deal-
|
||||||
|
# ings in this Software without prior written authorization from the X Consor-
|
||||||
|
# tium.
|
||||||
|
#
|
||||||
|
#
|
||||||
|
# FSF changes to this file are in the public domain.
|
||||||
|
#
|
||||||
|
# Calling this script install-sh is preferred over install.sh, to prevent
|
||||||
|
# `make' implicit rules from creating a file called install from it
|
||||||
|
# when there is no Makefile.
|
||||||
|
#
|
||||||
|
# This script is compatible with the BSD install script, but was written
|
||||||
|
# from scratch.
|
||||||
|
|
||||||
|
nl='
|
||||||
|
'
|
||||||
|
IFS=" "" $nl"
|
||||||
|
|
||||||
|
# set DOITPROG to echo to test this script
|
||||||
|
|
||||||
|
# Don't use :- since 4.3BSD and earlier shells don't like it.
|
||||||
|
doit=${DOITPROG-}
|
||||||
|
if test -z "$doit"; then
|
||||||
|
doit_exec=exec
|
||||||
|
else
|
||||||
|
doit_exec=$doit
|
||||||
|
fi
|
||||||
|
|
||||||
|
# Put in absolute file names if you don't have them in your path;
|
||||||
|
# or use environment vars.
|
||||||
|
|
||||||
|
chgrpprog=${CHGRPPROG-chgrp}
|
||||||
|
chmodprog=${CHMODPROG-chmod}
|
||||||
|
chownprog=${CHOWNPROG-chown}
|
||||||
|
cmpprog=${CMPPROG-cmp}
|
||||||
|
cpprog=${CPPROG-cp}
|
||||||
|
mkdirprog=${MKDIRPROG-mkdir}
|
||||||
|
mvprog=${MVPROG-mv}
|
||||||
|
rmprog=${RMPROG-rm}
|
||||||
|
stripprog=${STRIPPROG-strip}
|
||||||
|
|
||||||
|
posix_glob='?'
|
||||||
|
initialize_posix_glob='
|
||||||
|
test "$posix_glob" != "?" || {
|
||||||
|
if (set -f) 2>/dev/null; then
|
||||||
|
posix_glob=
|
||||||
|
else
|
||||||
|
posix_glob=:
|
||||||
|
fi
|
||||||
|
}
|
||||||
|
'
|
||||||
|
|
||||||
|
posix_mkdir=
|
||||||
|
|
||||||
|
# Desired mode of installed file.
|
||||||
|
mode=0755
|
||||||
|
|
||||||
|
chgrpcmd=
|
||||||
|
chmodcmd=$chmodprog
|
||||||
|
chowncmd=
|
||||||
|
mvcmd=$mvprog
|
||||||
|
rmcmd="$rmprog -f"
|
||||||
|
stripcmd=
|
||||||
|
|
||||||
|
src=
|
||||||
|
dst=
|
||||||
|
dir_arg=
|
||||||
|
dst_arg=
|
||||||
|
|
||||||
|
copy_on_change=false
|
||||||
|
no_target_directory=
|
||||||
|
|
||||||
|
usage="\
|
||||||
|
Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
|
||||||
|
or: $0 [OPTION]... SRCFILES... DIRECTORY
|
||||||
|
or: $0 [OPTION]... -t DIRECTORY SRCFILES...
|
||||||
|
or: $0 [OPTION]... -d DIRECTORIES...
|
||||||
|
|
||||||
|
In the 1st form, copy SRCFILE to DSTFILE.
|
||||||
|
In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
|
||||||
|
In the 4th, create DIRECTORIES.
|
||||||
|
|
||||||
|
Options:
|
||||||
|
--help display this help and exit.
|
||||||
|
--version display version info and exit.
|
||||||
|
|
||||||
|
-c (ignored)
|
||||||
|
-C install only if different (preserve the last data modification time)
|
||||||
|
-d create directories instead of installing files.
|
||||||
|
-g GROUP $chgrpprog installed files to GROUP.
|
||||||
|
-m MODE $chmodprog installed files to MODE.
|
||||||
|
-o USER $chownprog installed files to USER.
|
||||||
|
-s $stripprog installed files.
|
||||||
|
-t DIRECTORY install into DIRECTORY.
|
||||||
|
-T report an error if DSTFILE is a directory.
|
||||||
|
|
||||||
|
Environment variables override the default commands:
|
||||||
|
CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
|
||||||
|
RMPROG STRIPPROG
|
||||||
|
"
|
||||||
|
|
||||||
|
while test $# -ne 0; do
|
||||||
|
case $1 in
|
||||||
|
-c) ;;
|
||||||
|
|
||||||
|
-C) copy_on_change=true;;
|
||||||
|
|
||||||
|
-d) dir_arg=true;;
|
||||||
|
|
||||||
|
-g) chgrpcmd="$chgrpprog $2"
|
||||||
|
shift;;
|
||||||
|
|
||||||
|
--help) echo "$usage"; exit $?;;
|
||||||
|
|
||||||
|
-m) mode=$2
|
||||||
|
case $mode in
|
||||||
|
*' '* | *' '* | *'
|
||||||
|
'* | *'*'* | *'?'* | *'['*)
|
||||||
|
echo "$0: invalid mode: $mode" >&2
|
||||||
|
exit 1;;
|
||||||
|
esac
|
||||||
|
shift;;
|
||||||
|
|
||||||
|
-o) chowncmd="$chownprog $2"
|
||||||
|
shift;;
|
||||||
|
|
||||||
|
-s) stripcmd=$stripprog;;
|
||||||
|
|
||||||
|
-t) dst_arg=$2
|
||||||
|
shift;;
|
||||||
|
|
||||||
|
-T) no_target_directory=true;;
|
||||||
|
|
||||||
|
--version) echo "$0 $scriptversion"; exit $?;;
|
||||||
|
|
||||||
|
--) shift
|
||||||
|
break;;
|
||||||
|
|
||||||
|
-*) echo "$0: invalid option: $1" >&2
|
||||||
|
exit 1;;
|
||||||
|
|
||||||
|
*) break;;
|
||||||
|
esac
|
||||||
|
shift
|
||||||
|
done
|
||||||
|
|
||||||
|
if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
|
||||||
|
# When -d is used, all remaining arguments are directories to create.
|
||||||
|
# When -t is used, the destination is already specified.
|
||||||
|
# Otherwise, the last argument is the destination. Remove it from $@.
|
||||||
|
for arg
|
||||||
|
do
|
||||||
|
if test -n "$dst_arg"; then
|
||||||
|
# $@ is not empty: it contains at least $arg.
|
||||||
|
set fnord "$@" "$dst_arg"
|
||||||
|
shift # fnord
|
||||||
|
fi
|
||||||
|
shift # arg
|
||||||
|
dst_arg=$arg
|
||||||
|
done
|
||||||
|
fi
|
||||||
|
|
||||||
|
if test $# -eq 0; then
|
||||||
|
if test -z "$dir_arg"; then
|
||||||
|
echo "$0: no input file specified." >&2
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
|
# It's OK to call `install-sh -d' without argument.
|
||||||
|
# This can happen when creating conditional directories.
|
||||||
|
exit 0
|
||||||
|
fi
|
||||||
|
|
||||||
|
if test -z "$dir_arg"; then
|
||||||
|
trap '(exit $?); exit' 1 2 13 15
|
||||||
|
|
||||||
|
# Set umask so as not to create temps with too-generous modes.
|
||||||
|
# However, 'strip' requires both read and write access to temps.
|
||||||
|
case $mode in
|
||||||
|
# Optimize common cases.
|
||||||
|
*644) cp_umask=133;;
|
||||||
|
*755) cp_umask=22;;
|
||||||
|
|
||||||
|
*[0-7])
|
||||||
|
if test -z "$stripcmd"; then
|
||||||
|
u_plus_rw=
|
||||||
|
else
|
||||||
|
u_plus_rw='% 200'
|
||||||
|
fi
|
||||||
|
cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
|
||||||
|
*)
|
||||||
|
if test -z "$stripcmd"; then
|
||||||
|
u_plus_rw=
|
||||||
|
else
|
||||||
|
u_plus_rw=,u+rw
|
||||||
|
fi
|
||||||
|
cp_umask=$mode$u_plus_rw;;
|
||||||
|
esac
|
||||||
|
fi
|
||||||
|
|
||||||
|
for src
|
||||||
|
do
|
||||||
|
# Protect names starting with `-'.
|
||||||
|
case $src in
|
||||||
|
-*) src=./$src;;
|
||||||
|
esac
|
||||||
|
|
||||||
|
if test -n "$dir_arg"; then
|
||||||
|
dst=$src
|
||||||
|
dstdir=$dst
|
||||||
|
test -d "$dstdir"
|
||||||
|
dstdir_status=$?
|
||||||
|
else
|
||||||
|
|
||||||
|
# Waiting for this to be detected by the "$cpprog $src $dsttmp" command
|
||||||
|
# might cause directories to be created, which would be especially bad
|
||||||
|
# if $src (and thus $dsttmp) contains '*'.
|
||||||
|
if test ! -f "$src" && test ! -d "$src"; then
|
||||||
|
echo "$0: $src does not exist." >&2
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
|
|
||||||
|
if test -z "$dst_arg"; then
|
||||||
|
echo "$0: no destination specified." >&2
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
|
|
||||||
|
dst=$dst_arg
|
||||||
|
# Protect names starting with `-'.
|
||||||
|
case $dst in
|
||||||
|
-*) dst=./$dst;;
|
||||||
|
esac
|
||||||
|
|
||||||
|
# If destination is a directory, append the input filename; won't work
|
||||||
|
# if double slashes aren't ignored.
|
||||||
|
if test -d "$dst"; then
|
||||||
|
if test -n "$no_target_directory"; then
|
||||||
|
echo "$0: $dst_arg: Is a directory" >&2
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
|
dstdir=$dst
|
||||||
|
dst=$dstdir/`basename "$src"`
|
||||||
|
dstdir_status=0
|
||||||
|
else
|
||||||
|
# Prefer dirname, but fall back on a substitute if dirname fails.
|
||||||
|
dstdir=`
|
||||||
|
(dirname "$dst") 2>/dev/null ||
|
||||||
|
expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
|
||||||
|
X"$dst" : 'X\(//\)[^/]' \| \
|
||||||
|
X"$dst" : 'X\(//\)$' \| \
|
||||||
|
X"$dst" : 'X\(/\)' \| . 2>/dev/null ||
|
||||||
|
echo X"$dst" |
|
||||||
|
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
|
||||||
|
s//\1/
|
||||||
|
q
|
||||||
|
}
|
||||||
|
/^X\(\/\/\)[^/].*/{
|
||||||
|
s//\1/
|
||||||
|
q
|
||||||
|
}
|
||||||
|
/^X\(\/\/\)$/{
|
||||||
|
s//\1/
|
||||||
|
q
|
||||||
|
}
|
||||||
|
/^X\(\/\).*/{
|
||||||
|
s//\1/
|
||||||
|
q
|
||||||
|
}
|
||||||
|
s/.*/./; q'
|
||||||
|
`
|
||||||
|
|
||||||
|
test -d "$dstdir"
|
||||||
|
dstdir_status=$?
|
||||||
|
fi
|
||||||
|
fi
|
||||||
|
|
||||||
|
obsolete_mkdir_used=false
|
||||||
|
|
||||||
|
if test $dstdir_status != 0; then
|
||||||
|
case $posix_mkdir in
|
||||||
|
'')
|
||||||
|
# Create intermediate dirs using mode 755 as modified by the umask.
|
||||||
|
# This is like FreeBSD 'install' as of 1997-10-28.
|
||||||
|
umask=`umask`
|
||||||
|
case $stripcmd.$umask in
|
||||||
|
# Optimize common cases.
|
||||||
|
*[2367][2367]) mkdir_umask=$umask;;
|
||||||
|
.*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;
|
||||||
|
|
||||||
|
*[0-7])
|
||||||
|
mkdir_umask=`expr $umask + 22 \
|
||||||
|
- $umask % 100 % 40 + $umask % 20 \
|
||||||
|
- $umask % 10 % 4 + $umask % 2
|
||||||
|
`;;
|
||||||
|
*) mkdir_umask=$umask,go-w;;
|
||||||
|
esac
|
||||||
|
|
||||||
|
# With -d, create the new directory with the user-specified mode.
|
||||||
|
# Otherwise, rely on $mkdir_umask.
|
||||||
|
if test -n "$dir_arg"; then
|
||||||
|
mkdir_mode=-m$mode
|
||||||
|
else
|
||||||
|
mkdir_mode=
|
||||||
|
fi
|
||||||
|
|
||||||
|
posix_mkdir=false
|
||||||
|
case $umask in
|
||||||
|
*[123567][0-7][0-7])
|
||||||
|
# POSIX mkdir -p sets u+wx bits regardless of umask, which
|
||||||
|
# is incompatible with FreeBSD 'install' when (umask & 300) != 0.
|
||||||
|
;;
|
||||||
|
*)
|
||||||
|
tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
|
||||||
|
trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0
|
||||||
|
|
||||||
|
if (umask $mkdir_umask &&
|
||||||
|
exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1
|
||||||
|
then
|
||||||
|
if test -z "$dir_arg" || {
|
||||||
|
# Check for POSIX incompatibilities with -m.
|
||||||
|
# HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
|
||||||
|
# other-writeable bit of parent directory when it shouldn't.
|
||||||
|
# FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
|
||||||
|
ls_ld_tmpdir=`ls -ld "$tmpdir"`
|
||||||
|
case $ls_ld_tmpdir in
|
||||||
|
d????-?r-*) different_mode=700;;
|
||||||
|
d????-?--*) different_mode=755;;
|
||||||
|
*) false;;
|
||||||
|
esac &&
|
||||||
|
$mkdirprog -m$different_mode -p -- "$tmpdir" && {
|
||||||
|
ls_ld_tmpdir_1=`ls -ld "$tmpdir"`
|
||||||
|
test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
then posix_mkdir=:
|
||||||
|
fi
|
||||||
|
rmdir "$tmpdir/d" "$tmpdir"
|
||||||
|
else
|
||||||
|
# Remove any dirs left behind by ancient mkdir implementations.
|
||||||
|
rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null
|
||||||
|
fi
|
||||||
|
trap '' 0;;
|
||||||
|
esac;;
|
||||||
|
esac
|
||||||
|
|
||||||
|
if
|
||||||
|
$posix_mkdir && (
|
||||||
|
umask $mkdir_umask &&
|
||||||
|
$doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
|
||||||
|
)
|
||||||
|
then :
|
||||||
|
else
|
||||||
|
|
||||||
|
# The umask is ridiculous, or mkdir does not conform to POSIX,
|
||||||
|
# or it failed possibly due to a race condition. Create the
|
||||||
|
# directory the slow way, step by step, checking for races as we go.
|
||||||
|
|
||||||
|
case $dstdir in
|
||||||
|
/*) prefix='/';;
|
||||||
|
-*) prefix='./';;
|
||||||
|
*) prefix='';;
|
||||||
|
esac
|
||||||
|
|
||||||
|
eval "$initialize_posix_glob"
|
||||||
|
|
||||||
|
oIFS=$IFS
|
||||||
|
IFS=/
|
||||||
|
$posix_glob set -f
|
||||||
|
set fnord $dstdir
|
||||||
|
shift
|
||||||
|
$posix_glob set +f
|
||||||
|
IFS=$oIFS
|
||||||
|
|
||||||
|
prefixes=
|
||||||
|
|
||||||
|
for d
|
||||||
|
do
|
||||||
|
test -z "$d" && continue
|
||||||
|
|
||||||
|
prefix=$prefix$d
|
||||||
|
if test -d "$prefix"; then
|
||||||
|
prefixes=
|
||||||
|
else
|
||||||
|
if $posix_mkdir; then
|
||||||
|
(umask=$mkdir_umask &&
|
||||||
|
$doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
|
||||||
|
# Don't fail if two instances are running concurrently.
|
||||||
|
test -d "$prefix" || exit 1
|
||||||
|
else
|
||||||
|
case $prefix in
|
||||||
|
*\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
|
||||||
|
*) qprefix=$prefix;;
|
||||||
|
esac
|
||||||
|
prefixes="$prefixes '$qprefix'"
|
||||||
|
fi
|
||||||
|
fi
|
||||||
|
prefix=$prefix/
|
||||||
|
done
|
||||||
|
|
||||||
|
if test -n "$prefixes"; then
|
||||||
|
# Don't fail if two instances are running concurrently.
|
||||||
|
(umask $mkdir_umask &&
|
||||||
|
eval "\$doit_exec \$mkdirprog $prefixes") ||
|
||||||
|
test -d "$dstdir" || exit 1
|
||||||
|
obsolete_mkdir_used=true
|
||||||
|
fi
|
||||||
|
fi
|
||||||
|
fi
|
||||||
|
|
||||||
|
if test -n "$dir_arg"; then
|
||||||
|
{ test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
|
||||||
|
{ test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
|
||||||
|
{ test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
|
||||||
|
test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
|
||||||
|
else
|
||||||
|
|
||||||
|
# Make a couple of temp file names in the proper directory.
|
||||||
|
dsttmp=$dstdir/_inst.$$_
|
||||||
|
rmtmp=$dstdir/_rm.$$_
|
||||||
|
|
||||||
|
# Trap to clean up those temp files at exit.
|
||||||
|
trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
|
||||||
|
|
||||||
|
# Copy the file name to the temp name.
|
||||||
|
(umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&
|
||||||
|
|
||||||
|
# and set any options; do chmod last to preserve setuid bits.
|
||||||
|
#
|
||||||
|
# If any of these fail, we abort the whole thing. If we want to
|
||||||
|
# ignore errors from any of these, just make sure not to ignore
|
||||||
|
# errors from the above "$doit $cpprog $src $dsttmp" command.
|
||||||
|
#
|
||||||
|
{ test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
|
||||||
|
{ test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
|
||||||
|
{ test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
|
||||||
|
{ test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
|
||||||
|
|
||||||
|
# If -C, don't bother to copy if it wouldn't change the file.
|
||||||
|
if $copy_on_change &&
|
||||||
|
old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` &&
|
||||||
|
new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` &&
|
||||||
|
|
||||||
|
eval "$initialize_posix_glob" &&
|
||||||
|
$posix_glob set -f &&
|
||||||
|
set X $old && old=:$2:$4:$5:$6 &&
|
||||||
|
set X $new && new=:$2:$4:$5:$6 &&
|
||||||
|
$posix_glob set +f &&
|
||||||
|
|
||||||
|
test "$old" = "$new" &&
|
||||||
|
$cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
|
||||||
|
then
|
||||||
|
rm -f "$dsttmp"
|
||||||
|
else
|
||||||
|
# Rename the file to the real destination.
|
||||||
|
$doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
|
||||||
|
|
||||||
|
# The rename failed, perhaps because mv can't rename something else
|
||||||
|
# to itself, or perhaps because mv is so ancient that it does not
|
||||||
|
# support -f.
|
||||||
|
{
|
||||||
|
# Now remove or move aside any old file at destination location.
|
||||||
|
# We try this two ways since rm can't unlink itself on some
|
||||||
|
# systems and the destination file might be busy for other
|
||||||
|
# reasons. In this case, the final cleanup might fail but the new
|
||||||
|
# file should still install successfully.
|
||||||
|
{
|
||||||
|
test ! -f "$dst" ||
|
||||||
|
$doit $rmcmd -f "$dst" 2>/dev/null ||
|
||||||
|
{ $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
|
||||||
|
{ $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
|
||||||
|
} ||
|
||||||
|
{ echo "$0: cannot unlink or rename $dst" >&2
|
||||||
|
(exit 1); exit 1
|
||||||
|
}
|
||||||
|
} &&
|
||||||
|
|
||||||
|
# Now rename the file to the real destination.
|
||||||
|
$doit $mvcmd "$dsttmp" "$dst"
|
||||||
|
}
|
||||||
|
fi || exit 1
|
||||||
|
|
||||||
|
trap '' 0
|
||||||
|
fi
|
||||||
|
done
|
||||||
|
|
||||||
|
# Local variables:
|
||||||
|
# eval: (add-hook 'write-file-hooks 'time-stamp)
|
||||||
|
# time-stamp-start: "scriptversion="
|
||||||
|
# time-stamp-format: "%:y-%02m-%02d.%02H"
|
||||||
|
# time-stamp-time-zone: "UTC"
|
||||||
|
# time-stamp-end: "; # UTC"
|
||||||
|
# End:
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,376 @@
|
||||||
|
#! /bin/sh
|
||||||
|
# Common stub for a few missing GNU programs while installing.
|
||||||
|
|
||||||
|
scriptversion=2009-04-28.21; # UTC
|
||||||
|
|
||||||
|
# Copyright (C) 1996, 1997, 1999, 2000, 2002, 2003, 2004, 2005, 2006,
|
||||||
|
# 2008, 2009 Free Software Foundation, Inc.
|
||||||
|
# Originally by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
|
||||||
|
|
||||||
|
# This program is free software; you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation; either version 2, or (at your option)
|
||||||
|
# any later version.
|
||||||
|
|
||||||
|
# This program is distributed in the hope that it will be useful,
|
||||||
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
# GNU General Public License for more details.
|
||||||
|
|
||||||
|
# You should have received a copy of the GNU General Public License
|
||||||
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
|
||||||
|
# As a special exception to the GNU General Public License, if you
|
||||||
|
# distribute this file as part of a program that contains a
|
||||||
|
# configuration script generated by Autoconf, you may include it under
|
||||||
|
# the same distribution terms that you use for the rest of that program.
|
||||||
|
|
||||||
|
if test $# -eq 0; then
|
||||||
|
echo 1>&2 "Try \`$0 --help' for more information"
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
|
|
||||||
|
run=:
|
||||||
|
sed_output='s/.* --output[ =]\([^ ]*\).*/\1/p'
|
||||||
|
sed_minuso='s/.* -o \([^ ]*\).*/\1/p'
|
||||||
|
|
||||||
|
# In the cases where this matters, `missing' is being run in the
|
||||||
|
# srcdir already.
|
||||||
|
if test -f configure.ac; then
|
||||||
|
configure_ac=configure.ac
|
||||||
|
else
|
||||||
|
configure_ac=configure.in
|
||||||
|
fi
|
||||||
|
|
||||||
|
msg="missing on your system"
|
||||||
|
|
||||||
|
case $1 in
|
||||||
|
--run)
|
||||||
|
# Try to run requested program, and just exit if it succeeds.
|
||||||
|
run=
|
||||||
|
shift
|
||||||
|
"$@" && exit 0
|
||||||
|
# Exit code 63 means version mismatch. This often happens
|
||||||
|
# when the user try to use an ancient version of a tool on
|
||||||
|
# a file that requires a minimum version. In this case we
|
||||||
|
# we should proceed has if the program had been absent, or
|
||||||
|
# if --run hadn't been passed.
|
||||||
|
if test $? = 63; then
|
||||||
|
run=:
|
||||||
|
msg="probably too old"
|
||||||
|
fi
|
||||||
|
;;
|
||||||
|
|
||||||
|
-h|--h|--he|--hel|--help)
|
||||||
|
echo "\
|
||||||
|
$0 [OPTION]... PROGRAM [ARGUMENT]...
|
||||||
|
|
||||||
|
Handle \`PROGRAM [ARGUMENT]...' for when PROGRAM is missing, or return an
|
||||||
|
error status if there is no known handling for PROGRAM.
|
||||||
|
|
||||||
|
Options:
|
||||||
|
-h, --help display this help and exit
|
||||||
|
-v, --version output version information and exit
|
||||||
|
--run try to run the given command, and emulate it if it fails
|
||||||
|
|
||||||
|
Supported PROGRAM values:
|
||||||
|
aclocal touch file \`aclocal.m4'
|
||||||
|
autoconf touch file \`configure'
|
||||||
|
autoheader touch file \`config.h.in'
|
||||||
|
autom4te touch the output file, or create a stub one
|
||||||
|
automake touch all \`Makefile.in' files
|
||||||
|
bison create \`y.tab.[ch]', if possible, from existing .[ch]
|
||||||
|
flex create \`lex.yy.c', if possible, from existing .c
|
||||||
|
help2man touch the output file
|
||||||
|
lex create \`lex.yy.c', if possible, from existing .c
|
||||||
|
makeinfo touch the output file
|
||||||
|
tar try tar, gnutar, gtar, then tar without non-portable flags
|
||||||
|
yacc create \`y.tab.[ch]', if possible, from existing .[ch]
|
||||||
|
|
||||||
|
Version suffixes to PROGRAM as well as the prefixes \`gnu-', \`gnu', and
|
||||||
|
\`g' are ignored when checking the name.
|
||||||
|
|
||||||
|
Send bug reports to <bug-automake@gnu.org>."
|
||||||
|
exit $?
|
||||||
|
;;
|
||||||
|
|
||||||
|
-v|--v|--ve|--ver|--vers|--versi|--versio|--version)
|
||||||
|
echo "missing $scriptversion (GNU Automake)"
|
||||||
|
exit $?
|
||||||
|
;;
|
||||||
|
|
||||||
|
-*)
|
||||||
|
echo 1>&2 "$0: Unknown \`$1' option"
|
||||||
|
echo 1>&2 "Try \`$0 --help' for more information"
|
||||||
|
exit 1
|
||||||
|
;;
|
||||||
|
|
||||||
|
esac
|
||||||
|
|
||||||
|
# normalize program name to check for.
|
||||||
|
program=`echo "$1" | sed '
|
||||||
|
s/^gnu-//; t
|
||||||
|
s/^gnu//; t
|
||||||
|
s/^g//; t'`
|
||||||
|
|
||||||
|
# Now exit if we have it, but it failed. Also exit now if we
|
||||||
|
# don't have it and --version was passed (most likely to detect
|
||||||
|
# the program). This is about non-GNU programs, so use $1 not
|
||||||
|
# $program.
|
||||||
|
case $1 in
|
||||||
|
lex*|yacc*)
|
||||||
|
# Not GNU programs, they don't have --version.
|
||||||
|
;;
|
||||||
|
|
||||||
|
tar*)
|
||||||
|
if test -n "$run"; then
|
||||||
|
echo 1>&2 "ERROR: \`tar' requires --run"
|
||||||
|
exit 1
|
||||||
|
elif test "x$2" = "x--version" || test "x$2" = "x--help"; then
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
|
;;
|
||||||
|
|
||||||
|
*)
|
||||||
|
if test -z "$run" && ($1 --version) > /dev/null 2>&1; then
|
||||||
|
# We have it, but it failed.
|
||||||
|
exit 1
|
||||||
|
elif test "x$2" = "x--version" || test "x$2" = "x--help"; then
|
||||||
|
# Could not run --version or --help. This is probably someone
|
||||||
|
# running `$TOOL --version' or `$TOOL --help' to check whether
|
||||||
|
# $TOOL exists and not knowing $TOOL uses missing.
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
|
;;
|
||||||
|
esac
|
||||||
|
|
||||||
|
# If it does not exist, or fails to run (possibly an outdated version),
|
||||||
|
# try to emulate it.
|
||||||
|
case $program in
|
||||||
|
aclocal*)
|
||||||
|
echo 1>&2 "\
|
||||||
|
WARNING: \`$1' is $msg. You should only need it if
|
||||||
|
you modified \`acinclude.m4' or \`${configure_ac}'. You might want
|
||||||
|
to install the \`Automake' and \`Perl' packages. Grab them from
|
||||||
|
any GNU archive site."
|
||||||
|
touch aclocal.m4
|
||||||
|
;;
|
||||||
|
|
||||||
|
autoconf*)
|
||||||
|
echo 1>&2 "\
|
||||||
|
WARNING: \`$1' is $msg. You should only need it if
|
||||||
|
you modified \`${configure_ac}'. You might want to install the
|
||||||
|
\`Autoconf' and \`GNU m4' packages. Grab them from any GNU
|
||||||
|
archive site."
|
||||||
|
touch configure
|
||||||
|
;;
|
||||||
|
|
||||||
|
autoheader*)
|
||||||
|
echo 1>&2 "\
|
||||||
|
WARNING: \`$1' is $msg. You should only need it if
|
||||||
|
you modified \`acconfig.h' or \`${configure_ac}'. You might want
|
||||||
|
to install the \`Autoconf' and \`GNU m4' packages. Grab them
|
||||||
|
from any GNU archive site."
|
||||||
|
files=`sed -n 's/^[ ]*A[CM]_CONFIG_HEADER(\([^)]*\)).*/\1/p' ${configure_ac}`
|
||||||
|
test -z "$files" && files="config.h"
|
||||||
|
touch_files=
|
||||||
|
for f in $files; do
|
||||||
|
case $f in
|
||||||
|
*:*) touch_files="$touch_files "`echo "$f" |
|
||||||
|
sed -e 's/^[^:]*://' -e 's/:.*//'`;;
|
||||||
|
*) touch_files="$touch_files $f.in";;
|
||||||
|
esac
|
||||||
|
done
|
||||||
|
touch $touch_files
|
||||||
|
;;
|
||||||
|
|
||||||
|
automake*)
|
||||||
|
echo 1>&2 "\
|
||||||
|
WARNING: \`$1' is $msg. You should only need it if
|
||||||
|
you modified \`Makefile.am', \`acinclude.m4' or \`${configure_ac}'.
|
||||||
|
You might want to install the \`Automake' and \`Perl' packages.
|
||||||
|
Grab them from any GNU archive site."
|
||||||
|
find . -type f -name Makefile.am -print |
|
||||||
|
sed 's/\.am$/.in/' |
|
||||||
|
while read f; do touch "$f"; done
|
||||||
|
;;
|
||||||
|
|
||||||
|
autom4te*)
|
||||||
|
echo 1>&2 "\
|
||||||
|
WARNING: \`$1' is needed, but is $msg.
|
||||||
|
You might have modified some files without having the
|
||||||
|
proper tools for further handling them.
|
||||||
|
You can get \`$1' as part of \`Autoconf' from any GNU
|
||||||
|
archive site."
|
||||||
|
|
||||||
|
file=`echo "$*" | sed -n "$sed_output"`
|
||||||
|
test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
|
||||||
|
if test -f "$file"; then
|
||||||
|
touch $file
|
||||||
|
else
|
||||||
|
test -z "$file" || exec >$file
|
||||||
|
echo "#! /bin/sh"
|
||||||
|
echo "# Created by GNU Automake missing as a replacement of"
|
||||||
|
echo "# $ $@"
|
||||||
|
echo "exit 0"
|
||||||
|
chmod +x $file
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
|
;;
|
||||||
|
|
||||||
|
bison*|yacc*)
|
||||||
|
echo 1>&2 "\
|
||||||
|
WARNING: \`$1' $msg. You should only need it if
|
||||||
|
you modified a \`.y' file. You may need the \`Bison' package
|
||||||
|
in order for those modifications to take effect. You can get
|
||||||
|
\`Bison' from any GNU archive site."
|
||||||
|
rm -f y.tab.c y.tab.h
|
||||||
|
if test $# -ne 1; then
|
||||||
|
eval LASTARG="\${$#}"
|
||||||
|
case $LASTARG in
|
||||||
|
*.y)
|
||||||
|
SRCFILE=`echo "$LASTARG" | sed 's/y$/c/'`
|
||||||
|
if test -f "$SRCFILE"; then
|
||||||
|
cp "$SRCFILE" y.tab.c
|
||||||
|
fi
|
||||||
|
SRCFILE=`echo "$LASTARG" | sed 's/y$/h/'`
|
||||||
|
if test -f "$SRCFILE"; then
|
||||||
|
cp "$SRCFILE" y.tab.h
|
||||||
|
fi
|
||||||
|
;;
|
||||||
|
esac
|
||||||
|
fi
|
||||||
|
if test ! -f y.tab.h; then
|
||||||
|
echo >y.tab.h
|
||||||
|
fi
|
||||||
|
if test ! -f y.tab.c; then
|
||||||
|
echo 'main() { return 0; }' >y.tab.c
|
||||||
|
fi
|
||||||
|
;;
|
||||||
|
|
||||||
|
lex*|flex*)
|
||||||
|
echo 1>&2 "\
|
||||||
|
WARNING: \`$1' is $msg. You should only need it if
|
||||||
|
you modified a \`.l' file. You may need the \`Flex' package
|
||||||
|
in order for those modifications to take effect. You can get
|
||||||
|
\`Flex' from any GNU archive site."
|
||||||
|
rm -f lex.yy.c
|
||||||
|
if test $# -ne 1; then
|
||||||
|
eval LASTARG="\${$#}"
|
||||||
|
case $LASTARG in
|
||||||
|
*.l)
|
||||||
|
SRCFILE=`echo "$LASTARG" | sed 's/l$/c/'`
|
||||||
|
if test -f "$SRCFILE"; then
|
||||||
|
cp "$SRCFILE" lex.yy.c
|
||||||
|
fi
|
||||||
|
;;
|
||||||
|
esac
|
||||||
|
fi
|
||||||
|
if test ! -f lex.yy.c; then
|
||||||
|
echo 'main() { return 0; }' >lex.yy.c
|
||||||
|
fi
|
||||||
|
;;
|
||||||
|
|
||||||
|
help2man*)
|
||||||
|
echo 1>&2 "\
|
||||||
|
WARNING: \`$1' is $msg. You should only need it if
|
||||||
|
you modified a dependency of a manual page. You may need the
|
||||||
|
\`Help2man' package in order for those modifications to take
|
||||||
|
effect. You can get \`Help2man' from any GNU archive site."
|
||||||
|
|
||||||
|
file=`echo "$*" | sed -n "$sed_output"`
|
||||||
|
test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
|
||||||
|
if test -f "$file"; then
|
||||||
|
touch $file
|
||||||
|
else
|
||||||
|
test -z "$file" || exec >$file
|
||||||
|
echo ".ab help2man is required to generate this page"
|
||||||
|
exit $?
|
||||||
|
fi
|
||||||
|
;;
|
||||||
|
|
||||||
|
makeinfo*)
|
||||||
|
echo 1>&2 "\
|
||||||
|
WARNING: \`$1' is $msg. You should only need it if
|
||||||
|
you modified a \`.texi' or \`.texinfo' file, or any other file
|
||||||
|
indirectly affecting the aspect of the manual. The spurious
|
||||||
|
call might also be the consequence of using a buggy \`make' (AIX,
|
||||||
|
DU, IRIX). You might want to install the \`Texinfo' package or
|
||||||
|
the \`GNU make' package. Grab either from any GNU archive site."
|
||||||
|
# The file to touch is that specified with -o ...
|
||||||
|
file=`echo "$*" | sed -n "$sed_output"`
|
||||||
|
test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
|
||||||
|
if test -z "$file"; then
|
||||||
|
# ... or it is the one specified with @setfilename ...
|
||||||
|
infile=`echo "$*" | sed 's/.* \([^ ]*\) *$/\1/'`
|
||||||
|
file=`sed -n '
|
||||||
|
/^@setfilename/{
|
||||||
|
s/.* \([^ ]*\) *$/\1/
|
||||||
|
p
|
||||||
|
q
|
||||||
|
}' $infile`
|
||||||
|
# ... or it is derived from the source name (dir/f.texi becomes f.info)
|
||||||
|
test -z "$file" && file=`echo "$infile" | sed 's,.*/,,;s,.[^.]*$,,'`.info
|
||||||
|
fi
|
||||||
|
# If the file does not exist, the user really needs makeinfo;
|
||||||
|
# let's fail without touching anything.
|
||||||
|
test -f $file || exit 1
|
||||||
|
touch $file
|
||||||
|
;;
|
||||||
|
|
||||||
|
tar*)
|
||||||
|
shift
|
||||||
|
|
||||||
|
# We have already tried tar in the generic part.
|
||||||
|
# Look for gnutar/gtar before invocation to avoid ugly error
|
||||||
|
# messages.
|
||||||
|
if (gnutar --version > /dev/null 2>&1); then
|
||||||
|
gnutar "$@" && exit 0
|
||||||
|
fi
|
||||||
|
if (gtar --version > /dev/null 2>&1); then
|
||||||
|
gtar "$@" && exit 0
|
||||||
|
fi
|
||||||
|
firstarg="$1"
|
||||||
|
if shift; then
|
||||||
|
case $firstarg in
|
||||||
|
*o*)
|
||||||
|
firstarg=`echo "$firstarg" | sed s/o//`
|
||||||
|
tar "$firstarg" "$@" && exit 0
|
||||||
|
;;
|
||||||
|
esac
|
||||||
|
case $firstarg in
|
||||||
|
*h*)
|
||||||
|
firstarg=`echo "$firstarg" | sed s/h//`
|
||||||
|
tar "$firstarg" "$@" && exit 0
|
||||||
|
;;
|
||||||
|
esac
|
||||||
|
fi
|
||||||
|
|
||||||
|
echo 1>&2 "\
|
||||||
|
WARNING: I can't seem to be able to run \`tar' with the given arguments.
|
||||||
|
You may want to install GNU tar or Free paxutils, or check the
|
||||||
|
command line arguments."
|
||||||
|
exit 1
|
||||||
|
;;
|
||||||
|
|
||||||
|
*)
|
||||||
|
echo 1>&2 "\
|
||||||
|
WARNING: \`$1' is needed, and is $msg.
|
||||||
|
You might have modified some files without having the
|
||||||
|
proper tools for further handling them. Check the \`README' file,
|
||||||
|
it often tells you about the needed prerequisites for installing
|
||||||
|
this package. You may also peek at any GNU archive site, in case
|
||||||
|
some other package would contain this missing \`$1' program."
|
||||||
|
exit 1
|
||||||
|
;;
|
||||||
|
esac
|
||||||
|
|
||||||
|
exit 0
|
||||||
|
|
||||||
|
# Local variables:
|
||||||
|
# eval: (add-hook 'write-file-hooks 'time-stamp)
|
||||||
|
# time-stamp-start: "scriptversion="
|
||||||
|
# time-stamp-format: "%:y-%02m-%02d.%02H"
|
||||||
|
# time-stamp-time-zone: "UTC"
|
||||||
|
# time-stamp-end: "; # UTC"
|
||||||
|
# End:
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,146 @@
|
||||||
|
m4_include(gtest/m4/acx_pthread.m4)
|
||||||
|
|
||||||
|
AC_INIT([Google C++ Mocking Framework],
|
||||||
|
[1.6.0],
|
||||||
|
[googlemock@googlegroups.com],
|
||||||
|
[gmock])
|
||||||
|
|
||||||
|
# Provide various options to initialize the Autoconf and configure processes.
|
||||||
|
AC_PREREQ([2.59])
|
||||||
|
AC_CONFIG_SRCDIR([./COPYING])
|
||||||
|
AC_CONFIG_AUX_DIR([build-aux])
|
||||||
|
AC_CONFIG_HEADERS([build-aux/config.h])
|
||||||
|
AC_CONFIG_FILES([Makefile])
|
||||||
|
AC_CONFIG_FILES([scripts/gmock-config], [chmod +x scripts/gmock-config])
|
||||||
|
|
||||||
|
# Initialize Automake with various options. We require at least v1.9, prevent
|
||||||
|
# pedantic complaints about package files, and enable various distribution
|
||||||
|
# targets.
|
||||||
|
AM_INIT_AUTOMAKE([1.9 dist-bzip2 dist-zip foreign subdir-objects])
|
||||||
|
|
||||||
|
# Check for programs used in building Google Test.
|
||||||
|
AC_PROG_CC
|
||||||
|
AC_PROG_CXX
|
||||||
|
AC_LANG([C++])
|
||||||
|
AC_PROG_LIBTOOL
|
||||||
|
|
||||||
|
# TODO(chandlerc@google.com): Currently we aren't running the Python tests
|
||||||
|
# against the interpreter detected by AM_PATH_PYTHON, and so we condition
|
||||||
|
# HAVE_PYTHON by requiring "python" to be in the PATH, and that interpreter's
|
||||||
|
# version to be >= 2.3. This will allow the scripts to use a "/usr/bin/env"
|
||||||
|
# hashbang.
|
||||||
|
PYTHON= # We *do not* allow the user to specify a python interpreter
|
||||||
|
AC_PATH_PROG([PYTHON],[python],[:])
|
||||||
|
AS_IF([test "$PYTHON" != ":"],
|
||||||
|
[AM_PYTHON_CHECK_VERSION([$PYTHON],[2.3],[:],[PYTHON=":"])])
|
||||||
|
AM_CONDITIONAL([HAVE_PYTHON],[test "$PYTHON" != ":"])
|
||||||
|
|
||||||
|
# TODO(chandlerc@google.com) Check for the necessary system headers.
|
||||||
|
|
||||||
|
# Configure pthreads.
|
||||||
|
AC_ARG_WITH([pthreads],
|
||||||
|
[AS_HELP_STRING([--with-pthreads],
|
||||||
|
[use pthreads (default is yes)])],
|
||||||
|
[with_pthreads=$withval],
|
||||||
|
[with_pthreads=check])
|
||||||
|
|
||||||
|
have_pthreads=no
|
||||||
|
AS_IF([test "x$with_pthreads" != "xno"],
|
||||||
|
[ACX_PTHREAD(
|
||||||
|
[],
|
||||||
|
[AS_IF([test "x$with_pthreads" != "xcheck"],
|
||||||
|
[AC_MSG_FAILURE(
|
||||||
|
[--with-pthreads was specified, but unable to be used])])])
|
||||||
|
have_pthreads="$acx_pthread_ok"])
|
||||||
|
AM_CONDITIONAL([HAVE_PTHREADS],[test "x$have_pthreads" == "xyes"])
|
||||||
|
AC_SUBST(PTHREAD_CFLAGS)
|
||||||
|
AC_SUBST(PTHREAD_LIBS)
|
||||||
|
|
||||||
|
# GoogleMock currently has hard dependencies upon GoogleTest above and beyond
|
||||||
|
# running its own test suite, so we both provide our own version in
|
||||||
|
# a subdirectory and provide some logic to use a custom version or a system
|
||||||
|
# installed version.
|
||||||
|
AC_ARG_WITH([gtest],
|
||||||
|
[AS_HELP_STRING([--with-gtest],
|
||||||
|
[Specifies how to find the gtest package. If no
|
||||||
|
arguments are given, the default behavior, a
|
||||||
|
system installed gtest will be used if present,
|
||||||
|
and an internal version built otherwise. If a
|
||||||
|
path is provided, the gtest built or installed at
|
||||||
|
that prefix will be used.])],
|
||||||
|
[],
|
||||||
|
[with_gtest=yes])
|
||||||
|
AC_ARG_ENABLE([external-gtest],
|
||||||
|
[AS_HELP_STRING([--disable-external-gtest],
|
||||||
|
[Disables any detection or use of a system
|
||||||
|
installed or user provided gtest. Any option to
|
||||||
|
'--with-gtest' is ignored. (Default is enabled.)])
|
||||||
|
], [], [enable_external_gtest=yes])
|
||||||
|
AS_IF([test "x$with_gtest" == "xno"],
|
||||||
|
[AC_MSG_ERROR([dnl
|
||||||
|
Support for GoogleTest was explicitly disabled. Currently GoogleMock has a hard
|
||||||
|
dependency upon GoogleTest to build, please provide a version, or allow
|
||||||
|
GoogleMock to use any installed version and fall back upon its internal
|
||||||
|
version.])])
|
||||||
|
|
||||||
|
# Setup various GTEST variables. TODO(chandlerc@google.com): When these are
|
||||||
|
# used below, they should be used such that any pre-existing values always
|
||||||
|
# trump values we set them to, so that they can be used to selectively override
|
||||||
|
# details of the detection process.
|
||||||
|
AC_ARG_VAR([GTEST_CONFIG],
|
||||||
|
[The exact path of Google Test's 'gtest-config' script.])
|
||||||
|
AC_ARG_VAR([GTEST_CPPFLAGS],
|
||||||
|
[C-like preprocessor flags for Google Test.])
|
||||||
|
AC_ARG_VAR([GTEST_CXXFLAGS],
|
||||||
|
[C++ compile flags for Google Test.])
|
||||||
|
AC_ARG_VAR([GTEST_LDFLAGS],
|
||||||
|
[Linker path and option flags for Google Test.])
|
||||||
|
AC_ARG_VAR([GTEST_LIBS],
|
||||||
|
[Library linking flags for Google Test.])
|
||||||
|
AC_ARG_VAR([GTEST_VERSION],
|
||||||
|
[The version of Google Test available.])
|
||||||
|
HAVE_BUILT_GTEST="no"
|
||||||
|
|
||||||
|
GTEST_MIN_VERSION="1.6.0"
|
||||||
|
|
||||||
|
AS_IF([test "x${enable_external_gtest}" = "xyes"],
|
||||||
|
[# Begin filling in variables as we are able.
|
||||||
|
AS_IF([test "x${with_gtest}" != "xyes"],
|
||||||
|
[AS_IF([test -x "${with_gtest}/scripts/gtest-config"],
|
||||||
|
[GTEST_CONFIG="${with_gtest}/scripts/gtest-config"],
|
||||||
|
[GTEST_CONFIG="${with_gtest}/bin/gtest-config"])
|
||||||
|
AS_IF([test -x "${GTEST_CONFIG}"], [],
|
||||||
|
[AC_MSG_ERROR([dnl
|
||||||
|
Unable to locate either a built or installed Google Test at '${with_gtest}'.])
|
||||||
|
])])
|
||||||
|
|
||||||
|
AS_IF([test -x "${GTEST_CONFIG}"], [],
|
||||||
|
[AC_PATH_PROG([GTEST_CONFIG], [gtest-config])])
|
||||||
|
AS_IF([test -x "${GTEST_CONFIG}"],
|
||||||
|
[AC_MSG_CHECKING([for Google Test version >= ${GTEST_MIN_VERSION}])
|
||||||
|
AS_IF([${GTEST_CONFIG} --min-version=${GTEST_MIN_VERSION}],
|
||||||
|
[AC_MSG_RESULT([yes])
|
||||||
|
HAVE_BUILT_GTEST="yes"],
|
||||||
|
[AC_MSG_RESULT([no])])])])
|
||||||
|
|
||||||
|
AS_IF([test "x${HAVE_BUILT_GTEST}" = "xyes"],
|
||||||
|
[GTEST_CPPFLAGS=`${GTEST_CONFIG} --cppflags`
|
||||||
|
GTEST_CXXFLAGS=`${GTEST_CONFIG} --cxxflags`
|
||||||
|
GTEST_LDFLAGS=`${GTEST_CONFIG} --ldflags`
|
||||||
|
GTEST_LIBS=`${GTEST_CONFIG} --libs`
|
||||||
|
GTEST_VERSION=`${GTEST_CONFIG} --version`],
|
||||||
|
[AC_CONFIG_SUBDIRS([gtest])
|
||||||
|
# GTEST_CONFIG needs to be executable both in a Makefile environmont and
|
||||||
|
# in a shell script environment, so resolve an absolute path for it here.
|
||||||
|
GTEST_CONFIG="`pwd -P`/gtest/scripts/gtest-config"
|
||||||
|
GTEST_CPPFLAGS='-I$(top_srcdir)/gtest/include'
|
||||||
|
GTEST_CXXFLAGS='-g'
|
||||||
|
GTEST_LDFLAGS=''
|
||||||
|
GTEST_LIBS='$(top_builddir)/gtest/lib/libgtest.la'
|
||||||
|
GTEST_VERSION="${GTEST_MIN_VERSION}"])
|
||||||
|
|
||||||
|
# TODO(chandlerc@google.com) Check the types, structures, and other compiler
|
||||||
|
# and architecture characteristics.
|
||||||
|
|
||||||
|
# Output the generated files. No further autoconf macros may be used.
|
||||||
|
AC_OUTPUT
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,54 @@
|
||||||
|
// 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 <iostream>
|
||||||
|
#include "gmock/gmock.h"
|
||||||
|
#include "gtest/gtest.h"
|
||||||
|
|
||||||
|
// MS C++ compiler/linker has a bug on Windows (not on Windows CE), which
|
||||||
|
// causes a link error when _tmain is defined in a static library and UNICODE
|
||||||
|
// is enabled. For this reason instead of _tmain, main function is used on
|
||||||
|
// Windows. See the following link to track the current status of this bug:
|
||||||
|
// http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=394464 // NOLINT
|
||||||
|
#if GTEST_OS_WINDOWS_MOBILE
|
||||||
|
# include <tchar.h> // NOLINT
|
||||||
|
|
||||||
|
int _tmain(int argc, TCHAR** argv) {
|
||||||
|
#else
|
||||||
|
int main(int argc, char** argv) {
|
||||||
|
#endif // GTEST_OS_WINDOWS_MOBILE
|
||||||
|
std::cout << "Running main() from gmock_main.cc\n";
|
||||||
|
// Since Google Mock depends on Google Test, InitGoogleMock() is
|
||||||
|
// also responsible for initializing Google Test. Therefore there's
|
||||||
|
// no need for calling testing::InitGoogleTest() separately.
|
||||||
|
testing::InitGoogleMock(&argc, argv);
|
||||||
|
return RUN_ALL_TESTS();
|
||||||
|
}
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,146 @@
|
||||||
|
// 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 Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file implements some commonly used cardinalities. More
|
||||||
|
// cardinalities can be defined by the user implementing the
|
||||||
|
// CardinalityInterface interface if necessary.
|
||||||
|
|
||||||
|
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
|
||||||
|
#define GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
|
||||||
|
|
||||||
|
#include <limits.h>
|
||||||
|
#include <ostream> // NOLINT
|
||||||
|
#include "gmock/internal/gmock-port.h"
|
||||||
|
#include "gtest/gtest.h"
|
||||||
|
|
||||||
|
namespace testing {
|
||||||
|
|
||||||
|
// To implement a cardinality Foo, define:
|
||||||
|
// 1. a class FooCardinality that implements the
|
||||||
|
// CardinalityInterface interface, and
|
||||||
|
// 2. a factory function that creates a Cardinality object from a
|
||||||
|
// const FooCardinality*.
|
||||||
|
//
|
||||||
|
// The two-level delegation design follows that of Matcher, providing
|
||||||
|
// consistency for extension developers. It also eases ownership
|
||||||
|
// management as Cardinality objects can now be copied like plain values.
|
||||||
|
|
||||||
|
// The implementation of a cardinality.
|
||||||
|
class CardinalityInterface {
|
||||||
|
public:
|
||||||
|
virtual ~CardinalityInterface() {}
|
||||||
|
|
||||||
|
// Conservative estimate on the lower/upper bound of the number of
|
||||||
|
// calls allowed.
|
||||||
|
virtual int ConservativeLowerBound() const { return 0; }
|
||||||
|
virtual int ConservativeUpperBound() const { return INT_MAX; }
|
||||||
|
|
||||||
|
// Returns true iff call_count calls will satisfy this cardinality.
|
||||||
|
virtual bool IsSatisfiedByCallCount(int call_count) const = 0;
|
||||||
|
|
||||||
|
// Returns true iff call_count calls will saturate this cardinality.
|
||||||
|
virtual bool IsSaturatedByCallCount(int call_count) const = 0;
|
||||||
|
|
||||||
|
// Describes self to an ostream.
|
||||||
|
virtual void DescribeTo(::std::ostream* os) const = 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
// A Cardinality is a copyable and IMMUTABLE (except by assignment)
|
||||||
|
// object that specifies how many times a mock function is expected to
|
||||||
|
// be called. The implementation of Cardinality is just a linked_ptr
|
||||||
|
// to const CardinalityInterface, so copying is fairly cheap.
|
||||||
|
// Don't inherit from Cardinality!
|
||||||
|
class Cardinality {
|
||||||
|
public:
|
||||||
|
// Constructs a null cardinality. Needed for storing Cardinality
|
||||||
|
// objects in STL containers.
|
||||||
|
Cardinality() {}
|
||||||
|
|
||||||
|
// Constructs a Cardinality from its implementation.
|
||||||
|
explicit Cardinality(const CardinalityInterface* impl) : impl_(impl) {}
|
||||||
|
|
||||||
|
// Conservative estimate on the lower/upper bound of the number of
|
||||||
|
// calls allowed.
|
||||||
|
int ConservativeLowerBound() const { return impl_->ConservativeLowerBound(); }
|
||||||
|
int ConservativeUpperBound() const { return impl_->ConservativeUpperBound(); }
|
||||||
|
|
||||||
|
// Returns true iff call_count calls will satisfy this cardinality.
|
||||||
|
bool IsSatisfiedByCallCount(int call_count) const {
|
||||||
|
return impl_->IsSatisfiedByCallCount(call_count);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Returns true iff call_count calls will saturate this cardinality.
|
||||||
|
bool IsSaturatedByCallCount(int call_count) const {
|
||||||
|
return impl_->IsSaturatedByCallCount(call_count);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Returns true iff call_count calls will over-saturate this
|
||||||
|
// cardinality, i.e. exceed the maximum number of allowed calls.
|
||||||
|
bool IsOverSaturatedByCallCount(int call_count) const {
|
||||||
|
return impl_->IsSaturatedByCallCount(call_count) &&
|
||||||
|
!impl_->IsSatisfiedByCallCount(call_count);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Describes self to an ostream
|
||||||
|
void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); }
|
||||||
|
|
||||||
|
// Describes the given actual call count to an ostream.
|
||||||
|
static void DescribeActualCallCountTo(int actual_call_count,
|
||||||
|
::std::ostream* os);
|
||||||
|
private:
|
||||||
|
internal::linked_ptr<const CardinalityInterface> impl_;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Creates a cardinality that allows at least n calls.
|
||||||
|
Cardinality AtLeast(int n);
|
||||||
|
|
||||||
|
// Creates a cardinality that allows at most n calls.
|
||||||
|
Cardinality AtMost(int n);
|
||||||
|
|
||||||
|
// Creates a cardinality that allows any number of calls.
|
||||||
|
Cardinality AnyNumber();
|
||||||
|
|
||||||
|
// Creates a cardinality that allows between min and max calls.
|
||||||
|
Cardinality Between(int min, int max);
|
||||||
|
|
||||||
|
// Creates a cardinality that allows exactly n calls.
|
||||||
|
Cardinality Exactly(int n);
|
||||||
|
|
||||||
|
// Creates a cardinality from its implementation.
|
||||||
|
inline Cardinality MakeCardinality(const CardinalityInterface* c) {
|
||||||
|
return Cardinality(c);
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace testing
|
||||||
|
|
||||||
|
#endif // GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,825 @@
|
||||||
|
$$ -*- mode: c++; -*-
|
||||||
|
$$ This is a Pump source file. Please use Pump to convert it to
|
||||||
|
$$ gmock-generated-actions.h.
|
||||||
|
$$
|
||||||
|
$var n = 10 $$ The maximum arity we support.
|
||||||
|
$$}} This meta comment fixes auto-indentation in editors.
|
||||||
|
// 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 Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file implements some commonly used variadic actions.
|
||||||
|
|
||||||
|
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
|
||||||
|
#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
|
||||||
|
|
||||||
|
#include "gmock/gmock-actions.h"
|
||||||
|
#include "gmock/internal/gmock-port.h"
|
||||||
|
|
||||||
|
namespace testing {
|
||||||
|
namespace internal {
|
||||||
|
|
||||||
|
// InvokeHelper<F> knows how to unpack an N-tuple and invoke an N-ary
|
||||||
|
// function or method with the unpacked values, where F is a function
|
||||||
|
// type that takes N arguments.
|
||||||
|
template <typename Result, typename ArgumentTuple>
|
||||||
|
class InvokeHelper;
|
||||||
|
|
||||||
|
|
||||||
|
$range i 0..n
|
||||||
|
$for i [[
|
||||||
|
$range j 1..i
|
||||||
|
$var types = [[$for j [[, typename A$j]]]]
|
||||||
|
$var as = [[$for j, [[A$j]]]]
|
||||||
|
$var args = [[$if i==0 [[]] $else [[ args]]]]
|
||||||
|
$var import = [[$if i==0 [[]] $else [[
|
||||||
|
using ::std::tr1::get;
|
||||||
|
|
||||||
|
]]]]
|
||||||
|
$var gets = [[$for j, [[get<$(j - 1)>(args)]]]]
|
||||||
|
template <typename R$types>
|
||||||
|
class InvokeHelper<R, ::std::tr1::tuple<$as> > {
|
||||||
|
public:
|
||||||
|
template <typename Function>
|
||||||
|
static R Invoke(Function function, const ::std::tr1::tuple<$as>&$args) {
|
||||||
|
$import return function($gets);
|
||||||
|
}
|
||||||
|
|
||||||
|
template <class Class, typename MethodPtr>
|
||||||
|
static R InvokeMethod(Class* obj_ptr,
|
||||||
|
MethodPtr method_ptr,
|
||||||
|
const ::std::tr1::tuple<$as>&$args) {
|
||||||
|
$import return (obj_ptr->*method_ptr)($gets);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
]]
|
||||||
|
// CallableHelper has static methods for invoking "callables",
|
||||||
|
// i.e. function pointers and functors. It uses overloading to
|
||||||
|
// provide a uniform interface for invoking different kinds of
|
||||||
|
// callables. In particular, you can use:
|
||||||
|
//
|
||||||
|
// CallableHelper<R>::Call(callable, a1, a2, ..., an)
|
||||||
|
//
|
||||||
|
// to invoke an n-ary callable, where R is its return type. If an
|
||||||
|
// argument, say a2, needs to be passed by reference, you should write
|
||||||
|
// ByRef(a2) instead of a2 in the above expression.
|
||||||
|
template <typename R>
|
||||||
|
class CallableHelper {
|
||||||
|
public:
|
||||||
|
// Calls a nullary callable.
|
||||||
|
template <typename Function>
|
||||||
|
static R Call(Function function) { return function(); }
|
||||||
|
|
||||||
|
// Calls a unary callable.
|
||||||
|
|
||||||
|
// We deliberately pass a1 by value instead of const reference here
|
||||||
|
// in case it is a C-string literal. If we had declared the
|
||||||
|
// parameter as 'const A1& a1' and write Call(function, "Hi"), the
|
||||||
|
// compiler would've thought A1 is 'char[3]', which causes trouble
|
||||||
|
// when you need to copy a value of type A1. By declaring the
|
||||||
|
// parameter as 'A1 a1', the compiler will correctly infer that A1
|
||||||
|
// is 'const char*' when it sees Call(function, "Hi").
|
||||||
|
//
|
||||||
|
// Since this function is defined inline, the compiler can get rid
|
||||||
|
// of the copying of the arguments. Therefore the performance won't
|
||||||
|
// be hurt.
|
||||||
|
template <typename Function, typename A1>
|
||||||
|
static R Call(Function function, A1 a1) { return function(a1); }
|
||||||
|
|
||||||
|
$range i 2..n
|
||||||
|
$for i
|
||||||
|
[[
|
||||||
|
$var arity = [[$if i==2 [[binary]] $elif i==3 [[ternary]] $else [[$i-ary]]]]
|
||||||
|
|
||||||
|
// Calls a $arity callable.
|
||||||
|
|
||||||
|
$range j 1..i
|
||||||
|
$var typename_As = [[$for j, [[typename A$j]]]]
|
||||||
|
$var Aas = [[$for j, [[A$j a$j]]]]
|
||||||
|
$var as = [[$for j, [[a$j]]]]
|
||||||
|
$var typename_Ts = [[$for j, [[typename T$j]]]]
|
||||||
|
$var Ts = [[$for j, [[T$j]]]]
|
||||||
|
template <typename Function, $typename_As>
|
||||||
|
static R Call(Function function, $Aas) {
|
||||||
|
return function($as);
|
||||||
|
}
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
}; // class CallableHelper
|
||||||
|
|
||||||
|
// An INTERNAL macro for extracting the type of a tuple field. It's
|
||||||
|
// subject to change without notice - DO NOT USE IN USER CODE!
|
||||||
|
#define GMOCK_FIELD_(Tuple, N) \
|
||||||
|
typename ::std::tr1::tuple_element<N, Tuple>::type
|
||||||
|
|
||||||
|
$range i 1..n
|
||||||
|
|
||||||
|
// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::type is the
|
||||||
|
// type of an n-ary function whose i-th (1-based) argument type is the
|
||||||
|
// k{i}-th (0-based) field of ArgumentTuple, which must be a tuple
|
||||||
|
// type, and whose return type is Result. For example,
|
||||||
|
// SelectArgs<int, ::std::tr1::tuple<bool, char, double, long>, 0, 3>::type
|
||||||
|
// is int(bool, long).
|
||||||
|
//
|
||||||
|
// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::Select(args)
|
||||||
|
// returns the selected fields (k1, k2, ..., k_n) of args as a tuple.
|
||||||
|
// For example,
|
||||||
|
// SelectArgs<int, ::std::tr1::tuple<bool, char, double>, 2, 0>::Select(
|
||||||
|
// ::std::tr1::make_tuple(true, 'a', 2.5))
|
||||||
|
// returns ::std::tr1::tuple (2.5, true).
|
||||||
|
//
|
||||||
|
// The numbers in list k1, k2, ..., k_n must be >= 0, where n can be
|
||||||
|
// in the range [0, $n]. Duplicates are allowed and they don't have
|
||||||
|
// to be in an ascending or descending order.
|
||||||
|
|
||||||
|
template <typename Result, typename ArgumentTuple, $for i, [[int k$i]]>
|
||||||
|
class SelectArgs {
|
||||||
|
public:
|
||||||
|
typedef Result type($for i, [[GMOCK_FIELD_(ArgumentTuple, k$i)]]);
|
||||||
|
typedef typename Function<type>::ArgumentTuple SelectedArgs;
|
||||||
|
static SelectedArgs Select(const ArgumentTuple& args) {
|
||||||
|
using ::std::tr1::get;
|
||||||
|
return SelectedArgs($for i, [[get<k$i>(args)]]);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
$for i [[
|
||||||
|
$range j 1..n
|
||||||
|
$range j1 1..i-1
|
||||||
|
template <typename Result, typename ArgumentTuple$for j1[[, int k$j1]]>
|
||||||
|
class SelectArgs<Result, ArgumentTuple,
|
||||||
|
$for j, [[$if j <= i-1 [[k$j]] $else [[-1]]]]> {
|
||||||
|
public:
|
||||||
|
typedef Result type($for j1, [[GMOCK_FIELD_(ArgumentTuple, k$j1)]]);
|
||||||
|
typedef typename Function<type>::ArgumentTuple SelectedArgs;
|
||||||
|
static SelectedArgs Select(const ArgumentTuple& [[]]
|
||||||
|
$if i == 1 [[/* args */]] $else [[args]]) {
|
||||||
|
using ::std::tr1::get;
|
||||||
|
return SelectedArgs($for j1, [[get<k$j1>(args)]]);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
]]
|
||||||
|
#undef GMOCK_FIELD_
|
||||||
|
|
||||||
|
$var ks = [[$for i, [[k$i]]]]
|
||||||
|
|
||||||
|
// Implements the WithArgs action.
|
||||||
|
template <typename InnerAction, $for i, [[int k$i = -1]]>
|
||||||
|
class WithArgsAction {
|
||||||
|
public:
|
||||||
|
explicit WithArgsAction(const InnerAction& action) : action_(action) {}
|
||||||
|
|
||||||
|
template <typename F>
|
||||||
|
operator Action<F>() const { return MakeAction(new Impl<F>(action_)); }
|
||||||
|
|
||||||
|
private:
|
||||||
|
template <typename F>
|
||||||
|
class Impl : public ActionInterface<F> {
|
||||||
|
public:
|
||||||
|
typedef typename Function<F>::Result Result;
|
||||||
|
typedef typename Function<F>::ArgumentTuple ArgumentTuple;
|
||||||
|
|
||||||
|
explicit Impl(const InnerAction& action) : action_(action) {}
|
||||||
|
|
||||||
|
virtual Result Perform(const ArgumentTuple& args) {
|
||||||
|
return action_.Perform(SelectArgs<Result, ArgumentTuple, $ks>::Select(args));
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
typedef typename SelectArgs<Result, ArgumentTuple,
|
||||||
|
$ks>::type InnerFunctionType;
|
||||||
|
|
||||||
|
Action<InnerFunctionType> action_;
|
||||||
|
};
|
||||||
|
|
||||||
|
const InnerAction action_;
|
||||||
|
|
||||||
|
GTEST_DISALLOW_ASSIGN_(WithArgsAction);
|
||||||
|
};
|
||||||
|
|
||||||
|
// A macro from the ACTION* family (defined later in this file)
|
||||||
|
// defines an action that can be used in a mock function. Typically,
|
||||||
|
// these actions only care about a subset of the arguments of the mock
|
||||||
|
// function. For example, if such an action only uses the second
|
||||||
|
// argument, it can be used in any mock function that takes >= 2
|
||||||
|
// arguments where the type of the second argument is compatible.
|
||||||
|
//
|
||||||
|
// Therefore, the action implementation must be prepared to take more
|
||||||
|
// arguments than it needs. The ExcessiveArg type is used to
|
||||||
|
// represent those excessive arguments. In order to keep the compiler
|
||||||
|
// error messages tractable, we define it in the testing namespace
|
||||||
|
// instead of testing::internal. However, this is an INTERNAL TYPE
|
||||||
|
// and subject to change without notice, so a user MUST NOT USE THIS
|
||||||
|
// TYPE DIRECTLY.
|
||||||
|
struct ExcessiveArg {};
|
||||||
|
|
||||||
|
// A helper class needed for implementing the ACTION* macros.
|
||||||
|
template <typename Result, class Impl>
|
||||||
|
class ActionHelper {
|
||||||
|
public:
|
||||||
|
$range i 0..n
|
||||||
|
$for i
|
||||||
|
|
||||||
|
[[
|
||||||
|
$var template = [[$if i==0 [[]] $else [[
|
||||||
|
$range j 0..i-1
|
||||||
|
template <$for j, [[typename A$j]]>
|
||||||
|
]]]]
|
||||||
|
$range j 0..i-1
|
||||||
|
$var As = [[$for j, [[A$j]]]]
|
||||||
|
$var as = [[$for j, [[get<$j>(args)]]]]
|
||||||
|
$range k 1..n-i
|
||||||
|
$var eas = [[$for k, [[ExcessiveArg()]]]]
|
||||||
|
$var arg_list = [[$if (i==0) | (i==n) [[$as$eas]] $else [[$as, $eas]]]]
|
||||||
|
$template
|
||||||
|
static Result Perform(Impl* impl, const ::std::tr1::tuple<$As>& args) {
|
||||||
|
using ::std::tr1::get;
|
||||||
|
return impl->template gmock_PerformImpl<$As>(args, $arg_list);
|
||||||
|
}
|
||||||
|
|
||||||
|
]]
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace internal
|
||||||
|
|
||||||
|
// Various overloads for Invoke().
|
||||||
|
|
||||||
|
// WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes
|
||||||
|
// the selected arguments of the mock function to an_action and
|
||||||
|
// performs it. It serves as an adaptor between actions with
|
||||||
|
// different argument lists. C++ doesn't support default arguments for
|
||||||
|
// function templates, so we have to overload it.
|
||||||
|
|
||||||
|
$range i 1..n
|
||||||
|
$for i [[
|
||||||
|
$range j 1..i
|
||||||
|
template <$for j [[int k$j, ]]typename InnerAction>
|
||||||
|
inline internal::WithArgsAction<InnerAction$for j [[, k$j]]>
|
||||||
|
WithArgs(const InnerAction& action) {
|
||||||
|
return internal::WithArgsAction<InnerAction$for j [[, k$j]]>(action);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
]]
|
||||||
|
// Creates an action that does actions a1, a2, ..., sequentially in
|
||||||
|
// each invocation.
|
||||||
|
$range i 2..n
|
||||||
|
$for i [[
|
||||||
|
$range j 2..i
|
||||||
|
$var types = [[$for j, [[typename Action$j]]]]
|
||||||
|
$var Aas = [[$for j [[, Action$j a$j]]]]
|
||||||
|
|
||||||
|
template <typename Action1, $types>
|
||||||
|
$range k 1..i-1
|
||||||
|
|
||||||
|
inline $for k [[internal::DoBothAction<Action$k, ]]Action$i$for k [[>]]
|
||||||
|
|
||||||
|
DoAll(Action1 a1$Aas) {
|
||||||
|
$if i==2 [[
|
||||||
|
|
||||||
|
return internal::DoBothAction<Action1, Action2>(a1, a2);
|
||||||
|
]] $else [[
|
||||||
|
$range j2 2..i
|
||||||
|
|
||||||
|
return DoAll(a1, DoAll($for j2, [[a$j2]]));
|
||||||
|
]]
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
} // namespace testing
|
||||||
|
|
||||||
|
// The ACTION* family of macros can be used in a namespace scope to
|
||||||
|
// define custom actions easily. The syntax:
|
||||||
|
//
|
||||||
|
// ACTION(name) { statements; }
|
||||||
|
//
|
||||||
|
// will define an action with the given name that executes the
|
||||||
|
// statements. The value returned by the statements will be used as
|
||||||
|
// the return value of the action. Inside the statements, you can
|
||||||
|
// refer to the K-th (0-based) argument of the mock function by
|
||||||
|
// 'argK', and refer to its type by 'argK_type'. For example:
|
||||||
|
//
|
||||||
|
// ACTION(IncrementArg1) {
|
||||||
|
// arg1_type temp = arg1;
|
||||||
|
// return ++(*temp);
|
||||||
|
// }
|
||||||
|
//
|
||||||
|
// allows you to write
|
||||||
|
//
|
||||||
|
// ...WillOnce(IncrementArg1());
|
||||||
|
//
|
||||||
|
// You can also refer to the entire argument tuple and its type by
|
||||||
|
// 'args' and 'args_type', and refer to the mock function type and its
|
||||||
|
// return type by 'function_type' and 'return_type'.
|
||||||
|
//
|
||||||
|
// Note that you don't need to specify the types of the mock function
|
||||||
|
// arguments. However rest assured that your code is still type-safe:
|
||||||
|
// you'll get a compiler error if *arg1 doesn't support the ++
|
||||||
|
// operator, or if the type of ++(*arg1) isn't compatible with the
|
||||||
|
// mock function's return type, for example.
|
||||||
|
//
|
||||||
|
// Sometimes you'll want to parameterize the action. For that you can use
|
||||||
|
// another macro:
|
||||||
|
//
|
||||||
|
// ACTION_P(name, param_name) { statements; }
|
||||||
|
//
|
||||||
|
// For example:
|
||||||
|
//
|
||||||
|
// ACTION_P(Add, n) { return arg0 + n; }
|
||||||
|
//
|
||||||
|
// will allow you to write:
|
||||||
|
//
|
||||||
|
// ...WillOnce(Add(5));
|
||||||
|
//
|
||||||
|
// Note that you don't need to provide the type of the parameter
|
||||||
|
// either. If you need to reference the type of a parameter named
|
||||||
|
// 'foo', you can write 'foo_type'. For example, in the body of
|
||||||
|
// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type
|
||||||
|
// of 'n'.
|
||||||
|
//
|
||||||
|
// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P$n to support
|
||||||
|
// multi-parameter actions.
|
||||||
|
//
|
||||||
|
// For the purpose of typing, you can view
|
||||||
|
//
|
||||||
|
// ACTION_Pk(Foo, p1, ..., pk) { ... }
|
||||||
|
//
|
||||||
|
// as shorthand for
|
||||||
|
//
|
||||||
|
// template <typename p1_type, ..., typename pk_type>
|
||||||
|
// FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... }
|
||||||
|
//
|
||||||
|
// In particular, you can provide the template type arguments
|
||||||
|
// explicitly when invoking Foo(), as in Foo<long, bool>(5, false);
|
||||||
|
// although usually you can rely on the compiler to infer the types
|
||||||
|
// for you automatically. You can assign the result of expression
|
||||||
|
// Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ...,
|
||||||
|
// pk_type>. This can be useful when composing actions.
|
||||||
|
//
|
||||||
|
// You can also overload actions with different numbers of parameters:
|
||||||
|
//
|
||||||
|
// ACTION_P(Plus, a) { ... }
|
||||||
|
// ACTION_P2(Plus, a, b) { ... }
|
||||||
|
//
|
||||||
|
// While it's tempting to always use the ACTION* macros when defining
|
||||||
|
// a new action, you should also consider implementing ActionInterface
|
||||||
|
// or using MakePolymorphicAction() instead, especially if you need to
|
||||||
|
// use the action a lot. While these approaches require more work,
|
||||||
|
// they give you more control on the types of the mock function
|
||||||
|
// arguments and the action parameters, which in general leads to
|
||||||
|
// better compiler error messages that pay off in the long run. They
|
||||||
|
// also allow overloading actions based on parameter types (as opposed
|
||||||
|
// to just based on the number of parameters).
|
||||||
|
//
|
||||||
|
// CAVEAT:
|
||||||
|
//
|
||||||
|
// ACTION*() can only be used in a namespace scope. The reason is
|
||||||
|
// that C++ doesn't yet allow function-local types to be used to
|
||||||
|
// instantiate templates. The up-coming C++0x standard will fix this.
|
||||||
|
// Once that's done, we'll consider supporting using ACTION*() inside
|
||||||
|
// a function.
|
||||||
|
//
|
||||||
|
// MORE INFORMATION:
|
||||||
|
//
|
||||||
|
// To learn more about using these macros, please search for 'ACTION'
|
||||||
|
// on http://code.google.com/p/googlemock/wiki/CookBook.
|
||||||
|
|
||||||
|
$range i 0..n
|
||||||
|
$range k 0..n-1
|
||||||
|
|
||||||
|
// An internal macro needed for implementing ACTION*().
|
||||||
|
#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\
|
||||||
|
const args_type& args GTEST_ATTRIBUTE_UNUSED_
|
||||||
|
$for k [[,\
|
||||||
|
arg$k[[]]_type arg$k GTEST_ATTRIBUTE_UNUSED_]]
|
||||||
|
|
||||||
|
|
||||||
|
// Sometimes you want to give an action explicit template parameters
|
||||||
|
// that cannot be inferred from its value parameters. ACTION() and
|
||||||
|
// ACTION_P*() don't support that. ACTION_TEMPLATE() remedies that
|
||||||
|
// and can be viewed as an extension to ACTION() and ACTION_P*().
|
||||||
|
//
|
||||||
|
// The syntax:
|
||||||
|
//
|
||||||
|
// ACTION_TEMPLATE(ActionName,
|
||||||
|
// HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m),
|
||||||
|
// AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; }
|
||||||
|
//
|
||||||
|
// defines an action template that takes m explicit template
|
||||||
|
// parameters and n value parameters. name_i is the name of the i-th
|
||||||
|
// template parameter, and kind_i specifies whether it's a typename,
|
||||||
|
// an integral constant, or a template. p_i is the name of the i-th
|
||||||
|
// value parameter.
|
||||||
|
//
|
||||||
|
// Example:
|
||||||
|
//
|
||||||
|
// // DuplicateArg<k, T>(output) converts the k-th argument of the mock
|
||||||
|
// // function to type T and copies it to *output.
|
||||||
|
// ACTION_TEMPLATE(DuplicateArg,
|
||||||
|
// HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
|
||||||
|
// AND_1_VALUE_PARAMS(output)) {
|
||||||
|
// *output = T(std::tr1::get<k>(args));
|
||||||
|
// }
|
||||||
|
// ...
|
||||||
|
// int n;
|
||||||
|
// EXPECT_CALL(mock, Foo(_, _))
|
||||||
|
// .WillOnce(DuplicateArg<1, unsigned char>(&n));
|
||||||
|
//
|
||||||
|
// To create an instance of an action template, write:
|
||||||
|
//
|
||||||
|
// ActionName<t1, ..., t_m>(v1, ..., v_n)
|
||||||
|
//
|
||||||
|
// where the ts are the template arguments and the vs are the value
|
||||||
|
// arguments. The value argument types are inferred by the compiler.
|
||||||
|
// If you want to explicitly specify the value argument types, you can
|
||||||
|
// provide additional template arguments:
|
||||||
|
//
|
||||||
|
// ActionName<t1, ..., t_m, u1, ..., u_k>(v1, ..., v_n)
|
||||||
|
//
|
||||||
|
// where u_i is the desired type of v_i.
|
||||||
|
//
|
||||||
|
// ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the
|
||||||
|
// number of value parameters, but not on the number of template
|
||||||
|
// parameters. Without the restriction, the meaning of the following
|
||||||
|
// is unclear:
|
||||||
|
//
|
||||||
|
// OverloadedAction<int, bool>(x);
|
||||||
|
//
|
||||||
|
// Are we using a single-template-parameter action where 'bool' refers
|
||||||
|
// to the type of x, or are we using a two-template-parameter action
|
||||||
|
// where the compiler is asked to infer the type of x?
|
||||||
|
//
|
||||||
|
// Implementation notes:
|
||||||
|
//
|
||||||
|
// GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and
|
||||||
|
// GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for
|
||||||
|
// implementing ACTION_TEMPLATE. The main trick we use is to create
|
||||||
|
// new macro invocations when expanding a macro. For example, we have
|
||||||
|
//
|
||||||
|
// #define ACTION_TEMPLATE(name, template_params, value_params)
|
||||||
|
// ... GMOCK_INTERNAL_DECL_##template_params ...
|
||||||
|
//
|
||||||
|
// which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...)
|
||||||
|
// to expand to
|
||||||
|
//
|
||||||
|
// ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ...
|
||||||
|
//
|
||||||
|
// Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the
|
||||||
|
// preprocessor will continue to expand it to
|
||||||
|
//
|
||||||
|
// ... typename T ...
|
||||||
|
//
|
||||||
|
// This technique conforms to the C++ standard and is portable. It
|
||||||
|
// allows us to implement action templates using O(N) code, where N is
|
||||||
|
// the maximum number of template/value parameters supported. Without
|
||||||
|
// using it, we'd have to devote O(N^2) amount of code to implement all
|
||||||
|
// combinations of m and n.
|
||||||
|
|
||||||
|
// Declares the template parameters.
|
||||||
|
|
||||||
|
$range j 1..n
|
||||||
|
$for j [[
|
||||||
|
$range m 0..j-1
|
||||||
|
#define GMOCK_INTERNAL_DECL_HAS_$j[[]]
|
||||||
|
_TEMPLATE_PARAMS($for m, [[kind$m, name$m]]) $for m, [[kind$m name$m]]
|
||||||
|
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
// Lists the template parameters.
|
||||||
|
|
||||||
|
$for j [[
|
||||||
|
$range m 0..j-1
|
||||||
|
#define GMOCK_INTERNAL_LIST_HAS_$j[[]]
|
||||||
|
_TEMPLATE_PARAMS($for m, [[kind$m, name$m]]) $for m, [[name$m]]
|
||||||
|
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
// Declares the types of value parameters.
|
||||||
|
|
||||||
|
$for i [[
|
||||||
|
$range j 0..i-1
|
||||||
|
#define GMOCK_INTERNAL_DECL_TYPE_AND_$i[[]]
|
||||||
|
_VALUE_PARAMS($for j, [[p$j]]) $for j [[, typename p$j##_type]]
|
||||||
|
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
// Initializes the value parameters.
|
||||||
|
|
||||||
|
$for i [[
|
||||||
|
$range j 0..i-1
|
||||||
|
#define GMOCK_INTERNAL_INIT_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]])\
|
||||||
|
($for j, [[p$j##_type gmock_p$j]])$if i>0 [[ : ]]$for j, [[p$j(gmock_p$j)]]
|
||||||
|
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
// Declares the fields for storing the value parameters.
|
||||||
|
|
||||||
|
$for i [[
|
||||||
|
$range j 0..i-1
|
||||||
|
#define GMOCK_INTERNAL_DEFN_AND_$i[[]]
|
||||||
|
_VALUE_PARAMS($for j, [[p$j]]) $for j [[p$j##_type p$j; ]]
|
||||||
|
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
// Lists the value parameters.
|
||||||
|
|
||||||
|
$for i [[
|
||||||
|
$range j 0..i-1
|
||||||
|
#define GMOCK_INTERNAL_LIST_AND_$i[[]]
|
||||||
|
_VALUE_PARAMS($for j, [[p$j]]) $for j, [[p$j]]
|
||||||
|
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
// Lists the value parameter types.
|
||||||
|
|
||||||
|
$for i [[
|
||||||
|
$range j 0..i-1
|
||||||
|
#define GMOCK_INTERNAL_LIST_TYPE_AND_$i[[]]
|
||||||
|
_VALUE_PARAMS($for j, [[p$j]]) $for j [[, p$j##_type]]
|
||||||
|
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
// Declares the value parameters.
|
||||||
|
|
||||||
|
$for i [[
|
||||||
|
$range j 0..i-1
|
||||||
|
#define GMOCK_INTERNAL_DECL_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]]) [[]]
|
||||||
|
$for j, [[p$j##_type p$j]]
|
||||||
|
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
// The suffix of the class template implementing the action template.
|
||||||
|
$for i [[
|
||||||
|
|
||||||
|
|
||||||
|
$range j 0..i-1
|
||||||
|
#define GMOCK_INTERNAL_COUNT_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]]) [[]]
|
||||||
|
$if i==1 [[P]] $elif i>=2 [[P$i]]
|
||||||
|
]]
|
||||||
|
|
||||||
|
|
||||||
|
// The name of the class template implementing the action template.
|
||||||
|
#define GMOCK_ACTION_CLASS_(name, value_params)\
|
||||||
|
GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params)
|
||||||
|
|
||||||
|
$range k 0..n-1
|
||||||
|
|
||||||
|
#define ACTION_TEMPLATE(name, template_params, value_params)\
|
||||||
|
template <GMOCK_INTERNAL_DECL_##template_params\
|
||||||
|
GMOCK_INTERNAL_DECL_TYPE_##value_params>\
|
||||||
|
class GMOCK_ACTION_CLASS_(name, value_params) {\
|
||||||
|
public:\
|
||||||
|
GMOCK_ACTION_CLASS_(name, value_params)\
|
||||||
|
GMOCK_INTERNAL_INIT_##value_params {}\
|
||||||
|
template <typename F>\
|
||||||
|
class gmock_Impl : public ::testing::ActionInterface<F> {\
|
||||||
|
public:\
|
||||||
|
typedef F function_type;\
|
||||||
|
typedef typename ::testing::internal::Function<F>::Result return_type;\
|
||||||
|
typedef typename ::testing::internal::Function<F>::ArgumentTuple\
|
||||||
|
args_type;\
|
||||||
|
explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}\
|
||||||
|
virtual return_type Perform(const args_type& args) {\
|
||||||
|
return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
|
||||||
|
Perform(this, args);\
|
||||||
|
}\
|
||||||
|
template <$for k, [[typename arg$k[[]]_type]]>\
|
||||||
|
return_type gmock_PerformImpl(const args_type& args[[]]
|
||||||
|
$for k [[, arg$k[[]]_type arg$k]]) const;\
|
||||||
|
GMOCK_INTERNAL_DEFN_##value_params\
|
||||||
|
private:\
|
||||||
|
GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
|
||||||
|
};\
|
||||||
|
template <typename F> operator ::testing::Action<F>() const {\
|
||||||
|
return ::testing::Action<F>(\
|
||||||
|
new gmock_Impl<F>(GMOCK_INTERNAL_LIST_##value_params));\
|
||||||
|
}\
|
||||||
|
GMOCK_INTERNAL_DEFN_##value_params\
|
||||||
|
private:\
|
||||||
|
GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\
|
||||||
|
};\
|
||||||
|
template <GMOCK_INTERNAL_DECL_##template_params\
|
||||||
|
GMOCK_INTERNAL_DECL_TYPE_##value_params>\
|
||||||
|
inline GMOCK_ACTION_CLASS_(name, value_params)<\
|
||||||
|
GMOCK_INTERNAL_LIST_##template_params\
|
||||||
|
GMOCK_INTERNAL_LIST_TYPE_##value_params> name(\
|
||||||
|
GMOCK_INTERNAL_DECL_##value_params) {\
|
||||||
|
return GMOCK_ACTION_CLASS_(name, value_params)<\
|
||||||
|
GMOCK_INTERNAL_LIST_##template_params\
|
||||||
|
GMOCK_INTERNAL_LIST_TYPE_##value_params>(\
|
||||||
|
GMOCK_INTERNAL_LIST_##value_params);\
|
||||||
|
}\
|
||||||
|
template <GMOCK_INTERNAL_DECL_##template_params\
|
||||||
|
GMOCK_INTERNAL_DECL_TYPE_##value_params>\
|
||||||
|
template <typename F>\
|
||||||
|
template <typename arg0_type, typename arg1_type, typename arg2_type,\
|
||||||
|
typename arg3_type, typename arg4_type, typename arg5_type,\
|
||||||
|
typename arg6_type, typename arg7_type, typename arg8_type,\
|
||||||
|
typename arg9_type>\
|
||||||
|
typename ::testing::internal::Function<F>::Result\
|
||||||
|
GMOCK_ACTION_CLASS_(name, value_params)<\
|
||||||
|
GMOCK_INTERNAL_LIST_##template_params\
|
||||||
|
GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl<F>::\
|
||||||
|
gmock_PerformImpl(\
|
||||||
|
GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
|
||||||
|
|
||||||
|
$for i
|
||||||
|
|
||||||
|
[[
|
||||||
|
$var template = [[$if i==0 [[]] $else [[
|
||||||
|
$range j 0..i-1
|
||||||
|
|
||||||
|
template <$for j, [[typename p$j##_type]]>\
|
||||||
|
]]]]
|
||||||
|
$var class_name = [[name##Action[[$if i==0 [[]] $elif i==1 [[P]]
|
||||||
|
$else [[P$i]]]]]]
|
||||||
|
$range j 0..i-1
|
||||||
|
$var ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]]
|
||||||
|
$var param_types_and_names = [[$for j, [[p$j##_type p$j]]]]
|
||||||
|
$var inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(gmock_p$j)]]]]]]
|
||||||
|
$var param_field_decls = [[$for j
|
||||||
|
[[
|
||||||
|
|
||||||
|
p$j##_type p$j;\
|
||||||
|
]]]]
|
||||||
|
$var param_field_decls2 = [[$for j
|
||||||
|
[[
|
||||||
|
|
||||||
|
p$j##_type p$j;\
|
||||||
|
]]]]
|
||||||
|
$var params = [[$for j, [[p$j]]]]
|
||||||
|
$var param_types = [[$if i==0 [[]] $else [[<$for j, [[p$j##_type]]>]]]]
|
||||||
|
$var typename_arg_types = [[$for k, [[typename arg$k[[]]_type]]]]
|
||||||
|
$var arg_types_and_names = [[$for k, [[arg$k[[]]_type arg$k]]]]
|
||||||
|
$var macro_name = [[$if i==0 [[ACTION]] $elif i==1 [[ACTION_P]]
|
||||||
|
$else [[ACTION_P$i]]]]
|
||||||
|
|
||||||
|
#define $macro_name(name$for j [[, p$j]])\$template
|
||||||
|
class $class_name {\
|
||||||
|
public:\
|
||||||
|
$class_name($ctor_param_list)$inits {}\
|
||||||
|
template <typename F>\
|
||||||
|
class gmock_Impl : public ::testing::ActionInterface<F> {\
|
||||||
|
public:\
|
||||||
|
typedef F function_type;\
|
||||||
|
typedef typename ::testing::internal::Function<F>::Result return_type;\
|
||||||
|
typedef typename ::testing::internal::Function<F>::ArgumentTuple\
|
||||||
|
args_type;\
|
||||||
|
[[$if i==1 [[explicit ]]]]gmock_Impl($ctor_param_list)$inits {}\
|
||||||
|
virtual return_type Perform(const args_type& args) {\
|
||||||
|
return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
|
||||||
|
Perform(this, args);\
|
||||||
|
}\
|
||||||
|
template <$typename_arg_types>\
|
||||||
|
return_type gmock_PerformImpl(const args_type& args, [[]]
|
||||||
|
$arg_types_and_names) const;\$param_field_decls
|
||||||
|
private:\
|
||||||
|
GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
|
||||||
|
};\
|
||||||
|
template <typename F> operator ::testing::Action<F>() const {\
|
||||||
|
return ::testing::Action<F>(new gmock_Impl<F>($params));\
|
||||||
|
}\$param_field_decls2
|
||||||
|
private:\
|
||||||
|
GTEST_DISALLOW_ASSIGN_($class_name);\
|
||||||
|
};\$template
|
||||||
|
inline $class_name$param_types name($param_types_and_names) {\
|
||||||
|
return $class_name$param_types($params);\
|
||||||
|
}\$template
|
||||||
|
template <typename F>\
|
||||||
|
template <$typename_arg_types>\
|
||||||
|
typename ::testing::internal::Function<F>::Result\
|
||||||
|
$class_name$param_types::gmock_Impl<F>::gmock_PerformImpl(\
|
||||||
|
GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
|
||||||
|
]]
|
||||||
|
$$ } // This meta comment fixes auto-indentation in Emacs. It won't
|
||||||
|
$$ // show up in the generated code.
|
||||||
|
|
||||||
|
|
||||||
|
// TODO(wan@google.com): move the following to a different .h file
|
||||||
|
// such that we don't have to run 'pump' every time the code is
|
||||||
|
// updated.
|
||||||
|
namespace testing {
|
||||||
|
|
||||||
|
// The ACTION*() macros trigger warning C4100 (unreferenced formal
|
||||||
|
// parameter) in MSVC with -W4. Unfortunately they cannot be fixed in
|
||||||
|
// the macro definition, as the warnings are generated when the macro
|
||||||
|
// is expanded and macro expansion cannot contain #pragma. Therefore
|
||||||
|
// we suppress them here.
|
||||||
|
#ifdef _MSC_VER
|
||||||
|
# pragma warning(push)
|
||||||
|
# pragma warning(disable:4100)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// Various overloads for InvokeArgument<N>().
|
||||||
|
//
|
||||||
|
// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
|
||||||
|
// (0-based) argument, which must be a k-ary callable, of the mock
|
||||||
|
// function, with arguments a1, a2, ..., a_k.
|
||||||
|
//
|
||||||
|
// Notes:
|
||||||
|
//
|
||||||
|
// 1. The arguments are passed by value by default. If you need to
|
||||||
|
// pass an argument by reference, wrap it inside ByRef(). For
|
||||||
|
// example,
|
||||||
|
//
|
||||||
|
// InvokeArgument<1>(5, string("Hello"), ByRef(foo))
|
||||||
|
//
|
||||||
|
// passes 5 and string("Hello") by value, and passes foo by
|
||||||
|
// reference.
|
||||||
|
//
|
||||||
|
// 2. If the callable takes an argument by reference but ByRef() is
|
||||||
|
// not used, it will receive the reference to a copy of the value,
|
||||||
|
// instead of the original value. For example, when the 0-th
|
||||||
|
// argument of the mock function takes a const string&, the action
|
||||||
|
//
|
||||||
|
// InvokeArgument<0>(string("Hello"))
|
||||||
|
//
|
||||||
|
// makes a copy of the temporary string("Hello") object and passes a
|
||||||
|
// reference of the copy, instead of the original temporary object,
|
||||||
|
// to the callable. This makes it easy for a user to define an
|
||||||
|
// InvokeArgument action from temporary values and have it performed
|
||||||
|
// later.
|
||||||
|
|
||||||
|
$range i 0..n
|
||||||
|
$for i [[
|
||||||
|
$range j 0..i-1
|
||||||
|
|
||||||
|
ACTION_TEMPLATE(InvokeArgument,
|
||||||
|
HAS_1_TEMPLATE_PARAMS(int, k),
|
||||||
|
AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]])) {
|
||||||
|
return internal::CallableHelper<return_type>::Call(
|
||||||
|
::std::tr1::get<k>(args)$for j [[, p$j]]);
|
||||||
|
}
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
// Various overloads for ReturnNew<T>().
|
||||||
|
//
|
||||||
|
// The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new
|
||||||
|
// instance of type T, constructed on the heap with constructor arguments
|
||||||
|
// a1, a2, ..., and a_k. The caller assumes ownership of the returned value.
|
||||||
|
$range i 0..n
|
||||||
|
$for i [[
|
||||||
|
$range j 0..i-1
|
||||||
|
$var ps = [[$for j, [[p$j]]]]
|
||||||
|
|
||||||
|
ACTION_TEMPLATE(ReturnNew,
|
||||||
|
HAS_1_TEMPLATE_PARAMS(typename, T),
|
||||||
|
AND_$i[[]]_VALUE_PARAMS($ps)) {
|
||||||
|
return new T($ps);
|
||||||
|
}
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
#ifdef _MSC_VER
|
||||||
|
# pragma warning(pop)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
} // namespace testing
|
||||||
|
|
||||||
|
#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
|
|
@ -0,0 +1,929 @@
|
||||||
|
// This file was GENERATED by command:
|
||||||
|
// pump.py gmock-generated-function-mockers.h.pump
|
||||||
|
// DO NOT EDIT BY HAND!!!
|
||||||
|
|
||||||
|
// 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 Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file implements function mockers of various arities.
|
||||||
|
|
||||||
|
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
|
||||||
|
#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
|
||||||
|
|
||||||
|
#include "gmock/gmock-spec-builders.h"
|
||||||
|
#include "gmock/internal/gmock-internal-utils.h"
|
||||||
|
|
||||||
|
namespace testing {
|
||||||
|
namespace internal {
|
||||||
|
|
||||||
|
template <typename F>
|
||||||
|
class FunctionMockerBase;
|
||||||
|
|
||||||
|
// Note: class FunctionMocker really belongs to the ::testing
|
||||||
|
// namespace. However if we define it in ::testing, MSVC will
|
||||||
|
// complain when classes in ::testing::internal declare it as a
|
||||||
|
// friend class template. To workaround this compiler bug, we define
|
||||||
|
// FunctionMocker in ::testing::internal and import it into ::testing.
|
||||||
|
template <typename F>
|
||||||
|
class FunctionMocker;
|
||||||
|
|
||||||
|
template <typename R>
|
||||||
|
class FunctionMocker<R()> : public
|
||||||
|
internal::FunctionMockerBase<R()> {
|
||||||
|
public:
|
||||||
|
typedef R F();
|
||||||
|
typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
|
||||||
|
|
||||||
|
MockSpec<F>& With() {
|
||||||
|
return this->current_spec();
|
||||||
|
}
|
||||||
|
|
||||||
|
R Invoke() {
|
||||||
|
// Even though gcc and MSVC don't enforce it, 'this->' is required
|
||||||
|
// by the C++ standard [14.6.4] here, as the base class type is
|
||||||
|
// dependent on the template argument (and thus shouldn't be
|
||||||
|
// looked into when resolving InvokeWith).
|
||||||
|
return this->InvokeWith(ArgumentTuple());
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1>
|
||||||
|
class FunctionMocker<R(A1)> : public
|
||||||
|
internal::FunctionMockerBase<R(A1)> {
|
||||||
|
public:
|
||||||
|
typedef R F(A1);
|
||||||
|
typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
|
||||||
|
|
||||||
|
MockSpec<F>& With(const Matcher<A1>& m1) {
|
||||||
|
this->current_spec().SetMatchers(::std::tr1::make_tuple(m1));
|
||||||
|
return this->current_spec();
|
||||||
|
}
|
||||||
|
|
||||||
|
R Invoke(A1 a1) {
|
||||||
|
// Even though gcc and MSVC don't enforce it, 'this->' is required
|
||||||
|
// by the C++ standard [14.6.4] here, as the base class type is
|
||||||
|
// dependent on the template argument (and thus shouldn't be
|
||||||
|
// looked into when resolving InvokeWith).
|
||||||
|
return this->InvokeWith(ArgumentTuple(a1));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2>
|
||||||
|
class FunctionMocker<R(A1, A2)> : public
|
||||||
|
internal::FunctionMockerBase<R(A1, A2)> {
|
||||||
|
public:
|
||||||
|
typedef R F(A1, A2);
|
||||||
|
typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
|
||||||
|
|
||||||
|
MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2) {
|
||||||
|
this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2));
|
||||||
|
return this->current_spec();
|
||||||
|
}
|
||||||
|
|
||||||
|
R Invoke(A1 a1, A2 a2) {
|
||||||
|
// Even though gcc and MSVC don't enforce it, 'this->' is required
|
||||||
|
// by the C++ standard [14.6.4] here, as the base class type is
|
||||||
|
// dependent on the template argument (and thus shouldn't be
|
||||||
|
// looked into when resolving InvokeWith).
|
||||||
|
return this->InvokeWith(ArgumentTuple(a1, a2));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2, typename A3>
|
||||||
|
class FunctionMocker<R(A1, A2, A3)> : public
|
||||||
|
internal::FunctionMockerBase<R(A1, A2, A3)> {
|
||||||
|
public:
|
||||||
|
typedef R F(A1, A2, A3);
|
||||||
|
typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
|
||||||
|
|
||||||
|
MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
|
||||||
|
const Matcher<A3>& m3) {
|
||||||
|
this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3));
|
||||||
|
return this->current_spec();
|
||||||
|
}
|
||||||
|
|
||||||
|
R Invoke(A1 a1, A2 a2, A3 a3) {
|
||||||
|
// Even though gcc and MSVC don't enforce it, 'this->' is required
|
||||||
|
// by the C++ standard [14.6.4] here, as the base class type is
|
||||||
|
// dependent on the template argument (and thus shouldn't be
|
||||||
|
// looked into when resolving InvokeWith).
|
||||||
|
return this->InvokeWith(ArgumentTuple(a1, a2, a3));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2, typename A3, typename A4>
|
||||||
|
class FunctionMocker<R(A1, A2, A3, A4)> : public
|
||||||
|
internal::FunctionMockerBase<R(A1, A2, A3, A4)> {
|
||||||
|
public:
|
||||||
|
typedef R F(A1, A2, A3, A4);
|
||||||
|
typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
|
||||||
|
|
||||||
|
MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
|
||||||
|
const Matcher<A3>& m3, const Matcher<A4>& m4) {
|
||||||
|
this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4));
|
||||||
|
return this->current_spec();
|
||||||
|
}
|
||||||
|
|
||||||
|
R Invoke(A1 a1, A2 a2, A3 a3, A4 a4) {
|
||||||
|
// Even though gcc and MSVC don't enforce it, 'this->' is required
|
||||||
|
// by the C++ standard [14.6.4] here, as the base class type is
|
||||||
|
// dependent on the template argument (and thus shouldn't be
|
||||||
|
// looked into when resolving InvokeWith).
|
||||||
|
return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2, typename A3, typename A4,
|
||||||
|
typename A5>
|
||||||
|
class FunctionMocker<R(A1, A2, A3, A4, A5)> : public
|
||||||
|
internal::FunctionMockerBase<R(A1, A2, A3, A4, A5)> {
|
||||||
|
public:
|
||||||
|
typedef R F(A1, A2, A3, A4, A5);
|
||||||
|
typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
|
||||||
|
|
||||||
|
MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
|
||||||
|
const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5) {
|
||||||
|
this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4,
|
||||||
|
m5));
|
||||||
|
return this->current_spec();
|
||||||
|
}
|
||||||
|
|
||||||
|
R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
|
||||||
|
// Even though gcc and MSVC don't enforce it, 'this->' is required
|
||||||
|
// by the C++ standard [14.6.4] here, as the base class type is
|
||||||
|
// dependent on the template argument (and thus shouldn't be
|
||||||
|
// looked into when resolving InvokeWith).
|
||||||
|
return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2, typename A3, typename A4,
|
||||||
|
typename A5, typename A6>
|
||||||
|
class FunctionMocker<R(A1, A2, A3, A4, A5, A6)> : public
|
||||||
|
internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6)> {
|
||||||
|
public:
|
||||||
|
typedef R F(A1, A2, A3, A4, A5, A6);
|
||||||
|
typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
|
||||||
|
|
||||||
|
MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
|
||||||
|
const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
|
||||||
|
const Matcher<A6>& m6) {
|
||||||
|
this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4, m5,
|
||||||
|
m6));
|
||||||
|
return this->current_spec();
|
||||||
|
}
|
||||||
|
|
||||||
|
R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
|
||||||
|
// Even though gcc and MSVC don't enforce it, 'this->' is required
|
||||||
|
// by the C++ standard [14.6.4] here, as the base class type is
|
||||||
|
// dependent on the template argument (and thus shouldn't be
|
||||||
|
// looked into when resolving InvokeWith).
|
||||||
|
return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2, typename A3, typename A4,
|
||||||
|
typename A5, typename A6, typename A7>
|
||||||
|
class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7)> : public
|
||||||
|
internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7)> {
|
||||||
|
public:
|
||||||
|
typedef R F(A1, A2, A3, A4, A5, A6, A7);
|
||||||
|
typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
|
||||||
|
|
||||||
|
MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
|
||||||
|
const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
|
||||||
|
const Matcher<A6>& m6, const Matcher<A7>& m7) {
|
||||||
|
this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4, m5,
|
||||||
|
m6, m7));
|
||||||
|
return this->current_spec();
|
||||||
|
}
|
||||||
|
|
||||||
|
R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
|
||||||
|
// Even though gcc and MSVC don't enforce it, 'this->' is required
|
||||||
|
// by the C++ standard [14.6.4] here, as the base class type is
|
||||||
|
// dependent on the template argument (and thus shouldn't be
|
||||||
|
// looked into when resolving InvokeWith).
|
||||||
|
return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2, typename A3, typename A4,
|
||||||
|
typename A5, typename A6, typename A7, typename A8>
|
||||||
|
class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8)> : public
|
||||||
|
internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8)> {
|
||||||
|
public:
|
||||||
|
typedef R F(A1, A2, A3, A4, A5, A6, A7, A8);
|
||||||
|
typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
|
||||||
|
|
||||||
|
MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
|
||||||
|
const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
|
||||||
|
const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8) {
|
||||||
|
this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4, m5,
|
||||||
|
m6, m7, m8));
|
||||||
|
return this->current_spec();
|
||||||
|
}
|
||||||
|
|
||||||
|
R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
|
||||||
|
// Even though gcc and MSVC don't enforce it, 'this->' is required
|
||||||
|
// by the C++ standard [14.6.4] here, as the base class type is
|
||||||
|
// dependent on the template argument (and thus shouldn't be
|
||||||
|
// looked into when resolving InvokeWith).
|
||||||
|
return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2, typename A3, typename A4,
|
||||||
|
typename A5, typename A6, typename A7, typename A8, typename A9>
|
||||||
|
class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> : public
|
||||||
|
internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
|
||||||
|
public:
|
||||||
|
typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9);
|
||||||
|
typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
|
||||||
|
|
||||||
|
MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
|
||||||
|
const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
|
||||||
|
const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8,
|
||||||
|
const Matcher<A9>& m9) {
|
||||||
|
this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4, m5,
|
||||||
|
m6, m7, m8, m9));
|
||||||
|
return this->current_spec();
|
||||||
|
}
|
||||||
|
|
||||||
|
R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
|
||||||
|
// Even though gcc and MSVC don't enforce it, 'this->' is required
|
||||||
|
// by the C++ standard [14.6.4] here, as the base class type is
|
||||||
|
// dependent on the template argument (and thus shouldn't be
|
||||||
|
// looked into when resolving InvokeWith).
|
||||||
|
return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8, a9));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2, typename A3, typename A4,
|
||||||
|
typename A5, typename A6, typename A7, typename A8, typename A9,
|
||||||
|
typename A10>
|
||||||
|
class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> : public
|
||||||
|
internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> {
|
||||||
|
public:
|
||||||
|
typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
|
||||||
|
typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
|
||||||
|
|
||||||
|
MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
|
||||||
|
const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
|
||||||
|
const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8,
|
||||||
|
const Matcher<A9>& m9, const Matcher<A10>& m10) {
|
||||||
|
this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4, m5,
|
||||||
|
m6, m7, m8, m9, m10));
|
||||||
|
return this->current_spec();
|
||||||
|
}
|
||||||
|
|
||||||
|
R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
|
||||||
|
A10 a10) {
|
||||||
|
// Even though gcc and MSVC don't enforce it, 'this->' is required
|
||||||
|
// by the C++ standard [14.6.4] here, as the base class type is
|
||||||
|
// dependent on the template argument (and thus shouldn't be
|
||||||
|
// looked into when resolving InvokeWith).
|
||||||
|
return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8, a9,
|
||||||
|
a10));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace internal
|
||||||
|
|
||||||
|
// The style guide prohibits "using" statements in a namespace scope
|
||||||
|
// inside a header file. However, the FunctionMocker class template
|
||||||
|
// is meant to be defined in the ::testing namespace. The following
|
||||||
|
// line is just a trick for working around a bug in MSVC 8.0, which
|
||||||
|
// cannot handle it if we define FunctionMocker in ::testing.
|
||||||
|
using internal::FunctionMocker;
|
||||||
|
|
||||||
|
// The result type of function type F.
|
||||||
|
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
|
||||||
|
#define GMOCK_RESULT_(tn, F) tn ::testing::internal::Function<F>::Result
|
||||||
|
|
||||||
|
// The type of argument N of function type F.
|
||||||
|
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
|
||||||
|
#define GMOCK_ARG_(tn, F, N) tn ::testing::internal::Function<F>::Argument##N
|
||||||
|
|
||||||
|
// The matcher type for argument N of function type F.
|
||||||
|
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
|
||||||
|
#define GMOCK_MATCHER_(tn, F, N) const ::testing::Matcher<GMOCK_ARG_(tn, F, N)>&
|
||||||
|
|
||||||
|
// The variable for mocking the given method.
|
||||||
|
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
|
||||||
|
#define GMOCK_MOCKER_(arity, constness, Method) \
|
||||||
|
GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)
|
||||||
|
|
||||||
|
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
|
||||||
|
#define GMOCK_METHOD0_(tn, constness, ct, Method, F) \
|
||||||
|
GMOCK_RESULT_(tn, F) ct Method() constness { \
|
||||||
|
GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
|
||||||
|
tn ::testing::internal::Function<F>::ArgumentTuple>::value == 0, \
|
||||||
|
this_method_does_not_take_0_arguments); \
|
||||||
|
GMOCK_MOCKER_(0, constness, Method).SetOwnerAndName(this, #Method); \
|
||||||
|
return GMOCK_MOCKER_(0, constness, Method).Invoke(); \
|
||||||
|
} \
|
||||||
|
::testing::MockSpec<F>& \
|
||||||
|
gmock_##Method() constness { \
|
||||||
|
GMOCK_MOCKER_(0, constness, Method).RegisterOwner(this); \
|
||||||
|
return GMOCK_MOCKER_(0, constness, Method).With(); \
|
||||||
|
} \
|
||||||
|
mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(0, constness, Method)
|
||||||
|
|
||||||
|
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
|
||||||
|
#define GMOCK_METHOD1_(tn, constness, ct, Method, F) \
|
||||||
|
GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1) constness { \
|
||||||
|
GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
|
||||||
|
tn ::testing::internal::Function<F>::ArgumentTuple>::value == 1, \
|
||||||
|
this_method_does_not_take_1_argument); \
|
||||||
|
GMOCK_MOCKER_(1, constness, Method).SetOwnerAndName(this, #Method); \
|
||||||
|
return GMOCK_MOCKER_(1, constness, Method).Invoke(gmock_a1); \
|
||||||
|
} \
|
||||||
|
::testing::MockSpec<F>& \
|
||||||
|
gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1) constness { \
|
||||||
|
GMOCK_MOCKER_(1, constness, Method).RegisterOwner(this); \
|
||||||
|
return GMOCK_MOCKER_(1, constness, Method).With(gmock_a1); \
|
||||||
|
} \
|
||||||
|
mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(1, constness, Method)
|
||||||
|
|
||||||
|
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
|
||||||
|
#define GMOCK_METHOD2_(tn, constness, ct, Method, F) \
|
||||||
|
GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
|
||||||
|
GMOCK_ARG_(tn, F, 2) gmock_a2) constness { \
|
||||||
|
GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
|
||||||
|
tn ::testing::internal::Function<F>::ArgumentTuple>::value == 2, \
|
||||||
|
this_method_does_not_take_2_arguments); \
|
||||||
|
GMOCK_MOCKER_(2, constness, Method).SetOwnerAndName(this, #Method); \
|
||||||
|
return GMOCK_MOCKER_(2, constness, Method).Invoke(gmock_a1, gmock_a2); \
|
||||||
|
} \
|
||||||
|
::testing::MockSpec<F>& \
|
||||||
|
gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 2) gmock_a2) constness { \
|
||||||
|
GMOCK_MOCKER_(2, constness, Method).RegisterOwner(this); \
|
||||||
|
return GMOCK_MOCKER_(2, constness, Method).With(gmock_a1, gmock_a2); \
|
||||||
|
} \
|
||||||
|
mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(2, constness, Method)
|
||||||
|
|
||||||
|
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
|
||||||
|
#define GMOCK_METHOD3_(tn, constness, ct, Method, F) \
|
||||||
|
GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
|
||||||
|
GMOCK_ARG_(tn, F, 2) gmock_a2, \
|
||||||
|
GMOCK_ARG_(tn, F, 3) gmock_a3) constness { \
|
||||||
|
GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
|
||||||
|
tn ::testing::internal::Function<F>::ArgumentTuple>::value == 3, \
|
||||||
|
this_method_does_not_take_3_arguments); \
|
||||||
|
GMOCK_MOCKER_(3, constness, Method).SetOwnerAndName(this, #Method); \
|
||||||
|
return GMOCK_MOCKER_(3, constness, Method).Invoke(gmock_a1, gmock_a2, \
|
||||||
|
gmock_a3); \
|
||||||
|
} \
|
||||||
|
::testing::MockSpec<F>& \
|
||||||
|
gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 3) gmock_a3) constness { \
|
||||||
|
GMOCK_MOCKER_(3, constness, Method).RegisterOwner(this); \
|
||||||
|
return GMOCK_MOCKER_(3, constness, Method).With(gmock_a1, gmock_a2, \
|
||||||
|
gmock_a3); \
|
||||||
|
} \
|
||||||
|
mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(3, constness, Method)
|
||||||
|
|
||||||
|
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
|
||||||
|
#define GMOCK_METHOD4_(tn, constness, ct, Method, F) \
|
||||||
|
GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
|
||||||
|
GMOCK_ARG_(tn, F, 2) gmock_a2, \
|
||||||
|
GMOCK_ARG_(tn, F, 3) gmock_a3, \
|
||||||
|
GMOCK_ARG_(tn, F, 4) gmock_a4) constness { \
|
||||||
|
GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
|
||||||
|
tn ::testing::internal::Function<F>::ArgumentTuple>::value == 4, \
|
||||||
|
this_method_does_not_take_4_arguments); \
|
||||||
|
GMOCK_MOCKER_(4, constness, Method).SetOwnerAndName(this, #Method); \
|
||||||
|
return GMOCK_MOCKER_(4, constness, Method).Invoke(gmock_a1, gmock_a2, \
|
||||||
|
gmock_a3, gmock_a4); \
|
||||||
|
} \
|
||||||
|
::testing::MockSpec<F>& \
|
||||||
|
gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 3) gmock_a3, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 4) gmock_a4) constness { \
|
||||||
|
GMOCK_MOCKER_(4, constness, Method).RegisterOwner(this); \
|
||||||
|
return GMOCK_MOCKER_(4, constness, Method).With(gmock_a1, gmock_a2, \
|
||||||
|
gmock_a3, gmock_a4); \
|
||||||
|
} \
|
||||||
|
mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(4, constness, Method)
|
||||||
|
|
||||||
|
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
|
||||||
|
#define GMOCK_METHOD5_(tn, constness, ct, Method, F) \
|
||||||
|
GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
|
||||||
|
GMOCK_ARG_(tn, F, 2) gmock_a2, \
|
||||||
|
GMOCK_ARG_(tn, F, 3) gmock_a3, \
|
||||||
|
GMOCK_ARG_(tn, F, 4) gmock_a4, \
|
||||||
|
GMOCK_ARG_(tn, F, 5) gmock_a5) constness { \
|
||||||
|
GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
|
||||||
|
tn ::testing::internal::Function<F>::ArgumentTuple>::value == 5, \
|
||||||
|
this_method_does_not_take_5_arguments); \
|
||||||
|
GMOCK_MOCKER_(5, constness, Method).SetOwnerAndName(this, #Method); \
|
||||||
|
return GMOCK_MOCKER_(5, constness, Method).Invoke(gmock_a1, gmock_a2, \
|
||||||
|
gmock_a3, gmock_a4, gmock_a5); \
|
||||||
|
} \
|
||||||
|
::testing::MockSpec<F>& \
|
||||||
|
gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 3) gmock_a3, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 4) gmock_a4, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 5) gmock_a5) constness { \
|
||||||
|
GMOCK_MOCKER_(5, constness, Method).RegisterOwner(this); \
|
||||||
|
return GMOCK_MOCKER_(5, constness, Method).With(gmock_a1, gmock_a2, \
|
||||||
|
gmock_a3, gmock_a4, gmock_a5); \
|
||||||
|
} \
|
||||||
|
mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(5, constness, Method)
|
||||||
|
|
||||||
|
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
|
||||||
|
#define GMOCK_METHOD6_(tn, constness, ct, Method, F) \
|
||||||
|
GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
|
||||||
|
GMOCK_ARG_(tn, F, 2) gmock_a2, \
|
||||||
|
GMOCK_ARG_(tn, F, 3) gmock_a3, \
|
||||||
|
GMOCK_ARG_(tn, F, 4) gmock_a4, \
|
||||||
|
GMOCK_ARG_(tn, F, 5) gmock_a5, \
|
||||||
|
GMOCK_ARG_(tn, F, 6) gmock_a6) constness { \
|
||||||
|
GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
|
||||||
|
tn ::testing::internal::Function<F>::ArgumentTuple>::value == 6, \
|
||||||
|
this_method_does_not_take_6_arguments); \
|
||||||
|
GMOCK_MOCKER_(6, constness, Method).SetOwnerAndName(this, #Method); \
|
||||||
|
return GMOCK_MOCKER_(6, constness, Method).Invoke(gmock_a1, gmock_a2, \
|
||||||
|
gmock_a3, gmock_a4, gmock_a5, gmock_a6); \
|
||||||
|
} \
|
||||||
|
::testing::MockSpec<F>& \
|
||||||
|
gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 3) gmock_a3, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 4) gmock_a4, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 5) gmock_a5, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 6) gmock_a6) constness { \
|
||||||
|
GMOCK_MOCKER_(6, constness, Method).RegisterOwner(this); \
|
||||||
|
return GMOCK_MOCKER_(6, constness, Method).With(gmock_a1, gmock_a2, \
|
||||||
|
gmock_a3, gmock_a4, gmock_a5, gmock_a6); \
|
||||||
|
} \
|
||||||
|
mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(6, constness, Method)
|
||||||
|
|
||||||
|
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
|
||||||
|
#define GMOCK_METHOD7_(tn, constness, ct, Method, F) \
|
||||||
|
GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
|
||||||
|
GMOCK_ARG_(tn, F, 2) gmock_a2, \
|
||||||
|
GMOCK_ARG_(tn, F, 3) gmock_a3, \
|
||||||
|
GMOCK_ARG_(tn, F, 4) gmock_a4, \
|
||||||
|
GMOCK_ARG_(tn, F, 5) gmock_a5, \
|
||||||
|
GMOCK_ARG_(tn, F, 6) gmock_a6, \
|
||||||
|
GMOCK_ARG_(tn, F, 7) gmock_a7) constness { \
|
||||||
|
GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
|
||||||
|
tn ::testing::internal::Function<F>::ArgumentTuple>::value == 7, \
|
||||||
|
this_method_does_not_take_7_arguments); \
|
||||||
|
GMOCK_MOCKER_(7, constness, Method).SetOwnerAndName(this, #Method); \
|
||||||
|
return GMOCK_MOCKER_(7, constness, Method).Invoke(gmock_a1, gmock_a2, \
|
||||||
|
gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7); \
|
||||||
|
} \
|
||||||
|
::testing::MockSpec<F>& \
|
||||||
|
gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 3) gmock_a3, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 4) gmock_a4, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 5) gmock_a5, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 6) gmock_a6, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 7) gmock_a7) constness { \
|
||||||
|
GMOCK_MOCKER_(7, constness, Method).RegisterOwner(this); \
|
||||||
|
return GMOCK_MOCKER_(7, constness, Method).With(gmock_a1, gmock_a2, \
|
||||||
|
gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7); \
|
||||||
|
} \
|
||||||
|
mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(7, constness, Method)
|
||||||
|
|
||||||
|
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
|
||||||
|
#define GMOCK_METHOD8_(tn, constness, ct, Method, F) \
|
||||||
|
GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
|
||||||
|
GMOCK_ARG_(tn, F, 2) gmock_a2, \
|
||||||
|
GMOCK_ARG_(tn, F, 3) gmock_a3, \
|
||||||
|
GMOCK_ARG_(tn, F, 4) gmock_a4, \
|
||||||
|
GMOCK_ARG_(tn, F, 5) gmock_a5, \
|
||||||
|
GMOCK_ARG_(tn, F, 6) gmock_a6, \
|
||||||
|
GMOCK_ARG_(tn, F, 7) gmock_a7, \
|
||||||
|
GMOCK_ARG_(tn, F, 8) gmock_a8) constness { \
|
||||||
|
GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
|
||||||
|
tn ::testing::internal::Function<F>::ArgumentTuple>::value == 8, \
|
||||||
|
this_method_does_not_take_8_arguments); \
|
||||||
|
GMOCK_MOCKER_(8, constness, Method).SetOwnerAndName(this, #Method); \
|
||||||
|
return GMOCK_MOCKER_(8, constness, Method).Invoke(gmock_a1, gmock_a2, \
|
||||||
|
gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8); \
|
||||||
|
} \
|
||||||
|
::testing::MockSpec<F>& \
|
||||||
|
gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 3) gmock_a3, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 4) gmock_a4, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 5) gmock_a5, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 6) gmock_a6, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 7) gmock_a7, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 8) gmock_a8) constness { \
|
||||||
|
GMOCK_MOCKER_(8, constness, Method).RegisterOwner(this); \
|
||||||
|
return GMOCK_MOCKER_(8, constness, Method).With(gmock_a1, gmock_a2, \
|
||||||
|
gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8); \
|
||||||
|
} \
|
||||||
|
mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(8, constness, Method)
|
||||||
|
|
||||||
|
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
|
||||||
|
#define GMOCK_METHOD9_(tn, constness, ct, Method, F) \
|
||||||
|
GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
|
||||||
|
GMOCK_ARG_(tn, F, 2) gmock_a2, \
|
||||||
|
GMOCK_ARG_(tn, F, 3) gmock_a3, \
|
||||||
|
GMOCK_ARG_(tn, F, 4) gmock_a4, \
|
||||||
|
GMOCK_ARG_(tn, F, 5) gmock_a5, \
|
||||||
|
GMOCK_ARG_(tn, F, 6) gmock_a6, \
|
||||||
|
GMOCK_ARG_(tn, F, 7) gmock_a7, \
|
||||||
|
GMOCK_ARG_(tn, F, 8) gmock_a8, \
|
||||||
|
GMOCK_ARG_(tn, F, 9) gmock_a9) constness { \
|
||||||
|
GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
|
||||||
|
tn ::testing::internal::Function<F>::ArgumentTuple>::value == 9, \
|
||||||
|
this_method_does_not_take_9_arguments); \
|
||||||
|
GMOCK_MOCKER_(9, constness, Method).SetOwnerAndName(this, #Method); \
|
||||||
|
return GMOCK_MOCKER_(9, constness, Method).Invoke(gmock_a1, gmock_a2, \
|
||||||
|
gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, \
|
||||||
|
gmock_a9); \
|
||||||
|
} \
|
||||||
|
::testing::MockSpec<F>& \
|
||||||
|
gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 3) gmock_a3, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 4) gmock_a4, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 5) gmock_a5, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 6) gmock_a6, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 7) gmock_a7, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 8) gmock_a8, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 9) gmock_a9) constness { \
|
||||||
|
GMOCK_MOCKER_(9, constness, Method).RegisterOwner(this); \
|
||||||
|
return GMOCK_MOCKER_(9, constness, Method).With(gmock_a1, gmock_a2, \
|
||||||
|
gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, \
|
||||||
|
gmock_a9); \
|
||||||
|
} \
|
||||||
|
mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(9, constness, Method)
|
||||||
|
|
||||||
|
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
|
||||||
|
#define GMOCK_METHOD10_(tn, constness, ct, Method, F) \
|
||||||
|
GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
|
||||||
|
GMOCK_ARG_(tn, F, 2) gmock_a2, \
|
||||||
|
GMOCK_ARG_(tn, F, 3) gmock_a3, \
|
||||||
|
GMOCK_ARG_(tn, F, 4) gmock_a4, \
|
||||||
|
GMOCK_ARG_(tn, F, 5) gmock_a5, \
|
||||||
|
GMOCK_ARG_(tn, F, 6) gmock_a6, \
|
||||||
|
GMOCK_ARG_(tn, F, 7) gmock_a7, \
|
||||||
|
GMOCK_ARG_(tn, F, 8) gmock_a8, \
|
||||||
|
GMOCK_ARG_(tn, F, 9) gmock_a9, \
|
||||||
|
GMOCK_ARG_(tn, F, 10) gmock_a10) constness { \
|
||||||
|
GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
|
||||||
|
tn ::testing::internal::Function<F>::ArgumentTuple>::value == 10, \
|
||||||
|
this_method_does_not_take_10_arguments); \
|
||||||
|
GMOCK_MOCKER_(10, constness, Method).SetOwnerAndName(this, #Method); \
|
||||||
|
return GMOCK_MOCKER_(10, constness, Method).Invoke(gmock_a1, gmock_a2, \
|
||||||
|
gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, gmock_a9, \
|
||||||
|
gmock_a10); \
|
||||||
|
} \
|
||||||
|
::testing::MockSpec<F>& \
|
||||||
|
gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 3) gmock_a3, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 4) gmock_a4, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 5) gmock_a5, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 6) gmock_a6, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 7) gmock_a7, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 8) gmock_a8, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 9) gmock_a9, \
|
||||||
|
GMOCK_MATCHER_(tn, F, 10) gmock_a10) constness { \
|
||||||
|
GMOCK_MOCKER_(10, constness, Method).RegisterOwner(this); \
|
||||||
|
return GMOCK_MOCKER_(10, constness, Method).With(gmock_a1, gmock_a2, \
|
||||||
|
gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, gmock_a9, \
|
||||||
|
gmock_a10); \
|
||||||
|
} \
|
||||||
|
mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(10, constness, Method)
|
||||||
|
|
||||||
|
#define MOCK_METHOD0(m, F) GMOCK_METHOD0_(, , , m, F)
|
||||||
|
#define MOCK_METHOD1(m, F) GMOCK_METHOD1_(, , , m, F)
|
||||||
|
#define MOCK_METHOD2(m, F) GMOCK_METHOD2_(, , , m, F)
|
||||||
|
#define MOCK_METHOD3(m, F) GMOCK_METHOD3_(, , , m, F)
|
||||||
|
#define MOCK_METHOD4(m, F) GMOCK_METHOD4_(, , , m, F)
|
||||||
|
#define MOCK_METHOD5(m, F) GMOCK_METHOD5_(, , , m, F)
|
||||||
|
#define MOCK_METHOD6(m, F) GMOCK_METHOD6_(, , , m, F)
|
||||||
|
#define MOCK_METHOD7(m, F) GMOCK_METHOD7_(, , , m, F)
|
||||||
|
#define MOCK_METHOD8(m, F) GMOCK_METHOD8_(, , , m, F)
|
||||||
|
#define MOCK_METHOD9(m, F) GMOCK_METHOD9_(, , , m, F)
|
||||||
|
#define MOCK_METHOD10(m, F) GMOCK_METHOD10_(, , , m, F)
|
||||||
|
|
||||||
|
#define MOCK_CONST_METHOD0(m, F) GMOCK_METHOD0_(, const, , m, F)
|
||||||
|
#define MOCK_CONST_METHOD1(m, F) GMOCK_METHOD1_(, const, , m, F)
|
||||||
|
#define MOCK_CONST_METHOD2(m, F) GMOCK_METHOD2_(, const, , m, F)
|
||||||
|
#define MOCK_CONST_METHOD3(m, F) GMOCK_METHOD3_(, const, , m, F)
|
||||||
|
#define MOCK_CONST_METHOD4(m, F) GMOCK_METHOD4_(, const, , m, F)
|
||||||
|
#define MOCK_CONST_METHOD5(m, F) GMOCK_METHOD5_(, const, , m, F)
|
||||||
|
#define MOCK_CONST_METHOD6(m, F) GMOCK_METHOD6_(, const, , m, F)
|
||||||
|
#define MOCK_CONST_METHOD7(m, F) GMOCK_METHOD7_(, const, , m, F)
|
||||||
|
#define MOCK_CONST_METHOD8(m, F) GMOCK_METHOD8_(, const, , m, F)
|
||||||
|
#define MOCK_CONST_METHOD9(m, F) GMOCK_METHOD9_(, const, , m, F)
|
||||||
|
#define MOCK_CONST_METHOD10(m, F) GMOCK_METHOD10_(, const, , m, F)
|
||||||
|
|
||||||
|
#define MOCK_METHOD0_T(m, F) GMOCK_METHOD0_(typename, , , m, F)
|
||||||
|
#define MOCK_METHOD1_T(m, F) GMOCK_METHOD1_(typename, , , m, F)
|
||||||
|
#define MOCK_METHOD2_T(m, F) GMOCK_METHOD2_(typename, , , m, F)
|
||||||
|
#define MOCK_METHOD3_T(m, F) GMOCK_METHOD3_(typename, , , m, F)
|
||||||
|
#define MOCK_METHOD4_T(m, F) GMOCK_METHOD4_(typename, , , m, F)
|
||||||
|
#define MOCK_METHOD5_T(m, F) GMOCK_METHOD5_(typename, , , m, F)
|
||||||
|
#define MOCK_METHOD6_T(m, F) GMOCK_METHOD6_(typename, , , m, F)
|
||||||
|
#define MOCK_METHOD7_T(m, F) GMOCK_METHOD7_(typename, , , m, F)
|
||||||
|
#define MOCK_METHOD8_T(m, F) GMOCK_METHOD8_(typename, , , m, F)
|
||||||
|
#define MOCK_METHOD9_T(m, F) GMOCK_METHOD9_(typename, , , m, F)
|
||||||
|
#define MOCK_METHOD10_T(m, F) GMOCK_METHOD10_(typename, , , m, F)
|
||||||
|
|
||||||
|
#define MOCK_CONST_METHOD0_T(m, F) GMOCK_METHOD0_(typename, const, , m, F)
|
||||||
|
#define MOCK_CONST_METHOD1_T(m, F) GMOCK_METHOD1_(typename, const, , m, F)
|
||||||
|
#define MOCK_CONST_METHOD2_T(m, F) GMOCK_METHOD2_(typename, const, , m, F)
|
||||||
|
#define MOCK_CONST_METHOD3_T(m, F) GMOCK_METHOD3_(typename, const, , m, F)
|
||||||
|
#define MOCK_CONST_METHOD4_T(m, F) GMOCK_METHOD4_(typename, const, , m, F)
|
||||||
|
#define MOCK_CONST_METHOD5_T(m, F) GMOCK_METHOD5_(typename, const, , m, F)
|
||||||
|
#define MOCK_CONST_METHOD6_T(m, F) GMOCK_METHOD6_(typename, const, , m, F)
|
||||||
|
#define MOCK_CONST_METHOD7_T(m, F) GMOCK_METHOD7_(typename, const, , m, F)
|
||||||
|
#define MOCK_CONST_METHOD8_T(m, F) GMOCK_METHOD8_(typename, const, , m, F)
|
||||||
|
#define MOCK_CONST_METHOD9_T(m, F) GMOCK_METHOD9_(typename, const, , m, F)
|
||||||
|
#define MOCK_CONST_METHOD10_T(m, F) GMOCK_METHOD10_(typename, const, , m, F)
|
||||||
|
|
||||||
|
#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD0_(, , ct, m, F)
|
||||||
|
#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD1_(, , ct, m, F)
|
||||||
|
#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD2_(, , ct, m, F)
|
||||||
|
#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD3_(, , ct, m, F)
|
||||||
|
#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD4_(, , ct, m, F)
|
||||||
|
#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD5_(, , ct, m, F)
|
||||||
|
#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD6_(, , ct, m, F)
|
||||||
|
#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD7_(, , ct, m, F)
|
||||||
|
#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD8_(, , ct, m, F)
|
||||||
|
#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD9_(, , ct, m, F)
|
||||||
|
#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD10_(, , ct, m, F)
|
||||||
|
|
||||||
|
#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD0_(, const, ct, m, F)
|
||||||
|
#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD1_(, const, ct, m, F)
|
||||||
|
#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD2_(, const, ct, m, F)
|
||||||
|
#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD3_(, const, ct, m, F)
|
||||||
|
#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD4_(, const, ct, m, F)
|
||||||
|
#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD5_(, const, ct, m, F)
|
||||||
|
#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD6_(, const, ct, m, F)
|
||||||
|
#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD7_(, const, ct, m, F)
|
||||||
|
#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD8_(, const, ct, m, F)
|
||||||
|
#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD9_(, const, ct, m, F)
|
||||||
|
#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD10_(, const, ct, m, F)
|
||||||
|
|
||||||
|
#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD0_(typename, , ct, m, F)
|
||||||
|
#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD1_(typename, , ct, m, F)
|
||||||
|
#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD2_(typename, , ct, m, F)
|
||||||
|
#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD3_(typename, , ct, m, F)
|
||||||
|
#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD4_(typename, , ct, m, F)
|
||||||
|
#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD5_(typename, , ct, m, F)
|
||||||
|
#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD6_(typename, , ct, m, F)
|
||||||
|
#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD7_(typename, , ct, m, F)
|
||||||
|
#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD8_(typename, , ct, m, F)
|
||||||
|
#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD9_(typename, , ct, m, F)
|
||||||
|
#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD10_(typename, , ct, m, F)
|
||||||
|
|
||||||
|
#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD0_(typename, const, ct, m, F)
|
||||||
|
#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD1_(typename, const, ct, m, F)
|
||||||
|
#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD2_(typename, const, ct, m, F)
|
||||||
|
#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD3_(typename, const, ct, m, F)
|
||||||
|
#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD4_(typename, const, ct, m, F)
|
||||||
|
#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD5_(typename, const, ct, m, F)
|
||||||
|
#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD6_(typename, const, ct, m, F)
|
||||||
|
#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD7_(typename, const, ct, m, F)
|
||||||
|
#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD8_(typename, const, ct, m, F)
|
||||||
|
#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD9_(typename, const, ct, m, F)
|
||||||
|
#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD10_(typename, const, ct, m, F)
|
||||||
|
|
||||||
|
// A MockFunction<F> class has one mock method whose type is F. It is
|
||||||
|
// useful when you just want your test code to emit some messages and
|
||||||
|
// have Google Mock verify the right messages are sent (and perhaps at
|
||||||
|
// the right times). For example, if you are exercising code:
|
||||||
|
//
|
||||||
|
// Foo(1);
|
||||||
|
// Foo(2);
|
||||||
|
// Foo(3);
|
||||||
|
//
|
||||||
|
// and want to verify that Foo(1) and Foo(3) both invoke
|
||||||
|
// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write:
|
||||||
|
//
|
||||||
|
// TEST(FooTest, InvokesBarCorrectly) {
|
||||||
|
// MyMock mock;
|
||||||
|
// MockFunction<void(string check_point_name)> check;
|
||||||
|
// {
|
||||||
|
// InSequence s;
|
||||||
|
//
|
||||||
|
// EXPECT_CALL(mock, Bar("a"));
|
||||||
|
// EXPECT_CALL(check, Call("1"));
|
||||||
|
// EXPECT_CALL(check, Call("2"));
|
||||||
|
// EXPECT_CALL(mock, Bar("a"));
|
||||||
|
// }
|
||||||
|
// Foo(1);
|
||||||
|
// check.Call("1");
|
||||||
|
// Foo(2);
|
||||||
|
// check.Call("2");
|
||||||
|
// Foo(3);
|
||||||
|
// }
|
||||||
|
//
|
||||||
|
// The expectation spec says that the first Bar("a") must happen
|
||||||
|
// before check point "1", the second Bar("a") must happen after check
|
||||||
|
// point "2", and nothing should happen between the two check
|
||||||
|
// points. The explicit check points make it easy to tell which
|
||||||
|
// Bar("a") is called by which call to Foo().
|
||||||
|
template <typename F>
|
||||||
|
class MockFunction;
|
||||||
|
|
||||||
|
template <typename R>
|
||||||
|
class MockFunction<R()> {
|
||||||
|
public:
|
||||||
|
MockFunction() {}
|
||||||
|
|
||||||
|
MOCK_METHOD0_T(Call, R());
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A0>
|
||||||
|
class MockFunction<R(A0)> {
|
||||||
|
public:
|
||||||
|
MockFunction() {}
|
||||||
|
|
||||||
|
MOCK_METHOD1_T(Call, R(A0));
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A0, typename A1>
|
||||||
|
class MockFunction<R(A0, A1)> {
|
||||||
|
public:
|
||||||
|
MockFunction() {}
|
||||||
|
|
||||||
|
MOCK_METHOD2_T(Call, R(A0, A1));
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A0, typename A1, typename A2>
|
||||||
|
class MockFunction<R(A0, A1, A2)> {
|
||||||
|
public:
|
||||||
|
MockFunction() {}
|
||||||
|
|
||||||
|
MOCK_METHOD3_T(Call, R(A0, A1, A2));
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A0, typename A1, typename A2, typename A3>
|
||||||
|
class MockFunction<R(A0, A1, A2, A3)> {
|
||||||
|
public:
|
||||||
|
MockFunction() {}
|
||||||
|
|
||||||
|
MOCK_METHOD4_T(Call, R(A0, A1, A2, A3));
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A0, typename A1, typename A2, typename A3,
|
||||||
|
typename A4>
|
||||||
|
class MockFunction<R(A0, A1, A2, A3, A4)> {
|
||||||
|
public:
|
||||||
|
MockFunction() {}
|
||||||
|
|
||||||
|
MOCK_METHOD5_T(Call, R(A0, A1, A2, A3, A4));
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A0, typename A1, typename A2, typename A3,
|
||||||
|
typename A4, typename A5>
|
||||||
|
class MockFunction<R(A0, A1, A2, A3, A4, A5)> {
|
||||||
|
public:
|
||||||
|
MockFunction() {}
|
||||||
|
|
||||||
|
MOCK_METHOD6_T(Call, R(A0, A1, A2, A3, A4, A5));
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A0, typename A1, typename A2, typename A3,
|
||||||
|
typename A4, typename A5, typename A6>
|
||||||
|
class MockFunction<R(A0, A1, A2, A3, A4, A5, A6)> {
|
||||||
|
public:
|
||||||
|
MockFunction() {}
|
||||||
|
|
||||||
|
MOCK_METHOD7_T(Call, R(A0, A1, A2, A3, A4, A5, A6));
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A0, typename A1, typename A2, typename A3,
|
||||||
|
typename A4, typename A5, typename A6, typename A7>
|
||||||
|
class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7)> {
|
||||||
|
public:
|
||||||
|
MockFunction() {}
|
||||||
|
|
||||||
|
MOCK_METHOD8_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7));
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A0, typename A1, typename A2, typename A3,
|
||||||
|
typename A4, typename A5, typename A6, typename A7, typename A8>
|
||||||
|
class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> {
|
||||||
|
public:
|
||||||
|
MockFunction() {}
|
||||||
|
|
||||||
|
MOCK_METHOD9_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8));
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A0, typename A1, typename A2, typename A3,
|
||||||
|
typename A4, typename A5, typename A6, typename A7, typename A8,
|
||||||
|
typename A9>
|
||||||
|
class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
|
||||||
|
public:
|
||||||
|
MockFunction() {}
|
||||||
|
|
||||||
|
MOCK_METHOD10_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9));
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace testing
|
||||||
|
|
||||||
|
#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
|
|
@ -0,0 +1,258 @@
|
||||||
|
$$ -*- mode: c++; -*-
|
||||||
|
$$ This is a Pump source file. Please use Pump to convert it to
|
||||||
|
$$ gmock-generated-function-mockers.h.
|
||||||
|
$$
|
||||||
|
$var n = 10 $$ The maximum arity we support.
|
||||||
|
// 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 Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file implements function mockers of various arities.
|
||||||
|
|
||||||
|
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
|
||||||
|
#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
|
||||||
|
|
||||||
|
#include "gmock/gmock-spec-builders.h"
|
||||||
|
#include "gmock/internal/gmock-internal-utils.h"
|
||||||
|
|
||||||
|
namespace testing {
|
||||||
|
namespace internal {
|
||||||
|
|
||||||
|
template <typename F>
|
||||||
|
class FunctionMockerBase;
|
||||||
|
|
||||||
|
// Note: class FunctionMocker really belongs to the ::testing
|
||||||
|
// namespace. However if we define it in ::testing, MSVC will
|
||||||
|
// complain when classes in ::testing::internal declare it as a
|
||||||
|
// friend class template. To workaround this compiler bug, we define
|
||||||
|
// FunctionMocker in ::testing::internal and import it into ::testing.
|
||||||
|
template <typename F>
|
||||||
|
class FunctionMocker;
|
||||||
|
|
||||||
|
|
||||||
|
$range i 0..n
|
||||||
|
$for i [[
|
||||||
|
$range j 1..i
|
||||||
|
$var typename_As = [[$for j [[, typename A$j]]]]
|
||||||
|
$var As = [[$for j, [[A$j]]]]
|
||||||
|
$var as = [[$for j, [[a$j]]]]
|
||||||
|
$var Aas = [[$for j, [[A$j a$j]]]]
|
||||||
|
$var ms = [[$for j, [[m$j]]]]
|
||||||
|
$var matchers = [[$for j, [[const Matcher<A$j>& m$j]]]]
|
||||||
|
template <typename R$typename_As>
|
||||||
|
class FunctionMocker<R($As)> : public
|
||||||
|
internal::FunctionMockerBase<R($As)> {
|
||||||
|
public:
|
||||||
|
typedef R F($As);
|
||||||
|
typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
|
||||||
|
|
||||||
|
MockSpec<F>& With($matchers) {
|
||||||
|
|
||||||
|
$if i >= 1 [[
|
||||||
|
this->current_spec().SetMatchers(::std::tr1::make_tuple($ms));
|
||||||
|
|
||||||
|
]]
|
||||||
|
return this->current_spec();
|
||||||
|
}
|
||||||
|
|
||||||
|
R Invoke($Aas) {
|
||||||
|
// Even though gcc and MSVC don't enforce it, 'this->' is required
|
||||||
|
// by the C++ standard [14.6.4] here, as the base class type is
|
||||||
|
// dependent on the template argument (and thus shouldn't be
|
||||||
|
// looked into when resolving InvokeWith).
|
||||||
|
return this->InvokeWith(ArgumentTuple($as));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
]]
|
||||||
|
} // namespace internal
|
||||||
|
|
||||||
|
// The style guide prohibits "using" statements in a namespace scope
|
||||||
|
// inside a header file. However, the FunctionMocker class template
|
||||||
|
// is meant to be defined in the ::testing namespace. The following
|
||||||
|
// line is just a trick for working around a bug in MSVC 8.0, which
|
||||||
|
// cannot handle it if we define FunctionMocker in ::testing.
|
||||||
|
using internal::FunctionMocker;
|
||||||
|
|
||||||
|
// The result type of function type F.
|
||||||
|
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
|
||||||
|
#define GMOCK_RESULT_(tn, F) tn ::testing::internal::Function<F>::Result
|
||||||
|
|
||||||
|
// The type of argument N of function type F.
|
||||||
|
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
|
||||||
|
#define GMOCK_ARG_(tn, F, N) tn ::testing::internal::Function<F>::Argument##N
|
||||||
|
|
||||||
|
// The matcher type for argument N of function type F.
|
||||||
|
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
|
||||||
|
#define GMOCK_MATCHER_(tn, F, N) const ::testing::Matcher<GMOCK_ARG_(tn, F, N)>&
|
||||||
|
|
||||||
|
// The variable for mocking the given method.
|
||||||
|
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
|
||||||
|
#define GMOCK_MOCKER_(arity, constness, Method) \
|
||||||
|
GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)
|
||||||
|
|
||||||
|
|
||||||
|
$for i [[
|
||||||
|
$range j 1..i
|
||||||
|
$var arg_as = [[$for j, \
|
||||||
|
[[GMOCK_ARG_(tn, F, $j) gmock_a$j]]]]
|
||||||
|
$var as = [[$for j, [[gmock_a$j]]]]
|
||||||
|
$var matcher_as = [[$for j, \
|
||||||
|
[[GMOCK_MATCHER_(tn, F, $j) gmock_a$j]]]]
|
||||||
|
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
|
||||||
|
#define GMOCK_METHOD$i[[]]_(tn, constness, ct, Method, F) \
|
||||||
|
GMOCK_RESULT_(tn, F) ct Method($arg_as) constness { \
|
||||||
|
GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
|
||||||
|
tn ::testing::internal::Function<F>::ArgumentTuple>::value == $i, \
|
||||||
|
this_method_does_not_take_$i[[]]_argument[[$if i != 1 [[s]]]]); \
|
||||||
|
GMOCK_MOCKER_($i, constness, Method).SetOwnerAndName(this, #Method); \
|
||||||
|
return GMOCK_MOCKER_($i, constness, Method).Invoke($as); \
|
||||||
|
} \
|
||||||
|
::testing::MockSpec<F>& \
|
||||||
|
gmock_##Method($matcher_as) constness { \
|
||||||
|
GMOCK_MOCKER_($i, constness, Method).RegisterOwner(this); \
|
||||||
|
return GMOCK_MOCKER_($i, constness, Method).With($as); \
|
||||||
|
} \
|
||||||
|
mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_($i, constness, Method)
|
||||||
|
|
||||||
|
|
||||||
|
]]
|
||||||
|
$for i [[
|
||||||
|
#define MOCK_METHOD$i(m, F) GMOCK_METHOD$i[[]]_(, , , m, F)
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
|
||||||
|
$for i [[
|
||||||
|
#define MOCK_CONST_METHOD$i(m, F) GMOCK_METHOD$i[[]]_(, const, , m, F)
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
|
||||||
|
$for i [[
|
||||||
|
#define MOCK_METHOD$i[[]]_T(m, F) GMOCK_METHOD$i[[]]_(typename, , , m, F)
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
|
||||||
|
$for i [[
|
||||||
|
#define MOCK_CONST_METHOD$i[[]]_T(m, F) [[]]
|
||||||
|
GMOCK_METHOD$i[[]]_(typename, const, , m, F)
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
|
||||||
|
$for i [[
|
||||||
|
#define MOCK_METHOD$i[[]]_WITH_CALLTYPE(ct, m, F) [[]]
|
||||||
|
GMOCK_METHOD$i[[]]_(, , ct, m, F)
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
|
||||||
|
$for i [[
|
||||||
|
#define MOCK_CONST_METHOD$i[[]]_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD$i[[]]_(, const, ct, m, F)
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
|
||||||
|
$for i [[
|
||||||
|
#define MOCK_METHOD$i[[]]_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD$i[[]]_(typename, , ct, m, F)
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
|
||||||
|
$for i [[
|
||||||
|
#define MOCK_CONST_METHOD$i[[]]_T_WITH_CALLTYPE(ct, m, F) \
|
||||||
|
GMOCK_METHOD$i[[]]_(typename, const, ct, m, F)
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
// A MockFunction<F> class has one mock method whose type is F. It is
|
||||||
|
// useful when you just want your test code to emit some messages and
|
||||||
|
// have Google Mock verify the right messages are sent (and perhaps at
|
||||||
|
// the right times). For example, if you are exercising code:
|
||||||
|
//
|
||||||
|
// Foo(1);
|
||||||
|
// Foo(2);
|
||||||
|
// Foo(3);
|
||||||
|
//
|
||||||
|
// and want to verify that Foo(1) and Foo(3) both invoke
|
||||||
|
// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write:
|
||||||
|
//
|
||||||
|
// TEST(FooTest, InvokesBarCorrectly) {
|
||||||
|
// MyMock mock;
|
||||||
|
// MockFunction<void(string check_point_name)> check;
|
||||||
|
// {
|
||||||
|
// InSequence s;
|
||||||
|
//
|
||||||
|
// EXPECT_CALL(mock, Bar("a"));
|
||||||
|
// EXPECT_CALL(check, Call("1"));
|
||||||
|
// EXPECT_CALL(check, Call("2"));
|
||||||
|
// EXPECT_CALL(mock, Bar("a"));
|
||||||
|
// }
|
||||||
|
// Foo(1);
|
||||||
|
// check.Call("1");
|
||||||
|
// Foo(2);
|
||||||
|
// check.Call("2");
|
||||||
|
// Foo(3);
|
||||||
|
// }
|
||||||
|
//
|
||||||
|
// The expectation spec says that the first Bar("a") must happen
|
||||||
|
// before check point "1", the second Bar("a") must happen after check
|
||||||
|
// point "2", and nothing should happen between the two check
|
||||||
|
// points. The explicit check points make it easy to tell which
|
||||||
|
// Bar("a") is called by which call to Foo().
|
||||||
|
template <typename F>
|
||||||
|
class MockFunction;
|
||||||
|
|
||||||
|
|
||||||
|
$for i [[
|
||||||
|
$range j 0..i-1
|
||||||
|
template <typename R$for j [[, typename A$j]]>
|
||||||
|
class MockFunction<R($for j, [[A$j]])> {
|
||||||
|
public:
|
||||||
|
MockFunction() {}
|
||||||
|
|
||||||
|
MOCK_METHOD$i[[]]_T(Call, R($for j, [[A$j]]));
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
]]
|
||||||
|
} // namespace testing
|
||||||
|
|
||||||
|
#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,651 @@
|
||||||
|
$$ -*- mode: c++; -*-
|
||||||
|
$$ This is a Pump source file. Please use Pump to convert it to
|
||||||
|
$$ gmock-generated-actions.h.
|
||||||
|
$$
|
||||||
|
$var n = 10 $$ The maximum arity we support.
|
||||||
|
$$ }} This line fixes auto-indentation of the following code in Emacs.
|
||||||
|
// Copyright 2008, Google Inc.
|
||||||
|
// All rights reserved.
|
||||||
|
//
|
||||||
|
// Redistribution and use in source and binary forms, with or without
|
||||||
|
// modification, are permitted provided that the following conditions are
|
||||||
|
// met:
|
||||||
|
//
|
||||||
|
// * Redistributions of source code must retain the above copyright
|
||||||
|
// notice, this list of conditions and the following disclaimer.
|
||||||
|
// * Redistributions in binary form must reproduce the above
|
||||||
|
// copyright notice, this list of conditions and the following disclaimer
|
||||||
|
// in the documentation and/or other materials provided with the
|
||||||
|
// distribution.
|
||||||
|
// * Neither the name of Google Inc. nor the names of its
|
||||||
|
// contributors may be used to endorse or promote products derived from
|
||||||
|
// this software without specific prior written permission.
|
||||||
|
//
|
||||||
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||||
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||||
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||||
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||||
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||||
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||||
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||||
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||||
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||||
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||||
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||||
|
|
||||||
|
// Google Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file implements some commonly used variadic matchers.
|
||||||
|
|
||||||
|
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
|
||||||
|
#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
|
||||||
|
|
||||||
|
#include <sstream>
|
||||||
|
#include <string>
|
||||||
|
#include <vector>
|
||||||
|
#include "gmock/gmock-matchers.h"
|
||||||
|
|
||||||
|
namespace testing {
|
||||||
|
namespace internal {
|
||||||
|
|
||||||
|
$range i 0..n-1
|
||||||
|
|
||||||
|
// The type of the i-th (0-based) field of Tuple.
|
||||||
|
#define GMOCK_FIELD_TYPE_(Tuple, i) \
|
||||||
|
typename ::std::tr1::tuple_element<i, Tuple>::type
|
||||||
|
|
||||||
|
// TupleFields<Tuple, k0, ..., kn> is for selecting fields from a
|
||||||
|
// tuple of type Tuple. It has two members:
|
||||||
|
//
|
||||||
|
// type: a tuple type whose i-th field is the ki-th field of Tuple.
|
||||||
|
// GetSelectedFields(t): returns fields k0, ..., and kn of t as a tuple.
|
||||||
|
//
|
||||||
|
// For example, in class TupleFields<tuple<bool, char, int>, 2, 0>, we have:
|
||||||
|
//
|
||||||
|
// type is tuple<int, bool>, and
|
||||||
|
// GetSelectedFields(make_tuple(true, 'a', 42)) is (42, true).
|
||||||
|
|
||||||
|
template <class Tuple$for i [[, int k$i = -1]]>
|
||||||
|
class TupleFields;
|
||||||
|
|
||||||
|
// This generic version is used when there are $n selectors.
|
||||||
|
template <class Tuple$for i [[, int k$i]]>
|
||||||
|
class TupleFields {
|
||||||
|
public:
|
||||||
|
typedef ::std::tr1::tuple<$for i, [[GMOCK_FIELD_TYPE_(Tuple, k$i)]]> type;
|
||||||
|
static type GetSelectedFields(const Tuple& t) {
|
||||||
|
using ::std::tr1::get;
|
||||||
|
return type($for i, [[get<k$i>(t)]]);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
// The following specialization is used for 0 ~ $(n-1) selectors.
|
||||||
|
|
||||||
|
$for i [[
|
||||||
|
$$ }}}
|
||||||
|
$range j 0..i-1
|
||||||
|
$range k 0..n-1
|
||||||
|
|
||||||
|
template <class Tuple$for j [[, int k$j]]>
|
||||||
|
class TupleFields<Tuple, $for k, [[$if k < i [[k$k]] $else [[-1]]]]> {
|
||||||
|
public:
|
||||||
|
typedef ::std::tr1::tuple<$for j, [[GMOCK_FIELD_TYPE_(Tuple, k$j)]]> type;
|
||||||
|
static type GetSelectedFields(const Tuple& $if i==0 [[/* t */]] $else [[t]]) {
|
||||||
|
using ::std::tr1::get;
|
||||||
|
return type($for j, [[get<k$j>(t)]]);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
#undef GMOCK_FIELD_TYPE_
|
||||||
|
|
||||||
|
// Implements the Args() matcher.
|
||||||
|
|
||||||
|
$var ks = [[$for i, [[k$i]]]]
|
||||||
|
template <class ArgsTuple$for i [[, int k$i = -1]]>
|
||||||
|
class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
|
||||||
|
public:
|
||||||
|
// ArgsTuple may have top-level const or reference modifiers.
|
||||||
|
typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple;
|
||||||
|
typedef typename internal::TupleFields<RawArgsTuple, $ks>::type SelectedArgs;
|
||||||
|
typedef Matcher<const SelectedArgs&> MonomorphicInnerMatcher;
|
||||||
|
|
||||||
|
template <typename InnerMatcher>
|
||||||
|
explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
|
||||||
|
: inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {}
|
||||||
|
|
||||||
|
virtual bool MatchAndExplain(ArgsTuple args,
|
||||||
|
MatchResultListener* listener) const {
|
||||||
|
const SelectedArgs& selected_args = GetSelectedArgs(args);
|
||||||
|
if (!listener->IsInterested())
|
||||||
|
return inner_matcher_.Matches(selected_args);
|
||||||
|
|
||||||
|
PrintIndices(listener->stream());
|
||||||
|
*listener << "are " << PrintToString(selected_args);
|
||||||
|
|
||||||
|
StringMatchResultListener inner_listener;
|
||||||
|
const bool match = inner_matcher_.MatchAndExplain(selected_args,
|
||||||
|
&inner_listener);
|
||||||
|
PrintIfNotEmpty(inner_listener.str(), listener->stream());
|
||||||
|
return match;
|
||||||
|
}
|
||||||
|
|
||||||
|
virtual void DescribeTo(::std::ostream* os) const {
|
||||||
|
*os << "are a tuple ";
|
||||||
|
PrintIndices(os);
|
||||||
|
inner_matcher_.DescribeTo(os);
|
||||||
|
}
|
||||||
|
|
||||||
|
virtual void DescribeNegationTo(::std::ostream* os) const {
|
||||||
|
*os << "are a tuple ";
|
||||||
|
PrintIndices(os);
|
||||||
|
inner_matcher_.DescribeNegationTo(os);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
static SelectedArgs GetSelectedArgs(ArgsTuple args) {
|
||||||
|
return TupleFields<RawArgsTuple, $ks>::GetSelectedFields(args);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Prints the indices of the selected fields.
|
||||||
|
static void PrintIndices(::std::ostream* os) {
|
||||||
|
*os << "whose fields (";
|
||||||
|
const int indices[$n] = { $ks };
|
||||||
|
for (int i = 0; i < $n; i++) {
|
||||||
|
if (indices[i] < 0)
|
||||||
|
break;
|
||||||
|
|
||||||
|
if (i >= 1)
|
||||||
|
*os << ", ";
|
||||||
|
|
||||||
|
*os << "#" << indices[i];
|
||||||
|
}
|
||||||
|
*os << ") ";
|
||||||
|
}
|
||||||
|
|
||||||
|
const MonomorphicInnerMatcher inner_matcher_;
|
||||||
|
|
||||||
|
GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <class InnerMatcher$for i [[, int k$i = -1]]>
|
||||||
|
class ArgsMatcher {
|
||||||
|
public:
|
||||||
|
explicit ArgsMatcher(const InnerMatcher& inner_matcher)
|
||||||
|
: inner_matcher_(inner_matcher) {}
|
||||||
|
|
||||||
|
template <typename ArgsTuple>
|
||||||
|
operator Matcher<ArgsTuple>() const {
|
||||||
|
return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, $ks>(inner_matcher_));
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
const InnerMatcher inner_matcher_;
|
||||||
|
|
||||||
|
GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
|
||||||
|
};
|
||||||
|
|
||||||
|
// Implements ElementsAre() of 1-$n arguments.
|
||||||
|
|
||||||
|
|
||||||
|
$range i 1..n
|
||||||
|
$for i [[
|
||||||
|
$range j 1..i
|
||||||
|
template <$for j, [[typename T$j]]>
|
||||||
|
class ElementsAreMatcher$i {
|
||||||
|
public:
|
||||||
|
$if i==1 [[explicit ]]ElementsAreMatcher$i($for j, [[const T$j& e$j]])$if i > 0 [[ : ]]
|
||||||
|
$for j, [[e$j[[]]_(e$j)]] {}
|
||||||
|
|
||||||
|
template <typename Container>
|
||||||
|
operator Matcher<Container>() const {
|
||||||
|
typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
|
||||||
|
typedef typename internal::StlContainerView<RawContainer>::type::value_type
|
||||||
|
Element;
|
||||||
|
|
||||||
|
$if i==1 [[
|
||||||
|
|
||||||
|
// Nokia's Symbian Compiler has a nasty bug where the object put
|
||||||
|
// in a one-element local array is not destructed when the array
|
||||||
|
// goes out of scope. This leads to obvious badness as we've
|
||||||
|
// added the linked_ptr in it to our other linked_ptrs list.
|
||||||
|
// Hence we implement ElementsAreMatcher1 specially to avoid using
|
||||||
|
// a local array.
|
||||||
|
const Matcher<const Element&> matcher =
|
||||||
|
MatcherCast<const Element&>(e1_);
|
||||||
|
return MakeMatcher(new ElementsAreMatcherImpl<Container>(&matcher, 1));
|
||||||
|
]] $else [[
|
||||||
|
|
||||||
|
const Matcher<const Element&> matchers[] = {
|
||||||
|
|
||||||
|
$for j [[
|
||||||
|
MatcherCast<const Element&>(e$j[[]]_),
|
||||||
|
|
||||||
|
]]
|
||||||
|
};
|
||||||
|
|
||||||
|
return MakeMatcher(new ElementsAreMatcherImpl<Container>(matchers, $i));
|
||||||
|
]]
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
|
||||||
|
$for j [[
|
||||||
|
const T$j& e$j[[]]_;
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher$i);
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
]]
|
||||||
|
} // namespace internal
|
||||||
|
|
||||||
|
// Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected
|
||||||
|
// fields of it matches a_matcher. C++ doesn't support default
|
||||||
|
// arguments for function templates, so we have to overload it.
|
||||||
|
|
||||||
|
$range i 0..n
|
||||||
|
$for i [[
|
||||||
|
$range j 1..i
|
||||||
|
template <$for j [[int k$j, ]]typename InnerMatcher>
|
||||||
|
inline internal::ArgsMatcher<InnerMatcher$for j [[, k$j]]>
|
||||||
|
Args(const InnerMatcher& matcher) {
|
||||||
|
return internal::ArgsMatcher<InnerMatcher$for j [[, k$j]]>(matcher);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
]]
|
||||||
|
// ElementsAre(e0, e1, ..., e_n) matches an STL-style container with
|
||||||
|
// (n + 1) elements, where the i-th element in the container must
|
||||||
|
// match the i-th argument in the list. Each argument of
|
||||||
|
// ElementsAre() can be either a value or a matcher. We support up to
|
||||||
|
// $n arguments.
|
||||||
|
//
|
||||||
|
// NOTE: Since ElementsAre() cares about the order of the elements, it
|
||||||
|
// must not be used with containers whose elements's order is
|
||||||
|
// undefined (e.g. hash_map).
|
||||||
|
|
||||||
|
inline internal::ElementsAreMatcher0 ElementsAre() {
|
||||||
|
return internal::ElementsAreMatcher0();
|
||||||
|
}
|
||||||
|
|
||||||
|
$range i 1..n
|
||||||
|
$for i [[
|
||||||
|
$range j 1..i
|
||||||
|
|
||||||
|
template <$for j, [[typename T$j]]>
|
||||||
|
inline internal::ElementsAreMatcher$i<$for j, [[T$j]]> ElementsAre($for j, [[const T$j& e$j]]) {
|
||||||
|
return internal::ElementsAreMatcher$i<$for j, [[T$j]]>($for j, [[e$j]]);
|
||||||
|
}
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
// ElementsAreArray(array) and ElementAreArray(array, count) are like
|
||||||
|
// ElementsAre(), except that they take an array of values or
|
||||||
|
// matchers. The former form infers the size of 'array', which must
|
||||||
|
// be a static C-style array. In the latter form, 'array' can either
|
||||||
|
// be a static array or a pointer to a dynamically created array.
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
|
||||||
|
const T* first, size_t count) {
|
||||||
|
return internal::ElementsAreArrayMatcher<T>(first, count);
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T, size_t N>
|
||||||
|
inline internal::ElementsAreArrayMatcher<T>
|
||||||
|
ElementsAreArray(const T (&array)[N]) {
|
||||||
|
return internal::ElementsAreArrayMatcher<T>(array, N);
|
||||||
|
}
|
||||||
|
|
||||||
|
// AllOf(m1, m2, ..., mk) matches any value that matches all of the given
|
||||||
|
// sub-matchers. AllOf is called fully qualified to prevent ADL from firing.
|
||||||
|
|
||||||
|
$range i 2..n
|
||||||
|
$for i [[
|
||||||
|
$range j 1..i
|
||||||
|
$range k 1..i-1
|
||||||
|
|
||||||
|
template <$for j, [[typename Matcher$j]]>
|
||||||
|
inline $for k[[internal::BothOfMatcher<Matcher$k, ]]Matcher$i[[]]$for k [[> ]]
|
||||||
|
|
||||||
|
AllOf($for j, [[Matcher$j m$j]]) {
|
||||||
|
|
||||||
|
$if i == 2 [[
|
||||||
|
return internal::BothOfMatcher<Matcher1, Matcher2>(m1, m2);
|
||||||
|
]] $else [[
|
||||||
|
return ::testing::AllOf(m1, ::testing::AllOf($for k, [[m$(k + 1)]]));
|
||||||
|
]]
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
// AnyOf(m1, m2, ..., mk) matches any value that matches any of the given
|
||||||
|
// sub-matchers. AnyOf is called fully qualified to prevent ADL from firing.
|
||||||
|
|
||||||
|
$range i 2..n
|
||||||
|
$for i [[
|
||||||
|
$range j 1..i
|
||||||
|
$range k 1..i-1
|
||||||
|
|
||||||
|
template <$for j, [[typename Matcher$j]]>
|
||||||
|
inline $for k[[internal::EitherOfMatcher<Matcher$k, ]]Matcher$i[[]]$for k [[> ]]
|
||||||
|
|
||||||
|
AnyOf($for j, [[Matcher$j m$j]]) {
|
||||||
|
|
||||||
|
$if i == 2 [[
|
||||||
|
return internal::EitherOfMatcher<Matcher1, Matcher2>(m1, m2);
|
||||||
|
]] $else [[
|
||||||
|
return ::testing::AnyOf(m1, ::testing::AnyOf($for k, [[m$(k + 1)]]));
|
||||||
|
]]
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
]]
|
||||||
|
|
||||||
|
} // namespace testing
|
||||||
|
$$ } // This Pump meta comment fixes auto-indentation in Emacs. It will not
|
||||||
|
$$ // show up in the generated code.
|
||||||
|
|
||||||
|
|
||||||
|
// The MATCHER* family of macros can be used in a namespace scope to
|
||||||
|
// define custom matchers easily.
|
||||||
|
//
|
||||||
|
// Basic Usage
|
||||||
|
// ===========
|
||||||
|
//
|
||||||
|
// The syntax
|
||||||
|
//
|
||||||
|
// MATCHER(name, description_string) { statements; }
|
||||||
|
//
|
||||||
|
// defines a matcher with the given name that executes the statements,
|
||||||
|
// which must return a bool to indicate if the match succeeds. Inside
|
||||||
|
// the statements, you can refer to the value being matched by 'arg',
|
||||||
|
// and refer to its type by 'arg_type'.
|
||||||
|
//
|
||||||
|
// The description string documents what the matcher does, and is used
|
||||||
|
// to generate the failure message when the match fails. Since a
|
||||||
|
// MATCHER() is usually defined in a header file shared by multiple
|
||||||
|
// C++ source files, we require the description to be a C-string
|
||||||
|
// literal to avoid possible side effects. It can be empty, in which
|
||||||
|
// case we'll use the sequence of words in the matcher name as the
|
||||||
|
// description.
|
||||||
|
//
|
||||||
|
// For example:
|
||||||
|
//
|
||||||
|
// MATCHER(IsEven, "") { return (arg % 2) == 0; }
|
||||||
|
//
|
||||||
|
// allows you to write
|
||||||
|
//
|
||||||
|
// // Expects mock_foo.Bar(n) to be called where n is even.
|
||||||
|
// EXPECT_CALL(mock_foo, Bar(IsEven()));
|
||||||
|
//
|
||||||
|
// or,
|
||||||
|
//
|
||||||
|
// // Verifies that the value of some_expression is even.
|
||||||
|
// EXPECT_THAT(some_expression, IsEven());
|
||||||
|
//
|
||||||
|
// If the above assertion fails, it will print something like:
|
||||||
|
//
|
||||||
|
// Value of: some_expression
|
||||||
|
// Expected: is even
|
||||||
|
// Actual: 7
|
||||||
|
//
|
||||||
|
// where the description "is even" is automatically calculated from the
|
||||||
|
// matcher name IsEven.
|
||||||
|
//
|
||||||
|
// Argument Type
|
||||||
|
// =============
|
||||||
|
//
|
||||||
|
// Note that the type of the value being matched (arg_type) is
|
||||||
|
// determined by the context in which you use the matcher and is
|
||||||
|
// supplied to you by the compiler, so you don't need to worry about
|
||||||
|
// declaring it (nor can you). This allows the matcher to be
|
||||||
|
// polymorphic. For example, IsEven() can be used to match any type
|
||||||
|
// where the value of "(arg % 2) == 0" can be implicitly converted to
|
||||||
|
// a bool. In the "Bar(IsEven())" example above, if method Bar()
|
||||||
|
// takes an int, 'arg_type' will be int; if it takes an unsigned long,
|
||||||
|
// 'arg_type' will be unsigned long; and so on.
|
||||||
|
//
|
||||||
|
// Parameterizing Matchers
|
||||||
|
// =======================
|
||||||
|
//
|
||||||
|
// Sometimes you'll want to parameterize the matcher. For that you
|
||||||
|
// can use another macro:
|
||||||
|
//
|
||||||
|
// MATCHER_P(name, param_name, description_string) { statements; }
|
||||||
|
//
|
||||||
|
// For example:
|
||||||
|
//
|
||||||
|
// MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; }
|
||||||
|
//
|
||||||
|
// will allow you to write:
|
||||||
|
//
|
||||||
|
// EXPECT_THAT(Blah("a"), HasAbsoluteValue(n));
|
||||||
|
//
|
||||||
|
// which may lead to this message (assuming n is 10):
|
||||||
|
//
|
||||||
|
// Value of: Blah("a")
|
||||||
|
// Expected: has absolute value 10
|
||||||
|
// Actual: -9
|
||||||
|
//
|
||||||
|
// Note that both the matcher description and its parameter are
|
||||||
|
// printed, making the message human-friendly.
|
||||||
|
//
|
||||||
|
// In the matcher definition body, you can write 'foo_type' to
|
||||||
|
// reference the type of a parameter named 'foo'. For example, in the
|
||||||
|
// body of MATCHER_P(HasAbsoluteValue, value) above, you can write
|
||||||
|
// 'value_type' to refer to the type of 'value'.
|
||||||
|
//
|
||||||
|
// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P$n to
|
||||||
|
// support multi-parameter matchers.
|
||||||
|
//
|
||||||
|
// Describing Parameterized Matchers
|
||||||
|
// =================================
|
||||||
|
//
|
||||||
|
// The last argument to MATCHER*() is a string-typed expression. The
|
||||||
|
// expression can reference all of the matcher's parameters and a
|
||||||
|
// special bool-typed variable named 'negation'. When 'negation' is
|
||||||
|
// false, the expression should evaluate to the matcher's description;
|
||||||
|
// otherwise it should evaluate to the description of the negation of
|
||||||
|
// the matcher. For example,
|
||||||
|
//
|
||||||
|
// using testing::PrintToString;
|
||||||
|
//
|
||||||
|
// MATCHER_P2(InClosedRange, low, hi,
|
||||||
|
// string(negation ? "is not" : "is") + " in range [" +
|
||||||
|
// PrintToString(low) + ", " + PrintToString(hi) + "]") {
|
||||||
|
// return low <= arg && arg <= hi;
|
||||||
|
// }
|
||||||
|
// ...
|
||||||
|
// EXPECT_THAT(3, InClosedRange(4, 6));
|
||||||
|
// EXPECT_THAT(3, Not(InClosedRange(2, 4)));
|
||||||
|
//
|
||||||
|
// would generate two failures that contain the text:
|
||||||
|
//
|
||||||
|
// Expected: is in range [4, 6]
|
||||||
|
// ...
|
||||||
|
// Expected: is not in range [2, 4]
|
||||||
|
//
|
||||||
|
// If you specify "" as the description, the failure message will
|
||||||
|
// contain the sequence of words in the matcher name followed by the
|
||||||
|
// parameter values printed as a tuple. For example,
|
||||||
|
//
|
||||||
|
// MATCHER_P2(InClosedRange, low, hi, "") { ... }
|
||||||
|
// ...
|
||||||
|
// EXPECT_THAT(3, InClosedRange(4, 6));
|
||||||
|
// EXPECT_THAT(3, Not(InClosedRange(2, 4)));
|
||||||
|
//
|
||||||
|
// would generate two failures that contain the text:
|
||||||
|
//
|
||||||
|
// Expected: in closed range (4, 6)
|
||||||
|
// ...
|
||||||
|
// Expected: not (in closed range (2, 4))
|
||||||
|
//
|
||||||
|
// Types of Matcher Parameters
|
||||||
|
// ===========================
|
||||||
|
//
|
||||||
|
// For the purpose of typing, you can view
|
||||||
|
//
|
||||||
|
// MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... }
|
||||||
|
//
|
||||||
|
// as shorthand for
|
||||||
|
//
|
||||||
|
// template <typename p1_type, ..., typename pk_type>
|
||||||
|
// FooMatcherPk<p1_type, ..., pk_type>
|
||||||
|
// Foo(p1_type p1, ..., pk_type pk) { ... }
|
||||||
|
//
|
||||||
|
// When you write Foo(v1, ..., vk), the compiler infers the types of
|
||||||
|
// the parameters v1, ..., and vk for you. If you are not happy with
|
||||||
|
// the result of the type inference, you can specify the types by
|
||||||
|
// explicitly instantiating the template, as in Foo<long, bool>(5,
|
||||||
|
// false). As said earlier, you don't get to (or need to) specify
|
||||||
|
// 'arg_type' as that's determined by the context in which the matcher
|
||||||
|
// is used. You can assign the result of expression Foo(p1, ..., pk)
|
||||||
|
// to a variable of type FooMatcherPk<p1_type, ..., pk_type>. This
|
||||||
|
// can be useful when composing matchers.
|
||||||
|
//
|
||||||
|
// While you can instantiate a matcher template with reference types,
|
||||||
|
// passing the parameters by pointer usually makes your code more
|
||||||
|
// readable. If, however, you still want to pass a parameter by
|
||||||
|
// reference, be aware that in the failure message generated by the
|
||||||
|
// matcher you will see the value of the referenced object but not its
|
||||||
|
// address.
|
||||||
|
//
|
||||||
|
// Explaining Match Results
|
||||||
|
// ========================
|
||||||
|
//
|
||||||
|
// Sometimes the matcher description alone isn't enough to explain why
|
||||||
|
// the match has failed or succeeded. For example, when expecting a
|
||||||
|
// long string, it can be very helpful to also print the diff between
|
||||||
|
// the expected string and the actual one. To achieve that, you can
|
||||||
|
// optionally stream additional information to a special variable
|
||||||
|
// named result_listener, whose type is a pointer to class
|
||||||
|
// MatchResultListener:
|
||||||
|
//
|
||||||
|
// MATCHER_P(EqualsLongString, str, "") {
|
||||||
|
// if (arg == str) return true;
|
||||||
|
//
|
||||||
|
// *result_listener << "the difference: "
|
||||||
|
/// << DiffStrings(str, arg);
|
||||||
|
// return false;
|
||||||
|
// }
|
||||||
|
//
|
||||||
|
// Overloading Matchers
|
||||||
|
// ====================
|
||||||
|
//
|
||||||
|
// You can overload matchers with different numbers of parameters:
|
||||||
|
//
|
||||||
|
// MATCHER_P(Blah, a, description_string1) { ... }
|
||||||
|
// MATCHER_P2(Blah, a, b, description_string2) { ... }
|
||||||
|
//
|
||||||
|
// Caveats
|
||||||
|
// =======
|
||||||
|
//
|
||||||
|
// When defining a new matcher, you should also consider implementing
|
||||||
|
// MatcherInterface or using MakePolymorphicMatcher(). These
|
||||||
|
// approaches require more work than the MATCHER* macros, but also
|
||||||
|
// give you more control on the types of the value being matched and
|
||||||
|
// the matcher parameters, which may leads to better compiler error
|
||||||
|
// messages when the matcher is used wrong. They also allow
|
||||||
|
// overloading matchers based on parameter types (as opposed to just
|
||||||
|
// based on the number of parameters).
|
||||||
|
//
|
||||||
|
// MATCHER*() can only be used in a namespace scope. The reason is
|
||||||
|
// that C++ doesn't yet allow function-local types to be used to
|
||||||
|
// instantiate templates. The up-coming C++0x standard will fix this.
|
||||||
|
// Once that's done, we'll consider supporting using MATCHER*() inside
|
||||||
|
// a function.
|
||||||
|
//
|
||||||
|
// More Information
|
||||||
|
// ================
|
||||||
|
//
|
||||||
|
// To learn more about using these macros, please search for 'MATCHER'
|
||||||
|
// on http://code.google.com/p/googlemock/wiki/CookBook.
|
||||||
|
|
||||||
|
$range i 0..n
|
||||||
|
$for i
|
||||||
|
|
||||||
|
[[
|
||||||
|
$var macro_name = [[$if i==0 [[MATCHER]] $elif i==1 [[MATCHER_P]]
|
||||||
|
$else [[MATCHER_P$i]]]]
|
||||||
|
$var class_name = [[name##Matcher[[$if i==0 [[]] $elif i==1 [[P]]
|
||||||
|
$else [[P$i]]]]]]
|
||||||
|
$range j 0..i-1
|
||||||
|
$var template = [[$if i==0 [[]] $else [[
|
||||||
|
|
||||||
|
template <$for j, [[typename p$j##_type]]>\
|
||||||
|
]]]]
|
||||||
|
$var ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]]
|
||||||
|
$var impl_ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]]
|
||||||
|
$var impl_inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(gmock_p$j)]]]]]]
|
||||||
|
$var inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(gmock_p$j)]]]]]]
|
||||||
|
$var params = [[$for j, [[p$j]]]]
|
||||||
|
$var param_types = [[$if i==0 [[]] $else [[<$for j, [[p$j##_type]]>]]]]
|
||||||
|
$var param_types_and_names = [[$for j, [[p$j##_type p$j]]]]
|
||||||
|
$var param_field_decls = [[$for j
|
||||||
|
[[
|
||||||
|
|
||||||
|
p$j##_type p$j;\
|
||||||
|
]]]]
|
||||||
|
$var param_field_decls2 = [[$for j
|
||||||
|
[[
|
||||||
|
|
||||||
|
p$j##_type p$j;\
|
||||||
|
]]]]
|
||||||
|
|
||||||
|
#define $macro_name(name$for j [[, p$j]], description)\$template
|
||||||
|
class $class_name {\
|
||||||
|
public:\
|
||||||
|
template <typename arg_type>\
|
||||||
|
class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
|
||||||
|
public:\
|
||||||
|
[[$if i==1 [[explicit ]]]]gmock_Impl($impl_ctor_param_list)\
|
||||||
|
$impl_inits {}\
|
||||||
|
virtual bool MatchAndExplain(\
|
||||||
|
arg_type arg, ::testing::MatchResultListener* result_listener) const;\
|
||||||
|
virtual void DescribeTo(::std::ostream* gmock_os) const {\
|
||||||
|
*gmock_os << FormatDescription(false);\
|
||||||
|
}\
|
||||||
|
virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
|
||||||
|
*gmock_os << FormatDescription(true);\
|
||||||
|
}\$param_field_decls
|
||||||
|
private:\
|
||||||
|
::testing::internal::string FormatDescription(bool negation) const {\
|
||||||
|
const ::testing::internal::string gmock_description = (description);\
|
||||||
|
if (!gmock_description.empty())\
|
||||||
|
return gmock_description;\
|
||||||
|
return ::testing::internal::FormatMatcherDescription(\
|
||||||
|
negation, #name,\
|
||||||
|
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
|
||||||
|
::std::tr1::tuple<$for j, [[p$j##_type]]>($for j, [[p$j]])));\
|
||||||
|
}\
|
||||||
|
GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
|
||||||
|
};\
|
||||||
|
template <typename arg_type>\
|
||||||
|
operator ::testing::Matcher<arg_type>() const {\
|
||||||
|
return ::testing::Matcher<arg_type>(\
|
||||||
|
new gmock_Impl<arg_type>($params));\
|
||||||
|
}\
|
||||||
|
$class_name($ctor_param_list)$inits {\
|
||||||
|
}\$param_field_decls2
|
||||||
|
private:\
|
||||||
|
GTEST_DISALLOW_ASSIGN_($class_name);\
|
||||||
|
};\$template
|
||||||
|
inline $class_name$param_types name($param_types_and_names) {\
|
||||||
|
return $class_name$param_types($params);\
|
||||||
|
}\$template
|
||||||
|
template <typename arg_type>\
|
||||||
|
bool $class_name$param_types::gmock_Impl<arg_type>::MatchAndExplain(\
|
||||||
|
arg_type arg,\
|
||||||
|
::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
|
||||||
|
const
|
||||||
|
]]
|
||||||
|
|
||||||
|
|
||||||
|
#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
|
|
@ -0,0 +1,274 @@
|
||||||
|
// This file was GENERATED by a script. DO NOT EDIT BY HAND!!!
|
||||||
|
|
||||||
|
// 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)
|
||||||
|
|
||||||
|
// Implements class templates NiceMock and StrictMock.
|
||||||
|
//
|
||||||
|
// Given a mock class MockFoo that is created using Google Mock,
|
||||||
|
// NiceMock<MockFoo> is a subclass of MockFoo that allows
|
||||||
|
// uninteresting calls (i.e. calls to mock methods that have no
|
||||||
|
// EXPECT_CALL specs), and StrictMock<MockFoo> is a subclass of
|
||||||
|
// MockFoo that treats all uninteresting calls as errors.
|
||||||
|
//
|
||||||
|
// NiceMock and StrictMock "inherits" the constructors of their
|
||||||
|
// respective base class, with up-to 10 arguments. Therefore you can
|
||||||
|
// write NiceMock<MockFoo>(5, "a") to construct a nice mock where
|
||||||
|
// MockFoo has a constructor that accepts (int, const char*), for
|
||||||
|
// example.
|
||||||
|
//
|
||||||
|
// A known limitation is that NiceMock<MockFoo> and
|
||||||
|
// StrictMock<MockFoo> only works for mock methods defined using the
|
||||||
|
// MOCK_METHOD* family of macros DIRECTLY in the MockFoo class. If a
|
||||||
|
// mock method is defined in a base class of MockFoo, the "nice" or
|
||||||
|
// "strict" modifier may not affect it, depending on the compiler. In
|
||||||
|
// particular, nesting NiceMock and StrictMock is NOT supported.
|
||||||
|
//
|
||||||
|
// Another known limitation is that the constructors of the base mock
|
||||||
|
// cannot have arguments passed by non-const reference, which are
|
||||||
|
// banned by the Google C++ style guide anyway.
|
||||||
|
|
||||||
|
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
|
||||||
|
#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
|
||||||
|
|
||||||
|
#include "gmock/gmock-spec-builders.h"
|
||||||
|
#include "gmock/internal/gmock-port.h"
|
||||||
|
|
||||||
|
namespace testing {
|
||||||
|
|
||||||
|
template <class MockClass>
|
||||||
|
class NiceMock : public MockClass {
|
||||||
|
public:
|
||||||
|
// We don't factor out the constructor body to a common method, as
|
||||||
|
// we have to avoid a possible clash with members of MockClass.
|
||||||
|
NiceMock() {
|
||||||
|
::testing::Mock::AllowUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
// C++ doesn't (yet) allow inheritance of constructors, so we have
|
||||||
|
// to define it for each arity.
|
||||||
|
template <typename A1>
|
||||||
|
explicit NiceMock(const A1& a1) : MockClass(a1) {
|
||||||
|
::testing::Mock::AllowUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
template <typename A1, typename A2>
|
||||||
|
NiceMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
|
||||||
|
::testing::Mock::AllowUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3>
|
||||||
|
NiceMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
|
||||||
|
::testing::Mock::AllowUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3, typename A4>
|
||||||
|
NiceMock(const A1& a1, const A2& a2, const A3& a3,
|
||||||
|
const A4& a4) : MockClass(a1, a2, a3, a4) {
|
||||||
|
::testing::Mock::AllowUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3, typename A4, typename A5>
|
||||||
|
NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
|
||||||
|
const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
|
||||||
|
::testing::Mock::AllowUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3, typename A4, typename A5,
|
||||||
|
typename A6>
|
||||||
|
NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
|
||||||
|
const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
|
||||||
|
::testing::Mock::AllowUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3, typename A4, typename A5,
|
||||||
|
typename A6, typename A7>
|
||||||
|
NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
|
||||||
|
const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
|
||||||
|
a6, a7) {
|
||||||
|
::testing::Mock::AllowUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3, typename A4, typename A5,
|
||||||
|
typename A6, typename A7, typename A8>
|
||||||
|
NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
|
||||||
|
const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
|
||||||
|
a2, a3, a4, a5, a6, a7, a8) {
|
||||||
|
::testing::Mock::AllowUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3, typename A4, typename A5,
|
||||||
|
typename A6, typename A7, typename A8, typename A9>
|
||||||
|
NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
|
||||||
|
const A5& a5, const A6& a6, const A7& a7, const A8& a8,
|
||||||
|
const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
|
||||||
|
::testing::Mock::AllowUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3, typename A4, typename A5,
|
||||||
|
typename A6, typename A7, typename A8, typename A9, typename A10>
|
||||||
|
NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
|
||||||
|
const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
|
||||||
|
const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
|
||||||
|
::testing::Mock::AllowUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
virtual ~NiceMock() {
|
||||||
|
::testing::Mock::UnregisterCallReaction(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <class MockClass>
|
||||||
|
class StrictMock : public MockClass {
|
||||||
|
public:
|
||||||
|
// We don't factor out the constructor body to a common method, as
|
||||||
|
// we have to avoid a possible clash with members of MockClass.
|
||||||
|
StrictMock() {
|
||||||
|
::testing::Mock::FailUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename A1>
|
||||||
|
explicit StrictMock(const A1& a1) : MockClass(a1) {
|
||||||
|
::testing::Mock::FailUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
template <typename A1, typename A2>
|
||||||
|
StrictMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
|
||||||
|
::testing::Mock::FailUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3>
|
||||||
|
StrictMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
|
||||||
|
::testing::Mock::FailUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3, typename A4>
|
||||||
|
StrictMock(const A1& a1, const A2& a2, const A3& a3,
|
||||||
|
const A4& a4) : MockClass(a1, a2, a3, a4) {
|
||||||
|
::testing::Mock::FailUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3, typename A4, typename A5>
|
||||||
|
StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
|
||||||
|
const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
|
||||||
|
::testing::Mock::FailUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3, typename A4, typename A5,
|
||||||
|
typename A6>
|
||||||
|
StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
|
||||||
|
const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
|
||||||
|
::testing::Mock::FailUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3, typename A4, typename A5,
|
||||||
|
typename A6, typename A7>
|
||||||
|
StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
|
||||||
|
const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
|
||||||
|
a6, a7) {
|
||||||
|
::testing::Mock::FailUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3, typename A4, typename A5,
|
||||||
|
typename A6, typename A7, typename A8>
|
||||||
|
StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
|
||||||
|
const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
|
||||||
|
a2, a3, a4, a5, a6, a7, a8) {
|
||||||
|
::testing::Mock::FailUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3, typename A4, typename A5,
|
||||||
|
typename A6, typename A7, typename A8, typename A9>
|
||||||
|
StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
|
||||||
|
const A5& a5, const A6& a6, const A7& a7, const A8& a8,
|
||||||
|
const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
|
||||||
|
::testing::Mock::FailUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3, typename A4, typename A5,
|
||||||
|
typename A6, typename A7, typename A8, typename A9, typename A10>
|
||||||
|
StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
|
||||||
|
const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
|
||||||
|
const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
|
||||||
|
::testing::Mock::FailUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
virtual ~StrictMock() {
|
||||||
|
::testing::Mock::UnregisterCallReaction(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
|
||||||
|
};
|
||||||
|
|
||||||
|
// The following specializations catch some (relatively more common)
|
||||||
|
// user errors of nesting nice and strict mocks. They do NOT catch
|
||||||
|
// all possible errors.
|
||||||
|
|
||||||
|
// These specializations are declared but not defined, as NiceMock and
|
||||||
|
// StrictMock cannot be nested.
|
||||||
|
template <typename MockClass>
|
||||||
|
class NiceMock<NiceMock<MockClass> >;
|
||||||
|
template <typename MockClass>
|
||||||
|
class NiceMock<StrictMock<MockClass> >;
|
||||||
|
template <typename MockClass>
|
||||||
|
class StrictMock<NiceMock<MockClass> >;
|
||||||
|
template <typename MockClass>
|
||||||
|
class StrictMock<StrictMock<MockClass> >;
|
||||||
|
|
||||||
|
} // namespace testing
|
||||||
|
|
||||||
|
#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
|
|
@ -0,0 +1,160 @@
|
||||||
|
$$ -*- mode: c++; -*-
|
||||||
|
$$ This is a Pump source file. Please use Pump to convert it to
|
||||||
|
$$ gmock-generated-nice-strict.h.
|
||||||
|
$$
|
||||||
|
$var n = 10 $$ The maximum arity we 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)
|
||||||
|
|
||||||
|
// Implements class templates NiceMock and StrictMock.
|
||||||
|
//
|
||||||
|
// Given a mock class MockFoo that is created using Google Mock,
|
||||||
|
// NiceMock<MockFoo> is a subclass of MockFoo that allows
|
||||||
|
// uninteresting calls (i.e. calls to mock methods that have no
|
||||||
|
// EXPECT_CALL specs), and StrictMock<MockFoo> is a subclass of
|
||||||
|
// MockFoo that treats all uninteresting calls as errors.
|
||||||
|
//
|
||||||
|
// NiceMock and StrictMock "inherits" the constructors of their
|
||||||
|
// respective base class, with up-to $n arguments. Therefore you can
|
||||||
|
// write NiceMock<MockFoo>(5, "a") to construct a nice mock where
|
||||||
|
// MockFoo has a constructor that accepts (int, const char*), for
|
||||||
|
// example.
|
||||||
|
//
|
||||||
|
// A known limitation is that NiceMock<MockFoo> and
|
||||||
|
// StrictMock<MockFoo> only works for mock methods defined using the
|
||||||
|
// MOCK_METHOD* family of macros DIRECTLY in the MockFoo class. If a
|
||||||
|
// mock method is defined in a base class of MockFoo, the "nice" or
|
||||||
|
// "strict" modifier may not affect it, depending on the compiler. In
|
||||||
|
// particular, nesting NiceMock and StrictMock is NOT supported.
|
||||||
|
//
|
||||||
|
// Another known limitation is that the constructors of the base mock
|
||||||
|
// cannot have arguments passed by non-const reference, which are
|
||||||
|
// banned by the Google C++ style guide anyway.
|
||||||
|
|
||||||
|
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
|
||||||
|
#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
|
||||||
|
|
||||||
|
#include "gmock/gmock-spec-builders.h"
|
||||||
|
#include "gmock/internal/gmock-port.h"
|
||||||
|
|
||||||
|
namespace testing {
|
||||||
|
|
||||||
|
template <class MockClass>
|
||||||
|
class NiceMock : public MockClass {
|
||||||
|
public:
|
||||||
|
// We don't factor out the constructor body to a common method, as
|
||||||
|
// we have to avoid a possible clash with members of MockClass.
|
||||||
|
NiceMock() {
|
||||||
|
::testing::Mock::AllowUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
// C++ doesn't (yet) allow inheritance of constructors, so we have
|
||||||
|
// to define it for each arity.
|
||||||
|
template <typename A1>
|
||||||
|
explicit NiceMock(const A1& a1) : MockClass(a1) {
|
||||||
|
::testing::Mock::AllowUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
$range i 2..n
|
||||||
|
$for i [[
|
||||||
|
$range j 1..i
|
||||||
|
template <$for j, [[typename A$j]]>
|
||||||
|
NiceMock($for j, [[const A$j& a$j]]) : MockClass($for j, [[a$j]]) {
|
||||||
|
::testing::Mock::AllowUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
]]
|
||||||
|
virtual ~NiceMock() {
|
||||||
|
::testing::Mock::UnregisterCallReaction(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <class MockClass>
|
||||||
|
class StrictMock : public MockClass {
|
||||||
|
public:
|
||||||
|
// We don't factor out the constructor body to a common method, as
|
||||||
|
// we have to avoid a possible clash with members of MockClass.
|
||||||
|
StrictMock() {
|
||||||
|
::testing::Mock::FailUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename A1>
|
||||||
|
explicit StrictMock(const A1& a1) : MockClass(a1) {
|
||||||
|
::testing::Mock::FailUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
$for i [[
|
||||||
|
$range j 1..i
|
||||||
|
template <$for j, [[typename A$j]]>
|
||||||
|
StrictMock($for j, [[const A$j& a$j]]) : MockClass($for j, [[a$j]]) {
|
||||||
|
::testing::Mock::FailUninterestingCalls(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
]]
|
||||||
|
virtual ~StrictMock() {
|
||||||
|
::testing::Mock::UnregisterCallReaction(
|
||||||
|
internal::ImplicitCast_<MockClass*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
|
||||||
|
};
|
||||||
|
|
||||||
|
// The following specializations catch some (relatively more common)
|
||||||
|
// user errors of nesting nice and strict mocks. They do NOT catch
|
||||||
|
// all possible errors.
|
||||||
|
|
||||||
|
// These specializations are declared but not defined, as NiceMock and
|
||||||
|
// StrictMock cannot be nested.
|
||||||
|
template <typename MockClass>
|
||||||
|
class NiceMock<NiceMock<MockClass> >;
|
||||||
|
template <typename MockClass>
|
||||||
|
class NiceMock<StrictMock<MockClass> >;
|
||||||
|
template <typename MockClass>
|
||||||
|
class StrictMock<NiceMock<MockClass> >;
|
||||||
|
template <typename MockClass>
|
||||||
|
class StrictMock<StrictMock<MockClass> >;
|
||||||
|
|
||||||
|
} // namespace testing
|
||||||
|
|
||||||
|
#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,233 @@
|
||||||
|
// 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 Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file implements some actions that depend on gmock-generated-actions.h.
|
||||||
|
|
||||||
|
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
|
||||||
|
#define GMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
|
#include "gmock/gmock-generated-actions.h"
|
||||||
|
|
||||||
|
namespace testing {
|
||||||
|
namespace internal {
|
||||||
|
|
||||||
|
// Implements the Invoke(f) action. The template argument
|
||||||
|
// FunctionImpl is the implementation type of f, which can be either a
|
||||||
|
// function pointer or a functor. Invoke(f) can be used as an
|
||||||
|
// Action<F> as long as f's type is compatible with F (i.e. f can be
|
||||||
|
// assigned to a tr1::function<F>).
|
||||||
|
template <typename FunctionImpl>
|
||||||
|
class InvokeAction {
|
||||||
|
public:
|
||||||
|
// The c'tor makes a copy of function_impl (either a function
|
||||||
|
// pointer or a functor).
|
||||||
|
explicit InvokeAction(FunctionImpl function_impl)
|
||||||
|
: function_impl_(function_impl) {}
|
||||||
|
|
||||||
|
template <typename Result, typename ArgumentTuple>
|
||||||
|
Result Perform(const ArgumentTuple& args) {
|
||||||
|
return InvokeHelper<Result, ArgumentTuple>::Invoke(function_impl_, args);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
FunctionImpl function_impl_;
|
||||||
|
|
||||||
|
GTEST_DISALLOW_ASSIGN_(InvokeAction);
|
||||||
|
};
|
||||||
|
|
||||||
|
// Implements the Invoke(object_ptr, &Class::Method) action.
|
||||||
|
template <class Class, typename MethodPtr>
|
||||||
|
class InvokeMethodAction {
|
||||||
|
public:
|
||||||
|
InvokeMethodAction(Class* obj_ptr, MethodPtr method_ptr)
|
||||||
|
: obj_ptr_(obj_ptr), method_ptr_(method_ptr) {}
|
||||||
|
|
||||||
|
template <typename Result, typename ArgumentTuple>
|
||||||
|
Result Perform(const ArgumentTuple& args) const {
|
||||||
|
return InvokeHelper<Result, ArgumentTuple>::InvokeMethod(
|
||||||
|
obj_ptr_, method_ptr_, args);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
Class* const obj_ptr_;
|
||||||
|
const MethodPtr method_ptr_;
|
||||||
|
|
||||||
|
GTEST_DISALLOW_ASSIGN_(InvokeMethodAction);
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace internal
|
||||||
|
|
||||||
|
// Various overloads for Invoke().
|
||||||
|
|
||||||
|
// Creates an action that invokes 'function_impl' with the mock
|
||||||
|
// function's arguments.
|
||||||
|
template <typename FunctionImpl>
|
||||||
|
PolymorphicAction<internal::InvokeAction<FunctionImpl> > Invoke(
|
||||||
|
FunctionImpl function_impl) {
|
||||||
|
return MakePolymorphicAction(
|
||||||
|
internal::InvokeAction<FunctionImpl>(function_impl));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Creates an action that invokes the given method on the given object
|
||||||
|
// with the mock function's arguments.
|
||||||
|
template <class Class, typename MethodPtr>
|
||||||
|
PolymorphicAction<internal::InvokeMethodAction<Class, MethodPtr> > Invoke(
|
||||||
|
Class* obj_ptr, MethodPtr method_ptr) {
|
||||||
|
return MakePolymorphicAction(
|
||||||
|
internal::InvokeMethodAction<Class, MethodPtr>(obj_ptr, method_ptr));
|
||||||
|
}
|
||||||
|
|
||||||
|
// WithoutArgs(inner_action) can be used in a mock function with a
|
||||||
|
// non-empty argument list to perform inner_action, which takes no
|
||||||
|
// argument. In other words, it adapts an action accepting no
|
||||||
|
// argument to one that accepts (and ignores) arguments.
|
||||||
|
template <typename InnerAction>
|
||||||
|
inline internal::WithArgsAction<InnerAction>
|
||||||
|
WithoutArgs(const InnerAction& action) {
|
||||||
|
return internal::WithArgsAction<InnerAction>(action);
|
||||||
|
}
|
||||||
|
|
||||||
|
// WithArg<k>(an_action) creates an action that passes the k-th
|
||||||
|
// (0-based) argument of the mock function to an_action and performs
|
||||||
|
// it. It adapts an action accepting one argument to one that accepts
|
||||||
|
// multiple arguments. For convenience, we also provide
|
||||||
|
// WithArgs<k>(an_action) (defined below) as a synonym.
|
||||||
|
template <int k, typename InnerAction>
|
||||||
|
inline internal::WithArgsAction<InnerAction, k>
|
||||||
|
WithArg(const InnerAction& action) {
|
||||||
|
return internal::WithArgsAction<InnerAction, k>(action);
|
||||||
|
}
|
||||||
|
|
||||||
|
// The ACTION*() macros trigger warning C4100 (unreferenced formal
|
||||||
|
// parameter) in MSVC with -W4. Unfortunately they cannot be fixed in
|
||||||
|
// the macro definition, as the warnings are generated when the macro
|
||||||
|
// is expanded and macro expansion cannot contain #pragma. Therefore
|
||||||
|
// we suppress them here.
|
||||||
|
#ifdef _MSC_VER
|
||||||
|
# pragma warning(push)
|
||||||
|
# pragma warning(disable:4100)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// Action ReturnArg<k>() returns the k-th argument of the mock function.
|
||||||
|
ACTION_TEMPLATE(ReturnArg,
|
||||||
|
HAS_1_TEMPLATE_PARAMS(int, k),
|
||||||
|
AND_0_VALUE_PARAMS()) {
|
||||||
|
return std::tr1::get<k>(args);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Action SaveArg<k>(pointer) saves the k-th (0-based) argument of the
|
||||||
|
// mock function to *pointer.
|
||||||
|
ACTION_TEMPLATE(SaveArg,
|
||||||
|
HAS_1_TEMPLATE_PARAMS(int, k),
|
||||||
|
AND_1_VALUE_PARAMS(pointer)) {
|
||||||
|
*pointer = ::std::tr1::get<k>(args);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Action SaveArgPointee<k>(pointer) saves the value pointed to
|
||||||
|
// by the k-th (0-based) argument of the mock function to *pointer.
|
||||||
|
ACTION_TEMPLATE(SaveArgPointee,
|
||||||
|
HAS_1_TEMPLATE_PARAMS(int, k),
|
||||||
|
AND_1_VALUE_PARAMS(pointer)) {
|
||||||
|
*pointer = *::std::tr1::get<k>(args);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Action SetArgReferee<k>(value) assigns 'value' to the variable
|
||||||
|
// referenced by the k-th (0-based) argument of the mock function.
|
||||||
|
ACTION_TEMPLATE(SetArgReferee,
|
||||||
|
HAS_1_TEMPLATE_PARAMS(int, k),
|
||||||
|
AND_1_VALUE_PARAMS(value)) {
|
||||||
|
typedef typename ::std::tr1::tuple_element<k, args_type>::type argk_type;
|
||||||
|
// Ensures that argument #k is a reference. If you get a compiler
|
||||||
|
// error on the next line, you are using SetArgReferee<k>(value) in
|
||||||
|
// a mock function whose k-th (0-based) argument is not a reference.
|
||||||
|
GTEST_COMPILE_ASSERT_(internal::is_reference<argk_type>::value,
|
||||||
|
SetArgReferee_must_be_used_with_a_reference_argument);
|
||||||
|
::std::tr1::get<k>(args) = value;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Action SetArrayArgument<k>(first, last) copies the elements in
|
||||||
|
// source range [first, last) to the array pointed to by the k-th
|
||||||
|
// (0-based) argument, which can be either a pointer or an
|
||||||
|
// iterator. The action does not take ownership of the elements in the
|
||||||
|
// source range.
|
||||||
|
ACTION_TEMPLATE(SetArrayArgument,
|
||||||
|
HAS_1_TEMPLATE_PARAMS(int, k),
|
||||||
|
AND_2_VALUE_PARAMS(first, last)) {
|
||||||
|
// Microsoft compiler deprecates ::std::copy, so we want to suppress warning
|
||||||
|
// 4996 (Function call with parameters that may be unsafe) there.
|
||||||
|
#ifdef _MSC_VER
|
||||||
|
# pragma warning(push) // Saves the current warning state.
|
||||||
|
# pragma warning(disable:4996) // Temporarily disables warning 4996.
|
||||||
|
#endif
|
||||||
|
::std::copy(first, last, ::std::tr1::get<k>(args));
|
||||||
|
#ifdef _MSC_VER
|
||||||
|
# pragma warning(pop) // Restores the warning state.
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
// Action DeleteArg<k>() deletes the k-th (0-based) argument of the mock
|
||||||
|
// function.
|
||||||
|
ACTION_TEMPLATE(DeleteArg,
|
||||||
|
HAS_1_TEMPLATE_PARAMS(int, k),
|
||||||
|
AND_0_VALUE_PARAMS()) {
|
||||||
|
delete ::std::tr1::get<k>(args);
|
||||||
|
}
|
||||||
|
|
||||||
|
// This action returns the value pointed to by 'pointer'.
|
||||||
|
ACTION_P(ReturnPointee, pointer) { return *pointer; }
|
||||||
|
|
||||||
|
// Action Throw(exception) can be used in a mock function of any type
|
||||||
|
// to throw the given exception. Any copyable value can be thrown.
|
||||||
|
#if GTEST_HAS_EXCEPTIONS
|
||||||
|
|
||||||
|
// Suppresses the 'unreachable code' warning that VC generates in opt modes.
|
||||||
|
# ifdef _MSC_VER
|
||||||
|
# pragma warning(push) // Saves the current warning state.
|
||||||
|
# pragma warning(disable:4702) // Temporarily disables warning 4702.
|
||||||
|
# endif
|
||||||
|
ACTION_P(Throw, exception) { throw exception; }
|
||||||
|
# ifdef _MSC_VER
|
||||||
|
# pragma warning(pop) // Restores the warning state.
|
||||||
|
# endif
|
||||||
|
|
||||||
|
#endif // GTEST_HAS_EXCEPTIONS
|
||||||
|
|
||||||
|
#ifdef _MSC_VER
|
||||||
|
# pragma warning(pop)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
} // namespace testing
|
||||||
|
|
||||||
|
#endif // GMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,93 @@
|
||||||
|
// 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 Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This is the main header file a user should include.
|
||||||
|
|
||||||
|
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_H_
|
||||||
|
#define GMOCK_INCLUDE_GMOCK_GMOCK_H_
|
||||||
|
|
||||||
|
// This file implements the following syntax:
|
||||||
|
//
|
||||||
|
// ON_CALL(mock_object.Method(...))
|
||||||
|
// .With(...) ?
|
||||||
|
// .WillByDefault(...);
|
||||||
|
//
|
||||||
|
// where With() is optional and WillByDefault() must appear exactly
|
||||||
|
// once.
|
||||||
|
//
|
||||||
|
// EXPECT_CALL(mock_object.Method(...))
|
||||||
|
// .With(...) ?
|
||||||
|
// .Times(...) ?
|
||||||
|
// .InSequence(...) *
|
||||||
|
// .WillOnce(...) *
|
||||||
|
// .WillRepeatedly(...) ?
|
||||||
|
// .RetiresOnSaturation() ? ;
|
||||||
|
//
|
||||||
|
// where all clauses are optional and WillOnce() can be repeated.
|
||||||
|
|
||||||
|
#include "gmock/gmock-actions.h"
|
||||||
|
#include "gmock/gmock-cardinalities.h"
|
||||||
|
#include "gmock/gmock-generated-actions.h"
|
||||||
|
#include "gmock/gmock-generated-function-mockers.h"
|
||||||
|
#include "gmock/gmock-generated-matchers.h"
|
||||||
|
#include "gmock/gmock-more-actions.h"
|
||||||
|
#include "gmock/gmock-generated-nice-strict.h"
|
||||||
|
#include "gmock/gmock-matchers.h"
|
||||||
|
#include "gmock/internal/gmock-internal-utils.h"
|
||||||
|
|
||||||
|
namespace testing {
|
||||||
|
|
||||||
|
// Declares Google Mock flags that we want a user to use programmatically.
|
||||||
|
GMOCK_DECLARE_bool_(catch_leaked_mocks);
|
||||||
|
GMOCK_DECLARE_string_(verbose);
|
||||||
|
|
||||||
|
// Initializes Google Mock. This must be called before running the
|
||||||
|
// tests. In particular, it parses the command line for the flags
|
||||||
|
// that Google Mock recognizes. Whenever a Google Mock flag is seen,
|
||||||
|
// it is removed from argv, and *argc is decremented.
|
||||||
|
//
|
||||||
|
// No value is returned. Instead, the Google Mock flag variables are
|
||||||
|
// updated.
|
||||||
|
//
|
||||||
|
// Since Google Test is needed for Google Mock to work, this function
|
||||||
|
// also initializes Google Test and parses its flags, if that hasn't
|
||||||
|
// been done.
|
||||||
|
void InitGoogleMock(int* argc, char** argv);
|
||||||
|
|
||||||
|
// This overloaded version can be used in Windows programs compiled in
|
||||||
|
// UNICODE mode.
|
||||||
|
void InitGoogleMock(int* argc, wchar_t** argv);
|
||||||
|
|
||||||
|
} // namespace testing
|
||||||
|
|
||||||
|
#endif // GMOCK_INCLUDE_GMOCK_GMOCK_H_
|
|
@ -0,0 +1,277 @@
|
||||||
|
// This file was GENERATED by a script. DO NOT EDIT BY HAND!!!
|
||||||
|
|
||||||
|
// 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 Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file contains template meta-programming utility classes needed
|
||||||
|
// for implementing Google Mock.
|
||||||
|
|
||||||
|
#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
|
||||||
|
#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
|
||||||
|
|
||||||
|
#include "gmock/internal/gmock-port.h"
|
||||||
|
|
||||||
|
namespace testing {
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
class Matcher;
|
||||||
|
|
||||||
|
namespace internal {
|
||||||
|
|
||||||
|
// An IgnoredValue object can be implicitly constructed from ANY value.
|
||||||
|
// This is used in implementing the IgnoreResult(a) action.
|
||||||
|
class IgnoredValue {
|
||||||
|
public:
|
||||||
|
// This constructor template allows any value to be implicitly
|
||||||
|
// converted to IgnoredValue. The object has no data member and
|
||||||
|
// doesn't try to remember anything about the argument. We
|
||||||
|
// deliberately omit the 'explicit' keyword in order to allow the
|
||||||
|
// conversion to be implicit.
|
||||||
|
template <typename T>
|
||||||
|
IgnoredValue(const T&) {}
|
||||||
|
};
|
||||||
|
|
||||||
|
// MatcherTuple<T>::type is a tuple type where each field is a Matcher
|
||||||
|
// for the corresponding field in tuple type T.
|
||||||
|
template <typename Tuple>
|
||||||
|
struct MatcherTuple;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
struct MatcherTuple< ::std::tr1::tuple<> > {
|
||||||
|
typedef ::std::tr1::tuple< > type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename A1>
|
||||||
|
struct MatcherTuple< ::std::tr1::tuple<A1> > {
|
||||||
|
typedef ::std::tr1::tuple<Matcher<A1> > type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename A1, typename A2>
|
||||||
|
struct MatcherTuple< ::std::tr1::tuple<A1, A2> > {
|
||||||
|
typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2> > type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3>
|
||||||
|
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3> > {
|
||||||
|
typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3> > type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3, typename A4>
|
||||||
|
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3, A4> > {
|
||||||
|
typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>,
|
||||||
|
Matcher<A4> > type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3, typename A4, typename A5>
|
||||||
|
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3, A4, A5> > {
|
||||||
|
typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
|
||||||
|
Matcher<A5> > type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3, typename A4, typename A5,
|
||||||
|
typename A6>
|
||||||
|
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3, A4, A5, A6> > {
|
||||||
|
typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
|
||||||
|
Matcher<A5>, Matcher<A6> > type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3, typename A4, typename A5,
|
||||||
|
typename A6, typename A7>
|
||||||
|
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7> > {
|
||||||
|
typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
|
||||||
|
Matcher<A5>, Matcher<A6>, Matcher<A7> > type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3, typename A4, typename A5,
|
||||||
|
typename A6, typename A7, typename A8>
|
||||||
|
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8> > {
|
||||||
|
typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
|
||||||
|
Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8> > type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3, typename A4, typename A5,
|
||||||
|
typename A6, typename A7, typename A8, typename A9>
|
||||||
|
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> > {
|
||||||
|
typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
|
||||||
|
Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8>, Matcher<A9> > type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename A1, typename A2, typename A3, typename A4, typename A5,
|
||||||
|
typename A6, typename A7, typename A8, typename A9, typename A10>
|
||||||
|
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
|
||||||
|
A10> > {
|
||||||
|
typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
|
||||||
|
Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8>, Matcher<A9>,
|
||||||
|
Matcher<A10> > type;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Template struct Function<F>, where F must be a function type, contains
|
||||||
|
// the following typedefs:
|
||||||
|
//
|
||||||
|
// Result: the function's return type.
|
||||||
|
// ArgumentN: the type of the N-th argument, where N starts with 1.
|
||||||
|
// ArgumentTuple: the tuple type consisting of all parameters of F.
|
||||||
|
// ArgumentMatcherTuple: the tuple type consisting of Matchers for all
|
||||||
|
// parameters of F.
|
||||||
|
// MakeResultVoid: the function type obtained by substituting void
|
||||||
|
// for the return type of F.
|
||||||
|
// MakeResultIgnoredValue:
|
||||||
|
// the function type obtained by substituting Something
|
||||||
|
// for the return type of F.
|
||||||
|
template <typename F>
|
||||||
|
struct Function;
|
||||||
|
|
||||||
|
template <typename R>
|
||||||
|
struct Function<R()> {
|
||||||
|
typedef R Result;
|
||||||
|
typedef ::std::tr1::tuple<> ArgumentTuple;
|
||||||
|
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
|
||||||
|
typedef void MakeResultVoid();
|
||||||
|
typedef IgnoredValue MakeResultIgnoredValue();
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1>
|
||||||
|
struct Function<R(A1)>
|
||||||
|
: Function<R()> {
|
||||||
|
typedef A1 Argument1;
|
||||||
|
typedef ::std::tr1::tuple<A1> ArgumentTuple;
|
||||||
|
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
|
||||||
|
typedef void MakeResultVoid(A1);
|
||||||
|
typedef IgnoredValue MakeResultIgnoredValue(A1);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2>
|
||||||
|
struct Function<R(A1, A2)>
|
||||||
|
: Function<R(A1)> {
|
||||||
|
typedef A2 Argument2;
|
||||||
|
typedef ::std::tr1::tuple<A1, A2> ArgumentTuple;
|
||||||
|
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
|
||||||
|
typedef void MakeResultVoid(A1, A2);
|
||||||
|
typedef IgnoredValue MakeResultIgnoredValue(A1, A2);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2, typename A3>
|
||||||
|
struct Function<R(A1, A2, A3)>
|
||||||
|
: Function<R(A1, A2)> {
|
||||||
|
typedef A3 Argument3;
|
||||||
|
typedef ::std::tr1::tuple<A1, A2, A3> ArgumentTuple;
|
||||||
|
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
|
||||||
|
typedef void MakeResultVoid(A1, A2, A3);
|
||||||
|
typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2, typename A3, typename A4>
|
||||||
|
struct Function<R(A1, A2, A3, A4)>
|
||||||
|
: Function<R(A1, A2, A3)> {
|
||||||
|
typedef A4 Argument4;
|
||||||
|
typedef ::std::tr1::tuple<A1, A2, A3, A4> ArgumentTuple;
|
||||||
|
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
|
||||||
|
typedef void MakeResultVoid(A1, A2, A3, A4);
|
||||||
|
typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2, typename A3, typename A4,
|
||||||
|
typename A5>
|
||||||
|
struct Function<R(A1, A2, A3, A4, A5)>
|
||||||
|
: Function<R(A1, A2, A3, A4)> {
|
||||||
|
typedef A5 Argument5;
|
||||||
|
typedef ::std::tr1::tuple<A1, A2, A3, A4, A5> ArgumentTuple;
|
||||||
|
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
|
||||||
|
typedef void MakeResultVoid(A1, A2, A3, A4, A5);
|
||||||
|
typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2, typename A3, typename A4,
|
||||||
|
typename A5, typename A6>
|
||||||
|
struct Function<R(A1, A2, A3, A4, A5, A6)>
|
||||||
|
: Function<R(A1, A2, A3, A4, A5)> {
|
||||||
|
typedef A6 Argument6;
|
||||||
|
typedef ::std::tr1::tuple<A1, A2, A3, A4, A5, A6> ArgumentTuple;
|
||||||
|
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
|
||||||
|
typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6);
|
||||||
|
typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2, typename A3, typename A4,
|
||||||
|
typename A5, typename A6, typename A7>
|
||||||
|
struct Function<R(A1, A2, A3, A4, A5, A6, A7)>
|
||||||
|
: Function<R(A1, A2, A3, A4, A5, A6)> {
|
||||||
|
typedef A7 Argument7;
|
||||||
|
typedef ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7> ArgumentTuple;
|
||||||
|
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
|
||||||
|
typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7);
|
||||||
|
typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2, typename A3, typename A4,
|
||||||
|
typename A5, typename A6, typename A7, typename A8>
|
||||||
|
struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8)>
|
||||||
|
: Function<R(A1, A2, A3, A4, A5, A6, A7)> {
|
||||||
|
typedef A8 Argument8;
|
||||||
|
typedef ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8> ArgumentTuple;
|
||||||
|
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
|
||||||
|
typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8);
|
||||||
|
typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2, typename A3, typename A4,
|
||||||
|
typename A5, typename A6, typename A7, typename A8, typename A9>
|
||||||
|
struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
|
||||||
|
: Function<R(A1, A2, A3, A4, A5, A6, A7, A8)> {
|
||||||
|
typedef A9 Argument9;
|
||||||
|
typedef ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> ArgumentTuple;
|
||||||
|
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
|
||||||
|
typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8, A9);
|
||||||
|
typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8,
|
||||||
|
A9);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2, typename A3, typename A4,
|
||||||
|
typename A5, typename A6, typename A7, typename A8, typename A9,
|
||||||
|
typename A10>
|
||||||
|
struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
|
||||||
|
: Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
|
||||||
|
typedef A10 Argument10;
|
||||||
|
typedef ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
|
||||||
|
A10> ArgumentTuple;
|
||||||
|
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
|
||||||
|
typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
|
||||||
|
typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8,
|
||||||
|
A9, A10);
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace internal
|
||||||
|
|
||||||
|
} // namespace testing
|
||||||
|
|
||||||
|
#endif // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
|
|
@ -0,0 +1,136 @@
|
||||||
|
$$ -*- mode: c++; -*-
|
||||||
|
$$ This is a Pump source file. Please use Pump to convert it to
|
||||||
|
$$ gmock-generated-function-mockers.h.
|
||||||
|
$$
|
||||||
|
$var n = 10 $$ The maximum arity we support.
|
||||||
|
// 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 Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file contains template meta-programming utility classes needed
|
||||||
|
// for implementing Google Mock.
|
||||||
|
|
||||||
|
#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
|
||||||
|
#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
|
||||||
|
|
||||||
|
#include "gmock/internal/gmock-port.h"
|
||||||
|
|
||||||
|
namespace testing {
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
class Matcher;
|
||||||
|
|
||||||
|
namespace internal {
|
||||||
|
|
||||||
|
// An IgnoredValue object can be implicitly constructed from ANY value.
|
||||||
|
// This is used in implementing the IgnoreResult(a) action.
|
||||||
|
class IgnoredValue {
|
||||||
|
public:
|
||||||
|
// This constructor template allows any value to be implicitly
|
||||||
|
// converted to IgnoredValue. The object has no data member and
|
||||||
|
// doesn't try to remember anything about the argument. We
|
||||||
|
// deliberately omit the 'explicit' keyword in order to allow the
|
||||||
|
// conversion to be implicit.
|
||||||
|
template <typename T>
|
||||||
|
IgnoredValue(const T&) {}
|
||||||
|
};
|
||||||
|
|
||||||
|
// MatcherTuple<T>::type is a tuple type where each field is a Matcher
|
||||||
|
// for the corresponding field in tuple type T.
|
||||||
|
template <typename Tuple>
|
||||||
|
struct MatcherTuple;
|
||||||
|
|
||||||
|
|
||||||
|
$range i 0..n
|
||||||
|
$for i [[
|
||||||
|
$range j 1..i
|
||||||
|
$var typename_As = [[$for j, [[typename A$j]]]]
|
||||||
|
$var As = [[$for j, [[A$j]]]]
|
||||||
|
$var matcher_As = [[$for j, [[Matcher<A$j>]]]]
|
||||||
|
template <$typename_As>
|
||||||
|
struct MatcherTuple< ::std::tr1::tuple<$As> > {
|
||||||
|
typedef ::std::tr1::tuple<$matcher_As > type;
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
]]
|
||||||
|
// Template struct Function<F>, where F must be a function type, contains
|
||||||
|
// the following typedefs:
|
||||||
|
//
|
||||||
|
// Result: the function's return type.
|
||||||
|
// ArgumentN: the type of the N-th argument, where N starts with 1.
|
||||||
|
// ArgumentTuple: the tuple type consisting of all parameters of F.
|
||||||
|
// ArgumentMatcherTuple: the tuple type consisting of Matchers for all
|
||||||
|
// parameters of F.
|
||||||
|
// MakeResultVoid: the function type obtained by substituting void
|
||||||
|
// for the return type of F.
|
||||||
|
// MakeResultIgnoredValue:
|
||||||
|
// the function type obtained by substituting Something
|
||||||
|
// for the return type of F.
|
||||||
|
template <typename F>
|
||||||
|
struct Function;
|
||||||
|
|
||||||
|
template <typename R>
|
||||||
|
struct Function<R()> {
|
||||||
|
typedef R Result;
|
||||||
|
typedef ::std::tr1::tuple<> ArgumentTuple;
|
||||||
|
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
|
||||||
|
typedef void MakeResultVoid();
|
||||||
|
typedef IgnoredValue MakeResultIgnoredValue();
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
$range i 1..n
|
||||||
|
$for i [[
|
||||||
|
$range j 1..i
|
||||||
|
$var typename_As = [[$for j [[, typename A$j]]]]
|
||||||
|
$var As = [[$for j, [[A$j]]]]
|
||||||
|
$var matcher_As = [[$for j, [[Matcher<A$j>]]]]
|
||||||
|
$range k 1..i-1
|
||||||
|
$var prev_As = [[$for k, [[A$k]]]]
|
||||||
|
template <typename R$typename_As>
|
||||||
|
struct Function<R($As)>
|
||||||
|
: Function<R($prev_As)> {
|
||||||
|
typedef A$i Argument$i;
|
||||||
|
typedef ::std::tr1::tuple<$As> ArgumentTuple;
|
||||||
|
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
|
||||||
|
typedef void MakeResultVoid($As);
|
||||||
|
typedef IgnoredValue MakeResultIgnoredValue($As);
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
]]
|
||||||
|
} // namespace internal
|
||||||
|
|
||||||
|
} // namespace testing
|
||||||
|
|
||||||
|
#endif // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
|
|
@ -0,0 +1,463 @@
|
||||||
|
// 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 Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file defines some utilities useful for implementing Google
|
||||||
|
// Mock. They are subject to change without notice, so please DO NOT
|
||||||
|
// USE THEM IN USER CODE.
|
||||||
|
|
||||||
|
#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
|
||||||
|
#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <ostream> // NOLINT
|
||||||
|
#include <string>
|
||||||
|
|
||||||
|
#include "gmock/internal/gmock-generated-internal-utils.h"
|
||||||
|
#include "gmock/internal/gmock-port.h"
|
||||||
|
#include "gtest/gtest.h"
|
||||||
|
|
||||||
|
namespace testing {
|
||||||
|
namespace internal {
|
||||||
|
|
||||||
|
// Converts an identifier name to a space-separated list of lower-case
|
||||||
|
// words. Each maximum substring of the form [A-Za-z][a-z]*|\d+ is
|
||||||
|
// treated as one word. For example, both "FooBar123" and
|
||||||
|
// "foo_bar_123" are converted to "foo bar 123".
|
||||||
|
string ConvertIdentifierNameToWords(const char* id_name);
|
||||||
|
|
||||||
|
// PointeeOf<Pointer>::type is the type of a value pointed to by a
|
||||||
|
// Pointer, which can be either a smart pointer or a raw pointer. The
|
||||||
|
// following default implementation is for the case where Pointer is a
|
||||||
|
// smart pointer.
|
||||||
|
template <typename Pointer>
|
||||||
|
struct PointeeOf {
|
||||||
|
// Smart pointer classes define type element_type as the type of
|
||||||
|
// their pointees.
|
||||||
|
typedef typename Pointer::element_type type;
|
||||||
|
};
|
||||||
|
// This specialization is for the raw pointer case.
|
||||||
|
template <typename T>
|
||||||
|
struct PointeeOf<T*> { typedef T type; }; // NOLINT
|
||||||
|
|
||||||
|
// GetRawPointer(p) returns the raw pointer underlying p when p is a
|
||||||
|
// smart pointer, or returns p itself when p is already a raw pointer.
|
||||||
|
// The following default implementation is for the smart pointer case.
|
||||||
|
template <typename Pointer>
|
||||||
|
inline typename Pointer::element_type* GetRawPointer(const Pointer& p) {
|
||||||
|
return p.get();
|
||||||
|
}
|
||||||
|
// This overloaded version is for the raw pointer case.
|
||||||
|
template <typename Element>
|
||||||
|
inline Element* GetRawPointer(Element* p) { return p; }
|
||||||
|
|
||||||
|
// This comparator allows linked_ptr to be stored in sets.
|
||||||
|
template <typename T>
|
||||||
|
struct LinkedPtrLessThan {
|
||||||
|
bool operator()(const ::testing::internal::linked_ptr<T>& lhs,
|
||||||
|
const ::testing::internal::linked_ptr<T>& rhs) const {
|
||||||
|
return lhs.get() < rhs.get();
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
// Symbian compilation can be done with wchar_t being either a native
|
||||||
|
// type or a typedef. Using Google Mock with OpenC without wchar_t
|
||||||
|
// should require the definition of _STLP_NO_WCHAR_T.
|
||||||
|
//
|
||||||
|
// MSVC treats wchar_t as a native type usually, but treats it as the
|
||||||
|
// same as unsigned short when the compiler option /Zc:wchar_t- is
|
||||||
|
// specified. It defines _NATIVE_WCHAR_T_DEFINED symbol when wchar_t
|
||||||
|
// is a native type.
|
||||||
|
#if (GTEST_OS_SYMBIAN && defined(_STLP_NO_WCHAR_T)) || \
|
||||||
|
(defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED))
|
||||||
|
// wchar_t is a typedef.
|
||||||
|
#else
|
||||||
|
# define GMOCK_WCHAR_T_IS_NATIVE_ 1
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// signed wchar_t and unsigned wchar_t are NOT in the C++ standard.
|
||||||
|
// Using them is a bad practice and not portable. So DON'T use them.
|
||||||
|
//
|
||||||
|
// Still, Google Mock is designed to work even if the user uses signed
|
||||||
|
// wchar_t or unsigned wchar_t (obviously, assuming the compiler
|
||||||
|
// supports them).
|
||||||
|
//
|
||||||
|
// To gcc,
|
||||||
|
// wchar_t == signed wchar_t != unsigned wchar_t == unsigned int
|
||||||
|
#ifdef __GNUC__
|
||||||
|
// signed/unsigned wchar_t are valid types.
|
||||||
|
# define GMOCK_HAS_SIGNED_WCHAR_T_ 1
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// In what follows, we use the term "kind" to indicate whether a type
|
||||||
|
// is bool, an integer type (excluding bool), a floating-point type,
|
||||||
|
// or none of them. This categorization is useful for determining
|
||||||
|
// when a matcher argument type can be safely converted to another
|
||||||
|
// type in the implementation of SafeMatcherCast.
|
||||||
|
enum TypeKind {
|
||||||
|
kBool, kInteger, kFloatingPoint, kOther
|
||||||
|
};
|
||||||
|
|
||||||
|
// KindOf<T>::value is the kind of type T.
|
||||||
|
template <typename T> struct KindOf {
|
||||||
|
enum { value = kOther }; // The default kind.
|
||||||
|
};
|
||||||
|
|
||||||
|
// This macro declares that the kind of 'type' is 'kind'.
|
||||||
|
#define GMOCK_DECLARE_KIND_(type, kind) \
|
||||||
|
template <> struct KindOf<type> { enum { value = kind }; }
|
||||||
|
|
||||||
|
GMOCK_DECLARE_KIND_(bool, kBool);
|
||||||
|
|
||||||
|
// All standard integer types.
|
||||||
|
GMOCK_DECLARE_KIND_(char, kInteger);
|
||||||
|
GMOCK_DECLARE_KIND_(signed char, kInteger);
|
||||||
|
GMOCK_DECLARE_KIND_(unsigned char, kInteger);
|
||||||
|
GMOCK_DECLARE_KIND_(short, kInteger); // NOLINT
|
||||||
|
GMOCK_DECLARE_KIND_(unsigned short, kInteger); // NOLINT
|
||||||
|
GMOCK_DECLARE_KIND_(int, kInteger);
|
||||||
|
GMOCK_DECLARE_KIND_(unsigned int, kInteger);
|
||||||
|
GMOCK_DECLARE_KIND_(long, kInteger); // NOLINT
|
||||||
|
GMOCK_DECLARE_KIND_(unsigned long, kInteger); // NOLINT
|
||||||
|
|
||||||
|
#if GMOCK_WCHAR_T_IS_NATIVE_
|
||||||
|
GMOCK_DECLARE_KIND_(wchar_t, kInteger);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// Non-standard integer types.
|
||||||
|
GMOCK_DECLARE_KIND_(Int64, kInteger);
|
||||||
|
GMOCK_DECLARE_KIND_(UInt64, kInteger);
|
||||||
|
|
||||||
|
// All standard floating-point types.
|
||||||
|
GMOCK_DECLARE_KIND_(float, kFloatingPoint);
|
||||||
|
GMOCK_DECLARE_KIND_(double, kFloatingPoint);
|
||||||
|
GMOCK_DECLARE_KIND_(long double, kFloatingPoint);
|
||||||
|
|
||||||
|
#undef GMOCK_DECLARE_KIND_
|
||||||
|
|
||||||
|
// Evaluates to the kind of 'type'.
|
||||||
|
#define GMOCK_KIND_OF_(type) \
|
||||||
|
static_cast< ::testing::internal::TypeKind>( \
|
||||||
|
::testing::internal::KindOf<type>::value)
|
||||||
|
|
||||||
|
// Evaluates to true iff integer type T is signed.
|
||||||
|
#define GMOCK_IS_SIGNED_(T) (static_cast<T>(-1) < 0)
|
||||||
|
|
||||||
|
// LosslessArithmeticConvertibleImpl<kFromKind, From, kToKind, To>::value
|
||||||
|
// is true iff arithmetic type From can be losslessly converted to
|
||||||
|
// arithmetic type To.
|
||||||
|
//
|
||||||
|
// It's the user's responsibility to ensure that both From and To are
|
||||||
|
// raw (i.e. has no CV modifier, is not a pointer, and is not a
|
||||||
|
// reference) built-in arithmetic types, kFromKind is the kind of
|
||||||
|
// From, and kToKind is the kind of To; the value is
|
||||||
|
// implementation-defined when the above pre-condition is violated.
|
||||||
|
template <TypeKind kFromKind, typename From, TypeKind kToKind, typename To>
|
||||||
|
struct LosslessArithmeticConvertibleImpl : public false_type {};
|
||||||
|
|
||||||
|
// Converting bool to bool is lossless.
|
||||||
|
template <>
|
||||||
|
struct LosslessArithmeticConvertibleImpl<kBool, bool, kBool, bool>
|
||||||
|
: public true_type {}; // NOLINT
|
||||||
|
|
||||||
|
// Converting bool to any integer type is lossless.
|
||||||
|
template <typename To>
|
||||||
|
struct LosslessArithmeticConvertibleImpl<kBool, bool, kInteger, To>
|
||||||
|
: public true_type {}; // NOLINT
|
||||||
|
|
||||||
|
// Converting bool to any floating-point type is lossless.
|
||||||
|
template <typename To>
|
||||||
|
struct LosslessArithmeticConvertibleImpl<kBool, bool, kFloatingPoint, To>
|
||||||
|
: public true_type {}; // NOLINT
|
||||||
|
|
||||||
|
// Converting an integer to bool is lossy.
|
||||||
|
template <typename From>
|
||||||
|
struct LosslessArithmeticConvertibleImpl<kInteger, From, kBool, bool>
|
||||||
|
: public false_type {}; // NOLINT
|
||||||
|
|
||||||
|
// Converting an integer to another non-bool integer is lossless iff
|
||||||
|
// the target type's range encloses the source type's range.
|
||||||
|
template <typename From, typename To>
|
||||||
|
struct LosslessArithmeticConvertibleImpl<kInteger, From, kInteger, To>
|
||||||
|
: public bool_constant<
|
||||||
|
// When converting from a smaller size to a larger size, we are
|
||||||
|
// fine as long as we are not converting from signed to unsigned.
|
||||||
|
((sizeof(From) < sizeof(To)) &&
|
||||||
|
(!GMOCK_IS_SIGNED_(From) || GMOCK_IS_SIGNED_(To))) ||
|
||||||
|
// When converting between the same size, the signedness must match.
|
||||||
|
((sizeof(From) == sizeof(To)) &&
|
||||||
|
(GMOCK_IS_SIGNED_(From) == GMOCK_IS_SIGNED_(To)))> {}; // NOLINT
|
||||||
|
|
||||||
|
#undef GMOCK_IS_SIGNED_
|
||||||
|
|
||||||
|
// Converting an integer to a floating-point type may be lossy, since
|
||||||
|
// the format of a floating-point number is implementation-defined.
|
||||||
|
template <typename From, typename To>
|
||||||
|
struct LosslessArithmeticConvertibleImpl<kInteger, From, kFloatingPoint, To>
|
||||||
|
: public false_type {}; // NOLINT
|
||||||
|
|
||||||
|
// Converting a floating-point to bool is lossy.
|
||||||
|
template <typename From>
|
||||||
|
struct LosslessArithmeticConvertibleImpl<kFloatingPoint, From, kBool, bool>
|
||||||
|
: public false_type {}; // NOLINT
|
||||||
|
|
||||||
|
// Converting a floating-point to an integer is lossy.
|
||||||
|
template <typename From, typename To>
|
||||||
|
struct LosslessArithmeticConvertibleImpl<kFloatingPoint, From, kInteger, To>
|
||||||
|
: public false_type {}; // NOLINT
|
||||||
|
|
||||||
|
// Converting a floating-point to another floating-point is lossless
|
||||||
|
// iff the target type is at least as big as the source type.
|
||||||
|
template <typename From, typename To>
|
||||||
|
struct LosslessArithmeticConvertibleImpl<
|
||||||
|
kFloatingPoint, From, kFloatingPoint, To>
|
||||||
|
: public bool_constant<sizeof(From) <= sizeof(To)> {}; // NOLINT
|
||||||
|
|
||||||
|
// LosslessArithmeticConvertible<From, To>::value is true iff arithmetic
|
||||||
|
// type From can be losslessly converted to arithmetic type To.
|
||||||
|
//
|
||||||
|
// It's the user's responsibility to ensure that both From and To are
|
||||||
|
// raw (i.e. has no CV modifier, is not a pointer, and is not a
|
||||||
|
// reference) built-in arithmetic types; the value is
|
||||||
|
// implementation-defined when the above pre-condition is violated.
|
||||||
|
template <typename From, typename To>
|
||||||
|
struct LosslessArithmeticConvertible
|
||||||
|
: public LosslessArithmeticConvertibleImpl<
|
||||||
|
GMOCK_KIND_OF_(From), From, GMOCK_KIND_OF_(To), To> {}; // NOLINT
|
||||||
|
|
||||||
|
// This interface knows how to report a Google Mock failure (either
|
||||||
|
// non-fatal or fatal).
|
||||||
|
class FailureReporterInterface {
|
||||||
|
public:
|
||||||
|
// The type of a failure (either non-fatal or fatal).
|
||||||
|
enum FailureType {
|
||||||
|
NONFATAL, FATAL
|
||||||
|
};
|
||||||
|
|
||||||
|
virtual ~FailureReporterInterface() {}
|
||||||
|
|
||||||
|
// Reports a failure that occurred at the given source file location.
|
||||||
|
virtual void ReportFailure(FailureType type, const char* file, int line,
|
||||||
|
const string& message) = 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Returns the failure reporter used by Google Mock.
|
||||||
|
FailureReporterInterface* GetFailureReporter();
|
||||||
|
|
||||||
|
// Asserts that condition is true; aborts the process with the given
|
||||||
|
// message if condition is false. We cannot use LOG(FATAL) or CHECK()
|
||||||
|
// as Google Mock might be used to mock the log sink itself. We
|
||||||
|
// inline this function to prevent it from showing up in the stack
|
||||||
|
// trace.
|
||||||
|
inline void Assert(bool condition, const char* file, int line,
|
||||||
|
const string& msg) {
|
||||||
|
if (!condition) {
|
||||||
|
GetFailureReporter()->ReportFailure(FailureReporterInterface::FATAL,
|
||||||
|
file, line, msg);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
inline void Assert(bool condition, const char* file, int line) {
|
||||||
|
Assert(condition, file, line, "Assertion failed.");
|
||||||
|
}
|
||||||
|
|
||||||
|
// Verifies that condition is true; generates a non-fatal failure if
|
||||||
|
// condition is false.
|
||||||
|
inline void Expect(bool condition, const char* file, int line,
|
||||||
|
const string& msg) {
|
||||||
|
if (!condition) {
|
||||||
|
GetFailureReporter()->ReportFailure(FailureReporterInterface::NONFATAL,
|
||||||
|
file, line, msg);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
inline void Expect(bool condition, const char* file, int line) {
|
||||||
|
Expect(condition, file, line, "Expectation failed.");
|
||||||
|
}
|
||||||
|
|
||||||
|
// Severity level of a log.
|
||||||
|
enum LogSeverity {
|
||||||
|
INFO = 0,
|
||||||
|
WARNING = 1
|
||||||
|
};
|
||||||
|
|
||||||
|
// Valid values for the --gmock_verbose flag.
|
||||||
|
|
||||||
|
// All logs (informational and warnings) are printed.
|
||||||
|
const char kInfoVerbosity[] = "info";
|
||||||
|
// Only warnings are printed.
|
||||||
|
const char kWarningVerbosity[] = "warning";
|
||||||
|
// No logs are printed.
|
||||||
|
const char kErrorVerbosity[] = "error";
|
||||||
|
|
||||||
|
// Returns true iff a log with the given severity is visible according
|
||||||
|
// to the --gmock_verbose flag.
|
||||||
|
bool LogIsVisible(LogSeverity severity);
|
||||||
|
|
||||||
|
// Prints the given message to stdout iff 'severity' >= the level
|
||||||
|
// specified by the --gmock_verbose flag. If stack_frames_to_skip >=
|
||||||
|
// 0, also prints the stack trace excluding the top
|
||||||
|
// stack_frames_to_skip frames. In opt mode, any positive
|
||||||
|
// stack_frames_to_skip is treated as 0, since we don't know which
|
||||||
|
// function calls will be inlined by the compiler and need to be
|
||||||
|
// conservative.
|
||||||
|
void Log(LogSeverity severity, const string& message, int stack_frames_to_skip);
|
||||||
|
|
||||||
|
// TODO(wan@google.com): group all type utilities together.
|
||||||
|
|
||||||
|
// Type traits.
|
||||||
|
|
||||||
|
// is_reference<T>::value is non-zero iff T is a reference type.
|
||||||
|
template <typename T> struct is_reference : public false_type {};
|
||||||
|
template <typename T> struct is_reference<T&> : public true_type {};
|
||||||
|
|
||||||
|
// type_equals<T1, T2>::value is non-zero iff T1 and T2 are the same type.
|
||||||
|
template <typename T1, typename T2> struct type_equals : public false_type {};
|
||||||
|
template <typename T> struct type_equals<T, T> : public true_type {};
|
||||||
|
|
||||||
|
// remove_reference<T>::type removes the reference from type T, if any.
|
||||||
|
template <typename T> struct remove_reference { typedef T type; }; // NOLINT
|
||||||
|
template <typename T> struct remove_reference<T&> { typedef T type; }; // NOLINT
|
||||||
|
|
||||||
|
// Invalid<T>() returns an invalid value of type T. This is useful
|
||||||
|
// when a value of type T is needed for compilation, but the statement
|
||||||
|
// will not really be executed (or we don't care if the statement
|
||||||
|
// crashes).
|
||||||
|
template <typename T>
|
||||||
|
inline T Invalid() {
|
||||||
|
return *static_cast<typename remove_reference<T>::type*>(NULL);
|
||||||
|
}
|
||||||
|
template <>
|
||||||
|
inline void Invalid<void>() {}
|
||||||
|
|
||||||
|
// Given a raw type (i.e. having no top-level reference or const
|
||||||
|
// modifier) RawContainer that's either an STL-style container or a
|
||||||
|
// native array, class StlContainerView<RawContainer> has the
|
||||||
|
// following members:
|
||||||
|
//
|
||||||
|
// - type is a type that provides an STL-style container view to
|
||||||
|
// (i.e. implements the STL container concept for) RawContainer;
|
||||||
|
// - const_reference is a type that provides a reference to a const
|
||||||
|
// RawContainer;
|
||||||
|
// - ConstReference(raw_container) returns a const reference to an STL-style
|
||||||
|
// container view to raw_container, which is a RawContainer.
|
||||||
|
// - Copy(raw_container) returns an STL-style container view of a
|
||||||
|
// copy of raw_container, which is a RawContainer.
|
||||||
|
//
|
||||||
|
// This generic version is used when RawContainer itself is already an
|
||||||
|
// STL-style container.
|
||||||
|
template <class RawContainer>
|
||||||
|
class StlContainerView {
|
||||||
|
public:
|
||||||
|
typedef RawContainer type;
|
||||||
|
typedef const type& const_reference;
|
||||||
|
|
||||||
|
static const_reference ConstReference(const RawContainer& container) {
|
||||||
|
// Ensures that RawContainer is not a const type.
|
||||||
|
testing::StaticAssertTypeEq<RawContainer,
|
||||||
|
GTEST_REMOVE_CONST_(RawContainer)>();
|
||||||
|
return container;
|
||||||
|
}
|
||||||
|
static type Copy(const RawContainer& container) { return container; }
|
||||||
|
};
|
||||||
|
|
||||||
|
// This specialization is used when RawContainer is a native array type.
|
||||||
|
template <typename Element, size_t N>
|
||||||
|
class StlContainerView<Element[N]> {
|
||||||
|
public:
|
||||||
|
typedef GTEST_REMOVE_CONST_(Element) RawElement;
|
||||||
|
typedef internal::NativeArray<RawElement> type;
|
||||||
|
// NativeArray<T> can represent a native array either by value or by
|
||||||
|
// reference (selected by a constructor argument), so 'const type'
|
||||||
|
// can be used to reference a const native array. We cannot
|
||||||
|
// 'typedef const type& const_reference' here, as that would mean
|
||||||
|
// ConstReference() has to return a reference to a local variable.
|
||||||
|
typedef const type const_reference;
|
||||||
|
|
||||||
|
static const_reference ConstReference(const Element (&array)[N]) {
|
||||||
|
// Ensures that Element is not a const type.
|
||||||
|
testing::StaticAssertTypeEq<Element, RawElement>();
|
||||||
|
#if GTEST_OS_SYMBIAN
|
||||||
|
// The Nokia Symbian compiler confuses itself in template instantiation
|
||||||
|
// for this call without the cast to Element*:
|
||||||
|
// function call '[testing::internal::NativeArray<char *>].NativeArray(
|
||||||
|
// {lval} const char *[4], long, testing::internal::RelationToSource)'
|
||||||
|
// does not match
|
||||||
|
// 'testing::internal::NativeArray<char *>::NativeArray(
|
||||||
|
// char *const *, unsigned int, testing::internal::RelationToSource)'
|
||||||
|
// (instantiating: 'testing::internal::ContainsMatcherImpl
|
||||||
|
// <const char * (&)[4]>::Matches(const char * (&)[4]) const')
|
||||||
|
// (instantiating: 'testing::internal::StlContainerView<char *[4]>::
|
||||||
|
// ConstReference(const char * (&)[4])')
|
||||||
|
// (and though the N parameter type is mismatched in the above explicit
|
||||||
|
// conversion of it doesn't help - only the conversion of the array).
|
||||||
|
return type(const_cast<Element*>(&array[0]), N, kReference);
|
||||||
|
#else
|
||||||
|
return type(array, N, kReference);
|
||||||
|
#endif // GTEST_OS_SYMBIAN
|
||||||
|
}
|
||||||
|
static type Copy(const Element (&array)[N]) {
|
||||||
|
#if GTEST_OS_SYMBIAN
|
||||||
|
return type(const_cast<Element*>(&array[0]), N, kCopy);
|
||||||
|
#else
|
||||||
|
return type(array, N, kCopy);
|
||||||
|
#endif // GTEST_OS_SYMBIAN
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
// This specialization is used when RawContainer is a native array
|
||||||
|
// represented as a (pointer, size) tuple.
|
||||||
|
template <typename ElementPointer, typename Size>
|
||||||
|
class StlContainerView< ::std::tr1::tuple<ElementPointer, Size> > {
|
||||||
|
public:
|
||||||
|
typedef GTEST_REMOVE_CONST_(
|
||||||
|
typename internal::PointeeOf<ElementPointer>::type) RawElement;
|
||||||
|
typedef internal::NativeArray<RawElement> type;
|
||||||
|
typedef const type const_reference;
|
||||||
|
|
||||||
|
static const_reference ConstReference(
|
||||||
|
const ::std::tr1::tuple<ElementPointer, Size>& array) {
|
||||||
|
using ::std::tr1::get;
|
||||||
|
return type(get<0>(array), get<1>(array), kReference);
|
||||||
|
}
|
||||||
|
static type Copy(const ::std::tr1::tuple<ElementPointer, Size>& array) {
|
||||||
|
using ::std::tr1::get;
|
||||||
|
return type(get<0>(array), get<1>(array), kCopy);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
// The following specialization prevents the user from instantiating
|
||||||
|
// StlContainer with a reference type.
|
||||||
|
template <typename T> class StlContainerView<T&>;
|
||||||
|
|
||||||
|
} // namespace internal
|
||||||
|
} // namespace testing
|
||||||
|
|
||||||
|
#endif // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
|
|
@ -0,0 +1,78 @@
|
||||||
|
// 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: vadimb@google.com (Vadim Berman)
|
||||||
|
//
|
||||||
|
// Low-level types and utilities for porting Google Mock to various
|
||||||
|
// platforms. They are subject to change without notice. DO NOT USE
|
||||||
|
// THEM IN USER CODE.
|
||||||
|
|
||||||
|
#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
|
||||||
|
#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
|
||||||
|
|
||||||
|
#include <assert.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <iostream>
|
||||||
|
|
||||||
|
// Most of the types needed for porting Google Mock are also required
|
||||||
|
// for Google Test and are defined in gtest-port.h.
|
||||||
|
#include "gtest/internal/gtest-linked_ptr.h"
|
||||||
|
#include "gtest/internal/gtest-port.h"
|
||||||
|
|
||||||
|
// To avoid conditional compilation everywhere, we make it
|
||||||
|
// gmock-port.h's responsibility to #include the header implementing
|
||||||
|
// tr1/tuple. gmock-port.h does this via gtest-port.h, which is
|
||||||
|
// guaranteed to pull in the tuple header.
|
||||||
|
|
||||||
|
// For MS Visual C++, check the compiler version. At least VS 2003 is
|
||||||
|
// required to compile Google Mock.
|
||||||
|
#if defined(_MSC_VER) && _MSC_VER < 1310
|
||||||
|
# error "At least Visual C++ 2003 (7.1) is required to compile Google Mock."
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// Macro for referencing flags. This is public as we want the user to
|
||||||
|
// use this syntax to reference Google Mock flags.
|
||||||
|
#define GMOCK_FLAG(name) FLAGS_gmock_##name
|
||||||
|
|
||||||
|
// Macros for declaring flags.
|
||||||
|
#define GMOCK_DECLARE_bool_(name) extern bool GMOCK_FLAG(name)
|
||||||
|
#define GMOCK_DECLARE_int32_(name) \
|
||||||
|
extern ::testing::internal::Int32 GMOCK_FLAG(name)
|
||||||
|
#define GMOCK_DECLARE_string_(name) \
|
||||||
|
extern ::testing::internal::String GMOCK_FLAG(name)
|
||||||
|
|
||||||
|
// Macros for defining flags.
|
||||||
|
#define GMOCK_DEFINE_bool_(name, default_val, doc) \
|
||||||
|
bool GMOCK_FLAG(name) = (default_val)
|
||||||
|
#define GMOCK_DEFINE_int32_(name, default_val, doc) \
|
||||||
|
::testing::internal::Int32 GMOCK_FLAG(name) = (default_val)
|
||||||
|
#define GMOCK_DEFINE_string_(name, default_val, doc) \
|
||||||
|
::testing::internal::String GMOCK_FLAG(name) = (default_val)
|
||||||
|
|
||||||
|
#endif // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
|
|
@ -0,0 +1,98 @@
|
||||||
|
# A sample Makefile for building both Google Mock and Google Test and
|
||||||
|
# using them in user tests. This file is self-contained, so you don't
|
||||||
|
# need to use the Makefile in Google Test's source tree. Please tweak
|
||||||
|
# it to suit your environment and project. You may want to move it to
|
||||||
|
# your project's root directory.
|
||||||
|
#
|
||||||
|
# SYNOPSIS:
|
||||||
|
#
|
||||||
|
# make [all] - makes everything.
|
||||||
|
# make TARGET - makes the given target.
|
||||||
|
# make clean - removes all files generated by make.
|
||||||
|
|
||||||
|
# Please tweak the following variable definitions as needed by your
|
||||||
|
# project, except GMOCK_HEADERS and GTEST_HEADERS, which you can use
|
||||||
|
# in your own targets but shouldn't modify.
|
||||||
|
|
||||||
|
# Points to the root of Google Test, relative to where this file is.
|
||||||
|
# Remember to tweak this if you move this file, or if you want to use
|
||||||
|
# a copy of Google Test at a different location.
|
||||||
|
GTEST_DIR = ../gtest
|
||||||
|
|
||||||
|
# Points to the root of Google Mock, relative to where this file is.
|
||||||
|
# Remember to tweak this if you move this file.
|
||||||
|
GMOCK_DIR = ..
|
||||||
|
|
||||||
|
# Where to find user code.
|
||||||
|
USER_DIR = ../test
|
||||||
|
|
||||||
|
# Flags passed to the preprocessor.
|
||||||
|
CPPFLAGS += -I$(GTEST_DIR)/include -I$(GMOCK_DIR)/include
|
||||||
|
|
||||||
|
# Flags passed to the C++ compiler.
|
||||||
|
CXXFLAGS += -g -Wall -Wextra
|
||||||
|
|
||||||
|
# All tests produced by this Makefile. Remember to add new tests you
|
||||||
|
# created to the list.
|
||||||
|
TESTS = gmock_test
|
||||||
|
|
||||||
|
# All Google Test headers. Usually you shouldn't change this
|
||||||
|
# definition.
|
||||||
|
GTEST_HEADERS = $(GTEST_DIR)/include/gtest/*.h \
|
||||||
|
$(GTEST_DIR)/include/gtest/internal/*.h
|
||||||
|
|
||||||
|
# All Google Mock headers. Note that all Google Test headers are
|
||||||
|
# included here too, as they are #included by Google Mock headers.
|
||||||
|
# Usually you shouldn't change this definition.
|
||||||
|
GMOCK_HEADERS = $(GMOCK_DIR)/include/gmock/*.h \
|
||||||
|
$(GMOCK_DIR)/include/gmock/internal/*.h \
|
||||||
|
$(GTEST_HEADERS)
|
||||||
|
|
||||||
|
# House-keeping build targets.
|
||||||
|
|
||||||
|
all : $(TESTS)
|
||||||
|
|
||||||
|
clean :
|
||||||
|
rm -f $(TESTS) gmock.a gmock_main.a *.o
|
||||||
|
|
||||||
|
# Builds gmock.a and gmock_main.a. These libraries contain both
|
||||||
|
# Google Mock and Google Test. A test should link with either gmock.a
|
||||||
|
# or gmock_main.a, depending on whether it defines its own main()
|
||||||
|
# function. It's fine if your test only uses features from Google
|
||||||
|
# Test (and not Google Mock).
|
||||||
|
|
||||||
|
# Usually you shouldn't tweak such internal variables, indicated by a
|
||||||
|
# trailing _.
|
||||||
|
GTEST_SRCS_ = $(GTEST_DIR)/src/*.cc $(GTEST_DIR)/src/*.h $(GTEST_HEADERS)
|
||||||
|
GMOCK_SRCS_ = $(GMOCK_DIR)/src/*.cc $(GMOCK_HEADERS)
|
||||||
|
|
||||||
|
# For simplicity and to avoid depending on implementation details of
|
||||||
|
# Google Mock and Google Test, the dependencies specified below are
|
||||||
|
# conservative and not optimized. This is fine as Google Mock and
|
||||||
|
# Google Test compile fast and for ordinary users their source rarely
|
||||||
|
# changes.
|
||||||
|
gtest-all.o : $(GTEST_SRCS_)
|
||||||
|
$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) -I$(GMOCK_DIR) $(CXXFLAGS) \
|
||||||
|
-c $(GTEST_DIR)/src/gtest-all.cc
|
||||||
|
|
||||||
|
gmock-all.o : $(GMOCK_SRCS_)
|
||||||
|
$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) -I$(GMOCK_DIR) $(CXXFLAGS) \
|
||||||
|
-c $(GMOCK_DIR)/src/gmock-all.cc
|
||||||
|
|
||||||
|
gmock_main.o : $(GMOCK_SRCS_)
|
||||||
|
$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) -I$(GMOCK_DIR) $(CXXFLAGS) \
|
||||||
|
-c $(GMOCK_DIR)/src/gmock_main.cc
|
||||||
|
|
||||||
|
gmock.a : gmock-all.o gtest-all.o
|
||||||
|
$(AR) $(ARFLAGS) $@ $^
|
||||||
|
|
||||||
|
gmock_main.a : gmock-all.o gtest-all.o gmock_main.o
|
||||||
|
$(AR) $(ARFLAGS) $@ $^
|
||||||
|
|
||||||
|
# Builds a sample test.
|
||||||
|
|
||||||
|
gmock_test.o : $(USER_DIR)/gmock_test.cc $(GMOCK_HEADERS)
|
||||||
|
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/gmock_test.cc
|
||||||
|
|
||||||
|
gmock_test : gmock_test.o gmock_main.a
|
||||||
|
$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
|
|
@ -0,0 +1,32 @@
|
||||||
|
|
||||||
|
Microsoft Visual Studio Solution File, Format Version 9.00
|
||||||
|
# Visual Studio 2005
|
||||||
|
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock", "gmock.vcproj", "{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}"
|
||||||
|
EndProject
|
||||||
|
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock_test", "gmock_test.vcproj", "{F10D22F8-AC7B-4213-8720-608E7D878CD2}"
|
||||||
|
EndProject
|
||||||
|
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock_main", "gmock_main.vcproj", "{E4EF614B-30DF-4954-8C53-580A0BF6B589}"
|
||||||
|
EndProject
|
||||||
|
Global
|
||||||
|
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
||||||
|
Debug|Win32 = Debug|Win32
|
||||||
|
Release|Win32 = Release|Win32
|
||||||
|
EndGlobalSection
|
||||||
|
GlobalSection(ProjectConfigurationPlatforms) = postSolution
|
||||||
|
{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||||
|
{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Debug|Win32.Build.0 = Debug|Win32
|
||||||
|
{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Release|Win32.ActiveCfg = Release|Win32
|
||||||
|
{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Release|Win32.Build.0 = Release|Win32
|
||||||
|
{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||||
|
{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Debug|Win32.Build.0 = Debug|Win32
|
||||||
|
{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Release|Win32.ActiveCfg = Release|Win32
|
||||||
|
{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Release|Win32.Build.0 = Release|Win32
|
||||||
|
{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||||
|
{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Debug|Win32.Build.0 = Debug|Win32
|
||||||
|
{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Release|Win32.ActiveCfg = Release|Win32
|
||||||
|
{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Release|Win32.Build.0 = Release|Win32
|
||||||
|
EndGlobalSection
|
||||||
|
GlobalSection(SolutionProperties) = preSolution
|
||||||
|
HideSolutionNode = FALSE
|
||||||
|
EndGlobalSection
|
||||||
|
EndGlobal
|
|
@ -0,0 +1,191 @@
|
||||||
|
<?xml version="1.0" encoding="Windows-1252"?>
|
||||||
|
<VisualStudioProject
|
||||||
|
ProjectType="Visual C++"
|
||||||
|
Version="8.00"
|
||||||
|
Name="gmock"
|
||||||
|
ProjectGUID="{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}"
|
||||||
|
RootNamespace="gmock"
|
||||||
|
Keyword="Win32Proj"
|
||||||
|
>
|
||||||
|
<Platforms>
|
||||||
|
<Platform
|
||||||
|
Name="Win32"
|
||||||
|
/>
|
||||||
|
</Platforms>
|
||||||
|
<ToolFiles>
|
||||||
|
</ToolFiles>
|
||||||
|
<Configurations>
|
||||||
|
<Configuration
|
||||||
|
Name="Debug|Win32"
|
||||||
|
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
|
||||||
|
IntermediateDirectory="$(OutDir)\$(ProjectName)"
|
||||||
|
ConfigurationType="4"
|
||||||
|
InheritedPropertySheets=".\gmock_config.vsprops"
|
||||||
|
CharacterSet="1"
|
||||||
|
>
|
||||||
|
<Tool
|
||||||
|
Name="VCPreBuildEventTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCCustomBuildTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCXMLDataGeneratorTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCWebServiceProxyGeneratorTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCMIDLTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCCLCompilerTool"
|
||||||
|
Optimization="0"
|
||||||
|
AdditionalIncludeDirectories="..\..\include;..\.."
|
||||||
|
PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
|
||||||
|
MinimalRebuild="true"
|
||||||
|
BasicRuntimeChecks="3"
|
||||||
|
RuntimeLibrary="1"
|
||||||
|
UsePrecompiledHeader="0"
|
||||||
|
WarningLevel="3"
|
||||||
|
Detect64BitPortabilityProblems="true"
|
||||||
|
DebugInformationFormat="3"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCManagedResourceCompilerTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCResourceCompilerTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCPreLinkEventTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCLibrarianTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCALinkTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCXDCMakeTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCBscMakeTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCFxCopTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCPostBuildEventTool"
|
||||||
|
/>
|
||||||
|
</Configuration>
|
||||||
|
<Configuration
|
||||||
|
Name="Release|Win32"
|
||||||
|
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
|
||||||
|
IntermediateDirectory="$(OutDir)\$(ProjectName)"
|
||||||
|
ConfigurationType="4"
|
||||||
|
InheritedPropertySheets=".\gmock_config.vsprops"
|
||||||
|
CharacterSet="1"
|
||||||
|
WholeProgramOptimization="1"
|
||||||
|
>
|
||||||
|
<Tool
|
||||||
|
Name="VCPreBuildEventTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCCustomBuildTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCXMLDataGeneratorTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCWebServiceProxyGeneratorTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCMIDLTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCCLCompilerTool"
|
||||||
|
AdditionalIncludeDirectories="..\..\include;..\.."
|
||||||
|
PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
|
||||||
|
RuntimeLibrary="0"
|
||||||
|
UsePrecompiledHeader="0"
|
||||||
|
WarningLevel="3"
|
||||||
|
Detect64BitPortabilityProblems="true"
|
||||||
|
DebugInformationFormat="3"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCManagedResourceCompilerTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCResourceCompilerTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCPreLinkEventTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCLibrarianTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCALinkTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCXDCMakeTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCBscMakeTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCFxCopTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCPostBuildEventTool"
|
||||||
|
/>
|
||||||
|
</Configuration>
|
||||||
|
</Configurations>
|
||||||
|
<References>
|
||||||
|
</References>
|
||||||
|
<Files>
|
||||||
|
<Filter
|
||||||
|
Name="Source Files"
|
||||||
|
Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
|
||||||
|
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
|
||||||
|
>
|
||||||
|
<File
|
||||||
|
RelativePath="..\..\src\gmock-all.cc"
|
||||||
|
>
|
||||||
|
</File>
|
||||||
|
<File
|
||||||
|
RelativePath="$(GTestDir)\src\gtest-all.cc"
|
||||||
|
>
|
||||||
|
<FileConfiguration
|
||||||
|
Name="Debug|Win32"
|
||||||
|
>
|
||||||
|
<Tool
|
||||||
|
Name="VCCLCompilerTool"
|
||||||
|
AdditionalIncludeDirectories="$(GTestDir)"
|
||||||
|
/>
|
||||||
|
</FileConfiguration>
|
||||||
|
<FileConfiguration
|
||||||
|
Name="Release|Win32"
|
||||||
|
>
|
||||||
|
<Tool
|
||||||
|
Name="VCCLCompilerTool"
|
||||||
|
AdditionalIncludeDirectories="$(GTestDir)"
|
||||||
|
/>
|
||||||
|
</FileConfiguration>
|
||||||
|
</File>
|
||||||
|
</Filter>
|
||||||
|
<Filter
|
||||||
|
Name="Public Header Files"
|
||||||
|
Filter="h;hpp;hxx;hm;inl;inc;xsd"
|
||||||
|
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
|
||||||
|
>
|
||||||
|
</Filter>
|
||||||
|
<Filter
|
||||||
|
Name="Private Header Files"
|
||||||
|
>
|
||||||
|
</Filter>
|
||||||
|
</Files>
|
||||||
|
<Globals>
|
||||||
|
</Globals>
|
||||||
|
</VisualStudioProject>
|
|
@ -0,0 +1,15 @@
|
||||||
|
<?xml version="1.0" encoding="Windows-1252"?>
|
||||||
|
<VisualStudioPropertySheet
|
||||||
|
ProjectType="Visual C++"
|
||||||
|
Version="8.00"
|
||||||
|
Name="gmock_config"
|
||||||
|
>
|
||||||
|
<Tool
|
||||||
|
Name="VCCLCompilerTool"
|
||||||
|
AdditionalIncludeDirectories=""$(GTestDir)/include""
|
||||||
|
/>
|
||||||
|
<UserMacro
|
||||||
|
Name="GTestDir"
|
||||||
|
Value="../../gtest"
|
||||||
|
/>
|
||||||
|
</VisualStudioPropertySheet>
|
|
@ -0,0 +1,187 @@
|
||||||
|
<?xml version="1.0" encoding="Windows-1252"?>
|
||||||
|
<VisualStudioProject
|
||||||
|
ProjectType="Visual C++"
|
||||||
|
Version="8.00"
|
||||||
|
Name="gmock_main"
|
||||||
|
ProjectGUID="{E4EF614B-30DF-4954-8C53-580A0BF6B589}"
|
||||||
|
RootNamespace="gmock_main"
|
||||||
|
Keyword="Win32Proj"
|
||||||
|
>
|
||||||
|
<Platforms>
|
||||||
|
<Platform
|
||||||
|
Name="Win32"
|
||||||
|
/>
|
||||||
|
</Platforms>
|
||||||
|
<ToolFiles>
|
||||||
|
</ToolFiles>
|
||||||
|
<Configurations>
|
||||||
|
<Configuration
|
||||||
|
Name="Debug|Win32"
|
||||||
|
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
|
||||||
|
IntermediateDirectory="$(OutDir)\$(ProjectName)"
|
||||||
|
ConfigurationType="4"
|
||||||
|
InheritedPropertySheets=".\gmock_config.vsprops"
|
||||||
|
CharacterSet="1"
|
||||||
|
>
|
||||||
|
<Tool
|
||||||
|
Name="VCPreBuildEventTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCCustomBuildTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCXMLDataGeneratorTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCWebServiceProxyGeneratorTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCMIDLTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCCLCompilerTool"
|
||||||
|
Optimization="0"
|
||||||
|
AdditionalIncludeDirectories="../../include"
|
||||||
|
PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
|
||||||
|
MinimalRebuild="true"
|
||||||
|
BasicRuntimeChecks="3"
|
||||||
|
RuntimeLibrary="1"
|
||||||
|
UsePrecompiledHeader="0"
|
||||||
|
WarningLevel="3"
|
||||||
|
Detect64BitPortabilityProblems="true"
|
||||||
|
DebugInformationFormat="3"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCManagedResourceCompilerTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCResourceCompilerTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCPreLinkEventTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCLibrarianTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCALinkTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCXDCMakeTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCBscMakeTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCFxCopTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCPostBuildEventTool"
|
||||||
|
/>
|
||||||
|
</Configuration>
|
||||||
|
<Configuration
|
||||||
|
Name="Release|Win32"
|
||||||
|
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
|
||||||
|
IntermediateDirectory="$(OutDir)\$(ProjectName)"
|
||||||
|
ConfigurationType="4"
|
||||||
|
InheritedPropertySheets=".\gmock_config.vsprops"
|
||||||
|
CharacterSet="1"
|
||||||
|
WholeProgramOptimization="1"
|
||||||
|
>
|
||||||
|
<Tool
|
||||||
|
Name="VCPreBuildEventTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCCustomBuildTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCXMLDataGeneratorTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCWebServiceProxyGeneratorTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCMIDLTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCCLCompilerTool"
|
||||||
|
AdditionalIncludeDirectories="../../include"
|
||||||
|
PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
|
||||||
|
RuntimeLibrary="0"
|
||||||
|
UsePrecompiledHeader="0"
|
||||||
|
WarningLevel="3"
|
||||||
|
Detect64BitPortabilityProblems="true"
|
||||||
|
DebugInformationFormat="3"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCManagedResourceCompilerTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCResourceCompilerTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCPreLinkEventTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCLibrarianTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCALinkTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCXDCMakeTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCBscMakeTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCFxCopTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCPostBuildEventTool"
|
||||||
|
/>
|
||||||
|
</Configuration>
|
||||||
|
</Configurations>
|
||||||
|
<References>
|
||||||
|
<ProjectReference
|
||||||
|
ReferencedProjectIdentifier="{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}"
|
||||||
|
RelativePathToProject=".\gmock.vcproj"
|
||||||
|
/>
|
||||||
|
</References>
|
||||||
|
<Files>
|
||||||
|
<Filter
|
||||||
|
Name="Source Files"
|
||||||
|
Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
|
||||||
|
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
|
||||||
|
>
|
||||||
|
<File
|
||||||
|
RelativePath="..\..\src\gmock_main.cc"
|
||||||
|
>
|
||||||
|
<FileConfiguration
|
||||||
|
Name="Debug|Win32"
|
||||||
|
>
|
||||||
|
<Tool
|
||||||
|
Name="VCCLCompilerTool"
|
||||||
|
AdditionalIncludeDirectories="../../include"
|
||||||
|
/>
|
||||||
|
</FileConfiguration>
|
||||||
|
<FileConfiguration
|
||||||
|
Name="Release|Win32"
|
||||||
|
>
|
||||||
|
<Tool
|
||||||
|
Name="VCCLCompilerTool"
|
||||||
|
AdditionalIncludeDirectories="../../include"
|
||||||
|
/>
|
||||||
|
</FileConfiguration>
|
||||||
|
</File>
|
||||||
|
</Filter>
|
||||||
|
<Filter
|
||||||
|
Name="Header Files"
|
||||||
|
Filter="h;hpp;hxx;hm;inl;inc;xsd"
|
||||||
|
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
|
||||||
|
>
|
||||||
|
</Filter>
|
||||||
|
</Files>
|
||||||
|
<Globals>
|
||||||
|
</Globals>
|
||||||
|
</VisualStudioProject>
|
|
@ -0,0 +1,201 @@
|
||||||
|
<?xml version="1.0" encoding="Windows-1252"?>
|
||||||
|
<VisualStudioProject
|
||||||
|
ProjectType="Visual C++"
|
||||||
|
Version="8.00"
|
||||||
|
Name="gmock_test"
|
||||||
|
ProjectGUID="{F10D22F8-AC7B-4213-8720-608E7D878CD2}"
|
||||||
|
RootNamespace="gmock_test"
|
||||||
|
Keyword="Win32Proj"
|
||||||
|
>
|
||||||
|
<Platforms>
|
||||||
|
<Platform
|
||||||
|
Name="Win32"
|
||||||
|
/>
|
||||||
|
</Platforms>
|
||||||
|
<ToolFiles>
|
||||||
|
</ToolFiles>
|
||||||
|
<Configurations>
|
||||||
|
<Configuration
|
||||||
|
Name="Debug|Win32"
|
||||||
|
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
|
||||||
|
IntermediateDirectory="$(OutDir)\$(ProjectName)"
|
||||||
|
ConfigurationType="1"
|
||||||
|
InheritedPropertySheets=".\gmock_config.vsprops"
|
||||||
|
CharacterSet="1"
|
||||||
|
>
|
||||||
|
<Tool
|
||||||
|
Name="VCPreBuildEventTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCCustomBuildTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCXMLDataGeneratorTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCWebServiceProxyGeneratorTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCMIDLTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCCLCompilerTool"
|
||||||
|
AdditionalOptions="/bigobj"
|
||||||
|
Optimization="0"
|
||||||
|
AdditionalIncludeDirectories="..\..\include;..\.."
|
||||||
|
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
|
||||||
|
MinimalRebuild="true"
|
||||||
|
BasicRuntimeChecks="3"
|
||||||
|
RuntimeLibrary="1"
|
||||||
|
UsePrecompiledHeader="0"
|
||||||
|
WarningLevel="3"
|
||||||
|
Detect64BitPortabilityProblems="true"
|
||||||
|
DebugInformationFormat="3"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCManagedResourceCompilerTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCResourceCompilerTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCPreLinkEventTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCLinkerTool"
|
||||||
|
LinkIncremental="2"
|
||||||
|
GenerateDebugInformation="true"
|
||||||
|
SubSystem="1"
|
||||||
|
TargetMachine="1"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCALinkTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCManifestTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCXDCMakeTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCBscMakeTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCFxCopTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCAppVerifierTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCWebDeploymentTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCPostBuildEventTool"
|
||||||
|
/>
|
||||||
|
</Configuration>
|
||||||
|
<Configuration
|
||||||
|
Name="Release|Win32"
|
||||||
|
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
|
||||||
|
IntermediateDirectory="$(OutDir)\$(ProjectName)"
|
||||||
|
ConfigurationType="1"
|
||||||
|
InheritedPropertySheets=".\gmock_config.vsprops"
|
||||||
|
CharacterSet="1"
|
||||||
|
WholeProgramOptimization="1"
|
||||||
|
>
|
||||||
|
<Tool
|
||||||
|
Name="VCPreBuildEventTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCCustomBuildTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCXMLDataGeneratorTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCWebServiceProxyGeneratorTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCMIDLTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCCLCompilerTool"
|
||||||
|
AdditionalOptions="/bigobj"
|
||||||
|
AdditionalIncludeDirectories="..\..\include;..\.."
|
||||||
|
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
|
||||||
|
RuntimeLibrary="0"
|
||||||
|
UsePrecompiledHeader="0"
|
||||||
|
WarningLevel="3"
|
||||||
|
Detect64BitPortabilityProblems="true"
|
||||||
|
DebugInformationFormat="3"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCManagedResourceCompilerTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCResourceCompilerTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCPreLinkEventTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCLinkerTool"
|
||||||
|
LinkIncremental="1"
|
||||||
|
GenerateDebugInformation="true"
|
||||||
|
SubSystem="1"
|
||||||
|
OptimizeReferences="2"
|
||||||
|
EnableCOMDATFolding="2"
|
||||||
|
TargetMachine="1"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCALinkTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCManifestTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCXDCMakeTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCBscMakeTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCFxCopTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCAppVerifierTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCWebDeploymentTool"
|
||||||
|
/>
|
||||||
|
<Tool
|
||||||
|
Name="VCPostBuildEventTool"
|
||||||
|
/>
|
||||||
|
</Configuration>
|
||||||
|
</Configurations>
|
||||||
|
<References>
|
||||||
|
<ProjectReference
|
||||||
|
ReferencedProjectIdentifier="{E4EF614B-30DF-4954-8C53-580A0BF6B589}"
|
||||||
|
RelativePathToProject=".\gmock_main.vcproj"
|
||||||
|
/>
|
||||||
|
</References>
|
||||||
|
<Files>
|
||||||
|
<Filter
|
||||||
|
Name="Source Files"
|
||||||
|
Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
|
||||||
|
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
|
||||||
|
>
|
||||||
|
<File
|
||||||
|
RelativePath="..\..\test\gmock_all_test.cc"
|
||||||
|
>
|
||||||
|
</File>
|
||||||
|
</Filter>
|
||||||
|
<Filter
|
||||||
|
Name="Header Files"
|
||||||
|
Filter="h;hpp;hxx;hm;inl;inc;xsd"
|
||||||
|
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
|
||||||
|
>
|
||||||
|
</Filter>
|
||||||
|
</Files>
|
||||||
|
<Globals>
|
||||||
|
</Globals>
|
||||||
|
</VisualStudioProject>
|
|
@ -0,0 +1,32 @@
|
||||||
|
|
||||||
|
Microsoft Visual Studio Solution File, Format Version 11.00
|
||||||
|
# Visual C++ Express 2010
|
||||||
|
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock", "gmock.vcxproj", "{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}"
|
||||||
|
EndProject
|
||||||
|
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock_test", "gmock_test.vcxproj", "{F10D22F8-AC7B-4213-8720-608E7D878CD2}"
|
||||||
|
EndProject
|
||||||
|
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock_main", "gmock_main.vcxproj", "{E4EF614B-30DF-4954-8C53-580A0BF6B589}"
|
||||||
|
EndProject
|
||||||
|
Global
|
||||||
|
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
||||||
|
Debug|Win32 = Debug|Win32
|
||||||
|
Release|Win32 = Release|Win32
|
||||||
|
EndGlobalSection
|
||||||
|
GlobalSection(ProjectConfigurationPlatforms) = postSolution
|
||||||
|
{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||||
|
{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Debug|Win32.Build.0 = Debug|Win32
|
||||||
|
{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Release|Win32.ActiveCfg = Release|Win32
|
||||||
|
{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Release|Win32.Build.0 = Release|Win32
|
||||||
|
{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||||
|
{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Debug|Win32.Build.0 = Debug|Win32
|
||||||
|
{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Release|Win32.ActiveCfg = Release|Win32
|
||||||
|
{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Release|Win32.Build.0 = Release|Win32
|
||||||
|
{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||||
|
{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Debug|Win32.Build.0 = Debug|Win32
|
||||||
|
{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Release|Win32.ActiveCfg = Release|Win32
|
||||||
|
{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Release|Win32.Build.0 = Release|Win32
|
||||||
|
EndGlobalSection
|
||||||
|
GlobalSection(SolutionProperties) = preSolution
|
||||||
|
HideSolutionNode = FALSE
|
||||||
|
EndGlobalSection
|
||||||
|
EndGlobal
|
|
@ -0,0 +1,82 @@
|
||||||
|
<?xml version="1.0" encoding="utf-8"?>
|
||||||
|
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||||
|
<ItemGroup Label="ProjectConfigurations">
|
||||||
|
<ProjectConfiguration Include="Debug|Win32">
|
||||||
|
<Configuration>Debug</Configuration>
|
||||||
|
<Platform>Win32</Platform>
|
||||||
|
</ProjectConfiguration>
|
||||||
|
<ProjectConfiguration Include="Release|Win32">
|
||||||
|
<Configuration>Release</Configuration>
|
||||||
|
<Platform>Win32</Platform>
|
||||||
|
</ProjectConfiguration>
|
||||||
|
</ItemGroup>
|
||||||
|
<PropertyGroup Label="Globals">
|
||||||
|
<ProjectGuid>{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}</ProjectGuid>
|
||||||
|
<RootNamespace>gmock</RootNamespace>
|
||||||
|
<Keyword>Win32Proj</Keyword>
|
||||||
|
</PropertyGroup>
|
||||||
|
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
||||||
|
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
|
||||||
|
<ConfigurationType>StaticLibrary</ConfigurationType>
|
||||||
|
<CharacterSet>Unicode</CharacterSet>
|
||||||
|
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||||
|
</PropertyGroup>
|
||||||
|
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
|
||||||
|
<ConfigurationType>StaticLibrary</ConfigurationType>
|
||||||
|
<CharacterSet>Unicode</CharacterSet>
|
||||||
|
</PropertyGroup>
|
||||||
|
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
|
||||||
|
<ImportGroup Label="ExtensionSettings">
|
||||||
|
</ImportGroup>
|
||||||
|
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
|
||||||
|
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||||
|
<Import Project="gmock_config.props" />
|
||||||
|
</ImportGroup>
|
||||||
|
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
|
||||||
|
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||||
|
<Import Project="gmock_config.props" />
|
||||||
|
</ImportGroup>
|
||||||
|
<PropertyGroup Label="UserMacros" />
|
||||||
|
<PropertyGroup>
|
||||||
|
<_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
|
||||||
|
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
|
||||||
|
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)$(ProjectName)\</IntDir>
|
||||||
|
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
|
||||||
|
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)$(ProjectName)\</IntDir>
|
||||||
|
</PropertyGroup>
|
||||||
|
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||||
|
<ClCompile>
|
||||||
|
<Optimization>Disabled</Optimization>
|
||||||
|
<AdditionalIncludeDirectories>..\..\include;..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||||
|
<PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||||
|
<MinimalRebuild>true</MinimalRebuild>
|
||||||
|
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
|
||||||
|
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
|
||||||
|
<PrecompiledHeader>
|
||||||
|
</PrecompiledHeader>
|
||||||
|
<WarningLevel>Level3</WarningLevel>
|
||||||
|
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
|
||||||
|
</ClCompile>
|
||||||
|
</ItemDefinitionGroup>
|
||||||
|
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||||
|
<ClCompile>
|
||||||
|
<AdditionalIncludeDirectories>..\..\include;..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||||
|
<PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||||
|
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
|
||||||
|
<PrecompiledHeader>
|
||||||
|
</PrecompiledHeader>
|
||||||
|
<WarningLevel>Level3</WarningLevel>
|
||||||
|
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
|
||||||
|
</ClCompile>
|
||||||
|
</ItemDefinitionGroup>
|
||||||
|
<ItemGroup>
|
||||||
|
<ClCompile Include="..\..\src\gmock-all.cc" />
|
||||||
|
<ClCompile Include="$(GTestDir)\src\gtest-all.cc">
|
||||||
|
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(GTestDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||||
|
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(GTestDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||||
|
</ClCompile>
|
||||||
|
</ItemGroup>
|
||||||
|
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||||
|
<ImportGroup Label="ExtensionTargets">
|
||||||
|
</ImportGroup>
|
||||||
|
</Project>
|
|
@ -0,0 +1,19 @@
|
||||||
|
<?xml version="1.0" encoding="utf-8"?>
|
||||||
|
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||||
|
<PropertyGroup Label="UserMacros">
|
||||||
|
<GTestDir>../../gtest</GTestDir>
|
||||||
|
</PropertyGroup>
|
||||||
|
<PropertyGroup>
|
||||||
|
<_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
|
||||||
|
</PropertyGroup>
|
||||||
|
<ItemDefinitionGroup>
|
||||||
|
<ClCompile>
|
||||||
|
<AdditionalIncludeDirectories>$(GTestDir)/include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||||
|
</ClCompile>
|
||||||
|
</ItemDefinitionGroup>
|
||||||
|
<ItemGroup>
|
||||||
|
<BuildMacro Include="GTestDir">
|
||||||
|
<Value>$(GTestDir)</Value>
|
||||||
|
</BuildMacro>
|
||||||
|
</ItemGroup>
|
||||||
|
</Project>
|
|
@ -0,0 +1,88 @@
|
||||||
|
<?xml version="1.0" encoding="utf-8"?>
|
||||||
|
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||||
|
<ItemGroup Label="ProjectConfigurations">
|
||||||
|
<ProjectConfiguration Include="Debug|Win32">
|
||||||
|
<Configuration>Debug</Configuration>
|
||||||
|
<Platform>Win32</Platform>
|
||||||
|
</ProjectConfiguration>
|
||||||
|
<ProjectConfiguration Include="Release|Win32">
|
||||||
|
<Configuration>Release</Configuration>
|
||||||
|
<Platform>Win32</Platform>
|
||||||
|
</ProjectConfiguration>
|
||||||
|
</ItemGroup>
|
||||||
|
<PropertyGroup Label="Globals">
|
||||||
|
<ProjectGuid>{E4EF614B-30DF-4954-8C53-580A0BF6B589}</ProjectGuid>
|
||||||
|
<RootNamespace>gmock_main</RootNamespace>
|
||||||
|
<Keyword>Win32Proj</Keyword>
|
||||||
|
</PropertyGroup>
|
||||||
|
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
||||||
|
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
|
||||||
|
<ConfigurationType>StaticLibrary</ConfigurationType>
|
||||||
|
<CharacterSet>Unicode</CharacterSet>
|
||||||
|
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||||
|
</PropertyGroup>
|
||||||
|
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
|
||||||
|
<ConfigurationType>StaticLibrary</ConfigurationType>
|
||||||
|
<CharacterSet>Unicode</CharacterSet>
|
||||||
|
</PropertyGroup>
|
||||||
|
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
|
||||||
|
<ImportGroup Label="ExtensionSettings">
|
||||||
|
</ImportGroup>
|
||||||
|
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
|
||||||
|
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||||
|
<Import Project="gmock_config.props" />
|
||||||
|
</ImportGroup>
|
||||||
|
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
|
||||||
|
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||||
|
<Import Project="gmock_config.props" />
|
||||||
|
</ImportGroup>
|
||||||
|
<PropertyGroup Label="UserMacros" />
|
||||||
|
<PropertyGroup>
|
||||||
|
<_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
|
||||||
|
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
|
||||||
|
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)$(ProjectName)\</IntDir>
|
||||||
|
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
|
||||||
|
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)$(ProjectName)\</IntDir>
|
||||||
|
</PropertyGroup>
|
||||||
|
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||||
|
<ClCompile>
|
||||||
|
<Optimization>Disabled</Optimization>
|
||||||
|
<AdditionalIncludeDirectories>../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||||
|
<PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||||
|
<MinimalRebuild>true</MinimalRebuild>
|
||||||
|
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
|
||||||
|
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
|
||||||
|
<PrecompiledHeader>
|
||||||
|
</PrecompiledHeader>
|
||||||
|
<WarningLevel>Level3</WarningLevel>
|
||||||
|
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
|
||||||
|
</ClCompile>
|
||||||
|
</ItemDefinitionGroup>
|
||||||
|
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||||
|
<ClCompile>
|
||||||
|
<AdditionalIncludeDirectories>../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||||
|
<PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||||
|
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
|
||||||
|
<PrecompiledHeader>
|
||||||
|
</PrecompiledHeader>
|
||||||
|
<WarningLevel>Level3</WarningLevel>
|
||||||
|
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
|
||||||
|
</ClCompile>
|
||||||
|
</ItemDefinitionGroup>
|
||||||
|
<ItemGroup>
|
||||||
|
<ProjectReference Include="gmock.vcxproj">
|
||||||
|
<Project>{34681f0d-ce45-415d-b5f2-5c662dfe3bd5}</Project>
|
||||||
|
<CopyLocalSatelliteAssemblies>true</CopyLocalSatelliteAssemblies>
|
||||||
|
<ReferenceOutputAssembly>true</ReferenceOutputAssembly>
|
||||||
|
</ProjectReference>
|
||||||
|
</ItemGroup>
|
||||||
|
<ItemGroup>
|
||||||
|
<ClCompile Include="..\..\src\gmock_main.cc">
|
||||||
|
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||||
|
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||||
|
</ClCompile>
|
||||||
|
</ItemGroup>
|
||||||
|
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||||
|
<ImportGroup Label="ExtensionTargets">
|
||||||
|
</ImportGroup>
|
||||||
|
</Project>
|
|
@ -0,0 +1,101 @@
|
||||||
|
<?xml version="1.0" encoding="utf-8"?>
|
||||||
|
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||||
|
<ItemGroup Label="ProjectConfigurations">
|
||||||
|
<ProjectConfiguration Include="Debug|Win32">
|
||||||
|
<Configuration>Debug</Configuration>
|
||||||
|
<Platform>Win32</Platform>
|
||||||
|
</ProjectConfiguration>
|
||||||
|
<ProjectConfiguration Include="Release|Win32">
|
||||||
|
<Configuration>Release</Configuration>
|
||||||
|
<Platform>Win32</Platform>
|
||||||
|
</ProjectConfiguration>
|
||||||
|
</ItemGroup>
|
||||||
|
<PropertyGroup Label="Globals">
|
||||||
|
<ProjectGuid>{F10D22F8-AC7B-4213-8720-608E7D878CD2}</ProjectGuid>
|
||||||
|
<RootNamespace>gmock_test</RootNamespace>
|
||||||
|
<Keyword>Win32Proj</Keyword>
|
||||||
|
</PropertyGroup>
|
||||||
|
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
||||||
|
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
|
||||||
|
<ConfigurationType>Application</ConfigurationType>
|
||||||
|
<CharacterSet>Unicode</CharacterSet>
|
||||||
|
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||||
|
</PropertyGroup>
|
||||||
|
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
|
||||||
|
<ConfigurationType>Application</ConfigurationType>
|
||||||
|
<CharacterSet>Unicode</CharacterSet>
|
||||||
|
</PropertyGroup>
|
||||||
|
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
|
||||||
|
<ImportGroup Label="ExtensionSettings">
|
||||||
|
</ImportGroup>
|
||||||
|
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
|
||||||
|
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||||
|
<Import Project="gmock_config.props" />
|
||||||
|
</ImportGroup>
|
||||||
|
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
|
||||||
|
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||||
|
<Import Project="gmock_config.props" />
|
||||||
|
</ImportGroup>
|
||||||
|
<PropertyGroup Label="UserMacros" />
|
||||||
|
<PropertyGroup>
|
||||||
|
<_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
|
||||||
|
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
|
||||||
|
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)$(ProjectName)\</IntDir>
|
||||||
|
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
|
||||||
|
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
|
||||||
|
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)$(ProjectName)\</IntDir>
|
||||||
|
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
|
||||||
|
</PropertyGroup>
|
||||||
|
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||||
|
<ClCompile>
|
||||||
|
<AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
|
||||||
|
<Optimization>Disabled</Optimization>
|
||||||
|
<AdditionalIncludeDirectories>..\..\include;..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||||
|
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||||
|
<MinimalRebuild>true</MinimalRebuild>
|
||||||
|
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
|
||||||
|
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
|
||||||
|
<PrecompiledHeader>
|
||||||
|
</PrecompiledHeader>
|
||||||
|
<WarningLevel>Level3</WarningLevel>
|
||||||
|
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
|
||||||
|
</ClCompile>
|
||||||
|
<Link>
|
||||||
|
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||||
|
<SubSystem>Console</SubSystem>
|
||||||
|
<TargetMachine>MachineX86</TargetMachine>
|
||||||
|
</Link>
|
||||||
|
</ItemDefinitionGroup>
|
||||||
|
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||||
|
<ClCompile>
|
||||||
|
<AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
|
||||||
|
<AdditionalIncludeDirectories>..\..\include;..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||||
|
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||||
|
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
|
||||||
|
<PrecompiledHeader>
|
||||||
|
</PrecompiledHeader>
|
||||||
|
<WarningLevel>Level3</WarningLevel>
|
||||||
|
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
|
||||||
|
</ClCompile>
|
||||||
|
<Link>
|
||||||
|
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||||
|
<SubSystem>Console</SubSystem>
|
||||||
|
<OptimizeReferences>true</OptimizeReferences>
|
||||||
|
<EnableCOMDATFolding>true</EnableCOMDATFolding>
|
||||||
|
<TargetMachine>MachineX86</TargetMachine>
|
||||||
|
</Link>
|
||||||
|
</ItemDefinitionGroup>
|
||||||
|
<ItemGroup>
|
||||||
|
<ProjectReference Include="gmock_main.vcxproj">
|
||||||
|
<Project>{e4ef614b-30df-4954-8c53-580a0bf6b589}</Project>
|
||||||
|
<CopyLocalSatelliteAssemblies>true</CopyLocalSatelliteAssemblies>
|
||||||
|
<ReferenceOutputAssembly>true</ReferenceOutputAssembly>
|
||||||
|
</ProjectReference>
|
||||||
|
</ItemGroup>
|
||||||
|
<ItemGroup>
|
||||||
|
<ClCompile Include="..\..\test\gmock_all_test.cc" />
|
||||||
|
</ItemGroup>
|
||||||
|
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||||
|
<ImportGroup Label="ExtensionTargets">
|
||||||
|
</ImportGroup>
|
||||||
|
</Project>
|
|
@ -0,0 +1,240 @@
|
||||||
|
#!/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.
|
||||||
|
|
||||||
|
"""fuse_gmock_files.py v0.1.0
|
||||||
|
Fuses Google Mock and Google Test source code into two .h files and a .cc file.
|
||||||
|
|
||||||
|
SYNOPSIS
|
||||||
|
fuse_gmock_files.py [GMOCK_ROOT_DIR] OUTPUT_DIR
|
||||||
|
|
||||||
|
Scans GMOCK_ROOT_DIR for Google Mock and Google Test source
|
||||||
|
code, assuming Google Test is in the GMOCK_ROOT_DIR/gtest
|
||||||
|
sub-directory, and generates three files:
|
||||||
|
OUTPUT_DIR/gtest/gtest.h, OUTPUT_DIR/gmock/gmock.h, and
|
||||||
|
OUTPUT_DIR/gmock-gtest-all.cc. Then you can build your tests
|
||||||
|
by adding OUTPUT_DIR to the include search path and linking
|
||||||
|
with OUTPUT_DIR/gmock-gtest-all.cc. These three files contain
|
||||||
|
everything you need to use Google Mock. Hence you can
|
||||||
|
"install" Google Mock by copying them to wherever you want.
|
||||||
|
|
||||||
|
GMOCK_ROOT_DIR can be omitted and defaults to the parent
|
||||||
|
directory of the directory holding this script.
|
||||||
|
|
||||||
|
EXAMPLES
|
||||||
|
./fuse_gmock_files.py fused_gmock
|
||||||
|
./fuse_gmock_files.py path/to/unpacked/gmock fused_gmock
|
||||||
|
|
||||||
|
This tool is experimental. In particular, it assumes that there is no
|
||||||
|
conditional inclusion of Google Mock or Google Test headers. Please
|
||||||
|
report any problems to googlemock@googlegroups.com. You can read
|
||||||
|
http://code.google.com/p/googlemock/wiki/CookBook for more
|
||||||
|
information.
|
||||||
|
"""
|
||||||
|
|
||||||
|
__author__ = 'wan@google.com (Zhanyong Wan)'
|
||||||
|
|
||||||
|
import os
|
||||||
|
import re
|
||||||
|
import sets
|
||||||
|
import sys
|
||||||
|
|
||||||
|
# We assume that this file is in the scripts/ directory in the Google
|
||||||
|
# Mock root directory.
|
||||||
|
DEFAULT_GMOCK_ROOT_DIR = os.path.join(os.path.dirname(__file__), '..')
|
||||||
|
|
||||||
|
# We need to call into gtest/scripts/fuse_gtest_files.py.
|
||||||
|
sys.path.append(os.path.join(DEFAULT_GMOCK_ROOT_DIR, 'gtest/scripts'))
|
||||||
|
import fuse_gtest_files
|
||||||
|
gtest = fuse_gtest_files
|
||||||
|
|
||||||
|
# Regex for matching '#include "gmock/..."'.
|
||||||
|
INCLUDE_GMOCK_FILE_REGEX = re.compile(r'^\s*#\s*include\s*"(gmock/.+)"')
|
||||||
|
|
||||||
|
# Where to find the source seed files.
|
||||||
|
GMOCK_H_SEED = 'include/gmock/gmock.h'
|
||||||
|
GMOCK_ALL_CC_SEED = 'src/gmock-all.cc'
|
||||||
|
|
||||||
|
# Where to put the generated files.
|
||||||
|
GTEST_H_OUTPUT = 'gtest/gtest.h'
|
||||||
|
GMOCK_H_OUTPUT = 'gmock/gmock.h'
|
||||||
|
GMOCK_GTEST_ALL_CC_OUTPUT = 'gmock-gtest-all.cc'
|
||||||
|
|
||||||
|
|
||||||
|
def GetGTestRootDir(gmock_root):
|
||||||
|
"""Returns the root directory of Google Test."""
|
||||||
|
|
||||||
|
return os.path.join(gmock_root, 'gtest')
|
||||||
|
|
||||||
|
|
||||||
|
def ValidateGMockRootDir(gmock_root):
|
||||||
|
"""Makes sure gmock_root points to a valid gmock root directory.
|
||||||
|
|
||||||
|
The function aborts the program on failure.
|
||||||
|
"""
|
||||||
|
|
||||||
|
gtest.ValidateGTestRootDir(GetGTestRootDir(gmock_root))
|
||||||
|
gtest.VerifyFileExists(gmock_root, GMOCK_H_SEED)
|
||||||
|
gtest.VerifyFileExists(gmock_root, GMOCK_ALL_CC_SEED)
|
||||||
|
|
||||||
|
|
||||||
|
def ValidateOutputDir(output_dir):
|
||||||
|
"""Makes sure output_dir points to a valid output directory.
|
||||||
|
|
||||||
|
The function aborts the program on failure.
|
||||||
|
"""
|
||||||
|
|
||||||
|
gtest.VerifyOutputFile(output_dir, gtest.GTEST_H_OUTPUT)
|
||||||
|
gtest.VerifyOutputFile(output_dir, GMOCK_H_OUTPUT)
|
||||||
|
gtest.VerifyOutputFile(output_dir, GMOCK_GTEST_ALL_CC_OUTPUT)
|
||||||
|
|
||||||
|
|
||||||
|
def FuseGMockH(gmock_root, output_dir):
|
||||||
|
"""Scans folder gmock_root to generate gmock/gmock.h in output_dir."""
|
||||||
|
|
||||||
|
output_file = file(os.path.join(output_dir, GMOCK_H_OUTPUT), 'w')
|
||||||
|
processed_files = sets.Set() # Holds all gmock headers we've processed.
|
||||||
|
|
||||||
|
def ProcessFile(gmock_header_path):
|
||||||
|
"""Processes the given gmock header file."""
|
||||||
|
|
||||||
|
# We don't process the same header twice.
|
||||||
|
if gmock_header_path in processed_files:
|
||||||
|
return
|
||||||
|
|
||||||
|
processed_files.add(gmock_header_path)
|
||||||
|
|
||||||
|
# Reads each line in the given gmock header.
|
||||||
|
for line in file(os.path.join(gmock_root, gmock_header_path), 'r'):
|
||||||
|
m = INCLUDE_GMOCK_FILE_REGEX.match(line)
|
||||||
|
if m:
|
||||||
|
# It's '#include "gmock/..."' - let's process it recursively.
|
||||||
|
ProcessFile('include/' + m.group(1))
|
||||||
|
else:
|
||||||
|
m = gtest.INCLUDE_GTEST_FILE_REGEX.match(line)
|
||||||
|
if m:
|
||||||
|
# It's '#include "gtest/foo.h"'. We translate it to
|
||||||
|
# "gtest/gtest.h", regardless of what foo is, since all
|
||||||
|
# gtest headers are fused into gtest/gtest.h.
|
||||||
|
|
||||||
|
# There is no need to #include gtest.h twice.
|
||||||
|
if not gtest.GTEST_H_SEED in processed_files:
|
||||||
|
processed_files.add(gtest.GTEST_H_SEED)
|
||||||
|
output_file.write('#include "%s"\n' % (gtest.GTEST_H_OUTPUT,))
|
||||||
|
else:
|
||||||
|
# Otherwise we copy the line unchanged to the output file.
|
||||||
|
output_file.write(line)
|
||||||
|
|
||||||
|
ProcessFile(GMOCK_H_SEED)
|
||||||
|
output_file.close()
|
||||||
|
|
||||||
|
|
||||||
|
def FuseGMockAllCcToFile(gmock_root, output_file):
|
||||||
|
"""Scans folder gmock_root to fuse gmock-all.cc into output_file."""
|
||||||
|
|
||||||
|
processed_files = sets.Set()
|
||||||
|
|
||||||
|
def ProcessFile(gmock_source_file):
|
||||||
|
"""Processes the given gmock source file."""
|
||||||
|
|
||||||
|
# We don't process the same #included file twice.
|
||||||
|
if gmock_source_file in processed_files:
|
||||||
|
return
|
||||||
|
|
||||||
|
processed_files.add(gmock_source_file)
|
||||||
|
|
||||||
|
# Reads each line in the given gmock source file.
|
||||||
|
for line in file(os.path.join(gmock_root, gmock_source_file), 'r'):
|
||||||
|
m = INCLUDE_GMOCK_FILE_REGEX.match(line)
|
||||||
|
if m:
|
||||||
|
# It's '#include "gmock/foo.h"'. We treat it as '#include
|
||||||
|
# "gmock/gmock.h"', as all other gmock headers are being fused
|
||||||
|
# into gmock.h and cannot be #included directly.
|
||||||
|
|
||||||
|
# There is no need to #include "gmock/gmock.h" more than once.
|
||||||
|
if not GMOCK_H_SEED in processed_files:
|
||||||
|
processed_files.add(GMOCK_H_SEED)
|
||||||
|
output_file.write('#include "%s"\n' % (GMOCK_H_OUTPUT,))
|
||||||
|
else:
|
||||||
|
m = gtest.INCLUDE_GTEST_FILE_REGEX.match(line)
|
||||||
|
if m:
|
||||||
|
# It's '#include "gtest/..."'.
|
||||||
|
# There is no need to #include gtest.h as it has been
|
||||||
|
# #included by gtest-all.cc.
|
||||||
|
pass
|
||||||
|
else:
|
||||||
|
m = gtest.INCLUDE_SRC_FILE_REGEX.match(line)
|
||||||
|
if m:
|
||||||
|
# It's '#include "src/foo"' - let's process it recursively.
|
||||||
|
ProcessFile(m.group(1))
|
||||||
|
else:
|
||||||
|
# Otherwise we copy the line unchanged to the output file.
|
||||||
|
output_file.write(line)
|
||||||
|
|
||||||
|
ProcessFile(GMOCK_ALL_CC_SEED)
|
||||||
|
|
||||||
|
|
||||||
|
def FuseGMockGTestAllCc(gmock_root, output_dir):
|
||||||
|
"""Scans folder gmock_root to generate gmock-gtest-all.cc in output_dir."""
|
||||||
|
|
||||||
|
output_file = file(os.path.join(output_dir, GMOCK_GTEST_ALL_CC_OUTPUT), 'w')
|
||||||
|
# First, fuse gtest-all.cc into gmock-gtest-all.cc.
|
||||||
|
gtest.FuseGTestAllCcToFile(GetGTestRootDir(gmock_root), output_file)
|
||||||
|
# Next, append fused gmock-all.cc to gmock-gtest-all.cc.
|
||||||
|
FuseGMockAllCcToFile(gmock_root, output_file)
|
||||||
|
output_file.close()
|
||||||
|
|
||||||
|
|
||||||
|
def FuseGMock(gmock_root, output_dir):
|
||||||
|
"""Fuses gtest.h, gmock.h, and gmock-gtest-all.h."""
|
||||||
|
|
||||||
|
ValidateGMockRootDir(gmock_root)
|
||||||
|
ValidateOutputDir(output_dir)
|
||||||
|
|
||||||
|
gtest.FuseGTestH(GetGTestRootDir(gmock_root), output_dir)
|
||||||
|
FuseGMockH(gmock_root, output_dir)
|
||||||
|
FuseGMockGTestAllCc(gmock_root, output_dir)
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
argc = len(sys.argv)
|
||||||
|
if argc == 2:
|
||||||
|
# fuse_gmock_files.py OUTPUT_DIR
|
||||||
|
FuseGMock(DEFAULT_GMOCK_ROOT_DIR, sys.argv[1])
|
||||||
|
elif argc == 3:
|
||||||
|
# fuse_gmock_files.py GMOCK_ROOT_DIR OUTPUT_DIR
|
||||||
|
FuseGMock(sys.argv[1], sys.argv[2])
|
||||||
|
else:
|
||||||
|
print __doc__
|
||||||
|
sys.exit(1)
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == '__main__':
|
||||||
|
main()
|
|
@ -0,0 +1,203 @@
|
||||||
|
|
||||||
|
Apache License
|
||||||
|
Version 2.0, January 2004
|
||||||
|
http://www.apache.org/licenses/
|
||||||
|
|
||||||
|
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||||
|
|
||||||
|
1. Definitions.
|
||||||
|
|
||||||
|
"License" shall mean the terms and conditions for use, reproduction,
|
||||||
|
and distribution as defined by Sections 1 through 9 of this document.
|
||||||
|
|
||||||
|
"Licensor" shall mean the copyright owner or entity authorized by
|
||||||
|
the copyright owner that is granting the License.
|
||||||
|
|
||||||
|
"Legal Entity" shall mean the union of the acting entity and all
|
||||||
|
other entities that control, are controlled by, or are under common
|
||||||
|
control with that entity. For the purposes of this definition,
|
||||||
|
"control" means (i) the power, direct or indirect, to cause the
|
||||||
|
direction or management of such entity, whether by contract or
|
||||||
|
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||||
|
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||||
|
|
||||||
|
"You" (or "Your") shall mean an individual or Legal Entity
|
||||||
|
exercising permissions granted by this License.
|
||||||
|
|
||||||
|
"Source" form shall mean the preferred form for making modifications,
|
||||||
|
including but not limited to software source code, documentation
|
||||||
|
source, and configuration files.
|
||||||
|
|
||||||
|
"Object" form shall mean any form resulting from mechanical
|
||||||
|
transformation or translation of a Source form, including but
|
||||||
|
not limited to compiled object code, generated documentation,
|
||||||
|
and conversions to other media types.
|
||||||
|
|
||||||
|
"Work" shall mean the work of authorship, whether in Source or
|
||||||
|
Object form, made available under the License, as indicated by a
|
||||||
|
copyright notice that is included in or attached to the work
|
||||||
|
(an example is provided in the Appendix below).
|
||||||
|
|
||||||
|
"Derivative Works" shall mean any work, whether in Source or Object
|
||||||
|
form, that is based on (or derived from) the Work and for which the
|
||||||
|
editorial revisions, annotations, elaborations, or other modifications
|
||||||
|
represent, as a whole, an original work of authorship. For the purposes
|
||||||
|
of this License, Derivative Works shall not include works that remain
|
||||||
|
separable from, or merely link (or bind by name) to the interfaces of,
|
||||||
|
the Work and Derivative Works thereof.
|
||||||
|
|
||||||
|
"Contribution" shall mean any work of authorship, including
|
||||||
|
the original version of the Work and any modifications or additions
|
||||||
|
to that Work or Derivative Works thereof, that is intentionally
|
||||||
|
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||||
|
or by an individual or Legal Entity authorized to submit on behalf of
|
||||||
|
the copyright owner. For the purposes of this definition, "submitted"
|
||||||
|
means any form of electronic, verbal, or written communication sent
|
||||||
|
to the Licensor or its representatives, including but not limited to
|
||||||
|
communication on electronic mailing lists, source code control systems,
|
||||||
|
and issue tracking systems that are managed by, or on behalf of, the
|
||||||
|
Licensor for the purpose of discussing and improving the Work, but
|
||||||
|
excluding communication that is conspicuously marked or otherwise
|
||||||
|
designated in writing by the copyright owner as "Not a Contribution."
|
||||||
|
|
||||||
|
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||||
|
on behalf of whom a Contribution has been received by Licensor and
|
||||||
|
subsequently incorporated within the Work.
|
||||||
|
|
||||||
|
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||||
|
this License, each Contributor hereby grants to You a perpetual,
|
||||||
|
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||||
|
copyright license to reproduce, prepare Derivative Works of,
|
||||||
|
publicly display, publicly perform, sublicense, and distribute the
|
||||||
|
Work and such Derivative Works in Source or Object form.
|
||||||
|
|
||||||
|
3. Grant of Patent License. Subject to the terms and conditions of
|
||||||
|
this License, each Contributor hereby grants to You a perpetual,
|
||||||
|
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||||
|
(except as stated in this section) patent license to make, have made,
|
||||||
|
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||||
|
where such license applies only to those patent claims licensable
|
||||||
|
by such Contributor that are necessarily infringed by their
|
||||||
|
Contribution(s) alone or by combination of their Contribution(s)
|
||||||
|
with the Work to which such Contribution(s) was submitted. If You
|
||||||
|
institute patent litigation against any entity (including a
|
||||||
|
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||||
|
or a Contribution incorporated within the Work constitutes direct
|
||||||
|
or contributory patent infringement, then any patent licenses
|
||||||
|
granted to You under this License for that Work shall terminate
|
||||||
|
as of the date such litigation is filed.
|
||||||
|
|
||||||
|
4. Redistribution. You may reproduce and distribute copies of the
|
||||||
|
Work or Derivative Works thereof in any medium, with or without
|
||||||
|
modifications, and in Source or Object form, provided that You
|
||||||
|
meet the following conditions:
|
||||||
|
|
||||||
|
(a) You must give any other recipients of the Work or
|
||||||
|
Derivative Works a copy of this License; and
|
||||||
|
|
||||||
|
(b) You must cause any modified files to carry prominent notices
|
||||||
|
stating that You changed the files; and
|
||||||
|
|
||||||
|
(c) You must retain, in the Source form of any Derivative Works
|
||||||
|
that You distribute, all copyright, patent, trademark, and
|
||||||
|
attribution notices from the Source form of the Work,
|
||||||
|
excluding those notices that do not pertain to any part of
|
||||||
|
the Derivative Works; and
|
||||||
|
|
||||||
|
(d) If the Work includes a "NOTICE" text file as part of its
|
||||||
|
distribution, then any Derivative Works that You distribute must
|
||||||
|
include a readable copy of the attribution notices contained
|
||||||
|
within such NOTICE file, excluding those notices that do not
|
||||||
|
pertain to any part of the Derivative Works, in at least one
|
||||||
|
of the following places: within a NOTICE text file distributed
|
||||||
|
as part of the Derivative Works; within the Source form or
|
||||||
|
documentation, if provided along with the Derivative Works; or,
|
||||||
|
within a display generated by the Derivative Works, if and
|
||||||
|
wherever such third-party notices normally appear. The contents
|
||||||
|
of the NOTICE file are for informational purposes only and
|
||||||
|
do not modify the License. You may add Your own attribution
|
||||||
|
notices within Derivative Works that You distribute, alongside
|
||||||
|
or as an addendum to the NOTICE text from the Work, provided
|
||||||
|
that such additional attribution notices cannot be construed
|
||||||
|
as modifying the License.
|
||||||
|
|
||||||
|
You may add Your own copyright statement to Your modifications and
|
||||||
|
may provide additional or different license terms and conditions
|
||||||
|
for use, reproduction, or distribution of Your modifications, or
|
||||||
|
for any such Derivative Works as a whole, provided Your use,
|
||||||
|
reproduction, and distribution of the Work otherwise complies with
|
||||||
|
the conditions stated in this License.
|
||||||
|
|
||||||
|
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||||
|
any Contribution intentionally submitted for inclusion in the Work
|
||||||
|
by You to the Licensor shall be under the terms and conditions of
|
||||||
|
this License, without any additional terms or conditions.
|
||||||
|
Notwithstanding the above, nothing herein shall supersede or modify
|
||||||
|
the terms of any separate license agreement you may have executed
|
||||||
|
with Licensor regarding such Contributions.
|
||||||
|
|
||||||
|
6. Trademarks. This License does not grant permission to use the trade
|
||||||
|
names, trademarks, service marks, or product names of the Licensor,
|
||||||
|
except as required for reasonable and customary use in describing the
|
||||||
|
origin of the Work and reproducing the content of the NOTICE file.
|
||||||
|
|
||||||
|
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||||
|
agreed to in writing, Licensor provides the Work (and each
|
||||||
|
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||||
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||||
|
implied, including, without limitation, any warranties or conditions
|
||||||
|
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||||
|
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||||
|
appropriateness of using or redistributing the Work and assume any
|
||||||
|
risks associated with Your exercise of permissions under this License.
|
||||||
|
|
||||||
|
8. Limitation of Liability. In no event and under no legal theory,
|
||||||
|
whether in tort (including negligence), contract, or otherwise,
|
||||||
|
unless required by applicable law (such as deliberate and grossly
|
||||||
|
negligent acts) or agreed to in writing, shall any Contributor be
|
||||||
|
liable to You for damages, including any direct, indirect, special,
|
||||||
|
incidental, or consequential damages of any character arising as a
|
||||||
|
result of this License or out of the use or inability to use the
|
||||||
|
Work (including but not limited to damages for loss of goodwill,
|
||||||
|
work stoppage, computer failure or malfunction, or any and all
|
||||||
|
other commercial damages or losses), even if such Contributor
|
||||||
|
has been advised of the possibility of such damages.
|
||||||
|
|
||||||
|
9. Accepting Warranty or Additional Liability. While redistributing
|
||||||
|
the Work or Derivative Works thereof, You may choose to offer,
|
||||||
|
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||||
|
or other liability obligations and/or rights consistent with this
|
||||||
|
License. However, in accepting such obligations, You may act only
|
||||||
|
on Your own behalf and on Your sole responsibility, not on behalf
|
||||||
|
of any other Contributor, and only if You agree to indemnify,
|
||||||
|
defend, and hold each Contributor harmless for any liability
|
||||||
|
incurred by, or claims asserted against, such Contributor by reason
|
||||||
|
of your accepting any such warranty or additional liability.
|
||||||
|
|
||||||
|
END OF TERMS AND CONDITIONS
|
||||||
|
|
||||||
|
APPENDIX: How to apply the Apache License to your work.
|
||||||
|
|
||||||
|
To apply the Apache License to your work, attach the following
|
||||||
|
boilerplate notice, with the fields enclosed by brackets "[]"
|
||||||
|
replaced with your own identifying information. (Don't include
|
||||||
|
the brackets!) The text should be enclosed in the appropriate
|
||||||
|
comment syntax for the file format. We also recommend that a
|
||||||
|
file or class name and description of purpose be included on the
|
||||||
|
same "printed page" as the copyright notice for easier
|
||||||
|
identification within third-party archives.
|
||||||
|
|
||||||
|
Copyright [2007] Neal Norwitz
|
||||||
|
Portions Copyright [2007] Google Inc.
|
||||||
|
|
||||||
|
Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
you may not use this file except in compliance with the License.
|
||||||
|
You may obtain a copy of the License at
|
||||||
|
|
||||||
|
http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
|
||||||
|
Unless required by applicable law or agreed to in writing, software
|
||||||
|
distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
See the License for the specific language governing permissions and
|
||||||
|
limitations under the License.
|
|
@ -0,0 +1,35 @@
|
||||||
|
|
||||||
|
The Google Mock class generator is an application that is part of cppclean.
|
||||||
|
For more information about cppclean, see the README.cppclean file or
|
||||||
|
visit http://code.google.com/p/cppclean/
|
||||||
|
|
||||||
|
cppclean requires Python 2.3.5 or later. If you don't have Python installed
|
||||||
|
on your system, you will also need to install it. You can download Python
|
||||||
|
from: http://www.python.org/download/releases/
|
||||||
|
|
||||||
|
To use the Google Mock class generator, you need to call it
|
||||||
|
on the command line passing the header file and class for which you want
|
||||||
|
to generate a Google Mock class.
|
||||||
|
|
||||||
|
Make sure to install the scripts somewhere in your path. Then you can
|
||||||
|
run the program.
|
||||||
|
|
||||||
|
gmock_gen.py header-file.h [ClassName]...
|
||||||
|
|
||||||
|
If no ClassNames are specified, all classes in the file are emitted.
|
||||||
|
|
||||||
|
To change the indentation from the default of 2, set INDENT in
|
||||||
|
the environment. For example to use an indent of 4 spaces:
|
||||||
|
|
||||||
|
INDENT=4 gmock_gen.py header-file.h ClassName
|
||||||
|
|
||||||
|
This version was made from SVN revision 281 in the cppclean repository.
|
||||||
|
|
||||||
|
Known Limitations
|
||||||
|
-----------------
|
||||||
|
Not all code will be generated properly. For example, when mocking templated
|
||||||
|
classes, the template information is lost. You will need to add the template
|
||||||
|
information manually.
|
||||||
|
|
||||||
|
Not all permutations of using multiple pointers/references will be rendered
|
||||||
|
properly. These will also have to be fixed manually.
|
|
@ -0,0 +1,115 @@
|
||||||
|
Goal:
|
||||||
|
-----
|
||||||
|
CppClean attempts to find problems in C++ source that slow development
|
||||||
|
in large code bases, for example various forms of unused code.
|
||||||
|
Unused code can be unused functions, methods, data members, types, etc
|
||||||
|
to unnecessary #include directives. Unnecessary #includes can cause
|
||||||
|
considerable extra compiles increasing the edit-compile-run cycle.
|
||||||
|
|
||||||
|
The project home page is: http://code.google.com/p/cppclean/
|
||||||
|
|
||||||
|
|
||||||
|
Features:
|
||||||
|
---------
|
||||||
|
* Find and print C++ language constructs: classes, methods, functions, etc.
|
||||||
|
* Find classes with virtual methods, no virtual destructor, and no bases
|
||||||
|
* Find global/static data that are potential problems when using threads
|
||||||
|
* Unnecessary forward class declarations
|
||||||
|
* Unnecessary function declarations
|
||||||
|
* Undeclared function definitions
|
||||||
|
* (planned) Find unnecessary header files #included
|
||||||
|
- No direct reference to anything in the header
|
||||||
|
- Header is unnecessary if classes were forward declared instead
|
||||||
|
* (planned) Source files that reference headers not directly #included,
|
||||||
|
ie, files that rely on a transitive #include from another header
|
||||||
|
* (planned) Unused members (private, protected, & public) methods and data
|
||||||
|
* (planned) Store AST in a SQL database so relationships can be queried
|
||||||
|
|
||||||
|
AST is Abstract Syntax Tree, a representation of parsed source code.
|
||||||
|
http://en.wikipedia.org/wiki/Abstract_syntax_tree
|
||||||
|
|
||||||
|
|
||||||
|
System Requirements:
|
||||||
|
--------------------
|
||||||
|
* Python 2.4 or later (2.3 probably works too)
|
||||||
|
* Works on Windows (untested), Mac OS X, and Unix
|
||||||
|
|
||||||
|
|
||||||
|
How to Run:
|
||||||
|
-----------
|
||||||
|
For all examples, it is assumed that cppclean resides in a directory called
|
||||||
|
/cppclean.
|
||||||
|
|
||||||
|
To print warnings for classes with virtual methods, no virtual destructor and
|
||||||
|
no base classes:
|
||||||
|
|
||||||
|
/cppclean/run.sh nonvirtual_dtors.py file1.h file2.h file3.cc ...
|
||||||
|
|
||||||
|
To print all the functions defined in header file(s):
|
||||||
|
|
||||||
|
/cppclean/run.sh functions.py file1.h file2.h ...
|
||||||
|
|
||||||
|
All the commands take multiple files on the command line. Other programs
|
||||||
|
include: find_warnings, headers, methods, and types. Some other programs
|
||||||
|
are available, but used primarily for debugging.
|
||||||
|
|
||||||
|
run.sh is a simple wrapper that sets PYTHONPATH to /cppclean and then
|
||||||
|
runs the program in /cppclean/cpp/PROGRAM.py. There is currently
|
||||||
|
no equivalent for Windows. Contributions for a run.bat file
|
||||||
|
would be greatly appreciated.
|
||||||
|
|
||||||
|
|
||||||
|
How to Configure:
|
||||||
|
-----------------
|
||||||
|
You can add a siteheaders.py file in /cppclean/cpp to configure where
|
||||||
|
to look for other headers (typically -I options passed to a compiler).
|
||||||
|
Currently two values are supported: _TRANSITIVE and GetIncludeDirs.
|
||||||
|
_TRANSITIVE should be set to a boolean value (True or False) indicating
|
||||||
|
whether to transitively process all header files. The default is False.
|
||||||
|
|
||||||
|
GetIncludeDirs is a function that takes a single argument and returns
|
||||||
|
a sequence of directories to include. This can be a generator or
|
||||||
|
return a static list.
|
||||||
|
|
||||||
|
def GetIncludeDirs(filename):
|
||||||
|
return ['/some/path/with/other/headers']
|
||||||
|
|
||||||
|
# Here is a more complicated example.
|
||||||
|
def GetIncludeDirs(filename):
|
||||||
|
yield '/path1'
|
||||||
|
yield os.path.join('/path2', os.path.dirname(filename))
|
||||||
|
yield '/path3'
|
||||||
|
|
||||||
|
|
||||||
|
How to Test:
|
||||||
|
------------
|
||||||
|
For all examples, it is assumed that cppclean resides in a directory called
|
||||||
|
/cppclean. The tests require
|
||||||
|
|
||||||
|
cd /cppclean
|
||||||
|
make test
|
||||||
|
# To generate expected results after a change:
|
||||||
|
make expected
|
||||||
|
|
||||||
|
|
||||||
|
Current Status:
|
||||||
|
---------------
|
||||||
|
The parser works pretty well for header files, parsing about 99% of Google's
|
||||||
|
header files. Anything which inspects structure of C++ source files should
|
||||||
|
work reasonably well. Function bodies are not transformed to an AST,
|
||||||
|
but left as tokens. Much work is still needed on finding unused header files
|
||||||
|
and storing an AST in a database.
|
||||||
|
|
||||||
|
|
||||||
|
Non-goals:
|
||||||
|
----------
|
||||||
|
* Parsing all valid C++ source
|
||||||
|
* Handling invalid C++ source gracefully
|
||||||
|
* Compiling to machine code (or anything beyond an AST)
|
||||||
|
|
||||||
|
|
||||||
|
Contact:
|
||||||
|
--------
|
||||||
|
If you used cppclean, I would love to hear about your experiences
|
||||||
|
cppclean@googlegroups.com. Even if you don't use cppclean, I'd like to
|
||||||
|
hear from you. :-) (You can contact me directly at: nnorwitz@gmail.com)
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,192 @@
|
||||||
|
#!/usr/bin/env python
|
||||||
|
#
|
||||||
|
# Copyright 2008 Google Inc. All Rights Reserved.
|
||||||
|
#
|
||||||
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
# you may not use this file except in compliance with the License.
|
||||||
|
# You may obtain a copy of the License at
|
||||||
|
#
|
||||||
|
# http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
#
|
||||||
|
# Unless required by applicable law or agreed to in writing, software
|
||||||
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
# See the License for the specific language governing permissions and
|
||||||
|
# limitations under the License.
|
||||||
|
|
||||||
|
"""Generate Google Mock classes from base classes.
|
||||||
|
|
||||||
|
This program will read in a C++ source file and output the Google Mock
|
||||||
|
classes for the specified classes. If no class is specified, all
|
||||||
|
classes in the source file are emitted.
|
||||||
|
|
||||||
|
Usage:
|
||||||
|
gmock_class.py header-file.h [ClassName]...
|
||||||
|
|
||||||
|
Output is sent to stdout.
|
||||||
|
"""
|
||||||
|
|
||||||
|
__author__ = 'nnorwitz@google.com (Neal Norwitz)'
|
||||||
|
|
||||||
|
|
||||||
|
import os
|
||||||
|
import re
|
||||||
|
import sys
|
||||||
|
|
||||||
|
from cpp import ast
|
||||||
|
from cpp import utils
|
||||||
|
|
||||||
|
# Preserve compatibility with Python 2.3.
|
||||||
|
try:
|
||||||
|
_dummy = set
|
||||||
|
except NameError:
|
||||||
|
import sets
|
||||||
|
set = sets.Set
|
||||||
|
|
||||||
|
_VERSION = (1, 0, 1) # The version of this script.
|
||||||
|
# How many spaces to indent. Can set me with the INDENT environment variable.
|
||||||
|
_INDENT = 2
|
||||||
|
|
||||||
|
|
||||||
|
def _GenerateMethods(output_lines, source, class_node):
|
||||||
|
function_type = ast.FUNCTION_VIRTUAL | ast.FUNCTION_PURE_VIRTUAL
|
||||||
|
ctor_or_dtor = ast.FUNCTION_CTOR | ast.FUNCTION_DTOR
|
||||||
|
indent = ' ' * _INDENT
|
||||||
|
|
||||||
|
for node in class_node.body:
|
||||||
|
# We only care about virtual functions.
|
||||||
|
if (isinstance(node, ast.Function) and
|
||||||
|
node.modifiers & function_type and
|
||||||
|
not node.modifiers & ctor_or_dtor):
|
||||||
|
# Pick out all the elements we need from the original function.
|
||||||
|
const = ''
|
||||||
|
if node.modifiers & ast.FUNCTION_CONST:
|
||||||
|
const = 'CONST_'
|
||||||
|
return_type = 'void'
|
||||||
|
if node.return_type:
|
||||||
|
# Add modifiers like 'const'.
|
||||||
|
modifiers = ''
|
||||||
|
if node.return_type.modifiers:
|
||||||
|
modifiers = ' '.join(node.return_type.modifiers) + ' '
|
||||||
|
return_type = modifiers + node.return_type.name
|
||||||
|
template_args = [arg.name for arg in node.return_type.templated_types]
|
||||||
|
if template_args:
|
||||||
|
return_type += '<' + ', '.join(template_args) + '>'
|
||||||
|
if len(template_args) > 1:
|
||||||
|
for line in [
|
||||||
|
'// The following line won\'t really compile, as the return',
|
||||||
|
'// type has multiple template arguments. To fix it, use a',
|
||||||
|
'// typedef for the return type.']:
|
||||||
|
output_lines.append(indent + line)
|
||||||
|
if node.return_type.pointer:
|
||||||
|
return_type += '*'
|
||||||
|
if node.return_type.reference:
|
||||||
|
return_type += '&'
|
||||||
|
mock_method_macro = 'MOCK_%sMETHOD%d' % (const, len(node.parameters))
|
||||||
|
args = ''
|
||||||
|
if node.parameters:
|
||||||
|
# Get the full text of the parameters from the start
|
||||||
|
# of the first parameter to the end of the last parameter.
|
||||||
|
start = node.parameters[0].start
|
||||||
|
end = node.parameters[-1].end
|
||||||
|
# Remove // comments.
|
||||||
|
args_strings = re.sub(r'//.*', '', source[start:end])
|
||||||
|
# Condense multiple spaces and eliminate newlines putting the
|
||||||
|
# parameters together on a single line. Ensure there is a
|
||||||
|
# space in an argument which is split by a newline without
|
||||||
|
# intervening whitespace, e.g.: int\nBar
|
||||||
|
args = re.sub(' +', ' ', args_strings.replace('\n', ' '))
|
||||||
|
|
||||||
|
# Create the mock method definition.
|
||||||
|
output_lines.extend(['%s%s(%s,' % (indent, mock_method_macro, node.name),
|
||||||
|
'%s%s(%s));' % (indent*3, return_type, args)])
|
||||||
|
|
||||||
|
|
||||||
|
def _GenerateMocks(filename, source, ast_list, desired_class_names):
|
||||||
|
processed_class_names = set()
|
||||||
|
lines = []
|
||||||
|
for node in ast_list:
|
||||||
|
if (isinstance(node, ast.Class) and node.body and
|
||||||
|
# desired_class_names being None means that all classes are selected.
|
||||||
|
(not desired_class_names or node.name in desired_class_names)):
|
||||||
|
class_name = node.name
|
||||||
|
processed_class_names.add(class_name)
|
||||||
|
class_node = node
|
||||||
|
# Add namespace before the class.
|
||||||
|
if class_node.namespace:
|
||||||
|
lines.extend(['namespace %s {' % n for n in class_node.namespace]) # }
|
||||||
|
lines.append('')
|
||||||
|
|
||||||
|
# Add the class prolog.
|
||||||
|
lines.append('class Mock%s : public %s {' % (class_name, class_name)) # }
|
||||||
|
lines.append('%spublic:' % (' ' * (_INDENT // 2)))
|
||||||
|
|
||||||
|
# Add all the methods.
|
||||||
|
_GenerateMethods(lines, source, class_node)
|
||||||
|
|
||||||
|
# Close the class.
|
||||||
|
if lines:
|
||||||
|
# If there are no virtual methods, no need for a public label.
|
||||||
|
if len(lines) == 2:
|
||||||
|
del lines[-1]
|
||||||
|
|
||||||
|
# Only close the class if there really is a class.
|
||||||
|
lines.append('};')
|
||||||
|
lines.append('') # Add an extra newline.
|
||||||
|
|
||||||
|
# Close the namespace.
|
||||||
|
if class_node.namespace:
|
||||||
|
for i in range(len(class_node.namespace)-1, -1, -1):
|
||||||
|
lines.append('} // namespace %s' % class_node.namespace[i])
|
||||||
|
lines.append('') # Add an extra newline.
|
||||||
|
|
||||||
|
if desired_class_names:
|
||||||
|
missing_class_name_list = list(desired_class_names - processed_class_names)
|
||||||
|
if missing_class_name_list:
|
||||||
|
missing_class_name_list.sort()
|
||||||
|
sys.stderr.write('Class(es) not found in %s: %s\n' %
|
||||||
|
(filename, ', '.join(missing_class_name_list)))
|
||||||
|
elif not processed_class_names:
|
||||||
|
sys.stderr.write('No class found in %s\n' % filename)
|
||||||
|
|
||||||
|
return lines
|
||||||
|
|
||||||
|
|
||||||
|
def main(argv=sys.argv):
|
||||||
|
if len(argv) < 2:
|
||||||
|
sys.stderr.write('Google Mock Class Generator v%s\n\n' %
|
||||||
|
'.'.join(map(str, _VERSION)))
|
||||||
|
sys.stderr.write(__doc__)
|
||||||
|
return 1
|
||||||
|
|
||||||
|
global _INDENT
|
||||||
|
try:
|
||||||
|
_INDENT = int(os.environ['INDENT'])
|
||||||
|
except KeyError:
|
||||||
|
pass
|
||||||
|
except:
|
||||||
|
sys.stderr.write('Unable to use indent of %s\n' % os.environ.get('INDENT'))
|
||||||
|
|
||||||
|
filename = argv[1]
|
||||||
|
desired_class_names = None # None means all classes in the source file.
|
||||||
|
if len(argv) >= 3:
|
||||||
|
desired_class_names = set(argv[2:])
|
||||||
|
source = utils.ReadFile(filename)
|
||||||
|
if source is None:
|
||||||
|
return 1
|
||||||
|
|
||||||
|
builder = ast.BuilderFromSource(source, filename)
|
||||||
|
try:
|
||||||
|
entire_ast = filter(None, builder.Generate())
|
||||||
|
except KeyboardInterrupt:
|
||||||
|
return
|
||||||
|
except:
|
||||||
|
# An error message was already printed since we couldn't parse.
|
||||||
|
pass
|
||||||
|
else:
|
||||||
|
lines = _GenerateMocks(filename, source, entire_ast, desired_class_names)
|
||||||
|
sys.stdout.write('\n'.join(lines))
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == '__main__':
|
||||||
|
main(sys.argv)
|
|
@ -0,0 +1,59 @@
|
||||||
|
#!/usr/bin/env python
|
||||||
|
#
|
||||||
|
# Copyright 2007 Neal Norwitz
|
||||||
|
# Portions Copyright 2007 Google Inc.
|
||||||
|
#
|
||||||
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
# you may not use this file except in compliance with the License.
|
||||||
|
# You may obtain a copy of the License at
|
||||||
|
#
|
||||||
|
# http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
#
|
||||||
|
# Unless required by applicable law or agreed to in writing, software
|
||||||
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
# See the License for the specific language governing permissions and
|
||||||
|
# limitations under the License.
|
||||||
|
|
||||||
|
"""C++ keywords and helper utilities for determining keywords."""
|
||||||
|
|
||||||
|
__author__ = 'nnorwitz@google.com (Neal Norwitz)'
|
||||||
|
|
||||||
|
|
||||||
|
try:
|
||||||
|
# Python 3.x
|
||||||
|
import builtins
|
||||||
|
except ImportError:
|
||||||
|
# Python 2.x
|
||||||
|
import __builtin__ as builtins
|
||||||
|
|
||||||
|
|
||||||
|
if not hasattr(builtins, 'set'):
|
||||||
|
# Nominal support for Python 2.3.
|
||||||
|
from sets import Set as set
|
||||||
|
|
||||||
|
|
||||||
|
TYPES = set('bool char int long short double float void wchar_t unsigned signed'.split())
|
||||||
|
TYPE_MODIFIERS = set('auto register const inline extern static virtual volatile mutable'.split())
|
||||||
|
ACCESS = set('public protected private friend'.split())
|
||||||
|
|
||||||
|
CASTS = set('static_cast const_cast dynamic_cast reinterpret_cast'.split())
|
||||||
|
|
||||||
|
OTHERS = set('true false asm class namespace using explicit this operator sizeof'.split())
|
||||||
|
OTHER_TYPES = set('new delete typedef struct union enum typeid typename template'.split())
|
||||||
|
|
||||||
|
CONTROL = set('case switch default if else return goto'.split())
|
||||||
|
EXCEPTION = set('try catch throw'.split())
|
||||||
|
LOOP = set('while do for break continue'.split())
|
||||||
|
|
||||||
|
ALL = TYPES | TYPE_MODIFIERS | ACCESS | CASTS | OTHERS | OTHER_TYPES | CONTROL | EXCEPTION | LOOP
|
||||||
|
|
||||||
|
|
||||||
|
def IsKeyword(token):
|
||||||
|
return token in ALL
|
||||||
|
|
||||||
|
def IsBuiltinType(token):
|
||||||
|
if token in ('virtual', 'inline'):
|
||||||
|
# These only apply to methods, they can't be types by themselves.
|
||||||
|
return False
|
||||||
|
return token in TYPES or token in TYPE_MODIFIERS
|
|
@ -0,0 +1,287 @@
|
||||||
|
#!/usr/bin/env python
|
||||||
|
#
|
||||||
|
# Copyright 2007 Neal Norwitz
|
||||||
|
# Portions Copyright 2007 Google Inc.
|
||||||
|
#
|
||||||
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
# you may not use this file except in compliance with the License.
|
||||||
|
# You may obtain a copy of the License at
|
||||||
|
#
|
||||||
|
# http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
#
|
||||||
|
# Unless required by applicable law or agreed to in writing, software
|
||||||
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
# See the License for the specific language governing permissions and
|
||||||
|
# limitations under the License.
|
||||||
|
|
||||||
|
"""Tokenize C++ source code."""
|
||||||
|
|
||||||
|
__author__ = 'nnorwitz@google.com (Neal Norwitz)'
|
||||||
|
|
||||||
|
|
||||||
|
try:
|
||||||
|
# Python 3.x
|
||||||
|
import builtins
|
||||||
|
except ImportError:
|
||||||
|
# Python 2.x
|
||||||
|
import __builtin__ as builtins
|
||||||
|
|
||||||
|
|
||||||
|
import sys
|
||||||
|
|
||||||
|
from cpp import utils
|
||||||
|
|
||||||
|
|
||||||
|
if not hasattr(builtins, 'set'):
|
||||||
|
# Nominal support for Python 2.3.
|
||||||
|
from sets import Set as set
|
||||||
|
|
||||||
|
|
||||||
|
# Add $ as a valid identifier char since so much code uses it.
|
||||||
|
_letters = 'abcdefghijklmnopqrstuvwxyz'
|
||||||
|
VALID_IDENTIFIER_CHARS = set(_letters + _letters.upper() + '_0123456789$')
|
||||||
|
HEX_DIGITS = set('0123456789abcdefABCDEF')
|
||||||
|
INT_OR_FLOAT_DIGITS = set('01234567890eE-+')
|
||||||
|
|
||||||
|
|
||||||
|
# C++0x string preffixes.
|
||||||
|
_STR_PREFIXES = set(('R', 'u8', 'u8R', 'u', 'uR', 'U', 'UR', 'L', 'LR'))
|
||||||
|
|
||||||
|
|
||||||
|
# Token types.
|
||||||
|
UNKNOWN = 'UNKNOWN'
|
||||||
|
SYNTAX = 'SYNTAX'
|
||||||
|
CONSTANT = 'CONSTANT'
|
||||||
|
NAME = 'NAME'
|
||||||
|
PREPROCESSOR = 'PREPROCESSOR'
|
||||||
|
|
||||||
|
# Where the token originated from. This can be used for backtracking.
|
||||||
|
# It is always set to WHENCE_STREAM in this code.
|
||||||
|
WHENCE_STREAM, WHENCE_QUEUE = range(2)
|
||||||
|
|
||||||
|
|
||||||
|
class Token(object):
|
||||||
|
"""Data container to represent a C++ token.
|
||||||
|
|
||||||
|
Tokens can be identifiers, syntax char(s), constants, or
|
||||||
|
pre-processor directives.
|
||||||
|
|
||||||
|
start contains the index of the first char of the token in the source
|
||||||
|
end contains the index of the last char of the token in the source
|
||||||
|
"""
|
||||||
|
|
||||||
|
def __init__(self, token_type, name, start, end):
|
||||||
|
self.token_type = token_type
|
||||||
|
self.name = name
|
||||||
|
self.start = start
|
||||||
|
self.end = end
|
||||||
|
self.whence = WHENCE_STREAM
|
||||||
|
|
||||||
|
def __str__(self):
|
||||||
|
if not utils.DEBUG:
|
||||||
|
return 'Token(%r)' % self.name
|
||||||
|
return 'Token(%r, %s, %s)' % (self.name, self.start, self.end)
|
||||||
|
|
||||||
|
__repr__ = __str__
|
||||||
|
|
||||||
|
|
||||||
|
def _GetString(source, start, i):
|
||||||
|
i = source.find('"', i+1)
|
||||||
|
while source[i-1] == '\\':
|
||||||
|
# Count the trailing backslashes.
|
||||||
|
backslash_count = 1
|
||||||
|
j = i - 2
|
||||||
|
while source[j] == '\\':
|
||||||
|
backslash_count += 1
|
||||||
|
j -= 1
|
||||||
|
# When trailing backslashes are even, they escape each other.
|
||||||
|
if (backslash_count % 2) == 0:
|
||||||
|
break
|
||||||
|
i = source.find('"', i+1)
|
||||||
|
return i + 1
|
||||||
|
|
||||||
|
|
||||||
|
def _GetChar(source, start, i):
|
||||||
|
# NOTE(nnorwitz): may not be quite correct, should be good enough.
|
||||||
|
i = source.find("'", i+1)
|
||||||
|
while source[i-1] == '\\':
|
||||||
|
# Need to special case '\\'.
|
||||||
|
if (i - 2) > start and source[i-2] == '\\':
|
||||||
|
break
|
||||||
|
i = source.find("'", i+1)
|
||||||
|
# Try to handle unterminated single quotes (in a #if 0 block).
|
||||||
|
if i < 0:
|
||||||
|
i = start
|
||||||
|
return i + 1
|
||||||
|
|
||||||
|
|
||||||
|
def GetTokens(source):
|
||||||
|
"""Returns a sequence of Tokens.
|
||||||
|
|
||||||
|
Args:
|
||||||
|
source: string of C++ source code.
|
||||||
|
|
||||||
|
Yields:
|
||||||
|
Token that represents the next token in the source.
|
||||||
|
"""
|
||||||
|
# Cache various valid character sets for speed.
|
||||||
|
valid_identifier_chars = VALID_IDENTIFIER_CHARS
|
||||||
|
hex_digits = HEX_DIGITS
|
||||||
|
int_or_float_digits = INT_OR_FLOAT_DIGITS
|
||||||
|
int_or_float_digits2 = int_or_float_digits | set('.')
|
||||||
|
|
||||||
|
# Only ignore errors while in a #if 0 block.
|
||||||
|
ignore_errors = False
|
||||||
|
count_ifs = 0
|
||||||
|
|
||||||
|
i = 0
|
||||||
|
end = len(source)
|
||||||
|
while i < end:
|
||||||
|
# Skip whitespace.
|
||||||
|
while i < end and source[i].isspace():
|
||||||
|
i += 1
|
||||||
|
if i >= end:
|
||||||
|
return
|
||||||
|
|
||||||
|
token_type = UNKNOWN
|
||||||
|
start = i
|
||||||
|
c = source[i]
|
||||||
|
if c.isalpha() or c == '_': # Find a string token.
|
||||||
|
token_type = NAME
|
||||||
|
while source[i] in valid_identifier_chars:
|
||||||
|
i += 1
|
||||||
|
# String and character constants can look like a name if
|
||||||
|
# they are something like L"".
|
||||||
|
if (source[i] == "'" and (i - start) == 1 and
|
||||||
|
source[start:i] in 'uUL'):
|
||||||
|
# u, U, and L are valid C++0x character preffixes.
|
||||||
|
token_type = CONSTANT
|
||||||
|
i = _GetChar(source, start, i)
|
||||||
|
elif source[i] == "'" and source[start:i] in _STR_PREFIXES:
|
||||||
|
token_type = CONSTANT
|
||||||
|
i = _GetString(source, start, i)
|
||||||
|
elif c == '/' and source[i+1] == '/': # Find // comments.
|
||||||
|
i = source.find('\n', i)
|
||||||
|
if i == -1: # Handle EOF.
|
||||||
|
i = end
|
||||||
|
continue
|
||||||
|
elif c == '/' and source[i+1] == '*': # Find /* comments. */
|
||||||
|
i = source.find('*/', i) + 2
|
||||||
|
continue
|
||||||
|
elif c in ':+-<>&|*=': # : or :: (plus other chars).
|
||||||
|
token_type = SYNTAX
|
||||||
|
i += 1
|
||||||
|
new_ch = source[i]
|
||||||
|
if new_ch == c:
|
||||||
|
i += 1
|
||||||
|
elif c == '-' and new_ch == '>':
|
||||||
|
i += 1
|
||||||
|
elif new_ch == '=':
|
||||||
|
i += 1
|
||||||
|
elif c in '()[]{}~!?^%;/.,': # Handle single char tokens.
|
||||||
|
token_type = SYNTAX
|
||||||
|
i += 1
|
||||||
|
if c == '.' and source[i].isdigit():
|
||||||
|
token_type = CONSTANT
|
||||||
|
i += 1
|
||||||
|
while source[i] in int_or_float_digits:
|
||||||
|
i += 1
|
||||||
|
# Handle float suffixes.
|
||||||
|
for suffix in ('l', 'f'):
|
||||||
|
if suffix == source[i:i+1].lower():
|
||||||
|
i += 1
|
||||||
|
break
|
||||||
|
elif c.isdigit(): # Find integer.
|
||||||
|
token_type = CONSTANT
|
||||||
|
if c == '0' and source[i+1] in 'xX':
|
||||||
|
# Handle hex digits.
|
||||||
|
i += 2
|
||||||
|
while source[i] in hex_digits:
|
||||||
|
i += 1
|
||||||
|
else:
|
||||||
|
while source[i] in int_or_float_digits2:
|
||||||
|
i += 1
|
||||||
|
# Handle integer (and float) suffixes.
|
||||||
|
for suffix in ('ull', 'll', 'ul', 'l', 'f', 'u'):
|
||||||
|
size = len(suffix)
|
||||||
|
if suffix == source[i:i+size].lower():
|
||||||
|
i += size
|
||||||
|
break
|
||||||
|
elif c == '"': # Find string.
|
||||||
|
token_type = CONSTANT
|
||||||
|
i = _GetString(source, start, i)
|
||||||
|
elif c == "'": # Find char.
|
||||||
|
token_type = CONSTANT
|
||||||
|
i = _GetChar(source, start, i)
|
||||||
|
elif c == '#': # Find pre-processor command.
|
||||||
|
token_type = PREPROCESSOR
|
||||||
|
got_if = source[i:i+3] == '#if' and source[i+3:i+4].isspace()
|
||||||
|
if got_if:
|
||||||
|
count_ifs += 1
|
||||||
|
elif source[i:i+6] == '#endif':
|
||||||
|
count_ifs -= 1
|
||||||
|
if count_ifs == 0:
|
||||||
|
ignore_errors = False
|
||||||
|
|
||||||
|
# TODO(nnorwitz): handle preprocessor statements (\ continuations).
|
||||||
|
while 1:
|
||||||
|
i1 = source.find('\n', i)
|
||||||
|
i2 = source.find('//', i)
|
||||||
|
i3 = source.find('/*', i)
|
||||||
|
i4 = source.find('"', i)
|
||||||
|
# NOTE(nnorwitz): doesn't handle comments in #define macros.
|
||||||
|
# Get the first important symbol (newline, comment, EOF/end).
|
||||||
|
i = min([x for x in (i1, i2, i3, i4, end) if x != -1])
|
||||||
|
|
||||||
|
# Handle #include "dir//foo.h" properly.
|
||||||
|
if source[i] == '"':
|
||||||
|
i = source.find('"', i+1) + 1
|
||||||
|
assert i > 0
|
||||||
|
continue
|
||||||
|
# Keep going if end of the line and the line ends with \.
|
||||||
|
if not (i == i1 and source[i-1] == '\\'):
|
||||||
|
if got_if:
|
||||||
|
condition = source[start+4:i].lstrip()
|
||||||
|
if (condition.startswith('0') or
|
||||||
|
condition.startswith('(0)')):
|
||||||
|
ignore_errors = True
|
||||||
|
break
|
||||||
|
i += 1
|
||||||
|
elif c == '\\': # Handle \ in code.
|
||||||
|
# This is different from the pre-processor \ handling.
|
||||||
|
i += 1
|
||||||
|
continue
|
||||||
|
elif ignore_errors:
|
||||||
|
# The tokenizer seems to be in pretty good shape. This
|
||||||
|
# raise is conditionally disabled so that bogus code
|
||||||
|
# in an #if 0 block can be handled. Since we will ignore
|
||||||
|
# it anyways, this is probably fine. So disable the
|
||||||
|
# exception and return the bogus char.
|
||||||
|
i += 1
|
||||||
|
else:
|
||||||
|
sys.stderr.write('Got invalid token in %s @ %d token:%s: %r\n' %
|
||||||
|
('?', i, c, source[i-10:i+10]))
|
||||||
|
raise RuntimeError('unexpected token')
|
||||||
|
|
||||||
|
if i <= 0:
|
||||||
|
print('Invalid index, exiting now.')
|
||||||
|
return
|
||||||
|
yield Token(token_type, source[start:i], start, i)
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == '__main__':
|
||||||
|
def main(argv):
|
||||||
|
"""Driver mostly for testing purposes."""
|
||||||
|
for filename in argv[1:]:
|
||||||
|
source = utils.ReadFile(filename)
|
||||||
|
if source is None:
|
||||||
|
continue
|
||||||
|
|
||||||
|
for token in GetTokens(source):
|
||||||
|
print('%-12s: %s' % (token.token_type, token.name))
|
||||||
|
# print('\r%6.2f%%' % (100.0 * index / token.end),)
|
||||||
|
sys.stdout.write('\n')
|
||||||
|
|
||||||
|
|
||||||
|
main(sys.argv)
|
|
@ -0,0 +1,41 @@
|
||||||
|
#!/usr/bin/env python
|
||||||
|
#
|
||||||
|
# Copyright 2007 Neal Norwitz
|
||||||
|
# Portions Copyright 2007 Google Inc.
|
||||||
|
#
|
||||||
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
# you may not use this file except in compliance with the License.
|
||||||
|
# You may obtain a copy of the License at
|
||||||
|
#
|
||||||
|
# http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
#
|
||||||
|
# Unless required by applicable law or agreed to in writing, software
|
||||||
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
# See the License for the specific language governing permissions and
|
||||||
|
# limitations under the License.
|
||||||
|
|
||||||
|
"""Generic utilities for C++ parsing."""
|
||||||
|
|
||||||
|
__author__ = 'nnorwitz@google.com (Neal Norwitz)'
|
||||||
|
|
||||||
|
|
||||||
|
import sys
|
||||||
|
|
||||||
|
|
||||||
|
# Set to True to see the start/end token indices.
|
||||||
|
DEBUG = True
|
||||||
|
|
||||||
|
|
||||||
|
def ReadFile(filename, print_error=True):
|
||||||
|
"""Returns the contents of a file."""
|
||||||
|
try:
|
||||||
|
fp = open(filename)
|
||||||
|
try:
|
||||||
|
return fp.read()
|
||||||
|
finally:
|
||||||
|
fp.close()
|
||||||
|
except IOError:
|
||||||
|
if print_error:
|
||||||
|
print('Error reading %s: %s' % (filename, sys.exc_info()[1]))
|
||||||
|
return None
|
|
@ -0,0 +1,31 @@
|
||||||
|
#!/usr/bin/env python
|
||||||
|
#
|
||||||
|
# Copyright 2008 Google Inc. All Rights Reserved.
|
||||||
|
#
|
||||||
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
# you may not use this file except in compliance with the License.
|
||||||
|
# You may obtain a copy of the License at
|
||||||
|
#
|
||||||
|
# http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
#
|
||||||
|
# Unless required by applicable law or agreed to in writing, software
|
||||||
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
# See the License for the specific language governing permissions and
|
||||||
|
# limitations under the License.
|
||||||
|
|
||||||
|
"""Driver for starting up Google Mock class generator."""
|
||||||
|
|
||||||
|
__author__ = 'nnorwitz@google.com (Neal Norwitz)'
|
||||||
|
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
|
||||||
|
if __name__ == '__main__':
|
||||||
|
# Add the directory of this script to the path so we can import gmock_class.
|
||||||
|
sys.path.append(os.path.dirname(__file__))
|
||||||
|
|
||||||
|
from cpp import gmock_class
|
||||||
|
# Fix the docstring in case they require the usage.
|
||||||
|
gmock_class.__doc__ = gmock_class.__doc__.replace('gmock_class.py', __file__)
|
||||||
|
gmock_class.main()
|
|
@ -0,0 +1,303 @@
|
||||||
|
#!/bin/sh
|
||||||
|
|
||||||
|
# These variables are automatically filled in by the configure script.
|
||||||
|
name="@PACKAGE_TARNAME@"
|
||||||
|
version="@PACKAGE_VERSION@"
|
||||||
|
|
||||||
|
show_usage()
|
||||||
|
{
|
||||||
|
echo "Usage: gmock-config [OPTIONS...]"
|
||||||
|
}
|
||||||
|
|
||||||
|
show_help()
|
||||||
|
{
|
||||||
|
show_usage
|
||||||
|
cat <<\EOF
|
||||||
|
|
||||||
|
The `gmock-config' script provides access to the necessary compile and linking
|
||||||
|
flags to connect with Google C++ Mocking Framework, both in a build prior to
|
||||||
|
installation, and on the system proper after installation. The installation
|
||||||
|
overrides may be issued in combination with any other queries, but will only
|
||||||
|
affect installation queries if called on a built but not installed gmock. The
|
||||||
|
installation queries may not be issued with any other types of queries, and
|
||||||
|
only one installation query may be made at a time. The version queries and
|
||||||
|
compiler flag queries may be combined as desired but not mixed. Different
|
||||||
|
version queries are always combined with logical "and" semantics, and only the
|
||||||
|
last of any particular query is used while all previous ones ignored. All
|
||||||
|
versions must be specified as a sequence of numbers separated by periods.
|
||||||
|
Compiler flag queries output the union of the sets of flags when combined.
|
||||||
|
|
||||||
|
Examples:
|
||||||
|
gmock-config --min-version=1.0 || echo "Insufficient Google Mock version."
|
||||||
|
|
||||||
|
g++ $(gmock-config --cppflags --cxxflags) -o foo.o -c foo.cpp
|
||||||
|
g++ $(gmock-config --ldflags --libs) -o foo foo.o
|
||||||
|
|
||||||
|
# When using a built but not installed Google Mock:
|
||||||
|
g++ $(../../my_gmock_build/scripts/gmock-config ...) ...
|
||||||
|
|
||||||
|
# When using an installed Google Mock, but with installation overrides:
|
||||||
|
export GMOCK_PREFIX="/opt"
|
||||||
|
g++ $(gmock-config --libdir="/opt/lib64" ...) ...
|
||||||
|
|
||||||
|
Help:
|
||||||
|
--usage brief usage information
|
||||||
|
--help display this help message
|
||||||
|
|
||||||
|
Installation Overrides:
|
||||||
|
--prefix=<dir> overrides the installation prefix
|
||||||
|
--exec-prefix=<dir> overrides the executable installation prefix
|
||||||
|
--libdir=<dir> overrides the library installation prefix
|
||||||
|
--includedir=<dir> overrides the header file installation prefix
|
||||||
|
|
||||||
|
Installation Queries:
|
||||||
|
--prefix installation prefix
|
||||||
|
--exec-prefix executable installation prefix
|
||||||
|
--libdir library installation directory
|
||||||
|
--includedir header file installation directory
|
||||||
|
--version the version of the Google Mock installation
|
||||||
|
|
||||||
|
Version Queries:
|
||||||
|
--min-version=VERSION return 0 if the version is at least VERSION
|
||||||
|
--exact-version=VERSION return 0 if the version is exactly VERSION
|
||||||
|
--max-version=VERSION return 0 if the version is at most VERSION
|
||||||
|
|
||||||
|
Compilation Flag Queries:
|
||||||
|
--cppflags compile flags specific to the C-like preprocessors
|
||||||
|
--cxxflags compile flags appropriate for C++ programs
|
||||||
|
--ldflags linker flags
|
||||||
|
--libs libraries for linking
|
||||||
|
|
||||||
|
EOF
|
||||||
|
}
|
||||||
|
|
||||||
|
# This function bounds our version with a min and a max. It uses some clever
|
||||||
|
# POSIX-compliant variable expansion to portably do all the work in the shell
|
||||||
|
# and avoid any dependency on a particular "sed" or "awk" implementation.
|
||||||
|
# Notable is that it will only ever compare the first 3 components of versions.
|
||||||
|
# Further components will be cleanly stripped off. All versions must be
|
||||||
|
# unadorned, so "v1.0" will *not* work. The minimum version must be in $1, and
|
||||||
|
# the max in $2. TODO(chandlerc@google.com): If this ever breaks, we should
|
||||||
|
# investigate expanding this via autom4te from AS_VERSION_COMPARE rather than
|
||||||
|
# continuing to maintain our own shell version.
|
||||||
|
check_versions()
|
||||||
|
{
|
||||||
|
major_version=${version%%.*}
|
||||||
|
minor_version="0"
|
||||||
|
point_version="0"
|
||||||
|
if test "${version#*.}" != "${version}"; then
|
||||||
|
minor_version=${version#*.}
|
||||||
|
minor_version=${minor_version%%.*}
|
||||||
|
fi
|
||||||
|
if test "${version#*.*.}" != "${version}"; then
|
||||||
|
point_version=${version#*.*.}
|
||||||
|
point_version=${point_version%%.*}
|
||||||
|
fi
|
||||||
|
|
||||||
|
min_version="$1"
|
||||||
|
min_major_version=${min_version%%.*}
|
||||||
|
min_minor_version="0"
|
||||||
|
min_point_version="0"
|
||||||
|
if test "${min_version#*.}" != "${min_version}"; then
|
||||||
|
min_minor_version=${min_version#*.}
|
||||||
|
min_minor_version=${min_minor_version%%.*}
|
||||||
|
fi
|
||||||
|
if test "${min_version#*.*.}" != "${min_version}"; then
|
||||||
|
min_point_version=${min_version#*.*.}
|
||||||
|
min_point_version=${min_point_version%%.*}
|
||||||
|
fi
|
||||||
|
|
||||||
|
max_version="$2"
|
||||||
|
max_major_version=${max_version%%.*}
|
||||||
|
max_minor_version="0"
|
||||||
|
max_point_version="0"
|
||||||
|
if test "${max_version#*.}" != "${max_version}"; then
|
||||||
|
max_minor_version=${max_version#*.}
|
||||||
|
max_minor_version=${max_minor_version%%.*}
|
||||||
|
fi
|
||||||
|
if test "${max_version#*.*.}" != "${max_version}"; then
|
||||||
|
max_point_version=${max_version#*.*.}
|
||||||
|
max_point_version=${max_point_version%%.*}
|
||||||
|
fi
|
||||||
|
|
||||||
|
test $(($major_version)) -lt $(($min_major_version)) && exit 1
|
||||||
|
if test $(($major_version)) -eq $(($min_major_version)); then
|
||||||
|
test $(($minor_version)) -lt $(($min_minor_version)) && exit 1
|
||||||
|
if test $(($minor_version)) -eq $(($min_minor_version)); then
|
||||||
|
test $(($point_version)) -lt $(($min_point_version)) && exit 1
|
||||||
|
fi
|
||||||
|
fi
|
||||||
|
|
||||||
|
test $(($major_version)) -gt $(($max_major_version)) && exit 1
|
||||||
|
if test $(($major_version)) -eq $(($max_major_version)); then
|
||||||
|
test $(($minor_version)) -gt $(($max_minor_version)) && exit 1
|
||||||
|
if test $(($minor_version)) -eq $(($max_minor_version)); then
|
||||||
|
test $(($point_version)) -gt $(($max_point_version)) && exit 1
|
||||||
|
fi
|
||||||
|
fi
|
||||||
|
|
||||||
|
exit 0
|
||||||
|
}
|
||||||
|
|
||||||
|
# Show the usage line when no arguments are specified.
|
||||||
|
if test $# -eq 0; then
|
||||||
|
show_usage
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
|
|
||||||
|
while test $# -gt 0; do
|
||||||
|
case $1 in
|
||||||
|
--usage) show_usage; exit 0;;
|
||||||
|
--help) show_help; exit 0;;
|
||||||
|
|
||||||
|
# Installation overrides
|
||||||
|
--prefix=*) GMOCK_PREFIX=${1#--prefix=};;
|
||||||
|
--exec-prefix=*) GMOCK_EXEC_PREFIX=${1#--exec-prefix=};;
|
||||||
|
--libdir=*) GMOCK_LIBDIR=${1#--libdir=};;
|
||||||
|
--includedir=*) GMOCK_INCLUDEDIR=${1#--includedir=};;
|
||||||
|
|
||||||
|
# Installation queries
|
||||||
|
--prefix|--exec-prefix|--libdir|--includedir|--version)
|
||||||
|
if test -n "${do_query}"; then
|
||||||
|
show_usage
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
|
do_query=${1#--}
|
||||||
|
;;
|
||||||
|
|
||||||
|
# Version checking
|
||||||
|
--min-version=*)
|
||||||
|
do_check_versions=yes
|
||||||
|
min_version=${1#--min-version=}
|
||||||
|
;;
|
||||||
|
--max-version=*)
|
||||||
|
do_check_versions=yes
|
||||||
|
max_version=${1#--max-version=}
|
||||||
|
;;
|
||||||
|
--exact-version=*)
|
||||||
|
do_check_versions=yes
|
||||||
|
exact_version=${1#--exact-version=}
|
||||||
|
;;
|
||||||
|
|
||||||
|
# Compiler flag output
|
||||||
|
--cppflags) echo_cppflags=yes;;
|
||||||
|
--cxxflags) echo_cxxflags=yes;;
|
||||||
|
--ldflags) echo_ldflags=yes;;
|
||||||
|
--libs) echo_libs=yes;;
|
||||||
|
|
||||||
|
# Everything else is an error
|
||||||
|
*) show_usage; exit 1;;
|
||||||
|
esac
|
||||||
|
shift
|
||||||
|
done
|
||||||
|
|
||||||
|
# These have defaults filled in by the configure script but can also be
|
||||||
|
# overridden by environment variables or command line parameters.
|
||||||
|
prefix="${GMOCK_PREFIX:-@prefix@}"
|
||||||
|
exec_prefix="${GMOCK_EXEC_PREFIX:-@exec_prefix@}"
|
||||||
|
libdir="${GMOCK_LIBDIR:-@libdir@}"
|
||||||
|
includedir="${GMOCK_INCLUDEDIR:-@includedir@}"
|
||||||
|
|
||||||
|
# We try and detect if our binary is not located at its installed location. If
|
||||||
|
# it's not, we provide variables pointing to the source and build tree rather
|
||||||
|
# than to the install tree. We also locate Google Test using the configured
|
||||||
|
# gtest-config script rather than searching the PATH and our bindir for one.
|
||||||
|
# This allows building against a just-built gmock rather than an installed
|
||||||
|
# gmock.
|
||||||
|
bindir="@bindir@"
|
||||||
|
this_relative_bindir=`dirname $0`
|
||||||
|
this_bindir=`cd ${this_relative_bindir}; pwd -P`
|
||||||
|
if test "${this_bindir}" = "${this_bindir%${bindir}}"; then
|
||||||
|
# The path to the script doesn't end in the bindir sequence from Autoconf,
|
||||||
|
# assume that we are in a build tree.
|
||||||
|
build_dir=`dirname ${this_bindir}`
|
||||||
|
src_dir=`cd ${this_bindir}/@top_srcdir@; pwd -P`
|
||||||
|
|
||||||
|
# TODO(chandlerc@google.com): This is a dangerous dependency on libtool, we
|
||||||
|
# should work to remove it, and/or remove libtool altogether, replacing it
|
||||||
|
# with direct references to the library and a link path.
|
||||||
|
gmock_libs="${build_dir}/lib/libgmock.la"
|
||||||
|
gmock_ldflags=""
|
||||||
|
|
||||||
|
# We provide hooks to include from either the source or build dir, where the
|
||||||
|
# build dir is always preferred. This will potentially allow us to write
|
||||||
|
# build rules for generated headers and have them automatically be preferred
|
||||||
|
# over provided versions.
|
||||||
|
gmock_cppflags="-I${build_dir}/include -I${src_dir}/include"
|
||||||
|
gmock_cxxflags=""
|
||||||
|
|
||||||
|
# Directly invoke the gtest-config script used during the build process.
|
||||||
|
gtest_config="@GTEST_CONFIG@"
|
||||||
|
else
|
||||||
|
# We're using an installed gmock, although it may be staged under some
|
||||||
|
# prefix. Assume (as our own libraries do) that we can resolve the prefix,
|
||||||
|
# and are present in the dynamic link paths.
|
||||||
|
gmock_ldflags="-L${libdir}"
|
||||||
|
gmock_libs="-l${name}"
|
||||||
|
gmock_cppflags="-I${includedir}"
|
||||||
|
gmock_cxxflags=""
|
||||||
|
|
||||||
|
# We also prefer any gtest-config script installed in our prefix. Lacking
|
||||||
|
# one, we look in the PATH for one.
|
||||||
|
gtest_config="${bindir}/gtest-config"
|
||||||
|
if test ! -x "${gtest_config}"; then
|
||||||
|
gtest_config=`which gtest-config`
|
||||||
|
fi
|
||||||
|
fi
|
||||||
|
|
||||||
|
# Ensure that we have located a Google Test to link against.
|
||||||
|
if ! test -x "${gtest_config}"; then
|
||||||
|
echo "Unable to locate Google Test, check your Google Mock configuration" \
|
||||||
|
"and installation" >&2
|
||||||
|
exit 1
|
||||||
|
elif ! "${gtest_config}" "--exact-version=@GTEST_VERSION@"; then
|
||||||
|
echo "The Google Test found is not the same version as Google Mock was " \
|
||||||
|
"built against" >&2
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
|
|
||||||
|
# Add the necessary Google Test bits into the various flag variables
|
||||||
|
gmock_cppflags="${gmock_cppflags} `${gtest_config} --cppflags`"
|
||||||
|
gmock_cxxflags="${gmock_cxxflags} `${gtest_config} --cxxflags`"
|
||||||
|
gmock_ldflags="${gmock_ldflags} `${gtest_config} --ldflags`"
|
||||||
|
gmock_libs="${gmock_libs} `${gtest_config} --libs`"
|
||||||
|
|
||||||
|
# Do an installation query if requested.
|
||||||
|
if test -n "$do_query"; then
|
||||||
|
case $do_query in
|
||||||
|
prefix) echo $prefix; exit 0;;
|
||||||
|
exec-prefix) echo $exec_prefix; exit 0;;
|
||||||
|
libdir) echo $libdir; exit 0;;
|
||||||
|
includedir) echo $includedir; exit 0;;
|
||||||
|
version) echo $version; exit 0;;
|
||||||
|
*) show_usage; exit 1;;
|
||||||
|
esac
|
||||||
|
fi
|
||||||
|
|
||||||
|
# Do a version check if requested.
|
||||||
|
if test "$do_check_versions" = "yes"; then
|
||||||
|
# Make sure we didn't receive a bad combination of parameters.
|
||||||
|
test "$echo_cppflags" = "yes" && show_usage && exit 1
|
||||||
|
test "$echo_cxxflags" = "yes" && show_usage && exit 1
|
||||||
|
test "$echo_ldflags" = "yes" && show_usage && exit 1
|
||||||
|
test "$echo_libs" = "yes" && show_usage && exit 1
|
||||||
|
|
||||||
|
if test "$exact_version" != ""; then
|
||||||
|
check_versions $exact_version $exact_version
|
||||||
|
# unreachable
|
||||||
|
else
|
||||||
|
check_versions ${min_version:-0.0.0} ${max_version:-9999.9999.9999}
|
||||||
|
# unreachable
|
||||||
|
fi
|
||||||
|
fi
|
||||||
|
|
||||||
|
# Do the output in the correct order so that these can be used in-line of
|
||||||
|
# a compiler invocation.
|
||||||
|
output=""
|
||||||
|
test "$echo_cppflags" = "yes" && output="$output $gmock_cppflags"
|
||||||
|
test "$echo_cxxflags" = "yes" && output="$output $gmock_cxxflags"
|
||||||
|
test "$echo_ldflags" = "yes" && output="$output $gmock_ldflags"
|
||||||
|
test "$echo_libs" = "yes" && output="$output $gmock_libs"
|
||||||
|
echo $output
|
||||||
|
|
||||||
|
exit 0
|
|
@ -0,0 +1,47 @@
|
||||||
|
// 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)
|
||||||
|
//
|
||||||
|
// Google C++ Mocking Framework (Google Mock)
|
||||||
|
//
|
||||||
|
// This file #includes all Google Mock implementation .cc files. The
|
||||||
|
// purpose is to allow a user to build Google Mock by compiling this
|
||||||
|
// file alone.
|
||||||
|
|
||||||
|
// This line ensures that gmock.h can be compiled on its own, even
|
||||||
|
// when it's fused.
|
||||||
|
#include "gmock/gmock.h"
|
||||||
|
|
||||||
|
// The following lines pull in the real gmock *.cc files.
|
||||||
|
#include "src/gmock-cardinalities.cc"
|
||||||
|
#include "src/gmock-internal-utils.cc"
|
||||||
|
#include "src/gmock-matchers.cc"
|
||||||
|
#include "src/gmock-spec-builders.cc"
|
||||||
|
#include "src/gmock.cc"
|
|
@ -0,0 +1,155 @@
|
||||||
|
// Copyright 2007, Google Inc.
|
||||||
|
// All rights reserved.
|
||||||
|
//
|
||||||
|
// Redistribution and use in source and binary forms, with or without
|
||||||
|
// modification, are permitted provided that the following conditions are
|
||||||
|
// met:
|
||||||
|
//
|
||||||
|
// * Redistributions of source code must retain the above copyright
|
||||||
|
// notice, this list of conditions and the following disclaimer.
|
||||||
|
// * Redistributions in binary form must reproduce the above
|
||||||
|
// copyright notice, this list of conditions and the following disclaimer
|
||||||
|
// in the documentation and/or other materials provided with the
|
||||||
|
// distribution.
|
||||||
|
// * Neither the name of Google Inc. nor the names of its
|
||||||
|
// contributors may be used to endorse or promote products derived from
|
||||||
|
// this software without specific prior written permission.
|
||||||
|
//
|
||||||
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||||
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||||
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||||
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||||
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||||
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||||
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||||
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||||
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||||
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||||
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||||
|
//
|
||||||
|
// Author: wan@google.com (Zhanyong Wan)
|
||||||
|
|
||||||
|
// Google Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file implements cardinalities.
|
||||||
|
|
||||||
|
#include "gmock/gmock-cardinalities.h"
|
||||||
|
|
||||||
|
#include <limits.h>
|
||||||
|
#include <ostream> // NOLINT
|
||||||
|
#include <sstream>
|
||||||
|
#include <string>
|
||||||
|
#include "gmock/internal/gmock-internal-utils.h"
|
||||||
|
#include "gtest/gtest.h"
|
||||||
|
|
||||||
|
namespace testing {
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
|
||||||
|
// Implements the Between(m, n) cardinality.
|
||||||
|
class BetweenCardinalityImpl : public CardinalityInterface {
|
||||||
|
public:
|
||||||
|
BetweenCardinalityImpl(int min, int max)
|
||||||
|
: min_(min >= 0 ? min : 0),
|
||||||
|
max_(max >= min_ ? max : min_) {
|
||||||
|
std::stringstream ss;
|
||||||
|
if (min < 0) {
|
||||||
|
ss << "The invocation lower bound must be >= 0, "
|
||||||
|
<< "but is actually " << min << ".";
|
||||||
|
internal::Expect(false, __FILE__, __LINE__, ss.str());
|
||||||
|
} else if (max < 0) {
|
||||||
|
ss << "The invocation upper bound must be >= 0, "
|
||||||
|
<< "but is actually " << max << ".";
|
||||||
|
internal::Expect(false, __FILE__, __LINE__, ss.str());
|
||||||
|
} else if (min > max) {
|
||||||
|
ss << "The invocation upper bound (" << max
|
||||||
|
<< ") must be >= the invocation lower bound (" << min
|
||||||
|
<< ").";
|
||||||
|
internal::Expect(false, __FILE__, __LINE__, ss.str());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Conservative estimate on the lower/upper bound of the number of
|
||||||
|
// calls allowed.
|
||||||
|
virtual int ConservativeLowerBound() const { return min_; }
|
||||||
|
virtual int ConservativeUpperBound() const { return max_; }
|
||||||
|
|
||||||
|
virtual bool IsSatisfiedByCallCount(int call_count) const {
|
||||||
|
return min_ <= call_count && call_count <= max_ ;
|
||||||
|
}
|
||||||
|
|
||||||
|
virtual bool IsSaturatedByCallCount(int call_count) const {
|
||||||
|
return call_count >= max_;
|
||||||
|
}
|
||||||
|
|
||||||
|
virtual void DescribeTo(::std::ostream* os) const;
|
||||||
|
private:
|
||||||
|
const int min_;
|
||||||
|
const int max_;
|
||||||
|
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(BetweenCardinalityImpl);
|
||||||
|
};
|
||||||
|
|
||||||
|
// Formats "n times" in a human-friendly way.
|
||||||
|
inline internal::string FormatTimes(int n) {
|
||||||
|
if (n == 1) {
|
||||||
|
return "once";
|
||||||
|
} else if (n == 2) {
|
||||||
|
return "twice";
|
||||||
|
} else {
|
||||||
|
std::stringstream ss;
|
||||||
|
ss << n << " times";
|
||||||
|
return ss.str();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Describes the Between(m, n) cardinality in human-friendly text.
|
||||||
|
void BetweenCardinalityImpl::DescribeTo(::std::ostream* os) const {
|
||||||
|
if (min_ == 0) {
|
||||||
|
if (max_ == 0) {
|
||||||
|
*os << "never called";
|
||||||
|
} else if (max_ == INT_MAX) {
|
||||||
|
*os << "called any number of times";
|
||||||
|
} else {
|
||||||
|
*os << "called at most " << FormatTimes(max_);
|
||||||
|
}
|
||||||
|
} else if (min_ == max_) {
|
||||||
|
*os << "called " << FormatTimes(min_);
|
||||||
|
} else if (max_ == INT_MAX) {
|
||||||
|
*os << "called at least " << FormatTimes(min_);
|
||||||
|
} else {
|
||||||
|
// 0 < min_ < max_ < INT_MAX
|
||||||
|
*os << "called between " << min_ << " and " << max_ << " times";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
} // Unnamed namespace
|
||||||
|
|
||||||
|
// Describes the given call count to an ostream.
|
||||||
|
void Cardinality::DescribeActualCallCountTo(int actual_call_count,
|
||||||
|
::std::ostream* os) {
|
||||||
|
if (actual_call_count > 0) {
|
||||||
|
*os << "called " << FormatTimes(actual_call_count);
|
||||||
|
} else {
|
||||||
|
*os << "never called";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Creates a cardinality that allows at least n calls.
|
||||||
|
Cardinality AtLeast(int n) { return Between(n, INT_MAX); }
|
||||||
|
|
||||||
|
// Creates a cardinality that allows at most n calls.
|
||||||
|
Cardinality AtMost(int n) { return Between(0, n); }
|
||||||
|
|
||||||
|
// Creates a cardinality that allows any number of calls.
|
||||||
|
Cardinality AnyNumber() { return AtLeast(0); }
|
||||||
|
|
||||||
|
// Creates a cardinality that allows between min and max calls.
|
||||||
|
Cardinality Between(int min, int max) {
|
||||||
|
return Cardinality(new BetweenCardinalityImpl(min, max));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Creates a cardinality that allows exactly n calls.
|
||||||
|
Cardinality Exactly(int n) { return Between(n, n); }
|
||||||
|
|
||||||
|
} // namespace testing
|
|
@ -0,0 +1,173 @@
|
||||||
|
// 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 Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file defines some utilities useful for implementing Google
|
||||||
|
// Mock. They are subject to change without notice, so please DO NOT
|
||||||
|
// USE THEM IN USER CODE.
|
||||||
|
|
||||||
|
#include "gmock/internal/gmock-internal-utils.h"
|
||||||
|
|
||||||
|
#include <ctype.h>
|
||||||
|
#include <ostream> // NOLINT
|
||||||
|
#include <string>
|
||||||
|
#include "gmock/gmock.h"
|
||||||
|
#include "gmock/internal/gmock-port.h"
|
||||||
|
#include "gtest/gtest.h"
|
||||||
|
|
||||||
|
namespace testing {
|
||||||
|
namespace internal {
|
||||||
|
|
||||||
|
// Converts an identifier name to a space-separated list of lower-case
|
||||||
|
// words. Each maximum substring of the form [A-Za-z][a-z]*|\d+ is
|
||||||
|
// treated as one word. For example, both "FooBar123" and
|
||||||
|
// "foo_bar_123" are converted to "foo bar 123".
|
||||||
|
string ConvertIdentifierNameToWords(const char* id_name) {
|
||||||
|
string result;
|
||||||
|
char prev_char = '\0';
|
||||||
|
for (const char* p = id_name; *p != '\0'; prev_char = *(p++)) {
|
||||||
|
// We don't care about the current locale as the input is
|
||||||
|
// guaranteed to be a valid C++ identifier name.
|
||||||
|
const bool starts_new_word = IsUpper(*p) ||
|
||||||
|
(!IsAlpha(prev_char) && IsLower(*p)) ||
|
||||||
|
(!IsDigit(prev_char) && IsDigit(*p));
|
||||||
|
|
||||||
|
if (IsAlNum(*p)) {
|
||||||
|
if (starts_new_word && result != "")
|
||||||
|
result += ' ';
|
||||||
|
result += ToLower(*p);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
// This class reports Google Mock failures as Google Test failures. A
|
||||||
|
// user can define another class in a similar fashion if he intends to
|
||||||
|
// use Google Mock with a testing framework other than Google Test.
|
||||||
|
class GoogleTestFailureReporter : public FailureReporterInterface {
|
||||||
|
public:
|
||||||
|
virtual void ReportFailure(FailureType type, const char* file, int line,
|
||||||
|
const string& message) {
|
||||||
|
AssertHelper(type == FATAL ?
|
||||||
|
TestPartResult::kFatalFailure :
|
||||||
|
TestPartResult::kNonFatalFailure,
|
||||||
|
file,
|
||||||
|
line,
|
||||||
|
message.c_str()) = Message();
|
||||||
|
if (type == FATAL) {
|
||||||
|
posix::Abort();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
// Returns the global failure reporter. Will create a
|
||||||
|
// GoogleTestFailureReporter and return it the first time called.
|
||||||
|
FailureReporterInterface* GetFailureReporter() {
|
||||||
|
// Points to the global failure reporter used by Google Mock. gcc
|
||||||
|
// guarantees that the following use of failure_reporter is
|
||||||
|
// thread-safe. We may need to add additional synchronization to
|
||||||
|
// protect failure_reporter if we port Google Mock to other
|
||||||
|
// compilers.
|
||||||
|
static FailureReporterInterface* const failure_reporter =
|
||||||
|
new GoogleTestFailureReporter();
|
||||||
|
return failure_reporter;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Protects global resources (stdout in particular) used by Log().
|
||||||
|
static GTEST_DEFINE_STATIC_MUTEX_(g_log_mutex);
|
||||||
|
|
||||||
|
// Returns true iff a log with the given severity is visible according
|
||||||
|
// to the --gmock_verbose flag.
|
||||||
|
bool LogIsVisible(LogSeverity severity) {
|
||||||
|
if (GMOCK_FLAG(verbose) == kInfoVerbosity) {
|
||||||
|
// Always show the log if --gmock_verbose=info.
|
||||||
|
return true;
|
||||||
|
} else if (GMOCK_FLAG(verbose) == kErrorVerbosity) {
|
||||||
|
// Always hide it if --gmock_verbose=error.
|
||||||
|
return false;
|
||||||
|
} else {
|
||||||
|
// If --gmock_verbose is neither "info" nor "error", we treat it
|
||||||
|
// as "warning" (its default value).
|
||||||
|
return severity == WARNING;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Prints the given message to stdout iff 'severity' >= the level
|
||||||
|
// specified by the --gmock_verbose flag. If stack_frames_to_skip >=
|
||||||
|
// 0, also prints the stack trace excluding the top
|
||||||
|
// stack_frames_to_skip frames. In opt mode, any positive
|
||||||
|
// stack_frames_to_skip is treated as 0, since we don't know which
|
||||||
|
// function calls will be inlined by the compiler and need to be
|
||||||
|
// conservative.
|
||||||
|
void Log(LogSeverity severity, const string& message,
|
||||||
|
int stack_frames_to_skip) {
|
||||||
|
if (!LogIsVisible(severity))
|
||||||
|
return;
|
||||||
|
|
||||||
|
// Ensures that logs from different threads don't interleave.
|
||||||
|
MutexLock l(&g_log_mutex);
|
||||||
|
|
||||||
|
// "using ::std::cout;" doesn't work with Symbian's STLport, where cout is a
|
||||||
|
// macro.
|
||||||
|
|
||||||
|
if (severity == WARNING) {
|
||||||
|
// Prints a GMOCK WARNING marker to make the warnings easily searchable.
|
||||||
|
std::cout << "\nGMOCK WARNING:";
|
||||||
|
}
|
||||||
|
// Pre-pends a new-line to message if it doesn't start with one.
|
||||||
|
if (message.empty() || message[0] != '\n') {
|
||||||
|
std::cout << "\n";
|
||||||
|
}
|
||||||
|
std::cout << message;
|
||||||
|
if (stack_frames_to_skip >= 0) {
|
||||||
|
#ifdef NDEBUG
|
||||||
|
// In opt mode, we have to be conservative and skip no stack frame.
|
||||||
|
const int actual_to_skip = 0;
|
||||||
|
#else
|
||||||
|
// In dbg mode, we can do what the caller tell us to do (plus one
|
||||||
|
// for skipping this function's stack frame).
|
||||||
|
const int actual_to_skip = stack_frames_to_skip + 1;
|
||||||
|
#endif // NDEBUG
|
||||||
|
|
||||||
|
// Appends a new-line to message if it doesn't end with one.
|
||||||
|
if (!message.empty() && *message.rbegin() != '\n') {
|
||||||
|
std::cout << "\n";
|
||||||
|
}
|
||||||
|
std::cout << "Stack trace:\n"
|
||||||
|
<< ::testing::internal::GetCurrentOsStackTraceExceptTop(
|
||||||
|
::testing::UnitTest::GetInstance(), actual_to_skip);
|
||||||
|
}
|
||||||
|
std::cout << ::std::flush;
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace internal
|
||||||
|
} // namespace testing
|
|
@ -0,0 +1,101 @@
|
||||||
|
// 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 Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file implements Matcher<const string&>, Matcher<string>, and
|
||||||
|
// utilities for defining matchers.
|
||||||
|
|
||||||
|
#include "gmock/gmock-matchers.h"
|
||||||
|
#include "gmock/gmock-generated-matchers.h"
|
||||||
|
|
||||||
|
#include <string.h>
|
||||||
|
#include <sstream>
|
||||||
|
#include <string>
|
||||||
|
|
||||||
|
namespace testing {
|
||||||
|
|
||||||
|
// Constructs a matcher that matches a const string& whose value is
|
||||||
|
// equal to s.
|
||||||
|
Matcher<const internal::string&>::Matcher(const internal::string& s) {
|
||||||
|
*this = Eq(s);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Constructs a matcher that matches a const string& whose value is
|
||||||
|
// equal to s.
|
||||||
|
Matcher<const internal::string&>::Matcher(const char* s) {
|
||||||
|
*this = Eq(internal::string(s));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Constructs a matcher that matches a string whose value is equal to s.
|
||||||
|
Matcher<internal::string>::Matcher(const internal::string& s) { *this = Eq(s); }
|
||||||
|
|
||||||
|
// Constructs a matcher that matches a string whose value is equal to s.
|
||||||
|
Matcher<internal::string>::Matcher(const char* s) {
|
||||||
|
*this = Eq(internal::string(s));
|
||||||
|
}
|
||||||
|
|
||||||
|
namespace internal {
|
||||||
|
|
||||||
|
// Joins a vector of strings as if they are fields of a tuple; returns
|
||||||
|
// the joined string.
|
||||||
|
string JoinAsTuple(const Strings& fields) {
|
||||||
|
switch (fields.size()) {
|
||||||
|
case 0:
|
||||||
|
return "";
|
||||||
|
case 1:
|
||||||
|
return fields[0];
|
||||||
|
default:
|
||||||
|
string result = "(" + fields[0];
|
||||||
|
for (size_t i = 1; i < fields.size(); i++) {
|
||||||
|
result += ", ";
|
||||||
|
result += fields[i];
|
||||||
|
}
|
||||||
|
result += ")";
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Returns the description for a matcher defined using the MATCHER*()
|
||||||
|
// macro where the user-supplied description string is "", if
|
||||||
|
// 'negation' is false; otherwise returns the description of the
|
||||||
|
// negation of the matcher. 'param_values' contains a list of strings
|
||||||
|
// that are the print-out of the matcher's parameters.
|
||||||
|
string FormatMatcherDescription(bool negation, const char* matcher_name,
|
||||||
|
const Strings& param_values) {
|
||||||
|
string result = ConvertIdentifierNameToWords(matcher_name);
|
||||||
|
if (param_values.size() >= 1)
|
||||||
|
result += " " + JoinAsTuple(param_values);
|
||||||
|
return negation ? "not (" + result + ")" : result;
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace internal
|
||||||
|
} // namespace testing
|
|
@ -0,0 +1,797 @@
|
||||||
|
// 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 Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file implements the spec builder syntax (ON_CALL and
|
||||||
|
// EXPECT_CALL).
|
||||||
|
|
||||||
|
#include "gmock/gmock-spec-builders.h"
|
||||||
|
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <iostream> // NOLINT
|
||||||
|
#include <map>
|
||||||
|
#include <set>
|
||||||
|
#include <string>
|
||||||
|
#include "gmock/gmock.h"
|
||||||
|
#include "gtest/gtest.h"
|
||||||
|
|
||||||
|
#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC
|
||||||
|
# include <unistd.h> // NOLINT
|
||||||
|
#endif
|
||||||
|
|
||||||
|
namespace testing {
|
||||||
|
namespace internal {
|
||||||
|
|
||||||
|
// Protects the mock object registry (in class Mock), all function
|
||||||
|
// mockers, and all expectations.
|
||||||
|
GTEST_DEFINE_STATIC_MUTEX_(g_gmock_mutex);
|
||||||
|
|
||||||
|
// Logs a message including file and line number information.
|
||||||
|
void LogWithLocation(testing::internal::LogSeverity severity,
|
||||||
|
const char* file, int line,
|
||||||
|
const string& message) {
|
||||||
|
::std::ostringstream s;
|
||||||
|
s << file << ":" << line << ": " << message << ::std::endl;
|
||||||
|
Log(severity, s.str(), 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Constructs an ExpectationBase object.
|
||||||
|
ExpectationBase::ExpectationBase(const char* a_file,
|
||||||
|
int a_line,
|
||||||
|
const string& a_source_text)
|
||||||
|
: file_(a_file),
|
||||||
|
line_(a_line),
|
||||||
|
source_text_(a_source_text),
|
||||||
|
cardinality_specified_(false),
|
||||||
|
cardinality_(Exactly(1)),
|
||||||
|
call_count_(0),
|
||||||
|
retired_(false),
|
||||||
|
extra_matcher_specified_(false),
|
||||||
|
repeated_action_specified_(false),
|
||||||
|
retires_on_saturation_(false),
|
||||||
|
last_clause_(kNone),
|
||||||
|
action_count_checked_(false) {}
|
||||||
|
|
||||||
|
// Destructs an ExpectationBase object.
|
||||||
|
ExpectationBase::~ExpectationBase() {}
|
||||||
|
|
||||||
|
// Explicitly specifies the cardinality of this expectation. Used by
|
||||||
|
// the subclasses to implement the .Times() clause.
|
||||||
|
void ExpectationBase::SpecifyCardinality(const Cardinality& a_cardinality) {
|
||||||
|
cardinality_specified_ = true;
|
||||||
|
cardinality_ = a_cardinality;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Retires all pre-requisites of this expectation.
|
||||||
|
void ExpectationBase::RetireAllPreRequisites() {
|
||||||
|
if (is_retired()) {
|
||||||
|
// We can take this short-cut as we never retire an expectation
|
||||||
|
// until we have retired all its pre-requisites.
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (ExpectationSet::const_iterator it = immediate_prerequisites_.begin();
|
||||||
|
it != immediate_prerequisites_.end(); ++it) {
|
||||||
|
ExpectationBase* const prerequisite = it->expectation_base().get();
|
||||||
|
if (!prerequisite->is_retired()) {
|
||||||
|
prerequisite->RetireAllPreRequisites();
|
||||||
|
prerequisite->Retire();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Returns true iff all pre-requisites of this expectation have been
|
||||||
|
// satisfied.
|
||||||
|
// L >= g_gmock_mutex
|
||||||
|
bool ExpectationBase::AllPrerequisitesAreSatisfied() const {
|
||||||
|
g_gmock_mutex.AssertHeld();
|
||||||
|
for (ExpectationSet::const_iterator it = immediate_prerequisites_.begin();
|
||||||
|
it != immediate_prerequisites_.end(); ++it) {
|
||||||
|
if (!(it->expectation_base()->IsSatisfied()) ||
|
||||||
|
!(it->expectation_base()->AllPrerequisitesAreSatisfied()))
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Adds unsatisfied pre-requisites of this expectation to 'result'.
|
||||||
|
// L >= g_gmock_mutex
|
||||||
|
void ExpectationBase::FindUnsatisfiedPrerequisites(
|
||||||
|
ExpectationSet* result) const {
|
||||||
|
g_gmock_mutex.AssertHeld();
|
||||||
|
for (ExpectationSet::const_iterator it = immediate_prerequisites_.begin();
|
||||||
|
it != immediate_prerequisites_.end(); ++it) {
|
||||||
|
if (it->expectation_base()->IsSatisfied()) {
|
||||||
|
// If *it is satisfied and has a call count of 0, some of its
|
||||||
|
// pre-requisites may not be satisfied yet.
|
||||||
|
if (it->expectation_base()->call_count_ == 0) {
|
||||||
|
it->expectation_base()->FindUnsatisfiedPrerequisites(result);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// Now that we know *it is unsatisfied, we are not so interested
|
||||||
|
// in whether its pre-requisites are satisfied. Therefore we
|
||||||
|
// don't recursively call FindUnsatisfiedPrerequisites() here.
|
||||||
|
*result += *it;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Describes how many times a function call matching this
|
||||||
|
// expectation has occurred.
|
||||||
|
// L >= g_gmock_mutex
|
||||||
|
void ExpectationBase::DescribeCallCountTo(::std::ostream* os) const {
|
||||||
|
g_gmock_mutex.AssertHeld();
|
||||||
|
|
||||||
|
// Describes how many times the function is expected to be called.
|
||||||
|
*os << " Expected: to be ";
|
||||||
|
cardinality().DescribeTo(os);
|
||||||
|
*os << "\n Actual: ";
|
||||||
|
Cardinality::DescribeActualCallCountTo(call_count(), os);
|
||||||
|
|
||||||
|
// Describes the state of the expectation (e.g. is it satisfied?
|
||||||
|
// is it active?).
|
||||||
|
*os << " - " << (IsOverSaturated() ? "over-saturated" :
|
||||||
|
IsSaturated() ? "saturated" :
|
||||||
|
IsSatisfied() ? "satisfied" : "unsatisfied")
|
||||||
|
<< " and "
|
||||||
|
<< (is_retired() ? "retired" : "active");
|
||||||
|
}
|
||||||
|
|
||||||
|
// Checks the action count (i.e. the number of WillOnce() and
|
||||||
|
// WillRepeatedly() clauses) against the cardinality if this hasn't
|
||||||
|
// been done before. Prints a warning if there are too many or too
|
||||||
|
// few actions.
|
||||||
|
// L < mutex_
|
||||||
|
void ExpectationBase::CheckActionCountIfNotDone() const {
|
||||||
|
bool should_check = false;
|
||||||
|
{
|
||||||
|
MutexLock l(&mutex_);
|
||||||
|
if (!action_count_checked_) {
|
||||||
|
action_count_checked_ = true;
|
||||||
|
should_check = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (should_check) {
|
||||||
|
if (!cardinality_specified_) {
|
||||||
|
// The cardinality was inferred - no need to check the action
|
||||||
|
// count against it.
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// The cardinality was explicitly specified.
|
||||||
|
const int action_count = static_cast<int>(untyped_actions_.size());
|
||||||
|
const int upper_bound = cardinality().ConservativeUpperBound();
|
||||||
|
const int lower_bound = cardinality().ConservativeLowerBound();
|
||||||
|
bool too_many; // True if there are too many actions, or false
|
||||||
|
// if there are too few.
|
||||||
|
if (action_count > upper_bound ||
|
||||||
|
(action_count == upper_bound && repeated_action_specified_)) {
|
||||||
|
too_many = true;
|
||||||
|
} else if (0 < action_count && action_count < lower_bound &&
|
||||||
|
!repeated_action_specified_) {
|
||||||
|
too_many = false;
|
||||||
|
} else {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
::std::stringstream ss;
|
||||||
|
DescribeLocationTo(&ss);
|
||||||
|
ss << "Too " << (too_many ? "many" : "few")
|
||||||
|
<< " actions specified in " << source_text() << "...\n"
|
||||||
|
<< "Expected to be ";
|
||||||
|
cardinality().DescribeTo(&ss);
|
||||||
|
ss << ", but has " << (too_many ? "" : "only ")
|
||||||
|
<< action_count << " WillOnce()"
|
||||||
|
<< (action_count == 1 ? "" : "s");
|
||||||
|
if (repeated_action_specified_) {
|
||||||
|
ss << " and a WillRepeatedly()";
|
||||||
|
}
|
||||||
|
ss << ".";
|
||||||
|
Log(WARNING, ss.str(), -1); // -1 means "don't print stack trace".
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Implements the .Times() clause.
|
||||||
|
void ExpectationBase::UntypedTimes(const Cardinality& a_cardinality) {
|
||||||
|
if (last_clause_ == kTimes) {
|
||||||
|
ExpectSpecProperty(false,
|
||||||
|
".Times() cannot appear "
|
||||||
|
"more than once in an EXPECT_CALL().");
|
||||||
|
} else {
|
||||||
|
ExpectSpecProperty(last_clause_ < kTimes,
|
||||||
|
".Times() cannot appear after "
|
||||||
|
".InSequence(), .WillOnce(), .WillRepeatedly(), "
|
||||||
|
"or .RetiresOnSaturation().");
|
||||||
|
}
|
||||||
|
last_clause_ = kTimes;
|
||||||
|
|
||||||
|
SpecifyCardinality(a_cardinality);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Points to the implicit sequence introduced by a living InSequence
|
||||||
|
// object (if any) in the current thread or NULL.
|
||||||
|
ThreadLocal<Sequence*> g_gmock_implicit_sequence;
|
||||||
|
|
||||||
|
// Reports an uninteresting call (whose description is in msg) in the
|
||||||
|
// manner specified by 'reaction'.
|
||||||
|
void ReportUninterestingCall(CallReaction reaction, const string& msg) {
|
||||||
|
switch (reaction) {
|
||||||
|
case ALLOW:
|
||||||
|
Log(INFO, msg, 3);
|
||||||
|
break;
|
||||||
|
case WARN:
|
||||||
|
Log(WARNING, msg, 3);
|
||||||
|
break;
|
||||||
|
default: // FAIL
|
||||||
|
Expect(false, NULL, -1, msg);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
UntypedFunctionMockerBase::UntypedFunctionMockerBase()
|
||||||
|
: mock_obj_(NULL), name_("") {}
|
||||||
|
|
||||||
|
UntypedFunctionMockerBase::~UntypedFunctionMockerBase() {}
|
||||||
|
|
||||||
|
// Sets the mock object this mock method belongs to, and registers
|
||||||
|
// this information in the global mock registry. Will be called
|
||||||
|
// whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
|
||||||
|
// method.
|
||||||
|
// L < g_gmock_mutex
|
||||||
|
void UntypedFunctionMockerBase::RegisterOwner(const void* mock_obj) {
|
||||||
|
{
|
||||||
|
MutexLock l(&g_gmock_mutex);
|
||||||
|
mock_obj_ = mock_obj;
|
||||||
|
}
|
||||||
|
Mock::Register(mock_obj, this);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Sets the mock object this mock method belongs to, and sets the name
|
||||||
|
// of the mock function. Will be called upon each invocation of this
|
||||||
|
// mock function.
|
||||||
|
// L < g_gmock_mutex
|
||||||
|
void UntypedFunctionMockerBase::SetOwnerAndName(
|
||||||
|
const void* mock_obj, const char* name) {
|
||||||
|
// We protect name_ under g_gmock_mutex in case this mock function
|
||||||
|
// is called from two threads concurrently.
|
||||||
|
MutexLock l(&g_gmock_mutex);
|
||||||
|
mock_obj_ = mock_obj;
|
||||||
|
name_ = name;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Returns the name of the function being mocked. Must be called
|
||||||
|
// after RegisterOwner() or SetOwnerAndName() has been called.
|
||||||
|
// L < g_gmock_mutex
|
||||||
|
const void* UntypedFunctionMockerBase::MockObject() const {
|
||||||
|
const void* mock_obj;
|
||||||
|
{
|
||||||
|
// We protect mock_obj_ under g_gmock_mutex in case this mock
|
||||||
|
// function is called from two threads concurrently.
|
||||||
|
MutexLock l(&g_gmock_mutex);
|
||||||
|
Assert(mock_obj_ != NULL, __FILE__, __LINE__,
|
||||||
|
"MockObject() must not be called before RegisterOwner() or "
|
||||||
|
"SetOwnerAndName() has been called.");
|
||||||
|
mock_obj = mock_obj_;
|
||||||
|
}
|
||||||
|
return mock_obj;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Returns the name of this mock method. Must be called after
|
||||||
|
// SetOwnerAndName() has been called.
|
||||||
|
// L < g_gmock_mutex
|
||||||
|
const char* UntypedFunctionMockerBase::Name() const {
|
||||||
|
const char* name;
|
||||||
|
{
|
||||||
|
// We protect name_ under g_gmock_mutex in case this mock
|
||||||
|
// function is called from two threads concurrently.
|
||||||
|
MutexLock l(&g_gmock_mutex);
|
||||||
|
Assert(name_ != NULL, __FILE__, __LINE__,
|
||||||
|
"Name() must not be called before SetOwnerAndName() has "
|
||||||
|
"been called.");
|
||||||
|
name = name_;
|
||||||
|
}
|
||||||
|
return name;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Calculates the result of invoking this mock function with the given
|
||||||
|
// arguments, prints it, and returns it. The caller is responsible
|
||||||
|
// for deleting the result.
|
||||||
|
// L < g_gmock_mutex
|
||||||
|
const UntypedActionResultHolderBase*
|
||||||
|
UntypedFunctionMockerBase::UntypedInvokeWith(const void* const untyped_args) {
|
||||||
|
if (untyped_expectations_.size() == 0) {
|
||||||
|
// No expectation is set on this mock method - we have an
|
||||||
|
// uninteresting call.
|
||||||
|
|
||||||
|
// We must get Google Mock's reaction on uninteresting calls
|
||||||
|
// made on this mock object BEFORE performing the action,
|
||||||
|
// because the action may DELETE the mock object and make the
|
||||||
|
// following expression meaningless.
|
||||||
|
const CallReaction reaction =
|
||||||
|
Mock::GetReactionOnUninterestingCalls(MockObject());
|
||||||
|
|
||||||
|
// True iff we need to print this call's arguments and return
|
||||||
|
// value. This definition must be kept in sync with
|
||||||
|
// the behavior of ReportUninterestingCall().
|
||||||
|
const bool need_to_report_uninteresting_call =
|
||||||
|
// If the user allows this uninteresting call, we print it
|
||||||
|
// only when he wants informational messages.
|
||||||
|
reaction == ALLOW ? LogIsVisible(INFO) :
|
||||||
|
// If the user wants this to be a warning, we print it only
|
||||||
|
// when he wants to see warnings.
|
||||||
|
reaction == WARN ? LogIsVisible(WARNING) :
|
||||||
|
// Otherwise, the user wants this to be an error, and we
|
||||||
|
// should always print detailed information in the error.
|
||||||
|
true;
|
||||||
|
|
||||||
|
if (!need_to_report_uninteresting_call) {
|
||||||
|
// Perform the action without printing the call information.
|
||||||
|
return this->UntypedPerformDefaultAction(untyped_args, "");
|
||||||
|
}
|
||||||
|
|
||||||
|
// Warns about the uninteresting call.
|
||||||
|
::std::stringstream ss;
|
||||||
|
this->UntypedDescribeUninterestingCall(untyped_args, &ss);
|
||||||
|
|
||||||
|
// Calculates the function result.
|
||||||
|
const UntypedActionResultHolderBase* const result =
|
||||||
|
this->UntypedPerformDefaultAction(untyped_args, ss.str());
|
||||||
|
|
||||||
|
// Prints the function result.
|
||||||
|
if (result != NULL)
|
||||||
|
result->PrintAsActionResult(&ss);
|
||||||
|
|
||||||
|
ReportUninterestingCall(reaction, ss.str());
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool is_excessive = false;
|
||||||
|
::std::stringstream ss;
|
||||||
|
::std::stringstream why;
|
||||||
|
::std::stringstream loc;
|
||||||
|
const void* untyped_action = NULL;
|
||||||
|
|
||||||
|
// The UntypedFindMatchingExpectation() function acquires and
|
||||||
|
// releases g_gmock_mutex.
|
||||||
|
const ExpectationBase* const untyped_expectation =
|
||||||
|
this->UntypedFindMatchingExpectation(
|
||||||
|
untyped_args, &untyped_action, &is_excessive,
|
||||||
|
&ss, &why);
|
||||||
|
const bool found = untyped_expectation != NULL;
|
||||||
|
|
||||||
|
// True iff we need to print the call's arguments and return value.
|
||||||
|
// This definition must be kept in sync with the uses of Expect()
|
||||||
|
// and Log() in this function.
|
||||||
|
const bool need_to_report_call = !found || is_excessive || LogIsVisible(INFO);
|
||||||
|
if (!need_to_report_call) {
|
||||||
|
// Perform the action without printing the call information.
|
||||||
|
return
|
||||||
|
untyped_action == NULL ?
|
||||||
|
this->UntypedPerformDefaultAction(untyped_args, "") :
|
||||||
|
this->UntypedPerformAction(untyped_action, untyped_args);
|
||||||
|
}
|
||||||
|
|
||||||
|
ss << " Function call: " << Name();
|
||||||
|
this->UntypedPrintArgs(untyped_args, &ss);
|
||||||
|
|
||||||
|
// In case the action deletes a piece of the expectation, we
|
||||||
|
// generate the message beforehand.
|
||||||
|
if (found && !is_excessive) {
|
||||||
|
untyped_expectation->DescribeLocationTo(&loc);
|
||||||
|
}
|
||||||
|
|
||||||
|
const UntypedActionResultHolderBase* const result =
|
||||||
|
untyped_action == NULL ?
|
||||||
|
this->UntypedPerformDefaultAction(untyped_args, ss.str()) :
|
||||||
|
this->UntypedPerformAction(untyped_action, untyped_args);
|
||||||
|
if (result != NULL)
|
||||||
|
result->PrintAsActionResult(&ss);
|
||||||
|
ss << "\n" << why.str();
|
||||||
|
|
||||||
|
if (!found) {
|
||||||
|
// No expectation matches this call - reports a failure.
|
||||||
|
Expect(false, NULL, -1, ss.str());
|
||||||
|
} else if (is_excessive) {
|
||||||
|
// We had an upper-bound violation and the failure message is in ss.
|
||||||
|
Expect(false, untyped_expectation->file(),
|
||||||
|
untyped_expectation->line(), ss.str());
|
||||||
|
} else {
|
||||||
|
// We had an expected call and the matching expectation is
|
||||||
|
// described in ss.
|
||||||
|
Log(INFO, loc.str() + ss.str(), 2);
|
||||||
|
}
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Returns an Expectation object that references and co-owns exp,
|
||||||
|
// which must be an expectation on this mock function.
|
||||||
|
Expectation UntypedFunctionMockerBase::GetHandleOf(ExpectationBase* exp) {
|
||||||
|
for (UntypedExpectations::const_iterator it =
|
||||||
|
untyped_expectations_.begin();
|
||||||
|
it != untyped_expectations_.end(); ++it) {
|
||||||
|
if (it->get() == exp) {
|
||||||
|
return Expectation(*it);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Assert(false, __FILE__, __LINE__, "Cannot find expectation.");
|
||||||
|
return Expectation();
|
||||||
|
// The above statement is just to make the code compile, and will
|
||||||
|
// never be executed.
|
||||||
|
}
|
||||||
|
|
||||||
|
// Verifies that all expectations on this mock function have been
|
||||||
|
// satisfied. Reports one or more Google Test non-fatal failures
|
||||||
|
// and returns false if not.
|
||||||
|
// L >= g_gmock_mutex
|
||||||
|
bool UntypedFunctionMockerBase::VerifyAndClearExpectationsLocked() {
|
||||||
|
g_gmock_mutex.AssertHeld();
|
||||||
|
bool expectations_met = true;
|
||||||
|
for (UntypedExpectations::const_iterator it =
|
||||||
|
untyped_expectations_.begin();
|
||||||
|
it != untyped_expectations_.end(); ++it) {
|
||||||
|
ExpectationBase* const untyped_expectation = it->get();
|
||||||
|
if (untyped_expectation->IsOverSaturated()) {
|
||||||
|
// There was an upper-bound violation. Since the error was
|
||||||
|
// already reported when it occurred, there is no need to do
|
||||||
|
// anything here.
|
||||||
|
expectations_met = false;
|
||||||
|
} else if (!untyped_expectation->IsSatisfied()) {
|
||||||
|
expectations_met = false;
|
||||||
|
::std::stringstream ss;
|
||||||
|
ss << "Actual function call count doesn't match "
|
||||||
|
<< untyped_expectation->source_text() << "...\n";
|
||||||
|
// No need to show the source file location of the expectation
|
||||||
|
// in the description, as the Expect() call that follows already
|
||||||
|
// takes care of it.
|
||||||
|
untyped_expectation->MaybeDescribeExtraMatcherTo(&ss);
|
||||||
|
untyped_expectation->DescribeCallCountTo(&ss);
|
||||||
|
Expect(false, untyped_expectation->file(),
|
||||||
|
untyped_expectation->line(), ss.str());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
untyped_expectations_.clear();
|
||||||
|
return expectations_met;
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace internal
|
||||||
|
|
||||||
|
// Class Mock.
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
|
||||||
|
typedef std::set<internal::UntypedFunctionMockerBase*> FunctionMockers;
|
||||||
|
|
||||||
|
// The current state of a mock object. Such information is needed for
|
||||||
|
// detecting leaked mock objects and explicitly verifying a mock's
|
||||||
|
// expectations.
|
||||||
|
struct MockObjectState {
|
||||||
|
MockObjectState()
|
||||||
|
: first_used_file(NULL), first_used_line(-1), leakable(false) {}
|
||||||
|
|
||||||
|
// Where in the source file an ON_CALL or EXPECT_CALL is first
|
||||||
|
// invoked on this mock object.
|
||||||
|
const char* first_used_file;
|
||||||
|
int first_used_line;
|
||||||
|
::std::string first_used_test_case;
|
||||||
|
::std::string first_used_test;
|
||||||
|
bool leakable; // true iff it's OK to leak the object.
|
||||||
|
FunctionMockers function_mockers; // All registered methods of the object.
|
||||||
|
};
|
||||||
|
|
||||||
|
// A global registry holding the state of all mock objects that are
|
||||||
|
// alive. A mock object is added to this registry the first time
|
||||||
|
// Mock::AllowLeak(), ON_CALL(), or EXPECT_CALL() is called on it. It
|
||||||
|
// is removed from the registry in the mock object's destructor.
|
||||||
|
class MockObjectRegistry {
|
||||||
|
public:
|
||||||
|
// Maps a mock object (identified by its address) to its state.
|
||||||
|
typedef std::map<const void*, MockObjectState> StateMap;
|
||||||
|
|
||||||
|
// This destructor will be called when a program exits, after all
|
||||||
|
// tests in it have been run. By then, there should be no mock
|
||||||
|
// object alive. Therefore we report any living object as test
|
||||||
|
// failure, unless the user explicitly asked us to ignore it.
|
||||||
|
~MockObjectRegistry() {
|
||||||
|
// "using ::std::cout;" doesn't work with Symbian's STLport, where cout is
|
||||||
|
// a macro.
|
||||||
|
|
||||||
|
if (!GMOCK_FLAG(catch_leaked_mocks))
|
||||||
|
return;
|
||||||
|
|
||||||
|
int leaked_count = 0;
|
||||||
|
for (StateMap::const_iterator it = states_.begin(); it != states_.end();
|
||||||
|
++it) {
|
||||||
|
if (it->second.leakable) // The user said it's fine to leak this object.
|
||||||
|
continue;
|
||||||
|
|
||||||
|
// TODO(wan@google.com): Print the type of the leaked object.
|
||||||
|
// This can help the user identify the leaked object.
|
||||||
|
std::cout << "\n";
|
||||||
|
const MockObjectState& state = it->second;
|
||||||
|
std::cout << internal::FormatFileLocation(state.first_used_file,
|
||||||
|
state.first_used_line);
|
||||||
|
std::cout << " ERROR: this mock object";
|
||||||
|
if (state.first_used_test != "") {
|
||||||
|
std::cout << " (used in test " << state.first_used_test_case << "."
|
||||||
|
<< state.first_used_test << ")";
|
||||||
|
}
|
||||||
|
std::cout << " should be deleted but never is. Its address is @"
|
||||||
|
<< it->first << ".";
|
||||||
|
leaked_count++;
|
||||||
|
}
|
||||||
|
if (leaked_count > 0) {
|
||||||
|
std::cout << "\nERROR: " << leaked_count
|
||||||
|
<< " leaked mock " << (leaked_count == 1 ? "object" : "objects")
|
||||||
|
<< " found at program exit.\n";
|
||||||
|
std::cout.flush();
|
||||||
|
::std::cerr.flush();
|
||||||
|
// RUN_ALL_TESTS() has already returned when this destructor is
|
||||||
|
// called. Therefore we cannot use the normal Google Test
|
||||||
|
// failure reporting mechanism.
|
||||||
|
_exit(1); // We cannot call exit() as it is not reentrant and
|
||||||
|
// may already have been called.
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
StateMap& states() { return states_; }
|
||||||
|
private:
|
||||||
|
StateMap states_;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Protected by g_gmock_mutex.
|
||||||
|
MockObjectRegistry g_mock_object_registry;
|
||||||
|
|
||||||
|
// Maps a mock object to the reaction Google Mock should have when an
|
||||||
|
// uninteresting method is called. Protected by g_gmock_mutex.
|
||||||
|
std::map<const void*, internal::CallReaction> g_uninteresting_call_reaction;
|
||||||
|
|
||||||
|
// Sets the reaction Google Mock should have when an uninteresting
|
||||||
|
// method of the given mock object is called.
|
||||||
|
// L < g_gmock_mutex
|
||||||
|
void SetReactionOnUninterestingCalls(const void* mock_obj,
|
||||||
|
internal::CallReaction reaction) {
|
||||||
|
internal::MutexLock l(&internal::g_gmock_mutex);
|
||||||
|
g_uninteresting_call_reaction[mock_obj] = reaction;
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
// Tells Google Mock to allow uninteresting calls on the given mock
|
||||||
|
// object.
|
||||||
|
// L < g_gmock_mutex
|
||||||
|
void Mock::AllowUninterestingCalls(const void* mock_obj) {
|
||||||
|
SetReactionOnUninterestingCalls(mock_obj, internal::ALLOW);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tells Google Mock to warn the user about uninteresting calls on the
|
||||||
|
// given mock object.
|
||||||
|
// L < g_gmock_mutex
|
||||||
|
void Mock::WarnUninterestingCalls(const void* mock_obj) {
|
||||||
|
SetReactionOnUninterestingCalls(mock_obj, internal::WARN);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tells Google Mock to fail uninteresting calls on the given mock
|
||||||
|
// object.
|
||||||
|
// L < g_gmock_mutex
|
||||||
|
void Mock::FailUninterestingCalls(const void* mock_obj) {
|
||||||
|
SetReactionOnUninterestingCalls(mock_obj, internal::FAIL);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tells Google Mock the given mock object is being destroyed and its
|
||||||
|
// entry in the call-reaction table should be removed.
|
||||||
|
// L < g_gmock_mutex
|
||||||
|
void Mock::UnregisterCallReaction(const void* mock_obj) {
|
||||||
|
internal::MutexLock l(&internal::g_gmock_mutex);
|
||||||
|
g_uninteresting_call_reaction.erase(mock_obj);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Returns the reaction Google Mock will have on uninteresting calls
|
||||||
|
// made on the given mock object.
|
||||||
|
// L < g_gmock_mutex
|
||||||
|
internal::CallReaction Mock::GetReactionOnUninterestingCalls(
|
||||||
|
const void* mock_obj) {
|
||||||
|
internal::MutexLock l(&internal::g_gmock_mutex);
|
||||||
|
return (g_uninteresting_call_reaction.count(mock_obj) == 0) ?
|
||||||
|
internal::WARN : g_uninteresting_call_reaction[mock_obj];
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tells Google Mock to ignore mock_obj when checking for leaked mock
|
||||||
|
// objects.
|
||||||
|
// L < g_gmock_mutex
|
||||||
|
void Mock::AllowLeak(const void* mock_obj) {
|
||||||
|
internal::MutexLock l(&internal::g_gmock_mutex);
|
||||||
|
g_mock_object_registry.states()[mock_obj].leakable = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Verifies and clears all expectations on the given mock object. If
|
||||||
|
// the expectations aren't satisfied, generates one or more Google
|
||||||
|
// Test non-fatal failures and returns false.
|
||||||
|
// L < g_gmock_mutex
|
||||||
|
bool Mock::VerifyAndClearExpectations(void* mock_obj) {
|
||||||
|
internal::MutexLock l(&internal::g_gmock_mutex);
|
||||||
|
return VerifyAndClearExpectationsLocked(mock_obj);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Verifies all expectations on the given mock object and clears its
|
||||||
|
// default actions and expectations. Returns true iff the
|
||||||
|
// verification was successful.
|
||||||
|
// L < g_gmock_mutex
|
||||||
|
bool Mock::VerifyAndClear(void* mock_obj) {
|
||||||
|
internal::MutexLock l(&internal::g_gmock_mutex);
|
||||||
|
ClearDefaultActionsLocked(mock_obj);
|
||||||
|
return VerifyAndClearExpectationsLocked(mock_obj);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Verifies and clears all expectations on the given mock object. If
|
||||||
|
// the expectations aren't satisfied, generates one or more Google
|
||||||
|
// Test non-fatal failures and returns false.
|
||||||
|
// L >= g_gmock_mutex
|
||||||
|
bool Mock::VerifyAndClearExpectationsLocked(void* mock_obj) {
|
||||||
|
internal::g_gmock_mutex.AssertHeld();
|
||||||
|
if (g_mock_object_registry.states().count(mock_obj) == 0) {
|
||||||
|
// No EXPECT_CALL() was set on the given mock object.
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Verifies and clears the expectations on each mock method in the
|
||||||
|
// given mock object.
|
||||||
|
bool expectations_met = true;
|
||||||
|
FunctionMockers& mockers =
|
||||||
|
g_mock_object_registry.states()[mock_obj].function_mockers;
|
||||||
|
for (FunctionMockers::const_iterator it = mockers.begin();
|
||||||
|
it != mockers.end(); ++it) {
|
||||||
|
if (!(*it)->VerifyAndClearExpectationsLocked()) {
|
||||||
|
expectations_met = false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// We don't clear the content of mockers, as they may still be
|
||||||
|
// needed by ClearDefaultActionsLocked().
|
||||||
|
return expectations_met;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Registers a mock object and a mock method it owns.
|
||||||
|
// L < g_gmock_mutex
|
||||||
|
void Mock::Register(const void* mock_obj,
|
||||||
|
internal::UntypedFunctionMockerBase* mocker) {
|
||||||
|
internal::MutexLock l(&internal::g_gmock_mutex);
|
||||||
|
g_mock_object_registry.states()[mock_obj].function_mockers.insert(mocker);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tells Google Mock where in the source code mock_obj is used in an
|
||||||
|
// ON_CALL or EXPECT_CALL. In case mock_obj is leaked, this
|
||||||
|
// information helps the user identify which object it is.
|
||||||
|
// L < g_gmock_mutex
|
||||||
|
void Mock::RegisterUseByOnCallOrExpectCall(
|
||||||
|
const void* mock_obj, const char* file, int line) {
|
||||||
|
internal::MutexLock l(&internal::g_gmock_mutex);
|
||||||
|
MockObjectState& state = g_mock_object_registry.states()[mock_obj];
|
||||||
|
if (state.first_used_file == NULL) {
|
||||||
|
state.first_used_file = file;
|
||||||
|
state.first_used_line = line;
|
||||||
|
const TestInfo* const test_info =
|
||||||
|
UnitTest::GetInstance()->current_test_info();
|
||||||
|
if (test_info != NULL) {
|
||||||
|
// TODO(wan@google.com): record the test case name when the
|
||||||
|
// ON_CALL or EXPECT_CALL is invoked from SetUpTestCase() or
|
||||||
|
// TearDownTestCase().
|
||||||
|
state.first_used_test_case = test_info->test_case_name();
|
||||||
|
state.first_used_test = test_info->name();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Unregisters a mock method; removes the owning mock object from the
|
||||||
|
// registry when the last mock method associated with it has been
|
||||||
|
// unregistered. This is called only in the destructor of
|
||||||
|
// FunctionMockerBase.
|
||||||
|
// L >= g_gmock_mutex
|
||||||
|
void Mock::UnregisterLocked(internal::UntypedFunctionMockerBase* mocker) {
|
||||||
|
internal::g_gmock_mutex.AssertHeld();
|
||||||
|
for (MockObjectRegistry::StateMap::iterator it =
|
||||||
|
g_mock_object_registry.states().begin();
|
||||||
|
it != g_mock_object_registry.states().end(); ++it) {
|
||||||
|
FunctionMockers& mockers = it->second.function_mockers;
|
||||||
|
if (mockers.erase(mocker) > 0) {
|
||||||
|
// mocker was in mockers and has been just removed.
|
||||||
|
if (mockers.empty()) {
|
||||||
|
g_mock_object_registry.states().erase(it);
|
||||||
|
}
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Clears all ON_CALL()s set on the given mock object.
|
||||||
|
// L >= g_gmock_mutex
|
||||||
|
void Mock::ClearDefaultActionsLocked(void* mock_obj) {
|
||||||
|
internal::g_gmock_mutex.AssertHeld();
|
||||||
|
|
||||||
|
if (g_mock_object_registry.states().count(mock_obj) == 0) {
|
||||||
|
// No ON_CALL() was set on the given mock object.
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Clears the default actions for each mock method in the given mock
|
||||||
|
// object.
|
||||||
|
FunctionMockers& mockers =
|
||||||
|
g_mock_object_registry.states()[mock_obj].function_mockers;
|
||||||
|
for (FunctionMockers::const_iterator it = mockers.begin();
|
||||||
|
it != mockers.end(); ++it) {
|
||||||
|
(*it)->ClearDefaultActionsLocked();
|
||||||
|
}
|
||||||
|
|
||||||
|
// We don't clear the content of mockers, as they may still be
|
||||||
|
// needed by VerifyAndClearExpectationsLocked().
|
||||||
|
}
|
||||||
|
|
||||||
|
Expectation::Expectation() {}
|
||||||
|
|
||||||
|
Expectation::Expectation(
|
||||||
|
const internal::linked_ptr<internal::ExpectationBase>& an_expectation_base)
|
||||||
|
: expectation_base_(an_expectation_base) {}
|
||||||
|
|
||||||
|
Expectation::~Expectation() {}
|
||||||
|
|
||||||
|
// Adds an expectation to a sequence.
|
||||||
|
void Sequence::AddExpectation(const Expectation& expectation) const {
|
||||||
|
if (*last_expectation_ != expectation) {
|
||||||
|
if (last_expectation_->expectation_base() != NULL) {
|
||||||
|
expectation.expectation_base()->immediate_prerequisites_
|
||||||
|
+= *last_expectation_;
|
||||||
|
}
|
||||||
|
*last_expectation_ = expectation;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Creates the implicit sequence if there isn't one.
|
||||||
|
InSequence::InSequence() {
|
||||||
|
if (internal::g_gmock_implicit_sequence.get() == NULL) {
|
||||||
|
internal::g_gmock_implicit_sequence.set(new Sequence);
|
||||||
|
sequence_created_ = true;
|
||||||
|
} else {
|
||||||
|
sequence_created_ = false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Deletes the implicit sequence if it was created by the constructor
|
||||||
|
// of this object.
|
||||||
|
InSequence::~InSequence() {
|
||||||
|
if (sequence_created_) {
|
||||||
|
delete internal::g_gmock_implicit_sequence.get();
|
||||||
|
internal::g_gmock_implicit_sequence.set(NULL);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace testing
|
|
@ -0,0 +1,182 @@
|
||||||
|
// 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 "gmock/gmock.h"
|
||||||
|
#include "gmock/internal/gmock-port.h"
|
||||||
|
|
||||||
|
namespace testing {
|
||||||
|
|
||||||
|
// TODO(wan@google.com): support using environment variables to
|
||||||
|
// control the flag values, like what Google Test does.
|
||||||
|
|
||||||
|
GMOCK_DEFINE_bool_(catch_leaked_mocks, true,
|
||||||
|
"true iff Google Mock should report leaked mock objects "
|
||||||
|
"as failures.");
|
||||||
|
|
||||||
|
GMOCK_DEFINE_string_(verbose, internal::kWarningVerbosity,
|
||||||
|
"Controls how verbose Google Mock's output is."
|
||||||
|
" Valid values:\n"
|
||||||
|
" info - prints all messages.\n"
|
||||||
|
" warning - prints warnings and errors.\n"
|
||||||
|
" error - prints errors only.");
|
||||||
|
|
||||||
|
namespace internal {
|
||||||
|
|
||||||
|
// Parses a string as a command line flag. The string should have the
|
||||||
|
// format "--gmock_flag=value". When def_optional is true, the
|
||||||
|
// "=value" part can be omitted.
|
||||||
|
//
|
||||||
|
// Returns the value of the flag, or NULL if the parsing failed.
|
||||||
|
static const char* ParseGoogleMockFlagValue(const char* str,
|
||||||
|
const char* flag,
|
||||||
|
bool def_optional) {
|
||||||
|
// str and flag must not be NULL.
|
||||||
|
if (str == NULL || flag == NULL) return NULL;
|
||||||
|
|
||||||
|
// The flag must start with "--gmock_".
|
||||||
|
const String flag_str = String::Format("--gmock_%s", flag);
|
||||||
|
const size_t flag_len = flag_str.length();
|
||||||
|
if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL;
|
||||||
|
|
||||||
|
// Skips the flag name.
|
||||||
|
const char* flag_end = str + flag_len;
|
||||||
|
|
||||||
|
// When def_optional is true, it's OK to not have a "=value" part.
|
||||||
|
if (def_optional && (flag_end[0] == '\0')) {
|
||||||
|
return flag_end;
|
||||||
|
}
|
||||||
|
|
||||||
|
// If def_optional is true and there are more characters after the
|
||||||
|
// flag name, or if def_optional is false, there must be a '=' after
|
||||||
|
// the flag name.
|
||||||
|
if (flag_end[0] != '=') return NULL;
|
||||||
|
|
||||||
|
// Returns the string after "=".
|
||||||
|
return flag_end + 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Parses a string for a Google Mock bool flag, in the form of
|
||||||
|
// "--gmock_flag=value".
|
||||||
|
//
|
||||||
|
// On success, stores the value of the flag in *value, and returns
|
||||||
|
// true. On failure, returns false without changing *value.
|
||||||
|
static bool ParseGoogleMockBoolFlag(const char* str, const char* flag,
|
||||||
|
bool* value) {
|
||||||
|
// Gets the value of the flag as a string.
|
||||||
|
const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);
|
||||||
|
|
||||||
|
// Aborts if the parsing failed.
|
||||||
|
if (value_str == NULL) return false;
|
||||||
|
|
||||||
|
// Converts the string value to a bool.
|
||||||
|
*value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Parses a string for a Google Mock string flag, in the form of
|
||||||
|
// "--gmock_flag=value".
|
||||||
|
//
|
||||||
|
// On success, stores the value of the flag in *value, and returns
|
||||||
|
// true. On failure, returns false without changing *value.
|
||||||
|
static bool ParseGoogleMockStringFlag(const char* str, const char* flag,
|
||||||
|
String* value) {
|
||||||
|
// Gets the value of the flag as a string.
|
||||||
|
const char* const value_str = ParseGoogleMockFlagValue(str, flag, false);
|
||||||
|
|
||||||
|
// Aborts if the parsing failed.
|
||||||
|
if (value_str == NULL) return false;
|
||||||
|
|
||||||
|
// Sets *value to the value of the flag.
|
||||||
|
*value = value_str;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
// The internal implementation of InitGoogleMock().
|
||||||
|
//
|
||||||
|
// The type parameter CharType can be instantiated to either char or
|
||||||
|
// wchar_t.
|
||||||
|
template <typename CharType>
|
||||||
|
void InitGoogleMockImpl(int* argc, CharType** argv) {
|
||||||
|
// Makes sure Google Test is initialized. InitGoogleTest() is
|
||||||
|
// idempotent, so it's fine if the user has already called it.
|
||||||
|
InitGoogleTest(argc, argv);
|
||||||
|
if (*argc <= 0) return;
|
||||||
|
|
||||||
|
for (int i = 1; i != *argc; i++) {
|
||||||
|
const String arg_string = StreamableToString(argv[i]);
|
||||||
|
const char* const arg = arg_string.c_str();
|
||||||
|
|
||||||
|
// Do we see a Google Mock flag?
|
||||||
|
if (ParseGoogleMockBoolFlag(arg, "catch_leaked_mocks",
|
||||||
|
&GMOCK_FLAG(catch_leaked_mocks)) ||
|
||||||
|
ParseGoogleMockStringFlag(arg, "verbose", &GMOCK_FLAG(verbose))) {
|
||||||
|
// Yes. Shift the remainder of the argv list left by one. Note
|
||||||
|
// that argv has (*argc + 1) elements, the last one always being
|
||||||
|
// NULL. The following loop moves the trailing NULL element as
|
||||||
|
// well.
|
||||||
|
for (int j = i; j != *argc; j++) {
|
||||||
|
argv[j] = argv[j + 1];
|
||||||
|
}
|
||||||
|
|
||||||
|
// Decrements the argument count.
|
||||||
|
(*argc)--;
|
||||||
|
|
||||||
|
// We also need to decrement the iterator as we just removed
|
||||||
|
// an element.
|
||||||
|
i--;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace internal
|
||||||
|
|
||||||
|
// Initializes Google Mock. This must be called before running the
|
||||||
|
// tests. In particular, it parses a command line for the flags that
|
||||||
|
// Google Mock recognizes. Whenever a Google Mock flag is seen, it is
|
||||||
|
// removed from argv, and *argc is decremented.
|
||||||
|
//
|
||||||
|
// No value is returned. Instead, the Google Mock flag variables are
|
||||||
|
// updated.
|
||||||
|
//
|
||||||
|
// Since Google Test is needed for Google Mock to work, this function
|
||||||
|
// also initializes Google Test and parses its flags, if that hasn't
|
||||||
|
// been done.
|
||||||
|
void InitGoogleMock(int* argc, char** argv) {
|
||||||
|
internal::InitGoogleMockImpl(argc, argv);
|
||||||
|
}
|
||||||
|
|
||||||
|
// This overloaded version can be used in Windows programs compiled in
|
||||||
|
// UNICODE mode.
|
||||||
|
void InitGoogleMock(int* argc, wchar_t** argv) {
|
||||||
|
internal::InitGoogleMockImpl(argc, argv);
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace testing
|
|
@ -0,0 +1,54 @@
|
||||||
|
// 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 <iostream>
|
||||||
|
#include "gmock/gmock.h"
|
||||||
|
#include "gtest/gtest.h"
|
||||||
|
|
||||||
|
// MS C++ compiler/linker has a bug on Windows (not on Windows CE), which
|
||||||
|
// causes a link error when _tmain is defined in a static library and UNICODE
|
||||||
|
// is enabled. For this reason instead of _tmain, main function is used on
|
||||||
|
// Windows. See the following link to track the current status of this bug:
|
||||||
|
// http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=394464 // NOLINT
|
||||||
|
#if GTEST_OS_WINDOWS_MOBILE
|
||||||
|
# include <tchar.h> // NOLINT
|
||||||
|
|
||||||
|
int _tmain(int argc, TCHAR** argv) {
|
||||||
|
#else
|
||||||
|
int main(int argc, char** argv) {
|
||||||
|
#endif // GTEST_OS_WINDOWS_MOBILE
|
||||||
|
std::cout << "Running main() from gmock_main.cc\n";
|
||||||
|
// Since Google Mock depends on Google Test, InitGoogleMock() is
|
||||||
|
// also responsible for initializing Google Test. Therefore there's
|
||||||
|
// no need for calling testing::InitGoogleTest() separately.
|
||||||
|
testing::InitGoogleMock(&argc, argv);
|
||||||
|
return RUN_ALL_TESTS();
|
||||||
|
}
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,428 @@
|
||||||
|
// 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 Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file tests the built-in cardinalities.
|
||||||
|
|
||||||
|
#include "gmock/gmock.h"
|
||||||
|
#include "gtest/gtest.h"
|
||||||
|
#include "gtest/gtest-spi.h"
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
|
||||||
|
using std::stringstream;
|
||||||
|
using testing::AnyNumber;
|
||||||
|
using testing::AtLeast;
|
||||||
|
using testing::AtMost;
|
||||||
|
using testing::Between;
|
||||||
|
using testing::Cardinality;
|
||||||
|
using testing::CardinalityInterface;
|
||||||
|
using testing::Exactly;
|
||||||
|
using testing::IsSubstring;
|
||||||
|
using testing::MakeCardinality;
|
||||||
|
|
||||||
|
class MockFoo {
|
||||||
|
public:
|
||||||
|
MockFoo() {}
|
||||||
|
MOCK_METHOD0(Bar, int()); // NOLINT
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
|
||||||
|
};
|
||||||
|
|
||||||
|
// Tests that Cardinality objects can be default constructed.
|
||||||
|
TEST(CardinalityTest, IsDefaultConstructable) {
|
||||||
|
Cardinality c;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that Cardinality objects are copyable.
|
||||||
|
TEST(CardinalityTest, IsCopyable) {
|
||||||
|
// Tests the copy constructor.
|
||||||
|
Cardinality c = Exactly(1);
|
||||||
|
EXPECT_FALSE(c.IsSatisfiedByCallCount(0));
|
||||||
|
EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
|
||||||
|
EXPECT_TRUE(c.IsSaturatedByCallCount(1));
|
||||||
|
|
||||||
|
// Tests the assignment operator.
|
||||||
|
c = Exactly(2);
|
||||||
|
EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
|
||||||
|
EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
|
||||||
|
EXPECT_TRUE(c.IsSaturatedByCallCount(2));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(CardinalityTest, IsOverSaturatedByCallCountWorks) {
|
||||||
|
const Cardinality c = AtMost(5);
|
||||||
|
EXPECT_FALSE(c.IsOverSaturatedByCallCount(4));
|
||||||
|
EXPECT_FALSE(c.IsOverSaturatedByCallCount(5));
|
||||||
|
EXPECT_TRUE(c.IsOverSaturatedByCallCount(6));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that Cardinality::DescribeActualCallCountTo() creates the
|
||||||
|
// correct description.
|
||||||
|
TEST(CardinalityTest, CanDescribeActualCallCount) {
|
||||||
|
stringstream ss0;
|
||||||
|
Cardinality::DescribeActualCallCountTo(0, &ss0);
|
||||||
|
EXPECT_EQ("never called", ss0.str());
|
||||||
|
|
||||||
|
stringstream ss1;
|
||||||
|
Cardinality::DescribeActualCallCountTo(1, &ss1);
|
||||||
|
EXPECT_EQ("called once", ss1.str());
|
||||||
|
|
||||||
|
stringstream ss2;
|
||||||
|
Cardinality::DescribeActualCallCountTo(2, &ss2);
|
||||||
|
EXPECT_EQ("called twice", ss2.str());
|
||||||
|
|
||||||
|
stringstream ss3;
|
||||||
|
Cardinality::DescribeActualCallCountTo(3, &ss3);
|
||||||
|
EXPECT_EQ("called 3 times", ss3.str());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests AnyNumber()
|
||||||
|
TEST(AnyNumber, Works) {
|
||||||
|
const Cardinality c = AnyNumber();
|
||||||
|
EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
|
||||||
|
EXPECT_FALSE(c.IsSaturatedByCallCount(0));
|
||||||
|
|
||||||
|
EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
|
||||||
|
EXPECT_FALSE(c.IsSaturatedByCallCount(1));
|
||||||
|
|
||||||
|
EXPECT_TRUE(c.IsSatisfiedByCallCount(9));
|
||||||
|
EXPECT_FALSE(c.IsSaturatedByCallCount(9));
|
||||||
|
|
||||||
|
stringstream ss;
|
||||||
|
c.DescribeTo(&ss);
|
||||||
|
EXPECT_PRED_FORMAT2(IsSubstring, "called any number of times",
|
||||||
|
ss.str());
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(AnyNumberTest, HasCorrectBounds) {
|
||||||
|
const Cardinality c = AnyNumber();
|
||||||
|
EXPECT_EQ(0, c.ConservativeLowerBound());
|
||||||
|
EXPECT_EQ(INT_MAX, c.ConservativeUpperBound());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests AtLeast(n).
|
||||||
|
|
||||||
|
TEST(AtLeastTest, OnNegativeNumber) {
|
||||||
|
EXPECT_NONFATAL_FAILURE({ // NOLINT
|
||||||
|
AtLeast(-1);
|
||||||
|
}, "The invocation lower bound must be >= 0");
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(AtLeastTest, OnZero) {
|
||||||
|
const Cardinality c = AtLeast(0);
|
||||||
|
EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
|
||||||
|
EXPECT_FALSE(c.IsSaturatedByCallCount(0));
|
||||||
|
|
||||||
|
EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
|
||||||
|
EXPECT_FALSE(c.IsSaturatedByCallCount(1));
|
||||||
|
|
||||||
|
stringstream ss;
|
||||||
|
c.DescribeTo(&ss);
|
||||||
|
EXPECT_PRED_FORMAT2(IsSubstring, "any number of times",
|
||||||
|
ss.str());
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(AtLeastTest, OnPositiveNumber) {
|
||||||
|
const Cardinality c = AtLeast(2);
|
||||||
|
EXPECT_FALSE(c.IsSatisfiedByCallCount(0));
|
||||||
|
EXPECT_FALSE(c.IsSaturatedByCallCount(0));
|
||||||
|
|
||||||
|
EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
|
||||||
|
EXPECT_FALSE(c.IsSaturatedByCallCount(1));
|
||||||
|
|
||||||
|
EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
|
||||||
|
EXPECT_FALSE(c.IsSaturatedByCallCount(2));
|
||||||
|
|
||||||
|
stringstream ss1;
|
||||||
|
AtLeast(1).DescribeTo(&ss1);
|
||||||
|
EXPECT_PRED_FORMAT2(IsSubstring, "at least once",
|
||||||
|
ss1.str());
|
||||||
|
|
||||||
|
stringstream ss2;
|
||||||
|
c.DescribeTo(&ss2);
|
||||||
|
EXPECT_PRED_FORMAT2(IsSubstring, "at least twice",
|
||||||
|
ss2.str());
|
||||||
|
|
||||||
|
stringstream ss3;
|
||||||
|
AtLeast(3).DescribeTo(&ss3);
|
||||||
|
EXPECT_PRED_FORMAT2(IsSubstring, "at least 3 times",
|
||||||
|
ss3.str());
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(AtLeastTest, HasCorrectBounds) {
|
||||||
|
const Cardinality c = AtLeast(2);
|
||||||
|
EXPECT_EQ(2, c.ConservativeLowerBound());
|
||||||
|
EXPECT_EQ(INT_MAX, c.ConservativeUpperBound());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests AtMost(n).
|
||||||
|
|
||||||
|
TEST(AtMostTest, OnNegativeNumber) {
|
||||||
|
EXPECT_NONFATAL_FAILURE({ // NOLINT
|
||||||
|
AtMost(-1);
|
||||||
|
}, "The invocation upper bound must be >= 0");
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(AtMostTest, OnZero) {
|
||||||
|
const Cardinality c = AtMost(0);
|
||||||
|
EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
|
||||||
|
EXPECT_TRUE(c.IsSaturatedByCallCount(0));
|
||||||
|
|
||||||
|
EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
|
||||||
|
EXPECT_TRUE(c.IsSaturatedByCallCount(1));
|
||||||
|
|
||||||
|
stringstream ss;
|
||||||
|
c.DescribeTo(&ss);
|
||||||
|
EXPECT_PRED_FORMAT2(IsSubstring, "never called",
|
||||||
|
ss.str());
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(AtMostTest, OnPositiveNumber) {
|
||||||
|
const Cardinality c = AtMost(2);
|
||||||
|
EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
|
||||||
|
EXPECT_FALSE(c.IsSaturatedByCallCount(0));
|
||||||
|
|
||||||
|
EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
|
||||||
|
EXPECT_FALSE(c.IsSaturatedByCallCount(1));
|
||||||
|
|
||||||
|
EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
|
||||||
|
EXPECT_TRUE(c.IsSaturatedByCallCount(2));
|
||||||
|
|
||||||
|
stringstream ss1;
|
||||||
|
AtMost(1).DescribeTo(&ss1);
|
||||||
|
EXPECT_PRED_FORMAT2(IsSubstring, "called at most once",
|
||||||
|
ss1.str());
|
||||||
|
|
||||||
|
stringstream ss2;
|
||||||
|
c.DescribeTo(&ss2);
|
||||||
|
EXPECT_PRED_FORMAT2(IsSubstring, "called at most twice",
|
||||||
|
ss2.str());
|
||||||
|
|
||||||
|
stringstream ss3;
|
||||||
|
AtMost(3).DescribeTo(&ss3);
|
||||||
|
EXPECT_PRED_FORMAT2(IsSubstring, "called at most 3 times",
|
||||||
|
ss3.str());
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(AtMostTest, HasCorrectBounds) {
|
||||||
|
const Cardinality c = AtMost(2);
|
||||||
|
EXPECT_EQ(0, c.ConservativeLowerBound());
|
||||||
|
EXPECT_EQ(2, c.ConservativeUpperBound());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests Between(m, n).
|
||||||
|
|
||||||
|
TEST(BetweenTest, OnNegativeStart) {
|
||||||
|
EXPECT_NONFATAL_FAILURE({ // NOLINT
|
||||||
|
Between(-1, 2);
|
||||||
|
}, "The invocation lower bound must be >= 0, but is actually -1");
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(BetweenTest, OnNegativeEnd) {
|
||||||
|
EXPECT_NONFATAL_FAILURE({ // NOLINT
|
||||||
|
Between(1, -2);
|
||||||
|
}, "The invocation upper bound must be >= 0, but is actually -2");
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(BetweenTest, OnStartBiggerThanEnd) {
|
||||||
|
EXPECT_NONFATAL_FAILURE({ // NOLINT
|
||||||
|
Between(2, 1);
|
||||||
|
}, "The invocation upper bound (1) must be >= "
|
||||||
|
"the invocation lower bound (2)");
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(BetweenTest, OnZeroStartAndZeroEnd) {
|
||||||
|
const Cardinality c = Between(0, 0);
|
||||||
|
|
||||||
|
EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
|
||||||
|
EXPECT_TRUE(c.IsSaturatedByCallCount(0));
|
||||||
|
|
||||||
|
EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
|
||||||
|
EXPECT_TRUE(c.IsSaturatedByCallCount(1));
|
||||||
|
|
||||||
|
stringstream ss;
|
||||||
|
c.DescribeTo(&ss);
|
||||||
|
EXPECT_PRED_FORMAT2(IsSubstring, "never called",
|
||||||
|
ss.str());
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(BetweenTest, OnZeroStartAndNonZeroEnd) {
|
||||||
|
const Cardinality c = Between(0, 2);
|
||||||
|
|
||||||
|
EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
|
||||||
|
EXPECT_FALSE(c.IsSaturatedByCallCount(0));
|
||||||
|
|
||||||
|
EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
|
||||||
|
EXPECT_TRUE(c.IsSaturatedByCallCount(2));
|
||||||
|
|
||||||
|
EXPECT_FALSE(c.IsSatisfiedByCallCount(4));
|
||||||
|
EXPECT_TRUE(c.IsSaturatedByCallCount(4));
|
||||||
|
|
||||||
|
stringstream ss;
|
||||||
|
c.DescribeTo(&ss);
|
||||||
|
EXPECT_PRED_FORMAT2(IsSubstring, "called at most twice",
|
||||||
|
ss.str());
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(BetweenTest, OnSameStartAndEnd) {
|
||||||
|
const Cardinality c = Between(3, 3);
|
||||||
|
|
||||||
|
EXPECT_FALSE(c.IsSatisfiedByCallCount(2));
|
||||||
|
EXPECT_FALSE(c.IsSaturatedByCallCount(2));
|
||||||
|
|
||||||
|
EXPECT_TRUE(c.IsSatisfiedByCallCount(3));
|
||||||
|
EXPECT_TRUE(c.IsSaturatedByCallCount(3));
|
||||||
|
|
||||||
|
EXPECT_FALSE(c.IsSatisfiedByCallCount(4));
|
||||||
|
EXPECT_TRUE(c.IsSaturatedByCallCount(4));
|
||||||
|
|
||||||
|
stringstream ss;
|
||||||
|
c.DescribeTo(&ss);
|
||||||
|
EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times",
|
||||||
|
ss.str());
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(BetweenTest, OnDifferentStartAndEnd) {
|
||||||
|
const Cardinality c = Between(3, 5);
|
||||||
|
|
||||||
|
EXPECT_FALSE(c.IsSatisfiedByCallCount(2));
|
||||||
|
EXPECT_FALSE(c.IsSaturatedByCallCount(2));
|
||||||
|
|
||||||
|
EXPECT_TRUE(c.IsSatisfiedByCallCount(3));
|
||||||
|
EXPECT_FALSE(c.IsSaturatedByCallCount(3));
|
||||||
|
|
||||||
|
EXPECT_TRUE(c.IsSatisfiedByCallCount(5));
|
||||||
|
EXPECT_TRUE(c.IsSaturatedByCallCount(5));
|
||||||
|
|
||||||
|
EXPECT_FALSE(c.IsSatisfiedByCallCount(6));
|
||||||
|
EXPECT_TRUE(c.IsSaturatedByCallCount(6));
|
||||||
|
|
||||||
|
stringstream ss;
|
||||||
|
c.DescribeTo(&ss);
|
||||||
|
EXPECT_PRED_FORMAT2(IsSubstring, "called between 3 and 5 times",
|
||||||
|
ss.str());
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(BetweenTest, HasCorrectBounds) {
|
||||||
|
const Cardinality c = Between(3, 5);
|
||||||
|
EXPECT_EQ(3, c.ConservativeLowerBound());
|
||||||
|
EXPECT_EQ(5, c.ConservativeUpperBound());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests Exactly(n).
|
||||||
|
|
||||||
|
TEST(ExactlyTest, OnNegativeNumber) {
|
||||||
|
EXPECT_NONFATAL_FAILURE({ // NOLINT
|
||||||
|
Exactly(-1);
|
||||||
|
}, "The invocation lower bound must be >= 0");
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(ExactlyTest, OnZero) {
|
||||||
|
const Cardinality c = Exactly(0);
|
||||||
|
EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
|
||||||
|
EXPECT_TRUE(c.IsSaturatedByCallCount(0));
|
||||||
|
|
||||||
|
EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
|
||||||
|
EXPECT_TRUE(c.IsSaturatedByCallCount(1));
|
||||||
|
|
||||||
|
stringstream ss;
|
||||||
|
c.DescribeTo(&ss);
|
||||||
|
EXPECT_PRED_FORMAT2(IsSubstring, "never called",
|
||||||
|
ss.str());
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(ExactlyTest, OnPositiveNumber) {
|
||||||
|
const Cardinality c = Exactly(2);
|
||||||
|
EXPECT_FALSE(c.IsSatisfiedByCallCount(0));
|
||||||
|
EXPECT_FALSE(c.IsSaturatedByCallCount(0));
|
||||||
|
|
||||||
|
EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
|
||||||
|
EXPECT_TRUE(c.IsSaturatedByCallCount(2));
|
||||||
|
|
||||||
|
stringstream ss1;
|
||||||
|
Exactly(1).DescribeTo(&ss1);
|
||||||
|
EXPECT_PRED_FORMAT2(IsSubstring, "called once",
|
||||||
|
ss1.str());
|
||||||
|
|
||||||
|
stringstream ss2;
|
||||||
|
c.DescribeTo(&ss2);
|
||||||
|
EXPECT_PRED_FORMAT2(IsSubstring, "called twice",
|
||||||
|
ss2.str());
|
||||||
|
|
||||||
|
stringstream ss3;
|
||||||
|
Exactly(3).DescribeTo(&ss3);
|
||||||
|
EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times",
|
||||||
|
ss3.str());
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(ExactlyTest, HasCorrectBounds) {
|
||||||
|
const Cardinality c = Exactly(3);
|
||||||
|
EXPECT_EQ(3, c.ConservativeLowerBound());
|
||||||
|
EXPECT_EQ(3, c.ConservativeUpperBound());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that a user can make his own cardinality by implementing
|
||||||
|
// CardinalityInterface and calling MakeCardinality().
|
||||||
|
|
||||||
|
class EvenCardinality : public CardinalityInterface {
|
||||||
|
public:
|
||||||
|
// Returns true iff call_count calls will satisfy this cardinality.
|
||||||
|
virtual bool IsSatisfiedByCallCount(int call_count) const {
|
||||||
|
return (call_count % 2 == 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Returns true iff call_count calls will saturate this cardinality.
|
||||||
|
virtual bool IsSaturatedByCallCount(int /* call_count */) const {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Describes self to an ostream.
|
||||||
|
virtual void DescribeTo(::std::ostream* ss) const {
|
||||||
|
*ss << "called even number of times";
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
TEST(MakeCardinalityTest, ConstructsCardinalityFromInterface) {
|
||||||
|
const Cardinality c = MakeCardinality(new EvenCardinality);
|
||||||
|
|
||||||
|
EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
|
||||||
|
EXPECT_FALSE(c.IsSatisfiedByCallCount(3));
|
||||||
|
|
||||||
|
EXPECT_FALSE(c.IsSaturatedByCallCount(10000));
|
||||||
|
|
||||||
|
stringstream ss;
|
||||||
|
c.DescribeTo(&ss);
|
||||||
|
EXPECT_EQ("called even number of times", ss.str());
|
||||||
|
}
|
||||||
|
|
||||||
|
} // Unnamed namespace
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,540 @@
|
||||||
|
// 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 Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file tests the function mocker classes.
|
||||||
|
|
||||||
|
#include "gmock/gmock-generated-function-mockers.h"
|
||||||
|
|
||||||
|
#include <map>
|
||||||
|
#include <string>
|
||||||
|
#include "gmock/gmock.h"
|
||||||
|
#include "gtest/gtest.h"
|
||||||
|
|
||||||
|
#if GTEST_OS_WINDOWS
|
||||||
|
// MSDN says the header file to be included for STDMETHOD is BaseTyps.h but
|
||||||
|
// we are getting compiler errors if we use basetyps.h, hence including
|
||||||
|
// objbase.h for definition of STDMETHOD.
|
||||||
|
# include <objbase.h>
|
||||||
|
#endif // GTEST_OS_WINDOWS
|
||||||
|
|
||||||
|
// There is a bug in MSVC (fixed in VS 2008) that prevents creating a
|
||||||
|
// mock for a function with const arguments, so we don't test such
|
||||||
|
// cases for MSVC versions older than 2008.
|
||||||
|
#if !GTEST_OS_WINDOWS || (_MSC_VER >= 1500)
|
||||||
|
# define GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS
|
||||||
|
#endif // !GTEST_OS_WINDOWS || (_MSC_VER >= 1500)
|
||||||
|
|
||||||
|
namespace testing {
|
||||||
|
namespace gmock_generated_function_mockers_test {
|
||||||
|
|
||||||
|
using testing::internal::string;
|
||||||
|
using testing::_;
|
||||||
|
using testing::A;
|
||||||
|
using testing::An;
|
||||||
|
using testing::AnyNumber;
|
||||||
|
using testing::Const;
|
||||||
|
using testing::DoDefault;
|
||||||
|
using testing::Eq;
|
||||||
|
using testing::Lt;
|
||||||
|
using testing::MockFunction;
|
||||||
|
using testing::Ref;
|
||||||
|
using testing::Return;
|
||||||
|
using testing::ReturnRef;
|
||||||
|
using testing::TypedEq;
|
||||||
|
|
||||||
|
class FooInterface {
|
||||||
|
public:
|
||||||
|
virtual ~FooInterface() {}
|
||||||
|
|
||||||
|
virtual void VoidReturning(int x) = 0;
|
||||||
|
|
||||||
|
virtual int Nullary() = 0;
|
||||||
|
virtual bool Unary(int x) = 0;
|
||||||
|
virtual long Binary(short x, int y) = 0; // NOLINT
|
||||||
|
virtual int Decimal(bool b, char c, short d, int e, long f, // NOLINT
|
||||||
|
float g, double h, unsigned i, char* j, const string& k)
|
||||||
|
= 0;
|
||||||
|
|
||||||
|
virtual bool TakesNonConstReference(int& n) = 0; // NOLINT
|
||||||
|
virtual string TakesConstReference(const int& n) = 0;
|
||||||
|
#ifdef GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS
|
||||||
|
virtual bool TakesConst(const int x) = 0;
|
||||||
|
#endif // GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS
|
||||||
|
|
||||||
|
virtual int OverloadedOnArgumentNumber() = 0;
|
||||||
|
virtual int OverloadedOnArgumentNumber(int n) = 0;
|
||||||
|
|
||||||
|
virtual int OverloadedOnArgumentType(int n) = 0;
|
||||||
|
virtual char OverloadedOnArgumentType(char c) = 0;
|
||||||
|
|
||||||
|
virtual int OverloadedOnConstness() = 0;
|
||||||
|
virtual char OverloadedOnConstness() const = 0;
|
||||||
|
|
||||||
|
virtual int TypeWithHole(int (*func)()) = 0;
|
||||||
|
virtual int TypeWithComma(const std::map<int, string>& a_map) = 0;
|
||||||
|
|
||||||
|
#if GTEST_OS_WINDOWS
|
||||||
|
STDMETHOD_(int, CTNullary)() = 0;
|
||||||
|
STDMETHOD_(bool, CTUnary)(int x) = 0;
|
||||||
|
STDMETHOD_(int, CTDecimal)(bool b, char c, short d, int e, long f, // NOLINT
|
||||||
|
float g, double h, unsigned i, char* j, const string& k) = 0;
|
||||||
|
STDMETHOD_(char, CTConst)(int x) const = 0;
|
||||||
|
#endif // GTEST_OS_WINDOWS
|
||||||
|
};
|
||||||
|
|
||||||
|
class MockFoo : public FooInterface {
|
||||||
|
public:
|
||||||
|
MockFoo() {}
|
||||||
|
|
||||||
|
// Makes sure that a mock function parameter can be named.
|
||||||
|
MOCK_METHOD1(VoidReturning, void(int n)); // NOLINT
|
||||||
|
|
||||||
|
MOCK_METHOD0(Nullary, int()); // NOLINT
|
||||||
|
|
||||||
|
// Makes sure that a mock function parameter can be unnamed.
|
||||||
|
MOCK_METHOD1(Unary, bool(int)); // NOLINT
|
||||||
|
MOCK_METHOD2(Binary, long(short, int)); // NOLINT
|
||||||
|
MOCK_METHOD10(Decimal, int(bool, char, short, int, long, float, // NOLINT
|
||||||
|
double, unsigned, char*, const string& str));
|
||||||
|
|
||||||
|
MOCK_METHOD1(TakesNonConstReference, bool(int&)); // NOLINT
|
||||||
|
MOCK_METHOD1(TakesConstReference, string(const int&));
|
||||||
|
#ifdef GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS
|
||||||
|
MOCK_METHOD1(TakesConst, bool(const int)); // NOLINT
|
||||||
|
#endif // GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS
|
||||||
|
MOCK_METHOD0(OverloadedOnArgumentNumber, int()); // NOLINT
|
||||||
|
MOCK_METHOD1(OverloadedOnArgumentNumber, int(int)); // NOLINT
|
||||||
|
|
||||||
|
MOCK_METHOD1(OverloadedOnArgumentType, int(int)); // NOLINT
|
||||||
|
MOCK_METHOD1(OverloadedOnArgumentType, char(char)); // NOLINT
|
||||||
|
|
||||||
|
MOCK_METHOD0(OverloadedOnConstness, int()); // NOLINT
|
||||||
|
MOCK_CONST_METHOD0(OverloadedOnConstness, char()); // NOLINT
|
||||||
|
|
||||||
|
MOCK_METHOD1(TypeWithHole, int(int (*)())); // NOLINT
|
||||||
|
MOCK_METHOD1(TypeWithComma, int(const std::map<int, string>&)); // NOLINT
|
||||||
|
#if GTEST_OS_WINDOWS
|
||||||
|
MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, CTNullary, int());
|
||||||
|
MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, CTUnary, bool(int));
|
||||||
|
MOCK_METHOD10_WITH_CALLTYPE(STDMETHODCALLTYPE, CTDecimal, int(bool b, char c,
|
||||||
|
short d, int e, long f, float g, double h, unsigned i, char* j,
|
||||||
|
const string& k));
|
||||||
|
MOCK_CONST_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, CTConst, char(int));
|
||||||
|
#endif // GTEST_OS_WINDOWS
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
|
||||||
|
};
|
||||||
|
|
||||||
|
class FunctionMockerTest : public testing::Test {
|
||||||
|
protected:
|
||||||
|
FunctionMockerTest() : foo_(&mock_foo_) {}
|
||||||
|
|
||||||
|
FooInterface* const foo_;
|
||||||
|
MockFoo mock_foo_;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Tests mocking a void-returning function.
|
||||||
|
TEST_F(FunctionMockerTest, MocksVoidFunction) {
|
||||||
|
EXPECT_CALL(mock_foo_, VoidReturning(Lt(100)));
|
||||||
|
foo_->VoidReturning(0);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests mocking a nullary function.
|
||||||
|
TEST_F(FunctionMockerTest, MocksNullaryFunction) {
|
||||||
|
EXPECT_CALL(mock_foo_, Nullary())
|
||||||
|
.WillOnce(DoDefault())
|
||||||
|
.WillOnce(Return(1));
|
||||||
|
|
||||||
|
EXPECT_EQ(0, foo_->Nullary());
|
||||||
|
EXPECT_EQ(1, foo_->Nullary());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests mocking a unary function.
|
||||||
|
TEST_F(FunctionMockerTest, MocksUnaryFunction) {
|
||||||
|
EXPECT_CALL(mock_foo_, Unary(Eq(2)))
|
||||||
|
.Times(2)
|
||||||
|
.WillOnce(Return(true));
|
||||||
|
|
||||||
|
EXPECT_TRUE(foo_->Unary(2));
|
||||||
|
EXPECT_FALSE(foo_->Unary(2));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests mocking a binary function.
|
||||||
|
TEST_F(FunctionMockerTest, MocksBinaryFunction) {
|
||||||
|
EXPECT_CALL(mock_foo_, Binary(2, _))
|
||||||
|
.WillOnce(Return(3));
|
||||||
|
|
||||||
|
EXPECT_EQ(3, foo_->Binary(2, 1));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests mocking a decimal function.
|
||||||
|
TEST_F(FunctionMockerTest, MocksDecimalFunction) {
|
||||||
|
EXPECT_CALL(mock_foo_, Decimal(true, 'a', 0, 0, 1L, A<float>(),
|
||||||
|
Lt(100), 5U, NULL, "hi"))
|
||||||
|
.WillOnce(Return(5));
|
||||||
|
|
||||||
|
EXPECT_EQ(5, foo_->Decimal(true, 'a', 0, 0, 1, 0, 0, 5, NULL, "hi"));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests mocking a function that takes a non-const reference.
|
||||||
|
TEST_F(FunctionMockerTest, MocksFunctionWithNonConstReferenceArgument) {
|
||||||
|
int a = 0;
|
||||||
|
EXPECT_CALL(mock_foo_, TakesNonConstReference(Ref(a)))
|
||||||
|
.WillOnce(Return(true));
|
||||||
|
|
||||||
|
EXPECT_TRUE(foo_->TakesNonConstReference(a));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests mocking a function that takes a const reference.
|
||||||
|
TEST_F(FunctionMockerTest, MocksFunctionWithConstReferenceArgument) {
|
||||||
|
int a = 0;
|
||||||
|
EXPECT_CALL(mock_foo_, TakesConstReference(Ref(a)))
|
||||||
|
.WillOnce(Return("Hello"));
|
||||||
|
|
||||||
|
EXPECT_EQ("Hello", foo_->TakesConstReference(a));
|
||||||
|
}
|
||||||
|
|
||||||
|
#ifdef GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS
|
||||||
|
// Tests mocking a function that takes a const variable.
|
||||||
|
TEST_F(FunctionMockerTest, MocksFunctionWithConstArgument) {
|
||||||
|
EXPECT_CALL(mock_foo_, TakesConst(Lt(10)))
|
||||||
|
.WillOnce(DoDefault());
|
||||||
|
|
||||||
|
EXPECT_FALSE(foo_->TakesConst(5));
|
||||||
|
}
|
||||||
|
#endif // GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS
|
||||||
|
|
||||||
|
// Tests mocking functions overloaded on the number of arguments.
|
||||||
|
TEST_F(FunctionMockerTest, MocksFunctionsOverloadedOnArgumentNumber) {
|
||||||
|
EXPECT_CALL(mock_foo_, OverloadedOnArgumentNumber())
|
||||||
|
.WillOnce(Return(1));
|
||||||
|
EXPECT_CALL(mock_foo_, OverloadedOnArgumentNumber(_))
|
||||||
|
.WillOnce(Return(2));
|
||||||
|
|
||||||
|
EXPECT_EQ(2, foo_->OverloadedOnArgumentNumber(1));
|
||||||
|
EXPECT_EQ(1, foo_->OverloadedOnArgumentNumber());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests mocking functions overloaded on the types of argument.
|
||||||
|
TEST_F(FunctionMockerTest, MocksFunctionsOverloadedOnArgumentType) {
|
||||||
|
EXPECT_CALL(mock_foo_, OverloadedOnArgumentType(An<int>()))
|
||||||
|
.WillOnce(Return(1));
|
||||||
|
EXPECT_CALL(mock_foo_, OverloadedOnArgumentType(TypedEq<char>('a')))
|
||||||
|
.WillOnce(Return('b'));
|
||||||
|
|
||||||
|
EXPECT_EQ(1, foo_->OverloadedOnArgumentType(0));
|
||||||
|
EXPECT_EQ('b', foo_->OverloadedOnArgumentType('a'));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests mocking functions overloaded on the const-ness of this object.
|
||||||
|
TEST_F(FunctionMockerTest, MocksFunctionsOverloadedOnConstnessOfThis) {
|
||||||
|
EXPECT_CALL(mock_foo_, OverloadedOnConstness());
|
||||||
|
EXPECT_CALL(Const(mock_foo_), OverloadedOnConstness())
|
||||||
|
.WillOnce(Return('a'));
|
||||||
|
|
||||||
|
EXPECT_EQ(0, foo_->OverloadedOnConstness());
|
||||||
|
EXPECT_EQ('a', Const(*foo_).OverloadedOnConstness());
|
||||||
|
}
|
||||||
|
|
||||||
|
#if GTEST_OS_WINDOWS
|
||||||
|
// Tests mocking a nullary function with calltype.
|
||||||
|
TEST_F(FunctionMockerTest, MocksNullaryFunctionWithCallType) {
|
||||||
|
EXPECT_CALL(mock_foo_, CTNullary())
|
||||||
|
.WillOnce(Return(-1))
|
||||||
|
.WillOnce(Return(0));
|
||||||
|
|
||||||
|
EXPECT_EQ(-1, foo_->CTNullary());
|
||||||
|
EXPECT_EQ(0, foo_->CTNullary());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests mocking a unary function with calltype.
|
||||||
|
TEST_F(FunctionMockerTest, MocksUnaryFunctionWithCallType) {
|
||||||
|
EXPECT_CALL(mock_foo_, CTUnary(Eq(2)))
|
||||||
|
.Times(2)
|
||||||
|
.WillOnce(Return(true))
|
||||||
|
.WillOnce(Return(false));
|
||||||
|
|
||||||
|
EXPECT_TRUE(foo_->CTUnary(2));
|
||||||
|
EXPECT_FALSE(foo_->CTUnary(2));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests mocking a decimal function with calltype.
|
||||||
|
TEST_F(FunctionMockerTest, MocksDecimalFunctionWithCallType) {
|
||||||
|
EXPECT_CALL(mock_foo_, CTDecimal(true, 'a', 0, 0, 1L, A<float>(),
|
||||||
|
Lt(100), 5U, NULL, "hi"))
|
||||||
|
.WillOnce(Return(10));
|
||||||
|
|
||||||
|
EXPECT_EQ(10, foo_->CTDecimal(true, 'a', 0, 0, 1, 0, 0, 5, NULL, "hi"));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests mocking functions overloaded on the const-ness of this object.
|
||||||
|
TEST_F(FunctionMockerTest, MocksFunctionsConstFunctionWithCallType) {
|
||||||
|
EXPECT_CALL(Const(mock_foo_), CTConst(_))
|
||||||
|
.WillOnce(Return('a'));
|
||||||
|
|
||||||
|
EXPECT_EQ('a', Const(*foo_).CTConst(0));
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // GTEST_OS_WINDOWS
|
||||||
|
|
||||||
|
class MockB {
|
||||||
|
public:
|
||||||
|
MockB() {}
|
||||||
|
|
||||||
|
MOCK_METHOD0(DoB, void());
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockB);
|
||||||
|
};
|
||||||
|
|
||||||
|
// Tests that functions with no EXPECT_CALL() ruls can be called any
|
||||||
|
// number of times.
|
||||||
|
TEST(ExpectCallTest, UnmentionedFunctionCanBeCalledAnyNumberOfTimes) {
|
||||||
|
{
|
||||||
|
MockB b;
|
||||||
|
}
|
||||||
|
|
||||||
|
{
|
||||||
|
MockB b;
|
||||||
|
b.DoB();
|
||||||
|
}
|
||||||
|
|
||||||
|
{
|
||||||
|
MockB b;
|
||||||
|
b.DoB();
|
||||||
|
b.DoB();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests mocking template interfaces.
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
class StackInterface {
|
||||||
|
public:
|
||||||
|
virtual ~StackInterface() {}
|
||||||
|
|
||||||
|
// Template parameter appears in function parameter.
|
||||||
|
virtual void Push(const T& value) = 0;
|
||||||
|
virtual void Pop() = 0;
|
||||||
|
virtual int GetSize() const = 0;
|
||||||
|
// Template parameter appears in function return type.
|
||||||
|
virtual const T& GetTop() const = 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
class MockStack : public StackInterface<T> {
|
||||||
|
public:
|
||||||
|
MockStack() {}
|
||||||
|
|
||||||
|
MOCK_METHOD1_T(Push, void(const T& elem));
|
||||||
|
MOCK_METHOD0_T(Pop, void());
|
||||||
|
MOCK_CONST_METHOD0_T(GetSize, int()); // NOLINT
|
||||||
|
MOCK_CONST_METHOD0_T(GetTop, const T&());
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockStack);
|
||||||
|
};
|
||||||
|
|
||||||
|
// Tests that template mock works.
|
||||||
|
TEST(TemplateMockTest, Works) {
|
||||||
|
MockStack<int> mock;
|
||||||
|
|
||||||
|
EXPECT_CALL(mock, GetSize())
|
||||||
|
.WillOnce(Return(0))
|
||||||
|
.WillOnce(Return(1))
|
||||||
|
.WillOnce(Return(0));
|
||||||
|
EXPECT_CALL(mock, Push(_));
|
||||||
|
int n = 5;
|
||||||
|
EXPECT_CALL(mock, GetTop())
|
||||||
|
.WillOnce(ReturnRef(n));
|
||||||
|
EXPECT_CALL(mock, Pop())
|
||||||
|
.Times(AnyNumber());
|
||||||
|
|
||||||
|
EXPECT_EQ(0, mock.GetSize());
|
||||||
|
mock.Push(5);
|
||||||
|
EXPECT_EQ(1, mock.GetSize());
|
||||||
|
EXPECT_EQ(5, mock.GetTop());
|
||||||
|
mock.Pop();
|
||||||
|
EXPECT_EQ(0, mock.GetSize());
|
||||||
|
}
|
||||||
|
|
||||||
|
#if GTEST_OS_WINDOWS
|
||||||
|
// Tests mocking template interfaces with calltype.
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
class StackInterfaceWithCallType {
|
||||||
|
public:
|
||||||
|
virtual ~StackInterfaceWithCallType() {}
|
||||||
|
|
||||||
|
// Template parameter appears in function parameter.
|
||||||
|
STDMETHOD_(void, Push)(const T& value) = 0;
|
||||||
|
STDMETHOD_(void, Pop)() = 0;
|
||||||
|
STDMETHOD_(int, GetSize)() const = 0;
|
||||||
|
// Template parameter appears in function return type.
|
||||||
|
STDMETHOD_(const T&, GetTop)() const = 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
class MockStackWithCallType : public StackInterfaceWithCallType<T> {
|
||||||
|
public:
|
||||||
|
MockStackWithCallType() {}
|
||||||
|
|
||||||
|
MOCK_METHOD1_T_WITH_CALLTYPE(STDMETHODCALLTYPE, Push, void(const T& elem));
|
||||||
|
MOCK_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, Pop, void());
|
||||||
|
MOCK_CONST_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, GetSize, int());
|
||||||
|
MOCK_CONST_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, GetTop, const T&());
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockStackWithCallType);
|
||||||
|
};
|
||||||
|
|
||||||
|
// Tests that template mock with calltype works.
|
||||||
|
TEST(TemplateMockTestWithCallType, Works) {
|
||||||
|
MockStackWithCallType<int> mock;
|
||||||
|
|
||||||
|
EXPECT_CALL(mock, GetSize())
|
||||||
|
.WillOnce(Return(0))
|
||||||
|
.WillOnce(Return(1))
|
||||||
|
.WillOnce(Return(0));
|
||||||
|
EXPECT_CALL(mock, Push(_));
|
||||||
|
int n = 5;
|
||||||
|
EXPECT_CALL(mock, GetTop())
|
||||||
|
.WillOnce(ReturnRef(n));
|
||||||
|
EXPECT_CALL(mock, Pop())
|
||||||
|
.Times(AnyNumber());
|
||||||
|
|
||||||
|
EXPECT_EQ(0, mock.GetSize());
|
||||||
|
mock.Push(5);
|
||||||
|
EXPECT_EQ(1, mock.GetSize());
|
||||||
|
EXPECT_EQ(5, mock.GetTop());
|
||||||
|
mock.Pop();
|
||||||
|
EXPECT_EQ(0, mock.GetSize());
|
||||||
|
}
|
||||||
|
#endif // GTEST_OS_WINDOWS
|
||||||
|
|
||||||
|
#define MY_MOCK_METHODS1_ \
|
||||||
|
MOCK_METHOD0(Overloaded, void()); \
|
||||||
|
MOCK_CONST_METHOD1(Overloaded, int(int n)); \
|
||||||
|
MOCK_METHOD2(Overloaded, bool(bool f, int n))
|
||||||
|
|
||||||
|
class MockOverloadedOnArgNumber {
|
||||||
|
public:
|
||||||
|
MockOverloadedOnArgNumber() {}
|
||||||
|
|
||||||
|
MY_MOCK_METHODS1_;
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnArgNumber);
|
||||||
|
};
|
||||||
|
|
||||||
|
TEST(OverloadedMockMethodTest, CanOverloadOnArgNumberInMacroBody) {
|
||||||
|
MockOverloadedOnArgNumber mock;
|
||||||
|
EXPECT_CALL(mock, Overloaded());
|
||||||
|
EXPECT_CALL(mock, Overloaded(1)).WillOnce(Return(2));
|
||||||
|
EXPECT_CALL(mock, Overloaded(true, 1)).WillOnce(Return(true));
|
||||||
|
|
||||||
|
mock.Overloaded();
|
||||||
|
EXPECT_EQ(2, mock.Overloaded(1));
|
||||||
|
EXPECT_TRUE(mock.Overloaded(true, 1));
|
||||||
|
}
|
||||||
|
|
||||||
|
#define MY_MOCK_METHODS2_ \
|
||||||
|
MOCK_CONST_METHOD1(Overloaded, int(int n)); \
|
||||||
|
MOCK_METHOD1(Overloaded, int(int n));
|
||||||
|
|
||||||
|
class MockOverloadedOnConstness {
|
||||||
|
public:
|
||||||
|
MockOverloadedOnConstness() {}
|
||||||
|
|
||||||
|
MY_MOCK_METHODS2_;
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnConstness);
|
||||||
|
};
|
||||||
|
|
||||||
|
TEST(OverloadedMockMethodTest, CanOverloadOnConstnessInMacroBody) {
|
||||||
|
MockOverloadedOnConstness mock;
|
||||||
|
const MockOverloadedOnConstness* const_mock = &mock;
|
||||||
|
EXPECT_CALL(mock, Overloaded(1)).WillOnce(Return(2));
|
||||||
|
EXPECT_CALL(*const_mock, Overloaded(1)).WillOnce(Return(3));
|
||||||
|
|
||||||
|
EXPECT_EQ(2, mock.Overloaded(1));
|
||||||
|
EXPECT_EQ(3, const_mock->Overloaded(1));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(MockFunctionTest, WorksForVoidNullary) {
|
||||||
|
MockFunction<void()> foo;
|
||||||
|
EXPECT_CALL(foo, Call());
|
||||||
|
foo.Call();
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(MockFunctionTest, WorksForNonVoidNullary) {
|
||||||
|
MockFunction<int()> foo;
|
||||||
|
EXPECT_CALL(foo, Call())
|
||||||
|
.WillOnce(Return(1))
|
||||||
|
.WillOnce(Return(2));
|
||||||
|
EXPECT_EQ(1, foo.Call());
|
||||||
|
EXPECT_EQ(2, foo.Call());
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(MockFunctionTest, WorksForVoidUnary) {
|
||||||
|
MockFunction<void(int)> foo;
|
||||||
|
EXPECT_CALL(foo, Call(1));
|
||||||
|
foo.Call(1);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(MockFunctionTest, WorksForNonVoidBinary) {
|
||||||
|
MockFunction<int(bool, int)> foo;
|
||||||
|
EXPECT_CALL(foo, Call(false, 42))
|
||||||
|
.WillOnce(Return(1))
|
||||||
|
.WillOnce(Return(2));
|
||||||
|
EXPECT_CALL(foo, Call(true, Ge(100)))
|
||||||
|
.WillOnce(Return(3));
|
||||||
|
EXPECT_EQ(1, foo.Call(false, 42));
|
||||||
|
EXPECT_EQ(2, foo.Call(false, 42));
|
||||||
|
EXPECT_EQ(3, foo.Call(true, 120));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(MockFunctionTest, WorksFor10Arguments) {
|
||||||
|
MockFunction<int(bool a0, char a1, int a2, int a3, int a4,
|
||||||
|
int a5, int a6, char a7, int a8, bool a9)> foo;
|
||||||
|
EXPECT_CALL(foo, Call(_, 'a', _, _, _, _, _, _, _, _))
|
||||||
|
.WillOnce(Return(1))
|
||||||
|
.WillOnce(Return(2));
|
||||||
|
EXPECT_EQ(1, foo.Call(false, 'a', 0, 0, 0, 0, 0, 'b', 0, true));
|
||||||
|
EXPECT_EQ(2, foo.Call(true, 'a', 0, 0, 0, 0, 0, 'b', 1, false));
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace gmock_generated_function_mockers_test
|
||||||
|
} // namespace testing
|
|
@ -0,0 +1,127 @@
|
||||||
|
// 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 Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file tests the internal utilities.
|
||||||
|
|
||||||
|
#include "gmock/internal/gmock-generated-internal-utils.h"
|
||||||
|
#include "gmock/internal/gmock-internal-utils.h"
|
||||||
|
#include "gtest/gtest.h"
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
|
||||||
|
using ::std::tr1::tuple;
|
||||||
|
using ::testing::Matcher;
|
||||||
|
using ::testing::internal::CompileAssertTypesEqual;
|
||||||
|
using ::testing::internal::MatcherTuple;
|
||||||
|
using ::testing::internal::Function;
|
||||||
|
using ::testing::internal::IgnoredValue;
|
||||||
|
|
||||||
|
// Tests the MatcherTuple template struct.
|
||||||
|
|
||||||
|
TEST(MatcherTupleTest, ForSize0) {
|
||||||
|
CompileAssertTypesEqual<tuple<>, MatcherTuple<tuple<> >::type>();
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(MatcherTupleTest, ForSize1) {
|
||||||
|
CompileAssertTypesEqual<tuple<Matcher<int> >,
|
||||||
|
MatcherTuple<tuple<int> >::type>();
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(MatcherTupleTest, ForSize2) {
|
||||||
|
CompileAssertTypesEqual<tuple<Matcher<int>, Matcher<char> >,
|
||||||
|
MatcherTuple<tuple<int, char> >::type>();
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(MatcherTupleTest, ForSize5) {
|
||||||
|
CompileAssertTypesEqual<tuple<Matcher<int>, Matcher<char>, Matcher<bool>,
|
||||||
|
Matcher<double>, Matcher<char*> >,
|
||||||
|
MatcherTuple<tuple<int, char, bool, double, char*>
|
||||||
|
>::type>();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the Function template struct.
|
||||||
|
|
||||||
|
TEST(FunctionTest, Nullary) {
|
||||||
|
typedef Function<int()> F; // NOLINT
|
||||||
|
CompileAssertTypesEqual<int, F::Result>();
|
||||||
|
CompileAssertTypesEqual<tuple<>, F::ArgumentTuple>();
|
||||||
|
CompileAssertTypesEqual<tuple<>, F::ArgumentMatcherTuple>();
|
||||||
|
CompileAssertTypesEqual<void(), F::MakeResultVoid>();
|
||||||
|
CompileAssertTypesEqual<IgnoredValue(), F::MakeResultIgnoredValue>();
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(FunctionTest, Unary) {
|
||||||
|
typedef Function<int(bool)> F; // NOLINT
|
||||||
|
CompileAssertTypesEqual<int, F::Result>();
|
||||||
|
CompileAssertTypesEqual<bool, F::Argument1>();
|
||||||
|
CompileAssertTypesEqual<tuple<bool>, F::ArgumentTuple>();
|
||||||
|
CompileAssertTypesEqual<tuple<Matcher<bool> >, F::ArgumentMatcherTuple>();
|
||||||
|
CompileAssertTypesEqual<void(bool), F::MakeResultVoid>(); // NOLINT
|
||||||
|
CompileAssertTypesEqual<IgnoredValue(bool), // NOLINT
|
||||||
|
F::MakeResultIgnoredValue>();
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(FunctionTest, Binary) {
|
||||||
|
typedef Function<int(bool, const long&)> F; // NOLINT
|
||||||
|
CompileAssertTypesEqual<int, F::Result>();
|
||||||
|
CompileAssertTypesEqual<bool, F::Argument1>();
|
||||||
|
CompileAssertTypesEqual<const long&, F::Argument2>(); // NOLINT
|
||||||
|
CompileAssertTypesEqual<tuple<bool, const long&>, F::ArgumentTuple>(); // NOLINT
|
||||||
|
CompileAssertTypesEqual<tuple<Matcher<bool>, Matcher<const long&> >, // NOLINT
|
||||||
|
F::ArgumentMatcherTuple>();
|
||||||
|
CompileAssertTypesEqual<void(bool, const long&), F::MakeResultVoid>(); // NOLINT
|
||||||
|
CompileAssertTypesEqual<IgnoredValue(bool, const long&), // NOLINT
|
||||||
|
F::MakeResultIgnoredValue>();
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(FunctionTest, LongArgumentList) {
|
||||||
|
typedef Function<char(bool, int, char*, int&, const long&)> F; // NOLINT
|
||||||
|
CompileAssertTypesEqual<char, F::Result>();
|
||||||
|
CompileAssertTypesEqual<bool, F::Argument1>();
|
||||||
|
CompileAssertTypesEqual<int, F::Argument2>();
|
||||||
|
CompileAssertTypesEqual<char*, F::Argument3>();
|
||||||
|
CompileAssertTypesEqual<int&, F::Argument4>();
|
||||||
|
CompileAssertTypesEqual<const long&, F::Argument5>(); // NOLINT
|
||||||
|
CompileAssertTypesEqual<tuple<bool, int, char*, int&, const long&>, // NOLINT
|
||||||
|
F::ArgumentTuple>();
|
||||||
|
CompileAssertTypesEqual<tuple<Matcher<bool>, Matcher<int>, Matcher<char*>,
|
||||||
|
Matcher<int&>, Matcher<const long&> >, // NOLINT
|
||||||
|
F::ArgumentMatcherTuple>();
|
||||||
|
CompileAssertTypesEqual<void(bool, int, char*, int&, const long&), // NOLINT
|
||||||
|
F::MakeResultVoid>();
|
||||||
|
CompileAssertTypesEqual<
|
||||||
|
IgnoredValue(bool, int, char*, int&, const long&), // NOLINT
|
||||||
|
F::MakeResultIgnoredValue>();
|
||||||
|
}
|
||||||
|
|
||||||
|
} // Unnamed namespace
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,655 @@
|
||||||
|
// 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 Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file tests the internal utilities.
|
||||||
|
|
||||||
|
#include "gmock/internal/gmock-internal-utils.h"
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <map>
|
||||||
|
#include <string>
|
||||||
|
#include <sstream>
|
||||||
|
#include <vector>
|
||||||
|
#include "gmock/gmock.h"
|
||||||
|
#include "gmock/internal/gmock-port.h"
|
||||||
|
#include "gtest/gtest.h"
|
||||||
|
#include "gtest/gtest-spi.h"
|
||||||
|
|
||||||
|
#if GTEST_OS_CYGWIN
|
||||||
|
# include <sys/types.h> // For ssize_t. NOLINT
|
||||||
|
#endif
|
||||||
|
|
||||||
|
class ProtocolMessage;
|
||||||
|
|
||||||
|
namespace proto2 {
|
||||||
|
class Message;
|
||||||
|
} // namespace proto2
|
||||||
|
|
||||||
|
namespace testing {
|
||||||
|
namespace internal {
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
|
||||||
|
using ::std::tr1::make_tuple;
|
||||||
|
using ::std::tr1::tuple;
|
||||||
|
|
||||||
|
TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsNoWord) {
|
||||||
|
EXPECT_EQ("", ConvertIdentifierNameToWords(""));
|
||||||
|
EXPECT_EQ("", ConvertIdentifierNameToWords("_"));
|
||||||
|
EXPECT_EQ("", ConvertIdentifierNameToWords("__"));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsDigits) {
|
||||||
|
EXPECT_EQ("1", ConvertIdentifierNameToWords("_1"));
|
||||||
|
EXPECT_EQ("2", ConvertIdentifierNameToWords("2_"));
|
||||||
|
EXPECT_EQ("34", ConvertIdentifierNameToWords("_34_"));
|
||||||
|
EXPECT_EQ("34 56", ConvertIdentifierNameToWords("_34_56"));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsCamelCaseWords) {
|
||||||
|
EXPECT_EQ("a big word", ConvertIdentifierNameToWords("ABigWord"));
|
||||||
|
EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("FooBar"));
|
||||||
|
EXPECT_EQ("foo", ConvertIdentifierNameToWords("Foo_"));
|
||||||
|
EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("_Foo_Bar_"));
|
||||||
|
EXPECT_EQ("foo and bar", ConvertIdentifierNameToWords("_Foo__And_Bar"));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContains_SeparatedWords) {
|
||||||
|
EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("foo_bar"));
|
||||||
|
EXPECT_EQ("foo", ConvertIdentifierNameToWords("_foo_"));
|
||||||
|
EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("_foo_bar_"));
|
||||||
|
EXPECT_EQ("foo and bar", ConvertIdentifierNameToWords("_foo__and_bar"));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameIsMixture) {
|
||||||
|
EXPECT_EQ("foo bar 123", ConvertIdentifierNameToWords("Foo_bar123"));
|
||||||
|
EXPECT_EQ("chapter 11 section 1",
|
||||||
|
ConvertIdentifierNameToWords("_Chapter11Section_1_"));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(PointeeOfTest, WorksForSmartPointers) {
|
||||||
|
CompileAssertTypesEqual<const char,
|
||||||
|
PointeeOf<internal::linked_ptr<const char> >::type>();
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(PointeeOfTest, WorksForRawPointers) {
|
||||||
|
CompileAssertTypesEqual<int, PointeeOf<int*>::type>();
|
||||||
|
CompileAssertTypesEqual<const char, PointeeOf<const char*>::type>();
|
||||||
|
CompileAssertTypesEqual<void, PointeeOf<void*>::type>();
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(GetRawPointerTest, WorksForSmartPointers) {
|
||||||
|
const char* const raw_p4 = new const char('a'); // NOLINT
|
||||||
|
const internal::linked_ptr<const char> p4(raw_p4);
|
||||||
|
EXPECT_EQ(raw_p4, GetRawPointer(p4));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(GetRawPointerTest, WorksForRawPointers) {
|
||||||
|
int* p = NULL;
|
||||||
|
// Don't use EXPECT_EQ as no NULL-testing magic on Symbian.
|
||||||
|
EXPECT_TRUE(NULL == GetRawPointer(p));
|
||||||
|
int n = 1;
|
||||||
|
EXPECT_EQ(&n, GetRawPointer(&n));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests KindOf<T>.
|
||||||
|
|
||||||
|
class Base {};
|
||||||
|
class Derived : public Base {};
|
||||||
|
|
||||||
|
TEST(KindOfTest, Bool) {
|
||||||
|
EXPECT_EQ(kBool, GMOCK_KIND_OF_(bool)); // NOLINT
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(KindOfTest, Integer) {
|
||||||
|
EXPECT_EQ(kInteger, GMOCK_KIND_OF_(char)); // NOLINT
|
||||||
|
EXPECT_EQ(kInteger, GMOCK_KIND_OF_(signed char)); // NOLINT
|
||||||
|
EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned char)); // NOLINT
|
||||||
|
EXPECT_EQ(kInteger, GMOCK_KIND_OF_(short)); // NOLINT
|
||||||
|
EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned short)); // NOLINT
|
||||||
|
EXPECT_EQ(kInteger, GMOCK_KIND_OF_(int)); // NOLINT
|
||||||
|
EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned int)); // NOLINT
|
||||||
|
EXPECT_EQ(kInteger, GMOCK_KIND_OF_(long)); // NOLINT
|
||||||
|
EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned long)); // NOLINT
|
||||||
|
EXPECT_EQ(kInteger, GMOCK_KIND_OF_(wchar_t)); // NOLINT
|
||||||
|
EXPECT_EQ(kInteger, GMOCK_KIND_OF_(Int64)); // NOLINT
|
||||||
|
EXPECT_EQ(kInteger, GMOCK_KIND_OF_(UInt64)); // NOLINT
|
||||||
|
EXPECT_EQ(kInteger, GMOCK_KIND_OF_(size_t)); // NOLINT
|
||||||
|
#if GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN
|
||||||
|
// ssize_t is not defined on Windows and possibly some other OSes.
|
||||||
|
EXPECT_EQ(kInteger, GMOCK_KIND_OF_(ssize_t)); // NOLINT
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(KindOfTest, FloatingPoint) {
|
||||||
|
EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(float)); // NOLINT
|
||||||
|
EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(double)); // NOLINT
|
||||||
|
EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(long double)); // NOLINT
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(KindOfTest, Other) {
|
||||||
|
EXPECT_EQ(kOther, GMOCK_KIND_OF_(void*)); // NOLINT
|
||||||
|
EXPECT_EQ(kOther, GMOCK_KIND_OF_(char**)); // NOLINT
|
||||||
|
EXPECT_EQ(kOther, GMOCK_KIND_OF_(Base)); // NOLINT
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests LosslessArithmeticConvertible<T, U>.
|
||||||
|
|
||||||
|
TEST(LosslessArithmeticConvertibleTest, BoolToBool) {
|
||||||
|
EXPECT_TRUE((LosslessArithmeticConvertible<bool, bool>::value));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(LosslessArithmeticConvertibleTest, BoolToInteger) {
|
||||||
|
EXPECT_TRUE((LosslessArithmeticConvertible<bool, char>::value));
|
||||||
|
EXPECT_TRUE((LosslessArithmeticConvertible<bool, int>::value));
|
||||||
|
EXPECT_TRUE(
|
||||||
|
(LosslessArithmeticConvertible<bool, unsigned long>::value)); // NOLINT
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(LosslessArithmeticConvertibleTest, BoolToFloatingPoint) {
|
||||||
|
EXPECT_TRUE((LosslessArithmeticConvertible<bool, float>::value));
|
||||||
|
EXPECT_TRUE((LosslessArithmeticConvertible<bool, double>::value));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(LosslessArithmeticConvertibleTest, IntegerToBool) {
|
||||||
|
EXPECT_FALSE((LosslessArithmeticConvertible<unsigned char, bool>::value));
|
||||||
|
EXPECT_FALSE((LosslessArithmeticConvertible<int, bool>::value));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(LosslessArithmeticConvertibleTest, IntegerToInteger) {
|
||||||
|
// Unsigned => larger signed is fine.
|
||||||
|
EXPECT_TRUE((LosslessArithmeticConvertible<unsigned char, int>::value));
|
||||||
|
|
||||||
|
// Unsigned => larger unsigned is fine.
|
||||||
|
EXPECT_TRUE(
|
||||||
|
(LosslessArithmeticConvertible<unsigned short, UInt64>::value)); // NOLINT
|
||||||
|
|
||||||
|
// Signed => unsigned is not fine.
|
||||||
|
EXPECT_FALSE((LosslessArithmeticConvertible<short, UInt64>::value)); // NOLINT
|
||||||
|
EXPECT_FALSE((LosslessArithmeticConvertible<
|
||||||
|
signed char, unsigned int>::value)); // NOLINT
|
||||||
|
|
||||||
|
// Same size and same signedness: fine too.
|
||||||
|
EXPECT_TRUE((LosslessArithmeticConvertible<
|
||||||
|
unsigned char, unsigned char>::value));
|
||||||
|
EXPECT_TRUE((LosslessArithmeticConvertible<int, int>::value));
|
||||||
|
EXPECT_TRUE((LosslessArithmeticConvertible<wchar_t, wchar_t>::value));
|
||||||
|
EXPECT_TRUE((LosslessArithmeticConvertible<
|
||||||
|
unsigned long, unsigned long>::value)); // NOLINT
|
||||||
|
|
||||||
|
// Same size, different signedness: not fine.
|
||||||
|
EXPECT_FALSE((LosslessArithmeticConvertible<
|
||||||
|
unsigned char, signed char>::value));
|
||||||
|
EXPECT_FALSE((LosslessArithmeticConvertible<int, unsigned int>::value));
|
||||||
|
EXPECT_FALSE((LosslessArithmeticConvertible<UInt64, Int64>::value));
|
||||||
|
|
||||||
|
// Larger size => smaller size is not fine.
|
||||||
|
EXPECT_FALSE((LosslessArithmeticConvertible<long, char>::value)); // NOLINT
|
||||||
|
EXPECT_FALSE((LosslessArithmeticConvertible<int, signed char>::value));
|
||||||
|
EXPECT_FALSE((LosslessArithmeticConvertible<Int64, unsigned int>::value));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(LosslessArithmeticConvertibleTest, IntegerToFloatingPoint) {
|
||||||
|
// Integers cannot be losslessly converted to floating-points, as
|
||||||
|
// the format of the latter is implementation-defined.
|
||||||
|
EXPECT_FALSE((LosslessArithmeticConvertible<char, float>::value));
|
||||||
|
EXPECT_FALSE((LosslessArithmeticConvertible<int, double>::value));
|
||||||
|
EXPECT_FALSE((LosslessArithmeticConvertible<
|
||||||
|
short, long double>::value)); // NOLINT
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(LosslessArithmeticConvertibleTest, FloatingPointToBool) {
|
||||||
|
EXPECT_FALSE((LosslessArithmeticConvertible<float, bool>::value));
|
||||||
|
EXPECT_FALSE((LosslessArithmeticConvertible<double, bool>::value));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(LosslessArithmeticConvertibleTest, FloatingPointToInteger) {
|
||||||
|
EXPECT_FALSE((LosslessArithmeticConvertible<float, long>::value)); // NOLINT
|
||||||
|
EXPECT_FALSE((LosslessArithmeticConvertible<double, Int64>::value));
|
||||||
|
EXPECT_FALSE((LosslessArithmeticConvertible<long double, int>::value));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(LosslessArithmeticConvertibleTest, FloatingPointToFloatingPoint) {
|
||||||
|
// Smaller size => larger size is fine.
|
||||||
|
EXPECT_TRUE((LosslessArithmeticConvertible<float, double>::value));
|
||||||
|
EXPECT_TRUE((LosslessArithmeticConvertible<float, long double>::value));
|
||||||
|
EXPECT_TRUE((LosslessArithmeticConvertible<double, long double>::value));
|
||||||
|
|
||||||
|
// Same size: fine.
|
||||||
|
EXPECT_TRUE((LosslessArithmeticConvertible<float, float>::value));
|
||||||
|
EXPECT_TRUE((LosslessArithmeticConvertible<double, double>::value));
|
||||||
|
|
||||||
|
// Larger size => smaller size is not fine.
|
||||||
|
EXPECT_FALSE((LosslessArithmeticConvertible<double, float>::value));
|
||||||
|
if (sizeof(double) == sizeof(long double)) { // NOLINT
|
||||||
|
// In some implementations (e.g. MSVC), double and long double
|
||||||
|
// have the same size.
|
||||||
|
EXPECT_TRUE((LosslessArithmeticConvertible<long double, double>::value));
|
||||||
|
} else {
|
||||||
|
EXPECT_FALSE((LosslessArithmeticConvertible<long double, double>::value));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the TupleMatches() template function.
|
||||||
|
|
||||||
|
TEST(TupleMatchesTest, WorksForSize0) {
|
||||||
|
tuple<> matchers;
|
||||||
|
tuple<> values;
|
||||||
|
|
||||||
|
EXPECT_TRUE(TupleMatches(matchers, values));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(TupleMatchesTest, WorksForSize1) {
|
||||||
|
tuple<Matcher<int> > matchers(Eq(1));
|
||||||
|
tuple<int> values1(1),
|
||||||
|
values2(2);
|
||||||
|
|
||||||
|
EXPECT_TRUE(TupleMatches(matchers, values1));
|
||||||
|
EXPECT_FALSE(TupleMatches(matchers, values2));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(TupleMatchesTest, WorksForSize2) {
|
||||||
|
tuple<Matcher<int>, Matcher<char> > matchers(Eq(1), Eq('a'));
|
||||||
|
tuple<int, char> values1(1, 'a'),
|
||||||
|
values2(1, 'b'),
|
||||||
|
values3(2, 'a'),
|
||||||
|
values4(2, 'b');
|
||||||
|
|
||||||
|
EXPECT_TRUE(TupleMatches(matchers, values1));
|
||||||
|
EXPECT_FALSE(TupleMatches(matchers, values2));
|
||||||
|
EXPECT_FALSE(TupleMatches(matchers, values3));
|
||||||
|
EXPECT_FALSE(TupleMatches(matchers, values4));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(TupleMatchesTest, WorksForSize5) {
|
||||||
|
tuple<Matcher<int>, Matcher<char>, Matcher<bool>, Matcher<long>, // NOLINT
|
||||||
|
Matcher<string> >
|
||||||
|
matchers(Eq(1), Eq('a'), Eq(true), Eq(2L), Eq("hi"));
|
||||||
|
tuple<int, char, bool, long, string> // NOLINT
|
||||||
|
values1(1, 'a', true, 2L, "hi"),
|
||||||
|
values2(1, 'a', true, 2L, "hello"),
|
||||||
|
values3(2, 'a', true, 2L, "hi");
|
||||||
|
|
||||||
|
EXPECT_TRUE(TupleMatches(matchers, values1));
|
||||||
|
EXPECT_FALSE(TupleMatches(matchers, values2));
|
||||||
|
EXPECT_FALSE(TupleMatches(matchers, values3));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that Assert(true, ...) succeeds.
|
||||||
|
TEST(AssertTest, SucceedsOnTrue) {
|
||||||
|
Assert(true, __FILE__, __LINE__, "This should succeed.");
|
||||||
|
Assert(true, __FILE__, __LINE__); // This should succeed too.
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that Assert(false, ...) generates a fatal failure.
|
||||||
|
TEST(AssertTest, FailsFatallyOnFalse) {
|
||||||
|
EXPECT_DEATH_IF_SUPPORTED({
|
||||||
|
Assert(false, __FILE__, __LINE__, "This should fail.");
|
||||||
|
}, "");
|
||||||
|
|
||||||
|
EXPECT_DEATH_IF_SUPPORTED({
|
||||||
|
Assert(false, __FILE__, __LINE__);
|
||||||
|
}, "");
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that Expect(true, ...) succeeds.
|
||||||
|
TEST(ExpectTest, SucceedsOnTrue) {
|
||||||
|
Expect(true, __FILE__, __LINE__, "This should succeed.");
|
||||||
|
Expect(true, __FILE__, __LINE__); // This should succeed too.
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that Expect(false, ...) generates a non-fatal failure.
|
||||||
|
TEST(ExpectTest, FailsNonfatallyOnFalse) {
|
||||||
|
EXPECT_NONFATAL_FAILURE({ // NOLINT
|
||||||
|
Expect(false, __FILE__, __LINE__, "This should fail.");
|
||||||
|
}, "This should fail");
|
||||||
|
|
||||||
|
EXPECT_NONFATAL_FAILURE({ // NOLINT
|
||||||
|
Expect(false, __FILE__, __LINE__);
|
||||||
|
}, "Expectation failed");
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests LogIsVisible().
|
||||||
|
|
||||||
|
class LogIsVisibleTest : public ::testing::Test {
|
||||||
|
protected:
|
||||||
|
virtual void SetUp() {
|
||||||
|
// The code needs to work when both ::string and ::std::string are
|
||||||
|
// defined and the flag is implemented as a
|
||||||
|
// testing::internal::String. In this case, without the call to
|
||||||
|
// c_str(), the compiler will complain that it cannot figure out
|
||||||
|
// whether the String flag should be converted to a ::string or an
|
||||||
|
// ::std::string before being assigned to original_verbose_.
|
||||||
|
original_verbose_ = GMOCK_FLAG(verbose).c_str();
|
||||||
|
}
|
||||||
|
|
||||||
|
virtual void TearDown() { GMOCK_FLAG(verbose) = original_verbose_; }
|
||||||
|
|
||||||
|
string original_verbose_;
|
||||||
|
};
|
||||||
|
|
||||||
|
TEST_F(LogIsVisibleTest, AlwaysReturnsTrueIfVerbosityIsInfo) {
|
||||||
|
GMOCK_FLAG(verbose) = kInfoVerbosity;
|
||||||
|
EXPECT_TRUE(LogIsVisible(INFO));
|
||||||
|
EXPECT_TRUE(LogIsVisible(WARNING));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(LogIsVisibleTest, AlwaysReturnsFalseIfVerbosityIsError) {
|
||||||
|
GMOCK_FLAG(verbose) = kErrorVerbosity;
|
||||||
|
EXPECT_FALSE(LogIsVisible(INFO));
|
||||||
|
EXPECT_FALSE(LogIsVisible(WARNING));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(LogIsVisibleTest, WorksWhenVerbosityIsWarning) {
|
||||||
|
GMOCK_FLAG(verbose) = kWarningVerbosity;
|
||||||
|
EXPECT_FALSE(LogIsVisible(INFO));
|
||||||
|
EXPECT_TRUE(LogIsVisible(WARNING));
|
||||||
|
}
|
||||||
|
|
||||||
|
#if GTEST_HAS_STREAM_REDIRECTION
|
||||||
|
|
||||||
|
// Tests the Log() function.
|
||||||
|
|
||||||
|
// Verifies that Log() behaves correctly for the given verbosity level
|
||||||
|
// and log severity.
|
||||||
|
void TestLogWithSeverity(const string& verbosity, LogSeverity severity,
|
||||||
|
bool should_print) {
|
||||||
|
const string old_flag = GMOCK_FLAG(verbose);
|
||||||
|
GMOCK_FLAG(verbose) = verbosity;
|
||||||
|
CaptureStdout();
|
||||||
|
Log(severity, "Test log.\n", 0);
|
||||||
|
if (should_print) {
|
||||||
|
EXPECT_THAT(GetCapturedStdout().c_str(),
|
||||||
|
ContainsRegex(
|
||||||
|
severity == WARNING ?
|
||||||
|
"^\nGMOCK WARNING:\nTest log\\.\nStack trace:\n" :
|
||||||
|
"^\nTest log\\.\nStack trace:\n"));
|
||||||
|
} else {
|
||||||
|
EXPECT_STREQ("", GetCapturedStdout().c_str());
|
||||||
|
}
|
||||||
|
GMOCK_FLAG(verbose) = old_flag;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that when the stack_frames_to_skip parameter is negative,
|
||||||
|
// Log() doesn't include the stack trace in the output.
|
||||||
|
TEST(LogTest, NoStackTraceWhenStackFramesToSkipIsNegative) {
|
||||||
|
const string saved_flag = GMOCK_FLAG(verbose);
|
||||||
|
GMOCK_FLAG(verbose) = kInfoVerbosity;
|
||||||
|
CaptureStdout();
|
||||||
|
Log(INFO, "Test log.\n", -1);
|
||||||
|
EXPECT_STREQ("\nTest log.\n", GetCapturedStdout().c_str());
|
||||||
|
GMOCK_FLAG(verbose) = saved_flag;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that in opt mode, a positive stack_frames_to_skip argument is
|
||||||
|
// treated as 0.
|
||||||
|
TEST(LogTest, NoSkippingStackFrameInOptMode) {
|
||||||
|
CaptureStdout();
|
||||||
|
Log(WARNING, "Test log.\n", 100);
|
||||||
|
const String log = GetCapturedStdout();
|
||||||
|
|
||||||
|
# if defined(NDEBUG) && GTEST_GOOGLE3_MODE_
|
||||||
|
|
||||||
|
// In opt mode, no stack frame should be skipped.
|
||||||
|
EXPECT_THAT(log, ContainsRegex("\nGMOCK WARNING:\n"
|
||||||
|
"Test log\\.\n"
|
||||||
|
"Stack trace:\n"
|
||||||
|
".+"));
|
||||||
|
# else
|
||||||
|
|
||||||
|
// In dbg mode, the stack frames should be skipped.
|
||||||
|
EXPECT_STREQ("\nGMOCK WARNING:\n"
|
||||||
|
"Test log.\n"
|
||||||
|
"Stack trace:\n", log.c_str());
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that all logs are printed when the value of the
|
||||||
|
// --gmock_verbose flag is "info".
|
||||||
|
TEST(LogTest, AllLogsArePrintedWhenVerbosityIsInfo) {
|
||||||
|
TestLogWithSeverity(kInfoVerbosity, INFO, true);
|
||||||
|
TestLogWithSeverity(kInfoVerbosity, WARNING, true);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that only warnings are printed when the value of the
|
||||||
|
// --gmock_verbose flag is "warning".
|
||||||
|
TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsWarning) {
|
||||||
|
TestLogWithSeverity(kWarningVerbosity, INFO, false);
|
||||||
|
TestLogWithSeverity(kWarningVerbosity, WARNING, true);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that no logs are printed when the value of the
|
||||||
|
// --gmock_verbose flag is "error".
|
||||||
|
TEST(LogTest, NoLogsArePrintedWhenVerbosityIsError) {
|
||||||
|
TestLogWithSeverity(kErrorVerbosity, INFO, false);
|
||||||
|
TestLogWithSeverity(kErrorVerbosity, WARNING, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that only warnings are printed when the value of the
|
||||||
|
// --gmock_verbose flag is invalid.
|
||||||
|
TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsInvalid) {
|
||||||
|
TestLogWithSeverity("invalid", INFO, false);
|
||||||
|
TestLogWithSeverity("invalid", WARNING, true);
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // GTEST_HAS_STREAM_REDIRECTION
|
||||||
|
|
||||||
|
TEST(TypeTraitsTest, true_type) {
|
||||||
|
EXPECT_TRUE(true_type::value);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(TypeTraitsTest, false_type) {
|
||||||
|
EXPECT_FALSE(false_type::value);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(TypeTraitsTest, is_reference) {
|
||||||
|
EXPECT_FALSE(is_reference<int>::value);
|
||||||
|
EXPECT_FALSE(is_reference<char*>::value);
|
||||||
|
EXPECT_TRUE(is_reference<const int&>::value);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(TypeTraitsTest, is_pointer) {
|
||||||
|
EXPECT_FALSE(is_pointer<int>::value);
|
||||||
|
EXPECT_FALSE(is_pointer<char&>::value);
|
||||||
|
EXPECT_TRUE(is_pointer<const int*>::value);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(TypeTraitsTest, type_equals) {
|
||||||
|
EXPECT_FALSE((type_equals<int, const int>::value));
|
||||||
|
EXPECT_FALSE((type_equals<int, int&>::value));
|
||||||
|
EXPECT_FALSE((type_equals<int, double>::value));
|
||||||
|
EXPECT_TRUE((type_equals<char, char>::value));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(TypeTraitsTest, remove_reference) {
|
||||||
|
EXPECT_TRUE((type_equals<char, remove_reference<char&>::type>::value));
|
||||||
|
EXPECT_TRUE((type_equals<const int,
|
||||||
|
remove_reference<const int&>::type>::value));
|
||||||
|
EXPECT_TRUE((type_equals<int, remove_reference<int>::type>::value));
|
||||||
|
EXPECT_TRUE((type_equals<double*, remove_reference<double*>::type>::value));
|
||||||
|
}
|
||||||
|
|
||||||
|
#if GTEST_HAS_STREAM_REDIRECTION
|
||||||
|
|
||||||
|
// Verifies that Log() behaves correctly for the given verbosity level
|
||||||
|
// and log severity.
|
||||||
|
String GrabOutput(void(*logger)(), const char* verbosity) {
|
||||||
|
const string saved_flag = GMOCK_FLAG(verbose);
|
||||||
|
GMOCK_FLAG(verbose) = verbosity;
|
||||||
|
CaptureStdout();
|
||||||
|
logger();
|
||||||
|
GMOCK_FLAG(verbose) = saved_flag;
|
||||||
|
return GetCapturedStdout();
|
||||||
|
}
|
||||||
|
|
||||||
|
class DummyMock {
|
||||||
|
public:
|
||||||
|
MOCK_METHOD0(TestMethod, void());
|
||||||
|
MOCK_METHOD1(TestMethodArg, void(int dummy));
|
||||||
|
};
|
||||||
|
|
||||||
|
void ExpectCallLogger() {
|
||||||
|
DummyMock mock;
|
||||||
|
EXPECT_CALL(mock, TestMethod());
|
||||||
|
mock.TestMethod();
|
||||||
|
};
|
||||||
|
|
||||||
|
// Verifies that EXPECT_CALL logs if the --gmock_verbose flag is set to "info".
|
||||||
|
TEST(ExpectCallTest, LogsWhenVerbosityIsInfo) {
|
||||||
|
EXPECT_THAT(GrabOutput(ExpectCallLogger, kInfoVerbosity),
|
||||||
|
HasSubstr("EXPECT_CALL(mock, TestMethod())"));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Verifies that EXPECT_CALL doesn't log
|
||||||
|
// if the --gmock_verbose flag is set to "warning".
|
||||||
|
TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsWarning) {
|
||||||
|
EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kWarningVerbosity).c_str());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Verifies that EXPECT_CALL doesn't log
|
||||||
|
// if the --gmock_verbose flag is set to "error".
|
||||||
|
TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsError) {
|
||||||
|
EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kErrorVerbosity).c_str());
|
||||||
|
}
|
||||||
|
|
||||||
|
void OnCallLogger() {
|
||||||
|
DummyMock mock;
|
||||||
|
ON_CALL(mock, TestMethod());
|
||||||
|
};
|
||||||
|
|
||||||
|
// Verifies that ON_CALL logs if the --gmock_verbose flag is set to "info".
|
||||||
|
TEST(OnCallTest, LogsWhenVerbosityIsInfo) {
|
||||||
|
EXPECT_THAT(GrabOutput(OnCallLogger, kInfoVerbosity),
|
||||||
|
HasSubstr("ON_CALL(mock, TestMethod())"));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Verifies that ON_CALL doesn't log
|
||||||
|
// if the --gmock_verbose flag is set to "warning".
|
||||||
|
TEST(OnCallTest, DoesNotLogWhenVerbosityIsWarning) {
|
||||||
|
EXPECT_STREQ("", GrabOutput(OnCallLogger, kWarningVerbosity).c_str());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Verifies that ON_CALL doesn't log if
|
||||||
|
// the --gmock_verbose flag is set to "error".
|
||||||
|
TEST(OnCallTest, DoesNotLogWhenVerbosityIsError) {
|
||||||
|
EXPECT_STREQ("", GrabOutput(OnCallLogger, kErrorVerbosity).c_str());
|
||||||
|
}
|
||||||
|
|
||||||
|
void OnCallAnyArgumentLogger() {
|
||||||
|
DummyMock mock;
|
||||||
|
ON_CALL(mock, TestMethodArg(_));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Verifies that ON_CALL prints provided _ argument.
|
||||||
|
TEST(OnCallTest, LogsAnythingArgument) {
|
||||||
|
EXPECT_THAT(GrabOutput(OnCallAnyArgumentLogger, kInfoVerbosity),
|
||||||
|
HasSubstr("ON_CALL(mock, TestMethodArg(_)"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // GTEST_HAS_STREAM_REDIRECTION
|
||||||
|
|
||||||
|
// Tests StlContainerView.
|
||||||
|
|
||||||
|
TEST(StlContainerViewTest, WorksForStlContainer) {
|
||||||
|
StaticAssertTypeEq<std::vector<int>,
|
||||||
|
StlContainerView<std::vector<int> >::type>();
|
||||||
|
StaticAssertTypeEq<const std::vector<double>&,
|
||||||
|
StlContainerView<std::vector<double> >::const_reference>();
|
||||||
|
|
||||||
|
typedef std::vector<char> Chars;
|
||||||
|
Chars v1;
|
||||||
|
const Chars& v2(StlContainerView<Chars>::ConstReference(v1));
|
||||||
|
EXPECT_EQ(&v1, &v2);
|
||||||
|
|
||||||
|
v1.push_back('a');
|
||||||
|
Chars v3 = StlContainerView<Chars>::Copy(v1);
|
||||||
|
EXPECT_THAT(v3, Eq(v3));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(StlContainerViewTest, WorksForStaticNativeArray) {
|
||||||
|
StaticAssertTypeEq<NativeArray<int>,
|
||||||
|
StlContainerView<int[3]>::type>();
|
||||||
|
StaticAssertTypeEq<NativeArray<double>,
|
||||||
|
StlContainerView<const double[4]>::type>();
|
||||||
|
StaticAssertTypeEq<NativeArray<char[3]>,
|
||||||
|
StlContainerView<const char[2][3]>::type>();
|
||||||
|
|
||||||
|
StaticAssertTypeEq<const NativeArray<int>,
|
||||||
|
StlContainerView<int[2]>::const_reference>();
|
||||||
|
|
||||||
|
int a1[3] = { 0, 1, 2 };
|
||||||
|
NativeArray<int> a2 = StlContainerView<int[3]>::ConstReference(a1);
|
||||||
|
EXPECT_EQ(3U, a2.size());
|
||||||
|
EXPECT_EQ(a1, a2.begin());
|
||||||
|
|
||||||
|
const NativeArray<int> a3 = StlContainerView<int[3]>::Copy(a1);
|
||||||
|
ASSERT_EQ(3U, a3.size());
|
||||||
|
EXPECT_EQ(0, a3.begin()[0]);
|
||||||
|
EXPECT_EQ(1, a3.begin()[1]);
|
||||||
|
EXPECT_EQ(2, a3.begin()[2]);
|
||||||
|
|
||||||
|
// Makes sure a1 and a3 aren't aliases.
|
||||||
|
a1[0] = 3;
|
||||||
|
EXPECT_EQ(0, a3.begin()[0]);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(StlContainerViewTest, WorksForDynamicNativeArray) {
|
||||||
|
StaticAssertTypeEq<NativeArray<int>,
|
||||||
|
StlContainerView<tuple<const int*, size_t> >::type>();
|
||||||
|
StaticAssertTypeEq<NativeArray<double>,
|
||||||
|
StlContainerView<tuple<linked_ptr<double>, int> >::type>();
|
||||||
|
|
||||||
|
StaticAssertTypeEq<const NativeArray<int>,
|
||||||
|
StlContainerView<tuple<const int*, int> >::const_reference>();
|
||||||
|
|
||||||
|
int a1[3] = { 0, 1, 2 };
|
||||||
|
const int* const p1 = a1;
|
||||||
|
NativeArray<int> a2 = StlContainerView<tuple<const int*, int> >::
|
||||||
|
ConstReference(make_tuple(p1, 3));
|
||||||
|
EXPECT_EQ(3U, a2.size());
|
||||||
|
EXPECT_EQ(a1, a2.begin());
|
||||||
|
|
||||||
|
const NativeArray<int> a3 = StlContainerView<tuple<int*, size_t> >::
|
||||||
|
Copy(make_tuple(static_cast<int*>(a1), 3));
|
||||||
|
ASSERT_EQ(3U, a3.size());
|
||||||
|
EXPECT_EQ(0, a3.begin()[0]);
|
||||||
|
EXPECT_EQ(1, a3.begin()[1]);
|
||||||
|
EXPECT_EQ(2, a3.begin()[2]);
|
||||||
|
|
||||||
|
// Makes sure a1 and a3 aren't aliases.
|
||||||
|
a1[0] = 3;
|
||||||
|
EXPECT_EQ(0, a3.begin()[0]);
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace
|
||||||
|
} // namespace internal
|
||||||
|
} // namespace testing
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,704 @@
|
||||||
|
// 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 Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file tests the built-in actions in gmock-more-actions.h.
|
||||||
|
|
||||||
|
#include "gmock/gmock-more-actions.h"
|
||||||
|
|
||||||
|
#include <functional>
|
||||||
|
#include <sstream>
|
||||||
|
#include <string>
|
||||||
|
#include "gmock/gmock.h"
|
||||||
|
#include "gtest/gtest.h"
|
||||||
|
#include "gtest/internal/gtest-linked_ptr.h"
|
||||||
|
|
||||||
|
namespace testing {
|
||||||
|
namespace gmock_more_actions_test {
|
||||||
|
|
||||||
|
using ::std::plus;
|
||||||
|
using ::std::string;
|
||||||
|
using ::std::tr1::get;
|
||||||
|
using ::std::tr1::make_tuple;
|
||||||
|
using ::std::tr1::tuple;
|
||||||
|
using ::std::tr1::tuple_element;
|
||||||
|
using testing::_;
|
||||||
|
using testing::Action;
|
||||||
|
using testing::ActionInterface;
|
||||||
|
using testing::DeleteArg;
|
||||||
|
using testing::Invoke;
|
||||||
|
using testing::Return;
|
||||||
|
using testing::ReturnArg;
|
||||||
|
using testing::ReturnPointee;
|
||||||
|
using testing::SaveArg;
|
||||||
|
using testing::SaveArgPointee;
|
||||||
|
using testing::SetArgReferee;
|
||||||
|
using testing::StaticAssertTypeEq;
|
||||||
|
using testing::Unused;
|
||||||
|
using testing::WithArg;
|
||||||
|
using testing::WithoutArgs;
|
||||||
|
using testing::internal::linked_ptr;
|
||||||
|
|
||||||
|
// For suppressing compiler warnings on conversion possibly losing precision.
|
||||||
|
inline short Short(short n) { return n; } // NOLINT
|
||||||
|
inline char Char(char ch) { return ch; }
|
||||||
|
|
||||||
|
// Sample functions and functors for testing Invoke() and etc.
|
||||||
|
int Nullary() { return 1; }
|
||||||
|
|
||||||
|
class NullaryFunctor {
|
||||||
|
public:
|
||||||
|
int operator()() { return 2; }
|
||||||
|
};
|
||||||
|
|
||||||
|
bool g_done = false;
|
||||||
|
void VoidNullary() { g_done = true; }
|
||||||
|
|
||||||
|
class VoidNullaryFunctor {
|
||||||
|
public:
|
||||||
|
void operator()() { g_done = true; }
|
||||||
|
};
|
||||||
|
|
||||||
|
bool Unary(int x) { return x < 0; }
|
||||||
|
|
||||||
|
const char* Plus1(const char* s) { return s + 1; }
|
||||||
|
|
||||||
|
void VoidUnary(int /* n */) { g_done = true; }
|
||||||
|
|
||||||
|
bool ByConstRef(const string& s) { return s == "Hi"; }
|
||||||
|
|
||||||
|
const double g_double = 0;
|
||||||
|
bool ReferencesGlobalDouble(const double& x) { return &x == &g_double; }
|
||||||
|
|
||||||
|
string ByNonConstRef(string& s) { return s += "+"; } // NOLINT
|
||||||
|
|
||||||
|
struct UnaryFunctor {
|
||||||
|
int operator()(bool x) { return x ? 1 : -1; }
|
||||||
|
};
|
||||||
|
|
||||||
|
const char* Binary(const char* input, short n) { return input + n; } // NOLINT
|
||||||
|
|
||||||
|
void VoidBinary(int, char) { g_done = true; }
|
||||||
|
|
||||||
|
int Ternary(int x, char y, short z) { return x + y + z; } // NOLINT
|
||||||
|
|
||||||
|
void VoidTernary(int, char, bool) { g_done = true; }
|
||||||
|
|
||||||
|
int SumOf4(int a, int b, int c, int d) { return a + b + c + d; }
|
||||||
|
|
||||||
|
int SumOfFirst2(int a, int b, Unused, Unused) { return a + b; }
|
||||||
|
|
||||||
|
void VoidFunctionWithFourArguments(char, int, float, double) { g_done = true; }
|
||||||
|
|
||||||
|
string Concat4(const char* s1, const char* s2, const char* s3,
|
||||||
|
const char* s4) {
|
||||||
|
return string(s1) + s2 + s3 + s4;
|
||||||
|
}
|
||||||
|
|
||||||
|
int SumOf5(int a, int b, int c, int d, int e) { return a + b + c + d + e; }
|
||||||
|
|
||||||
|
struct SumOf5Functor {
|
||||||
|
int operator()(int a, int b, int c, int d, int e) {
|
||||||
|
return a + b + c + d + e;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
string Concat5(const char* s1, const char* s2, const char* s3,
|
||||||
|
const char* s4, const char* s5) {
|
||||||
|
return string(s1) + s2 + s3 + s4 + s5;
|
||||||
|
}
|
||||||
|
|
||||||
|
int SumOf6(int a, int b, int c, int d, int e, int f) {
|
||||||
|
return a + b + c + d + e + f;
|
||||||
|
}
|
||||||
|
|
||||||
|
struct SumOf6Functor {
|
||||||
|
int operator()(int a, int b, int c, int d, int e, int f) {
|
||||||
|
return a + b + c + d + e + f;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
string Concat6(const char* s1, const char* s2, const char* s3,
|
||||||
|
const char* s4, const char* s5, const char* s6) {
|
||||||
|
return string(s1) + s2 + s3 + s4 + s5 + s6;
|
||||||
|
}
|
||||||
|
|
||||||
|
string Concat7(const char* s1, const char* s2, const char* s3,
|
||||||
|
const char* s4, const char* s5, const char* s6,
|
||||||
|
const char* s7) {
|
||||||
|
return string(s1) + s2 + s3 + s4 + s5 + s6 + s7;
|
||||||
|
}
|
||||||
|
|
||||||
|
string Concat8(const char* s1, const char* s2, const char* s3,
|
||||||
|
const char* s4, const char* s5, const char* s6,
|
||||||
|
const char* s7, const char* s8) {
|
||||||
|
return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8;
|
||||||
|
}
|
||||||
|
|
||||||
|
string Concat9(const char* s1, const char* s2, const char* s3,
|
||||||
|
const char* s4, const char* s5, const char* s6,
|
||||||
|
const char* s7, const char* s8, const char* s9) {
|
||||||
|
return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9;
|
||||||
|
}
|
||||||
|
|
||||||
|
string Concat10(const char* s1, const char* s2, const char* s3,
|
||||||
|
const char* s4, const char* s5, const char* s6,
|
||||||
|
const char* s7, const char* s8, const char* s9,
|
||||||
|
const char* s10) {
|
||||||
|
return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10;
|
||||||
|
}
|
||||||
|
|
||||||
|
class Foo {
|
||||||
|
public:
|
||||||
|
Foo() : value_(123) {}
|
||||||
|
|
||||||
|
int Nullary() const { return value_; }
|
||||||
|
|
||||||
|
short Unary(long x) { return static_cast<short>(value_ + x); } // NOLINT
|
||||||
|
|
||||||
|
string Binary(const string& str, char c) const { return str + c; }
|
||||||
|
|
||||||
|
int Ternary(int x, bool y, char z) { return value_ + x + y*z; }
|
||||||
|
|
||||||
|
int SumOf4(int a, int b, int c, int d) const {
|
||||||
|
return a + b + c + d + value_;
|
||||||
|
}
|
||||||
|
|
||||||
|
int SumOfLast2(Unused, Unused, int a, int b) const { return a + b; }
|
||||||
|
|
||||||
|
int SumOf5(int a, int b, int c, int d, int e) { return a + b + c + d + e; }
|
||||||
|
|
||||||
|
int SumOf6(int a, int b, int c, int d, int e, int f) {
|
||||||
|
return a + b + c + d + e + f;
|
||||||
|
}
|
||||||
|
|
||||||
|
string Concat7(const char* s1, const char* s2, const char* s3,
|
||||||
|
const char* s4, const char* s5, const char* s6,
|
||||||
|
const char* s7) {
|
||||||
|
return string(s1) + s2 + s3 + s4 + s5 + s6 + s7;
|
||||||
|
}
|
||||||
|
|
||||||
|
string Concat8(const char* s1, const char* s2, const char* s3,
|
||||||
|
const char* s4, const char* s5, const char* s6,
|
||||||
|
const char* s7, const char* s8) {
|
||||||
|
return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8;
|
||||||
|
}
|
||||||
|
|
||||||
|
string Concat9(const char* s1, const char* s2, const char* s3,
|
||||||
|
const char* s4, const char* s5, const char* s6,
|
||||||
|
const char* s7, const char* s8, const char* s9) {
|
||||||
|
return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9;
|
||||||
|
}
|
||||||
|
|
||||||
|
string Concat10(const char* s1, const char* s2, const char* s3,
|
||||||
|
const char* s4, const char* s5, const char* s6,
|
||||||
|
const char* s7, const char* s8, const char* s9,
|
||||||
|
const char* s10) {
|
||||||
|
return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10;
|
||||||
|
}
|
||||||
|
private:
|
||||||
|
int value_;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Tests using Invoke() with a nullary function.
|
||||||
|
TEST(InvokeTest, Nullary) {
|
||||||
|
Action<int()> a = Invoke(Nullary); // NOLINT
|
||||||
|
EXPECT_EQ(1, a.Perform(make_tuple()));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with a unary function.
|
||||||
|
TEST(InvokeTest, Unary) {
|
||||||
|
Action<bool(int)> a = Invoke(Unary); // NOLINT
|
||||||
|
EXPECT_FALSE(a.Perform(make_tuple(1)));
|
||||||
|
EXPECT_TRUE(a.Perform(make_tuple(-1)));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with a binary function.
|
||||||
|
TEST(InvokeTest, Binary) {
|
||||||
|
Action<const char*(const char*, short)> a = Invoke(Binary); // NOLINT
|
||||||
|
const char* p = "Hello";
|
||||||
|
EXPECT_EQ(p + 2, a.Perform(make_tuple(p, Short(2))));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with a ternary function.
|
||||||
|
TEST(InvokeTest, Ternary) {
|
||||||
|
Action<int(int, char, short)> a = Invoke(Ternary); // NOLINT
|
||||||
|
EXPECT_EQ(6, a.Perform(make_tuple(1, '\2', Short(3))));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with a 4-argument function.
|
||||||
|
TEST(InvokeTest, FunctionThatTakes4Arguments) {
|
||||||
|
Action<int(int, int, int, int)> a = Invoke(SumOf4); // NOLINT
|
||||||
|
EXPECT_EQ(1234, a.Perform(make_tuple(1000, 200, 30, 4)));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with a 5-argument function.
|
||||||
|
TEST(InvokeTest, FunctionThatTakes5Arguments) {
|
||||||
|
Action<int(int, int, int, int, int)> a = Invoke(SumOf5); // NOLINT
|
||||||
|
EXPECT_EQ(12345, a.Perform(make_tuple(10000, 2000, 300, 40, 5)));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with a 6-argument function.
|
||||||
|
TEST(InvokeTest, FunctionThatTakes6Arguments) {
|
||||||
|
Action<int(int, int, int, int, int, int)> a = Invoke(SumOf6); // NOLINT
|
||||||
|
EXPECT_EQ(123456, a.Perform(make_tuple(100000, 20000, 3000, 400, 50, 6)));
|
||||||
|
}
|
||||||
|
|
||||||
|
// A helper that turns the type of a C-string literal from const
|
||||||
|
// char[N] to const char*.
|
||||||
|
inline const char* CharPtr(const char* s) { return s; }
|
||||||
|
|
||||||
|
// Tests using Invoke() with a 7-argument function.
|
||||||
|
TEST(InvokeTest, FunctionThatTakes7Arguments) {
|
||||||
|
Action<string(const char*, const char*, const char*, const char*,
|
||||||
|
const char*, const char*, const char*)> a =
|
||||||
|
Invoke(Concat7);
|
||||||
|
EXPECT_EQ("1234567",
|
||||||
|
a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
|
||||||
|
CharPtr("4"), CharPtr("5"), CharPtr("6"),
|
||||||
|
CharPtr("7"))));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with a 8-argument function.
|
||||||
|
TEST(InvokeTest, FunctionThatTakes8Arguments) {
|
||||||
|
Action<string(const char*, const char*, const char*, const char*,
|
||||||
|
const char*, const char*, const char*, const char*)> a =
|
||||||
|
Invoke(Concat8);
|
||||||
|
EXPECT_EQ("12345678",
|
||||||
|
a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
|
||||||
|
CharPtr("4"), CharPtr("5"), CharPtr("6"),
|
||||||
|
CharPtr("7"), CharPtr("8"))));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with a 9-argument function.
|
||||||
|
TEST(InvokeTest, FunctionThatTakes9Arguments) {
|
||||||
|
Action<string(const char*, const char*, const char*, const char*,
|
||||||
|
const char*, const char*, const char*, const char*,
|
||||||
|
const char*)> a = Invoke(Concat9);
|
||||||
|
EXPECT_EQ("123456789",
|
||||||
|
a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
|
||||||
|
CharPtr("4"), CharPtr("5"), CharPtr("6"),
|
||||||
|
CharPtr("7"), CharPtr("8"), CharPtr("9"))));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with a 10-argument function.
|
||||||
|
TEST(InvokeTest, FunctionThatTakes10Arguments) {
|
||||||
|
Action<string(const char*, const char*, const char*, const char*,
|
||||||
|
const char*, const char*, const char*, const char*,
|
||||||
|
const char*, const char*)> a = Invoke(Concat10);
|
||||||
|
EXPECT_EQ("1234567890",
|
||||||
|
a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
|
||||||
|
CharPtr("4"), CharPtr("5"), CharPtr("6"),
|
||||||
|
CharPtr("7"), CharPtr("8"), CharPtr("9"),
|
||||||
|
CharPtr("0"))));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with functions with parameters declared as Unused.
|
||||||
|
TEST(InvokeTest, FunctionWithUnusedParameters) {
|
||||||
|
Action<int(int, int, double, const string&)> a1 =
|
||||||
|
Invoke(SumOfFirst2);
|
||||||
|
EXPECT_EQ(12, a1.Perform(make_tuple(10, 2, 5.6, CharPtr("hi"))));
|
||||||
|
|
||||||
|
Action<int(int, int, bool, int*)> a2 =
|
||||||
|
Invoke(SumOfFirst2);
|
||||||
|
EXPECT_EQ(23, a2.Perform(make_tuple(20, 3, true, static_cast<int*>(NULL))));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with methods with parameters declared as Unused.
|
||||||
|
TEST(InvokeTest, MethodWithUnusedParameters) {
|
||||||
|
Foo foo;
|
||||||
|
Action<int(string, bool, int, int)> a1 =
|
||||||
|
Invoke(&foo, &Foo::SumOfLast2);
|
||||||
|
EXPECT_EQ(12, a1.Perform(make_tuple(CharPtr("hi"), true, 10, 2)));
|
||||||
|
|
||||||
|
Action<int(char, double, int, int)> a2 =
|
||||||
|
Invoke(&foo, &Foo::SumOfLast2);
|
||||||
|
EXPECT_EQ(23, a2.Perform(make_tuple('a', 2.5, 20, 3)));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with a functor.
|
||||||
|
TEST(InvokeTest, Functor) {
|
||||||
|
Action<long(long, int)> a = Invoke(plus<long>()); // NOLINT
|
||||||
|
EXPECT_EQ(3L, a.Perform(make_tuple(1, 2)));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke(f) as an action of a compatible type.
|
||||||
|
TEST(InvokeTest, FunctionWithCompatibleType) {
|
||||||
|
Action<long(int, short, char, bool)> a = Invoke(SumOf4); // NOLINT
|
||||||
|
EXPECT_EQ(4321, a.Perform(make_tuple(4000, Short(300), Char(20), true)));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with an object pointer and a method pointer.
|
||||||
|
|
||||||
|
// Tests using Invoke() with a nullary method.
|
||||||
|
TEST(InvokeMethodTest, Nullary) {
|
||||||
|
Foo foo;
|
||||||
|
Action<int()> a = Invoke(&foo, &Foo::Nullary); // NOLINT
|
||||||
|
EXPECT_EQ(123, a.Perform(make_tuple()));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with a unary method.
|
||||||
|
TEST(InvokeMethodTest, Unary) {
|
||||||
|
Foo foo;
|
||||||
|
Action<short(long)> a = Invoke(&foo, &Foo::Unary); // NOLINT
|
||||||
|
EXPECT_EQ(4123, a.Perform(make_tuple(4000)));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with a binary method.
|
||||||
|
TEST(InvokeMethodTest, Binary) {
|
||||||
|
Foo foo;
|
||||||
|
Action<string(const string&, char)> a = Invoke(&foo, &Foo::Binary);
|
||||||
|
string s("Hell");
|
||||||
|
EXPECT_EQ("Hello", a.Perform(make_tuple(s, 'o')));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with a ternary method.
|
||||||
|
TEST(InvokeMethodTest, Ternary) {
|
||||||
|
Foo foo;
|
||||||
|
Action<int(int, bool, char)> a = Invoke(&foo, &Foo::Ternary); // NOLINT
|
||||||
|
EXPECT_EQ(1124, a.Perform(make_tuple(1000, true, Char(1))));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with a 4-argument method.
|
||||||
|
TEST(InvokeMethodTest, MethodThatTakes4Arguments) {
|
||||||
|
Foo foo;
|
||||||
|
Action<int(int, int, int, int)> a = Invoke(&foo, &Foo::SumOf4); // NOLINT
|
||||||
|
EXPECT_EQ(1357, a.Perform(make_tuple(1000, 200, 30, 4)));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with a 5-argument method.
|
||||||
|
TEST(InvokeMethodTest, MethodThatTakes5Arguments) {
|
||||||
|
Foo foo;
|
||||||
|
Action<int(int, int, int, int, int)> a = Invoke(&foo, &Foo::SumOf5); // NOLINT
|
||||||
|
EXPECT_EQ(12345, a.Perform(make_tuple(10000, 2000, 300, 40, 5)));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with a 6-argument method.
|
||||||
|
TEST(InvokeMethodTest, MethodThatTakes6Arguments) {
|
||||||
|
Foo foo;
|
||||||
|
Action<int(int, int, int, int, int, int)> a = // NOLINT
|
||||||
|
Invoke(&foo, &Foo::SumOf6);
|
||||||
|
EXPECT_EQ(123456, a.Perform(make_tuple(100000, 20000, 3000, 400, 50, 6)));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with a 7-argument method.
|
||||||
|
TEST(InvokeMethodTest, MethodThatTakes7Arguments) {
|
||||||
|
Foo foo;
|
||||||
|
Action<string(const char*, const char*, const char*, const char*,
|
||||||
|
const char*, const char*, const char*)> a =
|
||||||
|
Invoke(&foo, &Foo::Concat7);
|
||||||
|
EXPECT_EQ("1234567",
|
||||||
|
a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
|
||||||
|
CharPtr("4"), CharPtr("5"), CharPtr("6"),
|
||||||
|
CharPtr("7"))));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with a 8-argument method.
|
||||||
|
TEST(InvokeMethodTest, MethodThatTakes8Arguments) {
|
||||||
|
Foo foo;
|
||||||
|
Action<string(const char*, const char*, const char*, const char*,
|
||||||
|
const char*, const char*, const char*, const char*)> a =
|
||||||
|
Invoke(&foo, &Foo::Concat8);
|
||||||
|
EXPECT_EQ("12345678",
|
||||||
|
a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
|
||||||
|
CharPtr("4"), CharPtr("5"), CharPtr("6"),
|
||||||
|
CharPtr("7"), CharPtr("8"))));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with a 9-argument method.
|
||||||
|
TEST(InvokeMethodTest, MethodThatTakes9Arguments) {
|
||||||
|
Foo foo;
|
||||||
|
Action<string(const char*, const char*, const char*, const char*,
|
||||||
|
const char*, const char*, const char*, const char*,
|
||||||
|
const char*)> a = Invoke(&foo, &Foo::Concat9);
|
||||||
|
EXPECT_EQ("123456789",
|
||||||
|
a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
|
||||||
|
CharPtr("4"), CharPtr("5"), CharPtr("6"),
|
||||||
|
CharPtr("7"), CharPtr("8"), CharPtr("9"))));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke() with a 10-argument method.
|
||||||
|
TEST(InvokeMethodTest, MethodThatTakes10Arguments) {
|
||||||
|
Foo foo;
|
||||||
|
Action<string(const char*, const char*, const char*, const char*,
|
||||||
|
const char*, const char*, const char*, const char*,
|
||||||
|
const char*, const char*)> a = Invoke(&foo, &Foo::Concat10);
|
||||||
|
EXPECT_EQ("1234567890",
|
||||||
|
a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
|
||||||
|
CharPtr("4"), CharPtr("5"), CharPtr("6"),
|
||||||
|
CharPtr("7"), CharPtr("8"), CharPtr("9"),
|
||||||
|
CharPtr("0"))));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using Invoke(f) as an action of a compatible type.
|
||||||
|
TEST(InvokeMethodTest, MethodWithCompatibleType) {
|
||||||
|
Foo foo;
|
||||||
|
Action<long(int, short, char, bool)> a = // NOLINT
|
||||||
|
Invoke(&foo, &Foo::SumOf4);
|
||||||
|
EXPECT_EQ(4444, a.Perform(make_tuple(4000, Short(300), Char(20), true)));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using WithoutArgs with an action that takes no argument.
|
||||||
|
TEST(WithoutArgsTest, NoArg) {
|
||||||
|
Action<int(int n)> a = WithoutArgs(Invoke(Nullary)); // NOLINT
|
||||||
|
EXPECT_EQ(1, a.Perform(make_tuple(2)));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests using WithArg with an action that takes 1 argument.
|
||||||
|
TEST(WithArgTest, OneArg) {
|
||||||
|
Action<bool(double x, int n)> b = WithArg<1>(Invoke(Unary)); // NOLINT
|
||||||
|
EXPECT_TRUE(b.Perform(make_tuple(1.5, -1)));
|
||||||
|
EXPECT_FALSE(b.Perform(make_tuple(1.5, 1)));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(ReturnArgActionTest, WorksForOneArgIntArg0) {
|
||||||
|
const Action<int(int)> a = ReturnArg<0>();
|
||||||
|
EXPECT_EQ(5, a.Perform(make_tuple(5)));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(ReturnArgActionTest, WorksForMultiArgBoolArg0) {
|
||||||
|
const Action<bool(bool, bool, bool)> a = ReturnArg<0>();
|
||||||
|
EXPECT_TRUE(a.Perform(make_tuple(true, false, false)));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(ReturnArgActionTest, WorksForMultiArgStringArg2) {
|
||||||
|
const Action<string(int, int, string, int)> a = ReturnArg<2>();
|
||||||
|
EXPECT_EQ("seven", a.Perform(make_tuple(5, 6, string("seven"), 8)));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(SaveArgActionTest, WorksForSameType) {
|
||||||
|
int result = 0;
|
||||||
|
const Action<void(int n)> a1 = SaveArg<0>(&result);
|
||||||
|
a1.Perform(make_tuple(5));
|
||||||
|
EXPECT_EQ(5, result);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(SaveArgActionTest, WorksForCompatibleType) {
|
||||||
|
int result = 0;
|
||||||
|
const Action<void(bool, char)> a1 = SaveArg<1>(&result);
|
||||||
|
a1.Perform(make_tuple(true, 'a'));
|
||||||
|
EXPECT_EQ('a', result);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(SaveArgPointeeActionTest, WorksForSameType) {
|
||||||
|
int result = 0;
|
||||||
|
const int value = 5;
|
||||||
|
const Action<void(const int*)> a1 = SaveArgPointee<0>(&result);
|
||||||
|
a1.Perform(make_tuple(&value));
|
||||||
|
EXPECT_EQ(5, result);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(SaveArgPointeeActionTest, WorksForCompatibleType) {
|
||||||
|
int result = 0;
|
||||||
|
char value = 'a';
|
||||||
|
const Action<void(bool, char*)> a1 = SaveArgPointee<1>(&result);
|
||||||
|
a1.Perform(make_tuple(true, &value));
|
||||||
|
EXPECT_EQ('a', result);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(SaveArgPointeeActionTest, WorksForLinkedPtr) {
|
||||||
|
int result = 0;
|
||||||
|
linked_ptr<int> value(new int(5));
|
||||||
|
const Action<void(linked_ptr<int>)> a1 = SaveArgPointee<0>(&result);
|
||||||
|
a1.Perform(make_tuple(value));
|
||||||
|
EXPECT_EQ(5, result);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(SetArgRefereeActionTest, WorksForSameType) {
|
||||||
|
int value = 0;
|
||||||
|
const Action<void(int&)> a1 = SetArgReferee<0>(1);
|
||||||
|
a1.Perform(tuple<int&>(value));
|
||||||
|
EXPECT_EQ(1, value);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(SetArgRefereeActionTest, WorksForCompatibleType) {
|
||||||
|
int value = 0;
|
||||||
|
const Action<void(int, int&)> a1 = SetArgReferee<1>('a');
|
||||||
|
a1.Perform(tuple<int, int&>(0, value));
|
||||||
|
EXPECT_EQ('a', value);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(SetArgRefereeActionTest, WorksWithExtraArguments) {
|
||||||
|
int value = 0;
|
||||||
|
const Action<void(bool, int, int&, const char*)> a1 = SetArgReferee<2>('a');
|
||||||
|
a1.Perform(tuple<bool, int, int&, const char*>(true, 0, value, "hi"));
|
||||||
|
EXPECT_EQ('a', value);
|
||||||
|
}
|
||||||
|
|
||||||
|
// A class that can be used to verify that its destructor is called: it will set
|
||||||
|
// the bool provided to the constructor to true when destroyed.
|
||||||
|
class DeletionTester {
|
||||||
|
public:
|
||||||
|
explicit DeletionTester(bool* is_deleted)
|
||||||
|
: is_deleted_(is_deleted) {
|
||||||
|
// Make sure the bit is set to false.
|
||||||
|
*is_deleted_ = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
~DeletionTester() {
|
||||||
|
*is_deleted_ = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
bool* is_deleted_;
|
||||||
|
};
|
||||||
|
|
||||||
|
TEST(DeleteArgActionTest, OneArg) {
|
||||||
|
bool is_deleted = false;
|
||||||
|
DeletionTester* t = new DeletionTester(&is_deleted);
|
||||||
|
const Action<void(DeletionTester*)> a1 = DeleteArg<0>(); // NOLINT
|
||||||
|
EXPECT_FALSE(is_deleted);
|
||||||
|
a1.Perform(make_tuple(t));
|
||||||
|
EXPECT_TRUE(is_deleted);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(DeleteArgActionTest, TenArgs) {
|
||||||
|
bool is_deleted = false;
|
||||||
|
DeletionTester* t = new DeletionTester(&is_deleted);
|
||||||
|
const Action<void(bool, int, int, const char*, bool,
|
||||||
|
int, int, int, int, DeletionTester*)> a1 = DeleteArg<9>();
|
||||||
|
EXPECT_FALSE(is_deleted);
|
||||||
|
a1.Perform(make_tuple(true, 5, 6, CharPtr("hi"), false, 7, 8, 9, 10, t));
|
||||||
|
EXPECT_TRUE(is_deleted);
|
||||||
|
}
|
||||||
|
|
||||||
|
#if GTEST_HAS_EXCEPTIONS
|
||||||
|
|
||||||
|
TEST(ThrowActionTest, ThrowsGivenExceptionInVoidFunction) {
|
||||||
|
const Action<void(int n)> a = Throw('a');
|
||||||
|
EXPECT_THROW(a.Perform(make_tuple(0)), char);
|
||||||
|
}
|
||||||
|
|
||||||
|
class MyException {};
|
||||||
|
|
||||||
|
TEST(ThrowActionTest, ThrowsGivenExceptionInNonVoidFunction) {
|
||||||
|
const Action<double(char ch)> a = Throw(MyException());
|
||||||
|
EXPECT_THROW(a.Perform(make_tuple('0')), MyException);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(ThrowActionTest, ThrowsGivenExceptionInNullaryFunction) {
|
||||||
|
const Action<double()> a = Throw(MyException());
|
||||||
|
EXPECT_THROW(a.Perform(make_tuple()), MyException);
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // GTEST_HAS_EXCEPTIONS
|
||||||
|
|
||||||
|
// Tests that SetArrayArgument<N>(first, last) sets the elements of the array
|
||||||
|
// pointed to by the N-th (0-based) argument to values in range [first, last).
|
||||||
|
TEST(SetArrayArgumentTest, SetsTheNthArray) {
|
||||||
|
typedef void MyFunction(bool, int*, char*);
|
||||||
|
int numbers[] = { 1, 2, 3 };
|
||||||
|
Action<MyFunction> a = SetArrayArgument<1>(numbers, numbers + 3);
|
||||||
|
|
||||||
|
int n[4] = {};
|
||||||
|
int* pn = n;
|
||||||
|
char ch[4] = {};
|
||||||
|
char* pch = ch;
|
||||||
|
a.Perform(make_tuple(true, pn, pch));
|
||||||
|
EXPECT_EQ(1, n[0]);
|
||||||
|
EXPECT_EQ(2, n[1]);
|
||||||
|
EXPECT_EQ(3, n[2]);
|
||||||
|
EXPECT_EQ(0, n[3]);
|
||||||
|
EXPECT_EQ('\0', ch[0]);
|
||||||
|
EXPECT_EQ('\0', ch[1]);
|
||||||
|
EXPECT_EQ('\0', ch[2]);
|
||||||
|
EXPECT_EQ('\0', ch[3]);
|
||||||
|
|
||||||
|
// Tests first and last are iterators.
|
||||||
|
std::string letters = "abc";
|
||||||
|
a = SetArrayArgument<2>(letters.begin(), letters.end());
|
||||||
|
std::fill_n(n, 4, 0);
|
||||||
|
std::fill_n(ch, 4, '\0');
|
||||||
|
a.Perform(make_tuple(true, pn, pch));
|
||||||
|
EXPECT_EQ(0, n[0]);
|
||||||
|
EXPECT_EQ(0, n[1]);
|
||||||
|
EXPECT_EQ(0, n[2]);
|
||||||
|
EXPECT_EQ(0, n[3]);
|
||||||
|
EXPECT_EQ('a', ch[0]);
|
||||||
|
EXPECT_EQ('b', ch[1]);
|
||||||
|
EXPECT_EQ('c', ch[2]);
|
||||||
|
EXPECT_EQ('\0', ch[3]);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests SetArrayArgument<N>(first, last) where first == last.
|
||||||
|
TEST(SetArrayArgumentTest, SetsTheNthArrayWithEmptyRange) {
|
||||||
|
typedef void MyFunction(bool, int*);
|
||||||
|
int numbers[] = { 1, 2, 3 };
|
||||||
|
Action<MyFunction> a = SetArrayArgument<1>(numbers, numbers);
|
||||||
|
|
||||||
|
int n[4] = {};
|
||||||
|
int* pn = n;
|
||||||
|
a.Perform(make_tuple(true, pn));
|
||||||
|
EXPECT_EQ(0, n[0]);
|
||||||
|
EXPECT_EQ(0, n[1]);
|
||||||
|
EXPECT_EQ(0, n[2]);
|
||||||
|
EXPECT_EQ(0, n[3]);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests SetArrayArgument<N>(first, last) where *first is convertible
|
||||||
|
// (but not equal) to the argument type.
|
||||||
|
TEST(SetArrayArgumentTest, SetsTheNthArrayWithConvertibleType) {
|
||||||
|
typedef void MyFunction(bool, char*);
|
||||||
|
int codes[] = { 97, 98, 99 };
|
||||||
|
Action<MyFunction> a = SetArrayArgument<1>(codes, codes + 3);
|
||||||
|
|
||||||
|
char ch[4] = {};
|
||||||
|
char* pch = ch;
|
||||||
|
a.Perform(make_tuple(true, pch));
|
||||||
|
EXPECT_EQ('a', ch[0]);
|
||||||
|
EXPECT_EQ('b', ch[1]);
|
||||||
|
EXPECT_EQ('c', ch[2]);
|
||||||
|
EXPECT_EQ('\0', ch[3]);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Test SetArrayArgument<N>(first, last) with iterator as argument.
|
||||||
|
TEST(SetArrayArgumentTest, SetsTheNthArrayWithIteratorArgument) {
|
||||||
|
typedef void MyFunction(bool, std::back_insert_iterator<std::string>);
|
||||||
|
std::string letters = "abc";
|
||||||
|
Action<MyFunction> a = SetArrayArgument<1>(letters.begin(), letters.end());
|
||||||
|
|
||||||
|
std::string s;
|
||||||
|
a.Perform(make_tuple(true, back_inserter(s)));
|
||||||
|
EXPECT_EQ(letters, s);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(ReturnPointeeTest, Works) {
|
||||||
|
int n = 42;
|
||||||
|
const Action<int()> a = ReturnPointee(&n);
|
||||||
|
EXPECT_EQ(42, a.Perform(make_tuple()));
|
||||||
|
|
||||||
|
n = 43;
|
||||||
|
EXPECT_EQ(43, a.Perform(make_tuple()));
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace gmock_generated_actions_test
|
||||||
|
} // namespace testing
|
|
@ -0,0 +1,284 @@
|
||||||
|
// 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 "gmock/gmock-generated-nice-strict.h"
|
||||||
|
|
||||||
|
#include <string>
|
||||||
|
#include "gmock/gmock.h"
|
||||||
|
#include "gtest/gtest.h"
|
||||||
|
#include "gtest/gtest-spi.h"
|
||||||
|
|
||||||
|
// This must not be defined inside the ::testing namespace, or it will
|
||||||
|
// clash with ::testing::Mock.
|
||||||
|
class Mock {
|
||||||
|
public:
|
||||||
|
Mock() {}
|
||||||
|
|
||||||
|
MOCK_METHOD0(DoThis, void());
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(Mock);
|
||||||
|
};
|
||||||
|
|
||||||
|
namespace testing {
|
||||||
|
namespace gmock_nice_strict_test {
|
||||||
|
|
||||||
|
using testing::internal::string;
|
||||||
|
using testing::GMOCK_FLAG(verbose);
|
||||||
|
using testing::HasSubstr;
|
||||||
|
using testing::NiceMock;
|
||||||
|
using testing::StrictMock;
|
||||||
|
|
||||||
|
#if GTEST_HAS_STREAM_REDIRECTION
|
||||||
|
using testing::internal::CaptureStdout;
|
||||||
|
using testing::internal::GetCapturedStdout;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// Defines some mock classes needed by the tests.
|
||||||
|
|
||||||
|
class Foo {
|
||||||
|
public:
|
||||||
|
virtual ~Foo() {}
|
||||||
|
|
||||||
|
virtual void DoThis() = 0;
|
||||||
|
virtual int DoThat(bool flag) = 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
class MockFoo : public Foo {
|
||||||
|
public:
|
||||||
|
MockFoo() {}
|
||||||
|
void Delete() { delete this; }
|
||||||
|
|
||||||
|
MOCK_METHOD0(DoThis, void());
|
||||||
|
MOCK_METHOD1(DoThat, int(bool flag));
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
|
||||||
|
};
|
||||||
|
|
||||||
|
class MockBar {
|
||||||
|
public:
|
||||||
|
explicit MockBar(const string& s) : str_(s) {}
|
||||||
|
|
||||||
|
MockBar(char a1, char a2, string a3, string a4, int a5, int a6,
|
||||||
|
const string& a7, const string& a8, bool a9, bool a10) {
|
||||||
|
str_ = string() + a1 + a2 + a3 + a4 + static_cast<char>(a5) +
|
||||||
|
static_cast<char>(a6) + a7 + a8 + (a9 ? 'T' : 'F') + (a10 ? 'T' : 'F');
|
||||||
|
}
|
||||||
|
|
||||||
|
virtual ~MockBar() {}
|
||||||
|
|
||||||
|
const string& str() const { return str_; }
|
||||||
|
|
||||||
|
MOCK_METHOD0(This, int());
|
||||||
|
MOCK_METHOD2(That, string(int, bool));
|
||||||
|
|
||||||
|
private:
|
||||||
|
string str_;
|
||||||
|
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockBar);
|
||||||
|
};
|
||||||
|
|
||||||
|
#if GTEST_HAS_STREAM_REDIRECTION
|
||||||
|
|
||||||
|
// Tests that a nice mock generates no warning for uninteresting calls.
|
||||||
|
TEST(NiceMockTest, NoWarningForUninterestingCall) {
|
||||||
|
NiceMock<MockFoo> nice_foo;
|
||||||
|
|
||||||
|
CaptureStdout();
|
||||||
|
nice_foo.DoThis();
|
||||||
|
nice_foo.DoThat(true);
|
||||||
|
EXPECT_STREQ("", GetCapturedStdout().c_str());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that a nice mock generates no warning for uninteresting calls
|
||||||
|
// that delete the mock object.
|
||||||
|
TEST(NiceMockTest, NoWarningForUninterestingCallAfterDeath) {
|
||||||
|
NiceMock<MockFoo>* const nice_foo = new NiceMock<MockFoo>;
|
||||||
|
|
||||||
|
ON_CALL(*nice_foo, DoThis())
|
||||||
|
.WillByDefault(Invoke(nice_foo, &MockFoo::Delete));
|
||||||
|
|
||||||
|
CaptureStdout();
|
||||||
|
nice_foo->DoThis();
|
||||||
|
EXPECT_STREQ("", GetCapturedStdout().c_str());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that a nice mock generates informational logs for
|
||||||
|
// uninteresting calls.
|
||||||
|
TEST(NiceMockTest, InfoForUninterestingCall) {
|
||||||
|
NiceMock<MockFoo> nice_foo;
|
||||||
|
|
||||||
|
const string saved_flag = GMOCK_FLAG(verbose);
|
||||||
|
GMOCK_FLAG(verbose) = "info";
|
||||||
|
CaptureStdout();
|
||||||
|
nice_foo.DoThis();
|
||||||
|
EXPECT_THAT(GetCapturedStdout(),
|
||||||
|
HasSubstr("Uninteresting mock function call"));
|
||||||
|
|
||||||
|
CaptureStdout();
|
||||||
|
nice_foo.DoThat(true);
|
||||||
|
EXPECT_THAT(GetCapturedStdout(),
|
||||||
|
HasSubstr("Uninteresting mock function call"));
|
||||||
|
GMOCK_FLAG(verbose) = saved_flag;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // GTEST_HAS_STREAM_REDIRECTION
|
||||||
|
|
||||||
|
// Tests that a nice mock allows expected calls.
|
||||||
|
TEST(NiceMockTest, AllowsExpectedCall) {
|
||||||
|
NiceMock<MockFoo> nice_foo;
|
||||||
|
|
||||||
|
EXPECT_CALL(nice_foo, DoThis());
|
||||||
|
nice_foo.DoThis();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that an unexpected call on a nice mock fails.
|
||||||
|
TEST(NiceMockTest, UnexpectedCallFails) {
|
||||||
|
NiceMock<MockFoo> nice_foo;
|
||||||
|
|
||||||
|
EXPECT_CALL(nice_foo, DoThis()).Times(0);
|
||||||
|
EXPECT_NONFATAL_FAILURE(nice_foo.DoThis(), "called more times than expected");
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that NiceMock works with a mock class that has a non-default
|
||||||
|
// constructor.
|
||||||
|
TEST(NiceMockTest, NonDefaultConstructor) {
|
||||||
|
NiceMock<MockBar> nice_bar("hi");
|
||||||
|
EXPECT_EQ("hi", nice_bar.str());
|
||||||
|
|
||||||
|
nice_bar.This();
|
||||||
|
nice_bar.That(5, true);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that NiceMock works with a mock class that has a 10-ary
|
||||||
|
// non-default constructor.
|
||||||
|
TEST(NiceMockTest, NonDefaultConstructor10) {
|
||||||
|
NiceMock<MockBar> nice_bar('a', 'b', "c", "d", 'e', 'f',
|
||||||
|
"g", "h", true, false);
|
||||||
|
EXPECT_EQ("abcdefghTF", nice_bar.str());
|
||||||
|
|
||||||
|
nice_bar.This();
|
||||||
|
nice_bar.That(5, true);
|
||||||
|
}
|
||||||
|
|
||||||
|
#if !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE
|
||||||
|
// Tests that NiceMock<Mock> compiles where Mock is a user-defined
|
||||||
|
// class (as opposed to ::testing::Mock). We had to workaround an
|
||||||
|
// MSVC 8.0 bug that caused the symbol Mock used in the definition of
|
||||||
|
// NiceMock to be looked up in the wrong context, and this test
|
||||||
|
// ensures that our fix works.
|
||||||
|
//
|
||||||
|
// We have to skip this test on Symbian and Windows Mobile, as it
|
||||||
|
// causes the program to crash there, for reasons unclear to us yet.
|
||||||
|
TEST(NiceMockTest, AcceptsClassNamedMock) {
|
||||||
|
NiceMock< ::Mock> nice;
|
||||||
|
EXPECT_CALL(nice, DoThis());
|
||||||
|
nice.DoThis();
|
||||||
|
}
|
||||||
|
#endif // !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE
|
||||||
|
|
||||||
|
// Tests that a strict mock allows expected calls.
|
||||||
|
TEST(StrictMockTest, AllowsExpectedCall) {
|
||||||
|
StrictMock<MockFoo> strict_foo;
|
||||||
|
|
||||||
|
EXPECT_CALL(strict_foo, DoThis());
|
||||||
|
strict_foo.DoThis();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that an unexpected call on a strict mock fails.
|
||||||
|
TEST(StrictMockTest, UnexpectedCallFails) {
|
||||||
|
StrictMock<MockFoo> strict_foo;
|
||||||
|
|
||||||
|
EXPECT_CALL(strict_foo, DoThis()).Times(0);
|
||||||
|
EXPECT_NONFATAL_FAILURE(strict_foo.DoThis(),
|
||||||
|
"called more times than expected");
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that an uninteresting call on a strict mock fails.
|
||||||
|
TEST(StrictMockTest, UninterestingCallFails) {
|
||||||
|
StrictMock<MockFoo> strict_foo;
|
||||||
|
|
||||||
|
EXPECT_NONFATAL_FAILURE(strict_foo.DoThis(),
|
||||||
|
"Uninteresting mock function call");
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that an uninteresting call on a strict mock fails, even if
|
||||||
|
// the call deletes the mock object.
|
||||||
|
TEST(StrictMockTest, UninterestingCallFailsAfterDeath) {
|
||||||
|
StrictMock<MockFoo>* const strict_foo = new StrictMock<MockFoo>;
|
||||||
|
|
||||||
|
ON_CALL(*strict_foo, DoThis())
|
||||||
|
.WillByDefault(Invoke(strict_foo, &MockFoo::Delete));
|
||||||
|
|
||||||
|
EXPECT_NONFATAL_FAILURE(strict_foo->DoThis(),
|
||||||
|
"Uninteresting mock function call");
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that StrictMock works with a mock class that has a
|
||||||
|
// non-default constructor.
|
||||||
|
TEST(StrictMockTest, NonDefaultConstructor) {
|
||||||
|
StrictMock<MockBar> strict_bar("hi");
|
||||||
|
EXPECT_EQ("hi", strict_bar.str());
|
||||||
|
|
||||||
|
EXPECT_NONFATAL_FAILURE(strict_bar.That(5, true),
|
||||||
|
"Uninteresting mock function call");
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests that StrictMock works with a mock class that has a 10-ary
|
||||||
|
// non-default constructor.
|
||||||
|
TEST(StrictMockTest, NonDefaultConstructor10) {
|
||||||
|
StrictMock<MockBar> strict_bar('a', 'b', "c", "d", 'e', 'f',
|
||||||
|
"g", "h", true, false);
|
||||||
|
EXPECT_EQ("abcdefghTF", strict_bar.str());
|
||||||
|
|
||||||
|
EXPECT_NONFATAL_FAILURE(strict_bar.That(5, true),
|
||||||
|
"Uninteresting mock function call");
|
||||||
|
}
|
||||||
|
|
||||||
|
#if !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE
|
||||||
|
// Tests that StrictMock<Mock> compiles where Mock is a user-defined
|
||||||
|
// class (as opposed to ::testing::Mock). We had to workaround an
|
||||||
|
// MSVC 8.0 bug that caused the symbol Mock used in the definition of
|
||||||
|
// StrictMock to be looked up in the wrong context, and this test
|
||||||
|
// ensures that our fix works.
|
||||||
|
//
|
||||||
|
// We have to skip this test on Symbian and Windows Mobile, as it
|
||||||
|
// causes the program to crash there, for reasons unclear to us yet.
|
||||||
|
TEST(StrictMockTest, AcceptsClassNamedMock) {
|
||||||
|
StrictMock< ::Mock> strict;
|
||||||
|
EXPECT_CALL(strict, DoThis());
|
||||||
|
strict.DoThis();
|
||||||
|
}
|
||||||
|
#endif // !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE
|
||||||
|
|
||||||
|
} // namespace gmock_nice_strict_test
|
||||||
|
} // namespace testing
|
|
@ -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: vladl@google.com (Vlad Losev)
|
||||||
|
|
||||||
|
// Google Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file tests the internal cross-platform support utilities.
|
||||||
|
|
||||||
|
#include "gmock/internal/gmock-port.h"
|
||||||
|
#include "gtest/gtest.h"
|
||||||
|
|
||||||
|
// NOTE: if this file is left without tests for some reason, put a dummy
|
||||||
|
// test here to make references to symbols in the gtest library and avoid
|
||||||
|
// 'undefined symbol' linker errors in gmock_main:
|
||||||
|
|
||||||
|
TEST(DummyTest, Dummy) {}
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,48 @@
|
||||||
|
// 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++ Mocking Framework (Google Mock)
|
||||||
|
//
|
||||||
|
// Sometimes it's desirable to build most of Google Mock's own tests
|
||||||
|
// by compiling a single file. This file serves this purpose.
|
||||||
|
#include "test/gmock-actions_test.cc"
|
||||||
|
#include "test/gmock-cardinalities_test.cc"
|
||||||
|
#include "test/gmock-generated-actions_test.cc"
|
||||||
|
#include "test/gmock-generated-function-mockers_test.cc"
|
||||||
|
#include "test/gmock-generated-internal-utils_test.cc"
|
||||||
|
#include "test/gmock-generated-matchers_test.cc"
|
||||||
|
#include "test/gmock-internal-utils_test.cc"
|
||||||
|
#include "test/gmock-matchers_test.cc"
|
||||||
|
#include "test/gmock-more-actions_test.cc"
|
||||||
|
#include "test/gmock-nice-strict_test.cc"
|
||||||
|
#include "test/gmock-port_test.cc"
|
||||||
|
#include "test/gmock-spec-builders_test.cc"
|
||||||
|
#include "test/gmock_test.cc"
|
|
@ -0,0 +1,90 @@
|
||||||
|
#!/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 that leaked mock objects can be caught be Google Mock."""
|
||||||
|
|
||||||
|
__author__ = 'wan@google.com (Zhanyong Wan)'
|
||||||
|
|
||||||
|
|
||||||
|
import gmock_test_utils
|
||||||
|
|
||||||
|
|
||||||
|
PROGRAM_PATH = gmock_test_utils.GetTestExecutablePath('gmock_leak_test_')
|
||||||
|
TEST_WITH_EXPECT_CALL = [PROGRAM_PATH, '--gtest_filter=*ExpectCall*']
|
||||||
|
TEST_WITH_ON_CALL = [PROGRAM_PATH, '--gtest_filter=*OnCall*']
|
||||||
|
TEST_MULTIPLE_LEAKS = [PROGRAM_PATH, '--gtest_filter=*MultipleLeaked*']
|
||||||
|
|
||||||
|
|
||||||
|
class GMockLeakTest(gmock_test_utils.TestCase):
|
||||||
|
|
||||||
|
def testCatchesLeakedMockByDefault(self):
|
||||||
|
self.assertNotEqual(
|
||||||
|
0,
|
||||||
|
gmock_test_utils.Subprocess(TEST_WITH_EXPECT_CALL).exit_code)
|
||||||
|
self.assertNotEqual(
|
||||||
|
0,
|
||||||
|
gmock_test_utils.Subprocess(TEST_WITH_ON_CALL).exit_code)
|
||||||
|
|
||||||
|
def testDoesNotCatchLeakedMockWhenDisabled(self):
|
||||||
|
self.assertEquals(
|
||||||
|
0,
|
||||||
|
gmock_test_utils.Subprocess(TEST_WITH_EXPECT_CALL +
|
||||||
|
['--gmock_catch_leaked_mocks=0']).exit_code)
|
||||||
|
self.assertEquals(
|
||||||
|
0,
|
||||||
|
gmock_test_utils.Subprocess(TEST_WITH_ON_CALL +
|
||||||
|
['--gmock_catch_leaked_mocks=0']).exit_code)
|
||||||
|
|
||||||
|
def testCatchesLeakedMockWhenEnabled(self):
|
||||||
|
self.assertNotEqual(
|
||||||
|
0,
|
||||||
|
gmock_test_utils.Subprocess(TEST_WITH_EXPECT_CALL +
|
||||||
|
['--gmock_catch_leaked_mocks']).exit_code)
|
||||||
|
self.assertNotEqual(
|
||||||
|
0,
|
||||||
|
gmock_test_utils.Subprocess(TEST_WITH_ON_CALL +
|
||||||
|
['--gmock_catch_leaked_mocks']).exit_code)
|
||||||
|
|
||||||
|
def testCatchesLeakedMockWhenEnabledWithExplictFlagValue(self):
|
||||||
|
self.assertNotEqual(
|
||||||
|
0,
|
||||||
|
gmock_test_utils.Subprocess(TEST_WITH_EXPECT_CALL +
|
||||||
|
['--gmock_catch_leaked_mocks=1']).exit_code)
|
||||||
|
|
||||||
|
def testCatchesMultipleLeakedMocks(self):
|
||||||
|
self.assertNotEqual(
|
||||||
|
0,
|
||||||
|
gmock_test_utils.Subprocess(TEST_MULTIPLE_LEAKS +
|
||||||
|
['--gmock_catch_leaked_mocks']).exit_code)
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == '__main__':
|
||||||
|
gmock_test_utils.Main()
|
|
@ -0,0 +1,100 @@
|
||||||
|
// 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)
|
||||||
|
|
||||||
|
// Google Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This program is for verifying that a leaked mock object can be
|
||||||
|
// caught by Google Mock's leak detector.
|
||||||
|
|
||||||
|
#include "gmock/gmock.h"
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
|
||||||
|
using ::testing::Return;
|
||||||
|
|
||||||
|
class FooInterface {
|
||||||
|
public:
|
||||||
|
virtual ~FooInterface() {}
|
||||||
|
virtual void DoThis() = 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
class MockFoo : public FooInterface {
|
||||||
|
public:
|
||||||
|
MockFoo() {}
|
||||||
|
|
||||||
|
MOCK_METHOD0(DoThis, void());
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
|
||||||
|
};
|
||||||
|
|
||||||
|
TEST(LeakTest, LeakedMockWithExpectCallCausesFailureWhenLeakCheckingIsEnabled) {
|
||||||
|
MockFoo* foo = new MockFoo;
|
||||||
|
|
||||||
|
EXPECT_CALL(*foo, DoThis());
|
||||||
|
foo->DoThis();
|
||||||
|
|
||||||
|
// In order to test the leak detector, we deliberately leak foo.
|
||||||
|
|
||||||
|
// Makes sure Google Mock's leak detector can change the exit code
|
||||||
|
// to 1 even when the code is already exiting with 0.
|
||||||
|
exit(0);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(LeakTest, LeakedMockWithOnCallCausesFailureWhenLeakCheckingIsEnabled) {
|
||||||
|
MockFoo* foo = new MockFoo;
|
||||||
|
|
||||||
|
ON_CALL(*foo, DoThis()).WillByDefault(Return());
|
||||||
|
|
||||||
|
// In order to test the leak detector, we deliberately leak foo.
|
||||||
|
|
||||||
|
// Makes sure Google Mock's leak detector can change the exit code
|
||||||
|
// to 1 even when the code is already exiting with 0.
|
||||||
|
exit(0);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(LeakTest, CatchesMultipleLeakedMockObjects) {
|
||||||
|
MockFoo* foo1 = new MockFoo;
|
||||||
|
MockFoo* foo2 = new MockFoo;
|
||||||
|
|
||||||
|
ON_CALL(*foo1, DoThis()).WillByDefault(Return());
|
||||||
|
EXPECT_CALL(*foo2, DoThis());
|
||||||
|
foo2->DoThis();
|
||||||
|
|
||||||
|
// In order to test the leak detector, we deliberately leak foo1 and
|
||||||
|
// foo2.
|
||||||
|
|
||||||
|
// Makes sure Google Mock's leak detector can change the exit code
|
||||||
|
// to 1 even when the code is already exiting with 0.
|
||||||
|
exit(0);
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace
|
|
@ -0,0 +1,40 @@
|
||||||
|
// 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), vladl@google.com (Vlad Losev)
|
||||||
|
|
||||||
|
// Google Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file is for verifying that various Google Mock constructs do not
|
||||||
|
// produce linker errors when instantiated in different translation units.
|
||||||
|
// Please see gmock_link_test.h for details.
|
||||||
|
|
||||||
|
#define LinkTest LinkTest2
|
||||||
|
|
||||||
|
#include "test/gmock_link_test.h"
|
|
@ -0,0 +1,40 @@
|
||||||
|
// 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), vladl@google.com (Vlad Losev)
|
||||||
|
|
||||||
|
// Google Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file is for verifying that various Google Mock constructs do not
|
||||||
|
// produce linker errors when instantiated in different translation units.
|
||||||
|
// Please see gmock_link_test.h for details.
|
||||||
|
|
||||||
|
#define LinkTest LinkTest1
|
||||||
|
|
||||||
|
#include "test/gmock_link_test.h"
|
|
@ -0,0 +1,669 @@
|
||||||
|
// 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)
|
||||||
|
|
||||||
|
// Google Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file tests that:
|
||||||
|
// a. A header file defining a mock class can be included in multiple
|
||||||
|
// translation units without causing a link error.
|
||||||
|
// b. Actions and matchers can be instantiated with identical template
|
||||||
|
// arguments in different translation units without causing link
|
||||||
|
// errors.
|
||||||
|
// The following constructs are currently tested:
|
||||||
|
// Actions:
|
||||||
|
// Return()
|
||||||
|
// Return(value)
|
||||||
|
// ReturnNull
|
||||||
|
// ReturnRef
|
||||||
|
// Assign
|
||||||
|
// SetArgPointee
|
||||||
|
// SetArrayArgument
|
||||||
|
// SetErrnoAndReturn
|
||||||
|
// Invoke(function)
|
||||||
|
// Invoke(object, method)
|
||||||
|
// InvokeWithoutArgs(function)
|
||||||
|
// InvokeWithoutArgs(object, method)
|
||||||
|
// InvokeArgument
|
||||||
|
// WithArg
|
||||||
|
// WithArgs
|
||||||
|
// WithoutArgs
|
||||||
|
// DoAll
|
||||||
|
// DoDefault
|
||||||
|
// IgnoreResult
|
||||||
|
// Throw
|
||||||
|
// ACTION()-generated
|
||||||
|
// ACTION_P()-generated
|
||||||
|
// ACTION_P2()-generated
|
||||||
|
// Matchers:
|
||||||
|
// _
|
||||||
|
// A
|
||||||
|
// An
|
||||||
|
// Eq
|
||||||
|
// Gt, Lt, Ge, Le, Ne
|
||||||
|
// NotNull
|
||||||
|
// Ref
|
||||||
|
// TypedEq
|
||||||
|
// DoubleEq
|
||||||
|
// FloatEq
|
||||||
|
// NanSensitiveDoubleEq
|
||||||
|
// NanSensitiveFloatEq
|
||||||
|
// ContainsRegex
|
||||||
|
// MatchesRegex
|
||||||
|
// EndsWith
|
||||||
|
// HasSubstr
|
||||||
|
// StartsWith
|
||||||
|
// StrCaseEq
|
||||||
|
// StrCaseNe
|
||||||
|
// StrEq
|
||||||
|
// StrNe
|
||||||
|
// ElementsAre
|
||||||
|
// ElementsAreArray
|
||||||
|
// ContainerEq
|
||||||
|
// Field
|
||||||
|
// Property
|
||||||
|
// ResultOf(function)
|
||||||
|
// Pointee
|
||||||
|
// Truly(predicate)
|
||||||
|
// AllOf
|
||||||
|
// AnyOf
|
||||||
|
// Not
|
||||||
|
// MatcherCast<T>
|
||||||
|
//
|
||||||
|
// Please note: this test does not verify the functioning of these
|
||||||
|
// constructs, only that the programs using them will link successfully.
|
||||||
|
//
|
||||||
|
// Implementation note:
|
||||||
|
// This test requires identical definitions of Interface and Mock to be
|
||||||
|
// included in different translation units. We achieve this by writing
|
||||||
|
// them in this header and #including it in gmock_link_test.cc and
|
||||||
|
// gmock_link2_test.cc. Because the symbols generated by the compiler for
|
||||||
|
// those constructs must be identical in both translation units,
|
||||||
|
// definitions of Interface and Mock tests MUST be kept in the SAME
|
||||||
|
// NON-ANONYMOUS namespace in this file. The test fixture class LinkTest
|
||||||
|
// is defined as LinkTest1 in gmock_link_test.cc and as LinkTest2 in
|
||||||
|
// gmock_link2_test.cc to avoid producing linker errors.
|
||||||
|
|
||||||
|
#ifndef GMOCK_TEST_GMOCK_LINK_TEST_H_
|
||||||
|
#define GMOCK_TEST_GMOCK_LINK_TEST_H_
|
||||||
|
|
||||||
|
#include "gmock/gmock.h"
|
||||||
|
|
||||||
|
#if !GTEST_OS_WINDOWS_MOBILE
|
||||||
|
# include <errno.h>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#include "gmock/internal/gmock-port.h"
|
||||||
|
#include "gtest/gtest.h"
|
||||||
|
#include <iostream>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
using testing::_;
|
||||||
|
using testing::A;
|
||||||
|
using testing::AllOf;
|
||||||
|
using testing::AnyOf;
|
||||||
|
using testing::Assign;
|
||||||
|
using testing::ContainerEq;
|
||||||
|
using testing::DoAll;
|
||||||
|
using testing::DoDefault;
|
||||||
|
using testing::DoubleEq;
|
||||||
|
using testing::ElementsAre;
|
||||||
|
using testing::ElementsAreArray;
|
||||||
|
using testing::EndsWith;
|
||||||
|
using testing::Eq;
|
||||||
|
using testing::Field;
|
||||||
|
using testing::FloatEq;
|
||||||
|
using testing::Ge;
|
||||||
|
using testing::Gt;
|
||||||
|
using testing::HasSubstr;
|
||||||
|
using testing::IgnoreResult;
|
||||||
|
using testing::Invoke;
|
||||||
|
using testing::InvokeArgument;
|
||||||
|
using testing::InvokeWithoutArgs;
|
||||||
|
using testing::IsNull;
|
||||||
|
using testing::Le;
|
||||||
|
using testing::Lt;
|
||||||
|
using testing::Matcher;
|
||||||
|
using testing::MatcherCast;
|
||||||
|
using testing::NanSensitiveDoubleEq;
|
||||||
|
using testing::NanSensitiveFloatEq;
|
||||||
|
using testing::Ne;
|
||||||
|
using testing::Not;
|
||||||
|
using testing::NotNull;
|
||||||
|
using testing::Pointee;
|
||||||
|
using testing::Property;
|
||||||
|
using testing::Ref;
|
||||||
|
using testing::ResultOf;
|
||||||
|
using testing::Return;
|
||||||
|
using testing::ReturnNull;
|
||||||
|
using testing::ReturnRef;
|
||||||
|
using testing::SetArgPointee;
|
||||||
|
using testing::SetArrayArgument;
|
||||||
|
using testing::StartsWith;
|
||||||
|
using testing::StrCaseEq;
|
||||||
|
using testing::StrCaseNe;
|
||||||
|
using testing::StrEq;
|
||||||
|
using testing::StrNe;
|
||||||
|
using testing::Truly;
|
||||||
|
using testing::TypedEq;
|
||||||
|
using testing::WithArg;
|
||||||
|
using testing::WithArgs;
|
||||||
|
using testing::WithoutArgs;
|
||||||
|
|
||||||
|
#if !GTEST_OS_WINDOWS_MOBILE
|
||||||
|
using testing::SetErrnoAndReturn;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if GTEST_HAS_EXCEPTIONS
|
||||||
|
using testing::Throw;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
using testing::ContainsRegex;
|
||||||
|
using testing::MatchesRegex;
|
||||||
|
|
||||||
|
class Interface {
|
||||||
|
public:
|
||||||
|
virtual ~Interface() {}
|
||||||
|
virtual void VoidFromString(char* str) = 0;
|
||||||
|
virtual char* StringFromString(char* str) = 0;
|
||||||
|
virtual int IntFromString(char* str) = 0;
|
||||||
|
virtual int& IntRefFromString(char* str) = 0;
|
||||||
|
virtual void VoidFromFunc(void(*)(char*)) = 0;
|
||||||
|
virtual void VoidFromIntRef(int& n) = 0;
|
||||||
|
virtual void VoidFromFloat(float n) = 0;
|
||||||
|
virtual void VoidFromDouble(double n) = 0;
|
||||||
|
virtual void VoidFromVector(const std::vector<int>& v) = 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
class Mock: public Interface {
|
||||||
|
public:
|
||||||
|
Mock() {}
|
||||||
|
|
||||||
|
MOCK_METHOD1(VoidFromString, void(char* str));
|
||||||
|
MOCK_METHOD1(StringFromString, char*(char* str));
|
||||||
|
MOCK_METHOD1(IntFromString, int(char* str));
|
||||||
|
MOCK_METHOD1(IntRefFromString, int&(char* str));
|
||||||
|
MOCK_METHOD1(VoidFromFunc, void(void(*func)(char* str)));
|
||||||
|
MOCK_METHOD1(VoidFromIntRef, void(int& n));
|
||||||
|
MOCK_METHOD1(VoidFromFloat, void(float n));
|
||||||
|
MOCK_METHOD1(VoidFromDouble, void(double n));
|
||||||
|
MOCK_METHOD1(VoidFromVector, void(const std::vector<int>& v));
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(Mock);
|
||||||
|
};
|
||||||
|
|
||||||
|
class InvokeHelper {
|
||||||
|
public:
|
||||||
|
static void StaticVoidFromVoid() {}
|
||||||
|
void VoidFromVoid() {}
|
||||||
|
static void StaticVoidFromString(char*) {}
|
||||||
|
void VoidFromString(char*) {}
|
||||||
|
static int StaticIntFromString(char*) { return 1; }
|
||||||
|
static bool StaticBoolFromString(const char*) { return true; }
|
||||||
|
};
|
||||||
|
|
||||||
|
class FieldHelper {
|
||||||
|
public:
|
||||||
|
FieldHelper(int a_field) : field_(a_field) {}
|
||||||
|
int field() const { return field_; }
|
||||||
|
int field_; // NOLINT -- need external access to field_ to test
|
||||||
|
// the Field matcher.
|
||||||
|
};
|
||||||
|
|
||||||
|
// Tests the linkage of the ReturnVoid action.
|
||||||
|
TEST(LinkTest, TestReturnVoid) {
|
||||||
|
Mock mock;
|
||||||
|
|
||||||
|
EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Return());
|
||||||
|
mock.VoidFromString(NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the Return action.
|
||||||
|
TEST(LinkTest, TestReturn) {
|
||||||
|
Mock mock;
|
||||||
|
char ch = 'x';
|
||||||
|
|
||||||
|
EXPECT_CALL(mock, StringFromString(_)).WillOnce(Return(&ch));
|
||||||
|
mock.StringFromString(NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the ReturnNull action.
|
||||||
|
TEST(LinkTest, TestReturnNull) {
|
||||||
|
Mock mock;
|
||||||
|
|
||||||
|
EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Return());
|
||||||
|
mock.VoidFromString(NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the ReturnRef action.
|
||||||
|
TEST(LinkTest, TestReturnRef) {
|
||||||
|
Mock mock;
|
||||||
|
int n = 42;
|
||||||
|
|
||||||
|
EXPECT_CALL(mock, IntRefFromString(_)).WillOnce(ReturnRef(n));
|
||||||
|
mock.IntRefFromString(NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the Assign action.
|
||||||
|
TEST(LinkTest, TestAssign) {
|
||||||
|
Mock mock;
|
||||||
|
char ch = 'x';
|
||||||
|
|
||||||
|
EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Assign(&ch, 'y'));
|
||||||
|
mock.VoidFromString(NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the SetArgPointee action.
|
||||||
|
TEST(LinkTest, TestSetArgPointee) {
|
||||||
|
Mock mock;
|
||||||
|
char ch = 'x';
|
||||||
|
|
||||||
|
EXPECT_CALL(mock, VoidFromString(_)).WillOnce(SetArgPointee<0>('y'));
|
||||||
|
mock.VoidFromString(&ch);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the SetArrayArgument action.
|
||||||
|
TEST(LinkTest, TestSetArrayArgument) {
|
||||||
|
Mock mock;
|
||||||
|
char ch = 'x';
|
||||||
|
char ch2 = 'y';
|
||||||
|
|
||||||
|
EXPECT_CALL(mock, VoidFromString(_)).WillOnce(SetArrayArgument<0>(&ch2,
|
||||||
|
&ch2 + 1));
|
||||||
|
mock.VoidFromString(&ch);
|
||||||
|
}
|
||||||
|
|
||||||
|
#if !GTEST_OS_WINDOWS_MOBILE
|
||||||
|
|
||||||
|
// Tests the linkage of the SetErrnoAndReturn action.
|
||||||
|
TEST(LinkTest, TestSetErrnoAndReturn) {
|
||||||
|
Mock mock;
|
||||||
|
|
||||||
|
int saved_errno = errno;
|
||||||
|
EXPECT_CALL(mock, IntFromString(_)).WillOnce(SetErrnoAndReturn(1, -1));
|
||||||
|
mock.IntFromString(NULL);
|
||||||
|
errno = saved_errno;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // !GTEST_OS_WINDOWS_MOBILE
|
||||||
|
|
||||||
|
// Tests the linkage of the Invoke(function) and Invoke(object, method) actions.
|
||||||
|
TEST(LinkTest, TestInvoke) {
|
||||||
|
Mock mock;
|
||||||
|
InvokeHelper test_invoke_helper;
|
||||||
|
|
||||||
|
EXPECT_CALL(mock, VoidFromString(_))
|
||||||
|
.WillOnce(Invoke(&InvokeHelper::StaticVoidFromString))
|
||||||
|
.WillOnce(Invoke(&test_invoke_helper, &InvokeHelper::VoidFromString));
|
||||||
|
mock.VoidFromString(NULL);
|
||||||
|
mock.VoidFromString(NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the InvokeWithoutArgs action.
|
||||||
|
TEST(LinkTest, TestInvokeWithoutArgs) {
|
||||||
|
Mock mock;
|
||||||
|
InvokeHelper test_invoke_helper;
|
||||||
|
|
||||||
|
EXPECT_CALL(mock, VoidFromString(_))
|
||||||
|
.WillOnce(InvokeWithoutArgs(&InvokeHelper::StaticVoidFromVoid))
|
||||||
|
.WillOnce(InvokeWithoutArgs(&test_invoke_helper,
|
||||||
|
&InvokeHelper::VoidFromVoid));
|
||||||
|
mock.VoidFromString(NULL);
|
||||||
|
mock.VoidFromString(NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the InvokeArgument action.
|
||||||
|
TEST(LinkTest, TestInvokeArgument) {
|
||||||
|
Mock mock;
|
||||||
|
char ch = 'x';
|
||||||
|
|
||||||
|
EXPECT_CALL(mock, VoidFromFunc(_)).WillOnce(InvokeArgument<0>(&ch));
|
||||||
|
mock.VoidFromFunc(InvokeHelper::StaticVoidFromString);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the WithArg action.
|
||||||
|
TEST(LinkTest, TestWithArg) {
|
||||||
|
Mock mock;
|
||||||
|
|
||||||
|
EXPECT_CALL(mock, VoidFromString(_))
|
||||||
|
.WillOnce(WithArg<0>(Invoke(&InvokeHelper::StaticVoidFromString)));
|
||||||
|
mock.VoidFromString(NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the WithArgs action.
|
||||||
|
TEST(LinkTest, TestWithArgs) {
|
||||||
|
Mock mock;
|
||||||
|
|
||||||
|
EXPECT_CALL(mock, VoidFromString(_))
|
||||||
|
.WillOnce(WithArgs<0>(Invoke(&InvokeHelper::StaticVoidFromString)));
|
||||||
|
mock.VoidFromString(NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the WithoutArgs action.
|
||||||
|
TEST(LinkTest, TestWithoutArgs) {
|
||||||
|
Mock mock;
|
||||||
|
|
||||||
|
EXPECT_CALL(mock, VoidFromString(_)).WillOnce(WithoutArgs(Return()));
|
||||||
|
mock.VoidFromString(NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the DoAll action.
|
||||||
|
TEST(LinkTest, TestDoAll) {
|
||||||
|
Mock mock;
|
||||||
|
char ch = 'x';
|
||||||
|
|
||||||
|
EXPECT_CALL(mock, VoidFromString(_))
|
||||||
|
.WillOnce(DoAll(SetArgPointee<0>('y'), Return()));
|
||||||
|
mock.VoidFromString(&ch);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the DoDefault action.
|
||||||
|
TEST(LinkTest, TestDoDefault) {
|
||||||
|
Mock mock;
|
||||||
|
char ch = 'x';
|
||||||
|
|
||||||
|
ON_CALL(mock, VoidFromString(_)).WillByDefault(Return());
|
||||||
|
EXPECT_CALL(mock, VoidFromString(_)).WillOnce(DoDefault());
|
||||||
|
mock.VoidFromString(&ch);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the IgnoreResult action.
|
||||||
|
TEST(LinkTest, TestIgnoreResult) {
|
||||||
|
Mock mock;
|
||||||
|
|
||||||
|
EXPECT_CALL(mock, VoidFromString(_)).WillOnce(IgnoreResult(Return(42)));
|
||||||
|
mock.VoidFromString(NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
#if GTEST_HAS_EXCEPTIONS
|
||||||
|
// Tests the linkage of the Throw action.
|
||||||
|
TEST(LinkTest, TestThrow) {
|
||||||
|
Mock mock;
|
||||||
|
|
||||||
|
EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Throw(42));
|
||||||
|
EXPECT_THROW(mock.VoidFromString(NULL), int);
|
||||||
|
}
|
||||||
|
#endif // GTEST_HAS_EXCEPTIONS
|
||||||
|
|
||||||
|
// The ACTION*() macros trigger warning C4100 (unreferenced formal
|
||||||
|
// parameter) in MSVC with -W4. Unfortunately they cannot be fixed in
|
||||||
|
// the macro definition, as the warnings are generated when the macro
|
||||||
|
// is expanded and macro expansion cannot contain #pragma. Therefore
|
||||||
|
// we suppress them here.
|
||||||
|
#ifdef _MSC_VER
|
||||||
|
# pragma warning(push)
|
||||||
|
# pragma warning(disable:4100)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// Tests the linkage of actions created using ACTION macro.
|
||||||
|
namespace {
|
||||||
|
ACTION(Return1) { return 1; }
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(LinkTest, TestActionMacro) {
|
||||||
|
Mock mock;
|
||||||
|
|
||||||
|
EXPECT_CALL(mock, IntFromString(_)).WillOnce(Return1());
|
||||||
|
mock.IntFromString(NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of actions created using ACTION_P macro.
|
||||||
|
namespace {
|
||||||
|
ACTION_P(ReturnArgument, ret_value) { return ret_value; }
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(LinkTest, TestActionPMacro) {
|
||||||
|
Mock mock;
|
||||||
|
|
||||||
|
EXPECT_CALL(mock, IntFromString(_)).WillOnce(ReturnArgument(42));
|
||||||
|
mock.IntFromString(NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of actions created using ACTION_P2 macro.
|
||||||
|
namespace {
|
||||||
|
ACTION_P2(ReturnEqualsEitherOf, first, second) {
|
||||||
|
return arg0 == first || arg0 == second;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#ifdef _MSC_VER
|
||||||
|
# pragma warning(pop)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
TEST(LinkTest, TestActionP2Macro) {
|
||||||
|
Mock mock;
|
||||||
|
char ch = 'x';
|
||||||
|
|
||||||
|
EXPECT_CALL(mock, IntFromString(_))
|
||||||
|
.WillOnce(ReturnEqualsEitherOf("one", "two"));
|
||||||
|
mock.IntFromString(&ch);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the "_" matcher.
|
||||||
|
TEST(LinkTest, TestMatcherAnything) {
|
||||||
|
Mock mock;
|
||||||
|
|
||||||
|
ON_CALL(mock, VoidFromString(_)).WillByDefault(Return());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the A matcher.
|
||||||
|
TEST(LinkTest, TestMatcherA) {
|
||||||
|
Mock mock;
|
||||||
|
|
||||||
|
ON_CALL(mock, VoidFromString(A<char*>())).WillByDefault(Return());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the Eq and the "bare value" matcher.
|
||||||
|
TEST(LinkTest, TestMatchersEq) {
|
||||||
|
Mock mock;
|
||||||
|
const char* p = "x";
|
||||||
|
|
||||||
|
ON_CALL(mock, VoidFromString(Eq(p))).WillByDefault(Return());
|
||||||
|
ON_CALL(mock, VoidFromString(const_cast<char*>("y")))
|
||||||
|
.WillByDefault(Return());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the Lt, Gt, Le, Ge, and Ne matchers.
|
||||||
|
TEST(LinkTest, TestMatchersRelations) {
|
||||||
|
Mock mock;
|
||||||
|
|
||||||
|
ON_CALL(mock, VoidFromFloat(Lt(1.0f))).WillByDefault(Return());
|
||||||
|
ON_CALL(mock, VoidFromFloat(Gt(1.0f))).WillByDefault(Return());
|
||||||
|
ON_CALL(mock, VoidFromFloat(Le(1.0f))).WillByDefault(Return());
|
||||||
|
ON_CALL(mock, VoidFromFloat(Ge(1.0f))).WillByDefault(Return());
|
||||||
|
ON_CALL(mock, VoidFromFloat(Ne(1.0f))).WillByDefault(Return());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the NotNull matcher.
|
||||||
|
TEST(LinkTest, TestMatcherNotNull) {
|
||||||
|
Mock mock;
|
||||||
|
|
||||||
|
ON_CALL(mock, VoidFromString(NotNull())).WillByDefault(Return());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the IsNull matcher.
|
||||||
|
TEST(LinkTest, TestMatcherIsNull) {
|
||||||
|
Mock mock;
|
||||||
|
|
||||||
|
ON_CALL(mock, VoidFromString(IsNull())).WillByDefault(Return());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the Ref matcher.
|
||||||
|
TEST(LinkTest, TestMatcherRef) {
|
||||||
|
Mock mock;
|
||||||
|
int a = 0;
|
||||||
|
|
||||||
|
ON_CALL(mock, VoidFromIntRef(Ref(a))).WillByDefault(Return());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the TypedEq matcher.
|
||||||
|
TEST(LinkTest, TestMatcherTypedEq) {
|
||||||
|
Mock mock;
|
||||||
|
long a = 0;
|
||||||
|
|
||||||
|
ON_CALL(mock, VoidFromIntRef(TypedEq<int&>(a))).WillByDefault(Return());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the FloatEq, DoubleEq, NanSensitiveFloatEq and
|
||||||
|
// NanSensitiveDoubleEq matchers.
|
||||||
|
TEST(LinkTest, TestMatchersFloatingPoint) {
|
||||||
|
Mock mock;
|
||||||
|
float a = 0;
|
||||||
|
|
||||||
|
ON_CALL(mock, VoidFromFloat(FloatEq(a))).WillByDefault(Return());
|
||||||
|
ON_CALL(mock, VoidFromDouble(DoubleEq(a))).WillByDefault(Return());
|
||||||
|
ON_CALL(mock, VoidFromFloat(NanSensitiveFloatEq(a))).WillByDefault(Return());
|
||||||
|
ON_CALL(mock, VoidFromDouble(NanSensitiveDoubleEq(a)))
|
||||||
|
.WillByDefault(Return());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the ContainsRegex matcher.
|
||||||
|
TEST(LinkTest, TestMatcherContainsRegex) {
|
||||||
|
Mock mock;
|
||||||
|
|
||||||
|
ON_CALL(mock, VoidFromString(ContainsRegex(".*"))).WillByDefault(Return());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the MatchesRegex matcher.
|
||||||
|
TEST(LinkTest, TestMatcherMatchesRegex) {
|
||||||
|
Mock mock;
|
||||||
|
|
||||||
|
ON_CALL(mock, VoidFromString(MatchesRegex(".*"))).WillByDefault(Return());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the StartsWith, EndsWith, and HasSubstr matchers.
|
||||||
|
TEST(LinkTest, TestMatchersSubstrings) {
|
||||||
|
Mock mock;
|
||||||
|
|
||||||
|
ON_CALL(mock, VoidFromString(StartsWith("a"))).WillByDefault(Return());
|
||||||
|
ON_CALL(mock, VoidFromString(EndsWith("c"))).WillByDefault(Return());
|
||||||
|
ON_CALL(mock, VoidFromString(HasSubstr("b"))).WillByDefault(Return());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the StrEq, StrNe, StrCaseEq, and StrCaseNe matchers.
|
||||||
|
TEST(LinkTest, TestMatchersStringEquality) {
|
||||||
|
Mock mock;
|
||||||
|
ON_CALL(mock, VoidFromString(StrEq("a"))).WillByDefault(Return());
|
||||||
|
ON_CALL(mock, VoidFromString(StrNe("a"))).WillByDefault(Return());
|
||||||
|
ON_CALL(mock, VoidFromString(StrCaseEq("a"))).WillByDefault(Return());
|
||||||
|
ON_CALL(mock, VoidFromString(StrCaseNe("a"))).WillByDefault(Return());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the ElementsAre matcher.
|
||||||
|
TEST(LinkTest, TestMatcherElementsAre) {
|
||||||
|
Mock mock;
|
||||||
|
|
||||||
|
ON_CALL(mock, VoidFromVector(ElementsAre('a', _))).WillByDefault(Return());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the ElementsAreArray matcher.
|
||||||
|
TEST(LinkTest, TestMatcherElementsAreArray) {
|
||||||
|
Mock mock;
|
||||||
|
char arr[] = { 'a', 'b' };
|
||||||
|
|
||||||
|
ON_CALL(mock, VoidFromVector(ElementsAreArray(arr))).WillByDefault(Return());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the ContainerEq matcher.
|
||||||
|
TEST(LinkTest, TestMatcherContainerEq) {
|
||||||
|
Mock mock;
|
||||||
|
std::vector<int> v;
|
||||||
|
|
||||||
|
ON_CALL(mock, VoidFromVector(ContainerEq(v))).WillByDefault(Return());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the Field matcher.
|
||||||
|
TEST(LinkTest, TestMatcherField) {
|
||||||
|
FieldHelper helper(0);
|
||||||
|
|
||||||
|
Matcher<const FieldHelper&> m = Field(&FieldHelper::field_, Eq(0));
|
||||||
|
EXPECT_TRUE(m.Matches(helper));
|
||||||
|
|
||||||
|
Matcher<const FieldHelper*> m2 = Field(&FieldHelper::field_, Eq(0));
|
||||||
|
EXPECT_TRUE(m2.Matches(&helper));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the Property matcher.
|
||||||
|
TEST(LinkTest, TestMatcherProperty) {
|
||||||
|
FieldHelper helper(0);
|
||||||
|
|
||||||
|
Matcher<const FieldHelper&> m = Property(&FieldHelper::field, Eq(0));
|
||||||
|
EXPECT_TRUE(m.Matches(helper));
|
||||||
|
|
||||||
|
Matcher<const FieldHelper*> m2 = Property(&FieldHelper::field, Eq(0));
|
||||||
|
EXPECT_TRUE(m2.Matches(&helper));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the ResultOf matcher.
|
||||||
|
TEST(LinkTest, TestMatcherResultOf) {
|
||||||
|
Matcher<char*> m = ResultOf(&InvokeHelper::StaticIntFromString, Eq(1));
|
||||||
|
EXPECT_TRUE(m.Matches(NULL));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the ResultOf matcher.
|
||||||
|
TEST(LinkTest, TestMatcherPointee) {
|
||||||
|
int n = 1;
|
||||||
|
|
||||||
|
Matcher<int*> m = Pointee(Eq(1));
|
||||||
|
EXPECT_TRUE(m.Matches(&n));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the Truly matcher.
|
||||||
|
TEST(LinkTest, TestMatcherTruly) {
|
||||||
|
Matcher<const char*> m = Truly(&InvokeHelper::StaticBoolFromString);
|
||||||
|
EXPECT_TRUE(m.Matches(NULL));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the AllOf matcher.
|
||||||
|
TEST(LinkTest, TestMatcherAllOf) {
|
||||||
|
Matcher<int> m = AllOf(_, Eq(1));
|
||||||
|
EXPECT_TRUE(m.Matches(1));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the AnyOf matcher.
|
||||||
|
TEST(LinkTest, TestMatcherAnyOf) {
|
||||||
|
Matcher<int> m = AnyOf(_, Eq(1));
|
||||||
|
EXPECT_TRUE(m.Matches(1));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the Not matcher.
|
||||||
|
TEST(LinkTest, TestMatcherNot) {
|
||||||
|
Matcher<int> m = Not(_);
|
||||||
|
EXPECT_FALSE(m.Matches(1));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tests the linkage of the MatcherCast<T>() function.
|
||||||
|
TEST(LinkTest, TestMatcherCast) {
|
||||||
|
Matcher<const char*> m = MatcherCast<const char*>(_);
|
||||||
|
EXPECT_TRUE(m.Matches(NULL));
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // GMOCK_TEST_GMOCK_LINK_TEST_H_
|
|
@ -0,0 +1,180 @@
|
||||||
|
#!/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++ Mocking Framework.
|
||||||
|
|
||||||
|
SYNOPSIS
|
||||||
|
gmock_output_test.py --build_dir=BUILD/DIR --gengolden
|
||||||
|
# where BUILD/DIR contains the built gmock_output_test_ file.
|
||||||
|
gmock_output_test.py --gengolden
|
||||||
|
gmock_output_test.py
|
||||||
|
"""
|
||||||
|
|
||||||
|
__author__ = 'wan@google.com (Zhanyong Wan)'
|
||||||
|
|
||||||
|
import os
|
||||||
|
import re
|
||||||
|
import sys
|
||||||
|
|
||||||
|
import gmock_test_utils
|
||||||
|
|
||||||
|
|
||||||
|
# The flag for generating the golden file
|
||||||
|
GENGOLDEN_FLAG = '--gengolden'
|
||||||
|
|
||||||
|
PROGRAM_PATH = gmock_test_utils.GetTestExecutablePath('gmock_output_test_')
|
||||||
|
COMMAND = [PROGRAM_PATH, '--gtest_stack_trace_depth=0', '--gtest_print_time=0']
|
||||||
|
GOLDEN_NAME = 'gmock_output_test_golden.txt'
|
||||||
|
GOLDEN_PATH = os.path.join(gmock_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 RemoveReportHeaderAndFooter(output):
|
||||||
|
"""Removes Google Test result report's header and footer from the output."""
|
||||||
|
|
||||||
|
output = re.sub(r'.*gtest_main.*\n', '', output)
|
||||||
|
output = re.sub(r'\[.*\d+ tests.*\n', '', output)
|
||||||
|
output = re.sub(r'\[.* test environment .*\n', '', output)
|
||||||
|
output = re.sub(r'\[=+\] \d+ tests .* ran.*', '', output)
|
||||||
|
output = re.sub(r'.* FAILED TESTS\n', '', output)
|
||||||
|
return output
|
||||||
|
|
||||||
|
|
||||||
|
def RemoveLocations(output):
|
||||||
|
"""Removes all file location info from a Google Test program's output.
|
||||||
|
|
||||||
|
Args:
|
||||||
|
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:#: '.
|
||||||
|
"""
|
||||||
|
|
||||||
|
return re.sub(r'.*[/\\](.+)(\:\d+|\(\d+\))\:', 'FILE:#:', output)
|
||||||
|
|
||||||
|
|
||||||
|
def NormalizeErrorMarker(output):
|
||||||
|
"""Normalizes the error marker, which is different on Windows vs on Linux."""
|
||||||
|
|
||||||
|
return re.sub(r' error: ', ' Failure\n', output)
|
||||||
|
|
||||||
|
|
||||||
|
def RemoveMemoryAddresses(output):
|
||||||
|
"""Removes memory addresses from the test output."""
|
||||||
|
|
||||||
|
return re.sub(r'@\w+', '@0x#', output)
|
||||||
|
|
||||||
|
|
||||||
|
def RemoveTestNamesOfLeakedMocks(output):
|
||||||
|
"""Removes the test names of leaked mock objects from the test output."""
|
||||||
|
|
||||||
|
return re.sub(r'\(used in test .+\) ', '', output)
|
||||||
|
|
||||||
|
|
||||||
|
def GetLeakyTests(output):
|
||||||
|
"""Returns a list of test names that leak mock objects."""
|
||||||
|
|
||||||
|
# findall() returns a list of all matches of the regex in output.
|
||||||
|
# For example, if '(used in test FooTest.Bar)' is in output, the
|
||||||
|
# list will contain 'FooTest.Bar'.
|
||||||
|
return re.findall(r'\(used in test (.+)\)', output)
|
||||||
|
|
||||||
|
|
||||||
|
def GetNormalizedOutputAndLeakyTests(output):
|
||||||
|
"""Normalizes the output of gmock_output_test_.
|
||||||
|
|
||||||
|
Args:
|
||||||
|
output: The test output.
|
||||||
|
|
||||||
|
Returns:
|
||||||
|
A tuple (the normalized test output, the list of test names that have
|
||||||
|
leaked mocks).
|
||||||
|
"""
|
||||||
|
|
||||||
|
output = ToUnixLineEnding(output)
|
||||||
|
output = RemoveReportHeaderAndFooter(output)
|
||||||
|
output = NormalizeErrorMarker(output)
|
||||||
|
output = RemoveLocations(output)
|
||||||
|
output = RemoveMemoryAddresses(output)
|
||||||
|
return (RemoveTestNamesOfLeakedMocks(output), GetLeakyTests(output))
|
||||||
|
|
||||||
|
|
||||||
|
def GetShellCommandOutput(cmd):
|
||||||
|
"""Runs a command in a sub-process, and returns its STDOUT in a string."""
|
||||||
|
|
||||||
|
return gmock_test_utils.Subprocess(cmd, capture_stderr=False).output
|
||||||
|
|
||||||
|
|
||||||
|
def GetNormalizedCommandOutputAndLeakyTests(cmd):
|
||||||
|
"""Runs a command and returns its normalized output and a list of leaky tests.
|
||||||
|
|
||||||
|
Args:
|
||||||
|
cmd: the shell command.
|
||||||
|
"""
|
||||||
|
|
||||||
|
# Disables exception pop-ups on Windows.
|
||||||
|
os.environ['GTEST_CATCH_EXCEPTIONS'] = '1'
|
||||||
|
return GetNormalizedOutputAndLeakyTests(GetShellCommandOutput(cmd))
|
||||||
|
|
||||||
|
|
||||||
|
class GMockOutputTest(gmock_test_utils.TestCase):
|
||||||
|
def testOutput(self):
|
||||||
|
(output, leaky_tests) = GetNormalizedCommandOutputAndLeakyTests(COMMAND)
|
||||||
|
golden_file = open(GOLDEN_PATH, 'rb')
|
||||||
|
golden = golden_file.read()
|
||||||
|
golden_file.close()
|
||||||
|
|
||||||
|
# The normalized output should match the golden file.
|
||||||
|
self.assertEquals(golden, output)
|
||||||
|
|
||||||
|
# The raw output should contain 2 leaked mock object errors for
|
||||||
|
# test GMockOutputTest.CatchesLeakedMocks.
|
||||||
|
self.assertEquals(['GMockOutputTest.CatchesLeakedMocks',
|
||||||
|
'GMockOutputTest.CatchesLeakedMocks'],
|
||||||
|
leaky_tests)
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == '__main__':
|
||||||
|
if sys.argv[1:] == [GENGOLDEN_FLAG]:
|
||||||
|
(output, _) = GetNormalizedCommandOutputAndLeakyTests(COMMAND)
|
||||||
|
golden_file = open(GOLDEN_PATH, 'wb')
|
||||||
|
golden_file.write(output)
|
||||||
|
golden_file.close()
|
||||||
|
else:
|
||||||
|
gmock_test_utils.Main()
|
|
@ -0,0 +1,290 @@
|
||||||
|
// 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 Google Mock's output in various scenarios. This ensures that
|
||||||
|
// Google Mock's messages are readable and useful.
|
||||||
|
|
||||||
|
#include "gmock/gmock.h"
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <string>
|
||||||
|
|
||||||
|
#include "gtest/gtest.h"
|
||||||
|
|
||||||
|
using testing::_;
|
||||||
|
using testing::AnyNumber;
|
||||||
|
using testing::Ge;
|
||||||
|
using testing::InSequence;
|
||||||
|
using testing::Ref;
|
||||||
|
using testing::Return;
|
||||||
|
using testing::Sequence;
|
||||||
|
|
||||||
|
class MockFoo {
|
||||||
|
public:
|
||||||
|
MockFoo() {}
|
||||||
|
|
||||||
|
MOCK_METHOD3(Bar, char(const std::string& s, int i, double x));
|
||||||
|
MOCK_METHOD2(Bar2, bool(int x, int y));
|
||||||
|
MOCK_METHOD2(Bar3, void(int x, int y));
|
||||||
|
|
||||||
|
private:
|
||||||
|
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
|
||||||
|
};
|
||||||
|
|
||||||
|
class GMockOutputTest : public testing::Test {
|
||||||
|
protected:
|
||||||
|
MockFoo foo_;
|
||||||
|
};
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, ExpectedCall) {
|
||||||
|
testing::GMOCK_FLAG(verbose) = "info";
|
||||||
|
|
||||||
|
EXPECT_CALL(foo_, Bar2(0, _));
|
||||||
|
foo_.Bar2(0, 0); // Expected call
|
||||||
|
|
||||||
|
testing::GMOCK_FLAG(verbose) = "warning";
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, ExpectedCallToVoidFunction) {
|
||||||
|
testing::GMOCK_FLAG(verbose) = "info";
|
||||||
|
|
||||||
|
EXPECT_CALL(foo_, Bar3(0, _));
|
||||||
|
foo_.Bar3(0, 0); // Expected call
|
||||||
|
|
||||||
|
testing::GMOCK_FLAG(verbose) = "warning";
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, ExplicitActionsRunOut) {
|
||||||
|
EXPECT_CALL(foo_, Bar2(_, _))
|
||||||
|
.Times(2)
|
||||||
|
.WillOnce(Return(false));
|
||||||
|
foo_.Bar2(2, 2);
|
||||||
|
foo_.Bar2(1, 1); // Explicit actions in EXPECT_CALL run out.
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, UnexpectedCall) {
|
||||||
|
EXPECT_CALL(foo_, Bar2(0, _));
|
||||||
|
|
||||||
|
foo_.Bar2(1, 0); // Unexpected call
|
||||||
|
foo_.Bar2(0, 0); // Expected call
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, UnexpectedCallToVoidFunction) {
|
||||||
|
EXPECT_CALL(foo_, Bar3(0, _));
|
||||||
|
|
||||||
|
foo_.Bar3(1, 0); // Unexpected call
|
||||||
|
foo_.Bar3(0, 0); // Expected call
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, ExcessiveCall) {
|
||||||
|
EXPECT_CALL(foo_, Bar2(0, _));
|
||||||
|
|
||||||
|
foo_.Bar2(0, 0); // Expected call
|
||||||
|
foo_.Bar2(0, 1); // Excessive call
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, ExcessiveCallToVoidFunction) {
|
||||||
|
EXPECT_CALL(foo_, Bar3(0, _));
|
||||||
|
|
||||||
|
foo_.Bar3(0, 0); // Expected call
|
||||||
|
foo_.Bar3(0, 1); // Excessive call
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, UninterestingCall) {
|
||||||
|
foo_.Bar2(0, 1); // Uninteresting call
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, UninterestingCallToVoidFunction) {
|
||||||
|
foo_.Bar3(0, 1); // Uninteresting call
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, RetiredExpectation) {
|
||||||
|
EXPECT_CALL(foo_, Bar2(_, _))
|
||||||
|
.RetiresOnSaturation();
|
||||||
|
EXPECT_CALL(foo_, Bar2(0, 0));
|
||||||
|
|
||||||
|
foo_.Bar2(1, 1);
|
||||||
|
foo_.Bar2(1, 1); // Matches a retired expectation
|
||||||
|
foo_.Bar2(0, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, UnsatisfiedPrerequisite) {
|
||||||
|
{
|
||||||
|
InSequence s;
|
||||||
|
EXPECT_CALL(foo_, Bar(_, 0, _));
|
||||||
|
EXPECT_CALL(foo_, Bar2(0, 0));
|
||||||
|
EXPECT_CALL(foo_, Bar2(1, _));
|
||||||
|
}
|
||||||
|
|
||||||
|
foo_.Bar2(1, 0); // Has one immediate unsatisfied pre-requisite
|
||||||
|
foo_.Bar("Hi", 0, 0);
|
||||||
|
foo_.Bar2(0, 0);
|
||||||
|
foo_.Bar2(1, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, UnsatisfiedPrerequisites) {
|
||||||
|
Sequence s1, s2;
|
||||||
|
|
||||||
|
EXPECT_CALL(foo_, Bar(_, 0, _))
|
||||||
|
.InSequence(s1);
|
||||||
|
EXPECT_CALL(foo_, Bar2(0, 0))
|
||||||
|
.InSequence(s2);
|
||||||
|
EXPECT_CALL(foo_, Bar2(1, _))
|
||||||
|
.InSequence(s1, s2);
|
||||||
|
|
||||||
|
foo_.Bar2(1, 0); // Has two immediate unsatisfied pre-requisites
|
||||||
|
foo_.Bar("Hi", 0, 0);
|
||||||
|
foo_.Bar2(0, 0);
|
||||||
|
foo_.Bar2(1, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, UnsatisfiedWith) {
|
||||||
|
EXPECT_CALL(foo_, Bar2(_, _)).With(Ge());
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, UnsatisfiedExpectation) {
|
||||||
|
EXPECT_CALL(foo_, Bar(_, _, _));
|
||||||
|
EXPECT_CALL(foo_, Bar2(0, _))
|
||||||
|
.Times(2);
|
||||||
|
|
||||||
|
foo_.Bar2(0, 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, MismatchArguments) {
|
||||||
|
const std::string s = "Hi";
|
||||||
|
EXPECT_CALL(foo_, Bar(Ref(s), _, Ge(0)));
|
||||||
|
|
||||||
|
foo_.Bar("Ho", 0, -0.1); // Mismatch arguments
|
||||||
|
foo_.Bar(s, 0, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, MismatchWith) {
|
||||||
|
EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))
|
||||||
|
.With(Ge());
|
||||||
|
|
||||||
|
foo_.Bar2(2, 3); // Mismatch With()
|
||||||
|
foo_.Bar2(2, 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, MismatchArgumentsAndWith) {
|
||||||
|
EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))
|
||||||
|
.With(Ge());
|
||||||
|
|
||||||
|
foo_.Bar2(1, 3); // Mismatch arguments and mismatch With()
|
||||||
|
foo_.Bar2(2, 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, UnexpectedCallWithDefaultAction) {
|
||||||
|
ON_CALL(foo_, Bar2(_, _))
|
||||||
|
.WillByDefault(Return(true)); // Default action #1
|
||||||
|
ON_CALL(foo_, Bar2(1, _))
|
||||||
|
.WillByDefault(Return(false)); // Default action #2
|
||||||
|
|
||||||
|
EXPECT_CALL(foo_, Bar2(2, 2));
|
||||||
|
foo_.Bar2(1, 0); // Unexpected call, takes default action #2.
|
||||||
|
foo_.Bar2(0, 0); // Unexpected call, takes default action #1.
|
||||||
|
foo_.Bar2(2, 2); // Expected call.
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, ExcessiveCallWithDefaultAction) {
|
||||||
|
ON_CALL(foo_, Bar2(_, _))
|
||||||
|
.WillByDefault(Return(true)); // Default action #1
|
||||||
|
ON_CALL(foo_, Bar2(1, _))
|
||||||
|
.WillByDefault(Return(false)); // Default action #2
|
||||||
|
|
||||||
|
EXPECT_CALL(foo_, Bar2(2, 2));
|
||||||
|
EXPECT_CALL(foo_, Bar2(1, 1));
|
||||||
|
|
||||||
|
foo_.Bar2(2, 2); // Expected call.
|
||||||
|
foo_.Bar2(2, 2); // Excessive call, takes default action #1.
|
||||||
|
foo_.Bar2(1, 1); // Expected call.
|
||||||
|
foo_.Bar2(1, 1); // Excessive call, takes default action #2.
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, UninterestingCallWithDefaultAction) {
|
||||||
|
ON_CALL(foo_, Bar2(_, _))
|
||||||
|
.WillByDefault(Return(true)); // Default action #1
|
||||||
|
ON_CALL(foo_, Bar2(1, _))
|
||||||
|
.WillByDefault(Return(false)); // Default action #2
|
||||||
|
|
||||||
|
foo_.Bar2(2, 2); // Uninteresting call, takes default action #1.
|
||||||
|
foo_.Bar2(1, 1); // Uninteresting call, takes default action #2.
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, ExplicitActionsRunOutWithDefaultAction) {
|
||||||
|
ON_CALL(foo_, Bar2(_, _))
|
||||||
|
.WillByDefault(Return(true)); // Default action #1
|
||||||
|
|
||||||
|
EXPECT_CALL(foo_, Bar2(_, _))
|
||||||
|
.Times(2)
|
||||||
|
.WillOnce(Return(false));
|
||||||
|
foo_.Bar2(2, 2);
|
||||||
|
foo_.Bar2(1, 1); // Explicit actions in EXPECT_CALL run out.
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(GMockOutputTest, CatchesLeakedMocks) {
|
||||||
|
MockFoo* foo1 = new MockFoo;
|
||||||
|
MockFoo* foo2 = new MockFoo;
|
||||||
|
|
||||||
|
// Invokes ON_CALL on foo1.
|
||||||
|
ON_CALL(*foo1, Bar(_, _, _)).WillByDefault(Return('a'));
|
||||||
|
|
||||||
|
// Invokes EXPECT_CALL on foo2.
|
||||||
|
EXPECT_CALL(*foo2, Bar2(_, _));
|
||||||
|
EXPECT_CALL(*foo2, Bar2(1, _));
|
||||||
|
EXPECT_CALL(*foo2, Bar3(_, _)).Times(AnyNumber());
|
||||||
|
foo2->Bar2(2, 1);
|
||||||
|
foo2->Bar2(1, 1);
|
||||||
|
|
||||||
|
// Both foo1 and foo2 are deliberately leaked.
|
||||||
|
}
|
||||||
|
|
||||||
|
void TestCatchesLeakedMocksInAdHocTests() {
|
||||||
|
MockFoo* foo = new MockFoo;
|
||||||
|
|
||||||
|
// Invokes EXPECT_CALL on foo.
|
||||||
|
EXPECT_CALL(*foo, Bar2(_, _));
|
||||||
|
foo->Bar2(2, 1);
|
||||||
|
|
||||||
|
// foo is deliberately leaked.
|
||||||
|
}
|
||||||
|
|
||||||
|
int main(int argc, char **argv) {
|
||||||
|
testing::InitGoogleMock(&argc, argv);
|
||||||
|
|
||||||
|
// Ensures that the tests pass no matter what value of
|
||||||
|
// --gmock_catch_leaked_mocks and --gmock_verbose the user specifies.
|
||||||
|
testing::GMOCK_FLAG(catch_leaked_mocks) = true;
|
||||||
|
testing::GMOCK_FLAG(verbose) = "warning";
|
||||||
|
|
||||||
|
TestCatchesLeakedMocksInAdHocTests();
|
||||||
|
return RUN_ALL_TESTS();
|
||||||
|
}
|
|
@ -0,0 +1,310 @@
|
||||||
|
[ RUN ] GMockOutputTest.ExpectedCall
|
||||||
|
|
||||||
|
FILE:#: EXPECT_CALL(foo_, Bar2(0, _)) invoked
|
||||||
|
Stack trace:
|
||||||
|
|
||||||
|
FILE:#: Mock function call matches EXPECT_CALL(foo_, Bar2(0, _))...
|
||||||
|
Function call: Bar2(0, 0)
|
||||||
|
Returns: false
|
||||||
|
Stack trace:
|
||||||
|
[ OK ] GMockOutputTest.ExpectedCall
|
||||||
|
[ RUN ] GMockOutputTest.ExpectedCallToVoidFunction
|
||||||
|
|
||||||
|
FILE:#: EXPECT_CALL(foo_, Bar3(0, _)) invoked
|
||||||
|
Stack trace:
|
||||||
|
|
||||||
|
FILE:#: Mock function call matches EXPECT_CALL(foo_, Bar3(0, _))...
|
||||||
|
Function call: Bar3(0, 0)
|
||||||
|
Stack trace:
|
||||||
|
[ OK ] GMockOutputTest.ExpectedCallToVoidFunction
|
||||||
|
[ RUN ] GMockOutputTest.ExplicitActionsRunOut
|
||||||
|
|
||||||
|
GMOCK WARNING:
|
||||||
|
FILE:#: Too few actions specified in EXPECT_CALL(foo_, Bar2(_, _))...
|
||||||
|
Expected to be called twice, but has only 1 WillOnce().
|
||||||
|
GMOCK WARNING:
|
||||||
|
FILE:#: Actions ran out in EXPECT_CALL(foo_, Bar2(_, _))...
|
||||||
|
Called 2 times, but only 1 WillOnce() is specified - returning default value.
|
||||||
|
Stack trace:
|
||||||
|
[ OK ] GMockOutputTest.ExplicitActionsRunOut
|
||||||
|
[ RUN ] GMockOutputTest.UnexpectedCall
|
||||||
|
unknown file: Failure
|
||||||
|
|
||||||
|
Unexpected mock function call - returning default value.
|
||||||
|
Function call: Bar2(1, 0)
|
||||||
|
Returns: false
|
||||||
|
Google Mock tried the following 1 expectation, but it didn't match:
|
||||||
|
|
||||||
|
FILE:#: EXPECT_CALL(foo_, Bar2(0, _))...
|
||||||
|
Expected arg #0: is equal to 0
|
||||||
|
Actual: 1
|
||||||
|
Expected: to be called once
|
||||||
|
Actual: never called - unsatisfied and active
|
||||||
|
[ FAILED ] GMockOutputTest.UnexpectedCall
|
||||||
|
[ RUN ] GMockOutputTest.UnexpectedCallToVoidFunction
|
||||||
|
unknown file: Failure
|
||||||
|
|
||||||
|
Unexpected mock function call - returning directly.
|
||||||
|
Function call: Bar3(1, 0)
|
||||||
|
Google Mock tried the following 1 expectation, but it didn't match:
|
||||||
|
|
||||||
|
FILE:#: EXPECT_CALL(foo_, Bar3(0, _))...
|
||||||
|
Expected arg #0: is equal to 0
|
||||||
|
Actual: 1
|
||||||
|
Expected: to be called once
|
||||||
|
Actual: never called - unsatisfied and active
|
||||||
|
[ FAILED ] GMockOutputTest.UnexpectedCallToVoidFunction
|
||||||
|
[ RUN ] GMockOutputTest.ExcessiveCall
|
||||||
|
FILE:#: Failure
|
||||||
|
Mock function called more times than expected - returning default value.
|
||||||
|
Function call: Bar2(0, 1)
|
||||||
|
Returns: false
|
||||||
|
Expected: to be called once
|
||||||
|
Actual: called twice - over-saturated and active
|
||||||
|
[ FAILED ] GMockOutputTest.ExcessiveCall
|
||||||
|
[ RUN ] GMockOutputTest.ExcessiveCallToVoidFunction
|
||||||
|
FILE:#: Failure
|
||||||
|
Mock function called more times than expected - returning directly.
|
||||||
|
Function call: Bar3(0, 1)
|
||||||
|
Expected: to be called once
|
||||||
|
Actual: called twice - over-saturated and active
|
||||||
|
[ FAILED ] GMockOutputTest.ExcessiveCallToVoidFunction
|
||||||
|
[ RUN ] GMockOutputTest.UninterestingCall
|
||||||
|
|
||||||
|
GMOCK WARNING:
|
||||||
|
Uninteresting mock function call - returning default value.
|
||||||
|
Function call: Bar2(0, 1)
|
||||||
|
Returns: false
|
||||||
|
Stack trace:
|
||||||
|
[ OK ] GMockOutputTest.UninterestingCall
|
||||||
|
[ RUN ] GMockOutputTest.UninterestingCallToVoidFunction
|
||||||
|
|
||||||
|
GMOCK WARNING:
|
||||||
|
Uninteresting mock function call - returning directly.
|
||||||
|
Function call: Bar3(0, 1)
|
||||||
|
Stack trace:
|
||||||
|
[ OK ] GMockOutputTest.UninterestingCallToVoidFunction
|
||||||
|
[ RUN ] GMockOutputTest.RetiredExpectation
|
||||||
|
unknown file: Failure
|
||||||
|
|
||||||
|
Unexpected mock function call - returning default value.
|
||||||
|
Function call: Bar2(1, 1)
|
||||||
|
Returns: false
|
||||||
|
Google Mock tried the following 2 expectations, but none matched:
|
||||||
|
|
||||||
|
FILE:#: tried expectation #0: EXPECT_CALL(foo_, Bar2(_, _))...
|
||||||
|
Expected: the expectation is active
|
||||||
|
Actual: it is retired
|
||||||
|
Expected: to be called once
|
||||||
|
Actual: called once - saturated and retired
|
||||||
|
FILE:#: tried expectation #1: EXPECT_CALL(foo_, Bar2(0, 0))...
|
||||||
|
Expected arg #0: is equal to 0
|
||||||
|
Actual: 1
|
||||||
|
Expected arg #1: is equal to 0
|
||||||
|
Actual: 1
|
||||||
|
Expected: to be called once
|
||||||
|
Actual: never called - unsatisfied and active
|
||||||
|
[ FAILED ] GMockOutputTest.RetiredExpectation
|
||||||
|
[ RUN ] GMockOutputTest.UnsatisfiedPrerequisite
|
||||||
|
unknown file: Failure
|
||||||
|
|
||||||
|
Unexpected mock function call - returning default value.
|
||||||
|
Function call: Bar2(1, 0)
|
||||||
|
Returns: false
|
||||||
|
Google Mock tried the following 2 expectations, but none matched:
|
||||||
|
|
||||||
|
FILE:#: tried expectation #0: EXPECT_CALL(foo_, Bar2(0, 0))...
|
||||||
|
Expected arg #0: is equal to 0
|
||||||
|
Actual: 1
|
||||||
|
Expected: to be called once
|
||||||
|
Actual: never called - unsatisfied and active
|
||||||
|
FILE:#: tried expectation #1: EXPECT_CALL(foo_, Bar2(1, _))...
|
||||||
|
Expected: all pre-requisites are satisfied
|
||||||
|
Actual: the following immediate pre-requisites are not satisfied:
|
||||||
|
FILE:#: pre-requisite #0
|
||||||
|
(end of pre-requisites)
|
||||||
|
Expected: to be called once
|
||||||
|
Actual: never called - unsatisfied and active
|
||||||
|
[ FAILED ] GMockOutputTest.UnsatisfiedPrerequisite
|
||||||
|
[ RUN ] GMockOutputTest.UnsatisfiedPrerequisites
|
||||||
|
unknown file: Failure
|
||||||
|
|
||||||
|
Unexpected mock function call - returning default value.
|
||||||
|
Function call: Bar2(1, 0)
|
||||||
|
Returns: false
|
||||||
|
Google Mock tried the following 2 expectations, but none matched:
|
||||||
|
|
||||||
|
FILE:#: tried expectation #0: EXPECT_CALL(foo_, Bar2(0, 0))...
|
||||||
|
Expected arg #0: is equal to 0
|
||||||
|
Actual: 1
|
||||||
|
Expected: to be called once
|
||||||
|
Actual: never called - unsatisfied and active
|
||||||
|
FILE:#: tried expectation #1: EXPECT_CALL(foo_, Bar2(1, _))...
|
||||||
|
Expected: all pre-requisites are satisfied
|
||||||
|
Actual: the following immediate pre-requisites are not satisfied:
|
||||||
|
FILE:#: pre-requisite #0
|
||||||
|
FILE:#: pre-requisite #1
|
||||||
|
(end of pre-requisites)
|
||||||
|
Expected: to be called once
|
||||||
|
Actual: never called - unsatisfied and active
|
||||||
|
[ FAILED ] GMockOutputTest.UnsatisfiedPrerequisites
|
||||||
|
[ RUN ] GMockOutputTest.UnsatisfiedWith
|
||||||
|
FILE:#: Failure
|
||||||
|
Actual function call count doesn't match EXPECT_CALL(foo_, Bar2(_, _))...
|
||||||
|
Expected args: are a pair where the first >= the second
|
||||||
|
Expected: to be called once
|
||||||
|
Actual: never called - unsatisfied and active
|
||||||
|
[ FAILED ] GMockOutputTest.UnsatisfiedWith
|
||||||
|
[ RUN ] GMockOutputTest.UnsatisfiedExpectation
|
||||||
|
FILE:#: Failure
|
||||||
|
Actual function call count doesn't match EXPECT_CALL(foo_, Bar2(0, _))...
|
||||||
|
Expected: to be called twice
|
||||||
|
Actual: called once - unsatisfied and active
|
||||||
|
FILE:#: Failure
|
||||||
|
Actual function call count doesn't match EXPECT_CALL(foo_, Bar(_, _, _))...
|
||||||
|
Expected: to be called once
|
||||||
|
Actual: never called - unsatisfied and active
|
||||||
|
[ FAILED ] GMockOutputTest.UnsatisfiedExpectation
|
||||||
|
[ RUN ] GMockOutputTest.MismatchArguments
|
||||||
|
unknown file: Failure
|
||||||
|
|
||||||
|
Unexpected mock function call - returning default value.
|
||||||
|
Function call: Bar(@0x# "Ho", 0, -0.1)
|
||||||
|
Returns: '\0'
|
||||||
|
Google Mock tried the following 1 expectation, but it didn't match:
|
||||||
|
|
||||||
|
FILE:#: EXPECT_CALL(foo_, Bar(Ref(s), _, Ge(0)))...
|
||||||
|
Expected arg #0: references the variable @0x# "Hi"
|
||||||
|
Actual: "Ho", which is located @0x#
|
||||||
|
Expected arg #2: is >= 0
|
||||||
|
Actual: -0.1
|
||||||
|
Expected: to be called once
|
||||||
|
Actual: never called - unsatisfied and active
|
||||||
|
[ FAILED ] GMockOutputTest.MismatchArguments
|
||||||
|
[ RUN ] GMockOutputTest.MismatchWith
|
||||||
|
unknown file: Failure
|
||||||
|
|
||||||
|
Unexpected mock function call - returning default value.
|
||||||
|
Function call: Bar2(2, 3)
|
||||||
|
Returns: false
|
||||||
|
Google Mock tried the following 1 expectation, but it didn't match:
|
||||||
|
|
||||||
|
FILE:#: EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))...
|
||||||
|
Expected args: are a pair where the first >= the second
|
||||||
|
Actual: don't match
|
||||||
|
Expected: to be called once
|
||||||
|
Actual: never called - unsatisfied and active
|
||||||
|
[ FAILED ] GMockOutputTest.MismatchWith
|
||||||
|
[ RUN ] GMockOutputTest.MismatchArgumentsAndWith
|
||||||
|
unknown file: Failure
|
||||||
|
|
||||||
|
Unexpected mock function call - returning default value.
|
||||||
|
Function call: Bar2(1, 3)
|
||||||
|
Returns: false
|
||||||
|
Google Mock tried the following 1 expectation, but it didn't match:
|
||||||
|
|
||||||
|
FILE:#: EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))...
|
||||||
|
Expected arg #0: is >= 2
|
||||||
|
Actual: 1
|
||||||
|
Expected args: are a pair where the first >= the second
|
||||||
|
Actual: don't match
|
||||||
|
Expected: to be called once
|
||||||
|
Actual: never called - unsatisfied and active
|
||||||
|
[ FAILED ] GMockOutputTest.MismatchArgumentsAndWith
|
||||||
|
[ RUN ] GMockOutputTest.UnexpectedCallWithDefaultAction
|
||||||
|
unknown file: Failure
|
||||||
|
|
||||||
|
Unexpected mock function call - taking default action specified at:
|
||||||
|
FILE:#:
|
||||||
|
Function call: Bar2(1, 0)
|
||||||
|
Returns: false
|
||||||
|
Google Mock tried the following 1 expectation, but it didn't match:
|
||||||
|
|
||||||
|
FILE:#: EXPECT_CALL(foo_, Bar2(2, 2))...
|
||||||
|
Expected arg #0: is equal to 2
|
||||||
|
Actual: 1
|
||||||
|
Expected arg #1: is equal to 2
|
||||||
|
Actual: 0
|
||||||
|
Expected: to be called once
|
||||||
|
Actual: never called - unsatisfied and active
|
||||||
|
unknown file: Failure
|
||||||
|
|
||||||
|
Unexpected mock function call - taking default action specified at:
|
||||||
|
FILE:#:
|
||||||
|
Function call: Bar2(0, 0)
|
||||||
|
Returns: true
|
||||||
|
Google Mock tried the following 1 expectation, but it didn't match:
|
||||||
|
|
||||||
|
FILE:#: EXPECT_CALL(foo_, Bar2(2, 2))...
|
||||||
|
Expected arg #0: is equal to 2
|
||||||
|
Actual: 0
|
||||||
|
Expected arg #1: is equal to 2
|
||||||
|
Actual: 0
|
||||||
|
Expected: to be called once
|
||||||
|
Actual: never called - unsatisfied and active
|
||||||
|
[ FAILED ] GMockOutputTest.UnexpectedCallWithDefaultAction
|
||||||
|
[ RUN ] GMockOutputTest.ExcessiveCallWithDefaultAction
|
||||||
|
FILE:#: Failure
|
||||||
|
Mock function called more times than expected - taking default action specified at:
|
||||||
|
FILE:#:
|
||||||
|
Function call: Bar2(2, 2)
|
||||||
|
Returns: true
|
||||||
|
Expected: to be called once
|
||||||
|
Actual: called twice - over-saturated and active
|
||||||
|
FILE:#: Failure
|
||||||
|
Mock function called more times than expected - taking default action specified at:
|
||||||
|
FILE:#:
|
||||||
|
Function call: Bar2(1, 1)
|
||||||
|
Returns: false
|
||||||
|
Expected: to be called once
|
||||||
|
Actual: called twice - over-saturated and active
|
||||||
|
[ FAILED ] GMockOutputTest.ExcessiveCallWithDefaultAction
|
||||||
|
[ RUN ] GMockOutputTest.UninterestingCallWithDefaultAction
|
||||||
|
|
||||||
|
GMOCK WARNING:
|
||||||
|
Uninteresting mock function call - taking default action specified at:
|
||||||
|
FILE:#:
|
||||||
|
Function call: Bar2(2, 2)
|
||||||
|
Returns: true
|
||||||
|
Stack trace:
|
||||||
|
|
||||||
|
GMOCK WARNING:
|
||||||
|
Uninteresting mock function call - taking default action specified at:
|
||||||
|
FILE:#:
|
||||||
|
Function call: Bar2(1, 1)
|
||||||
|
Returns: false
|
||||||
|
Stack trace:
|
||||||
|
[ OK ] GMockOutputTest.UninterestingCallWithDefaultAction
|
||||||
|
[ RUN ] GMockOutputTest.ExplicitActionsRunOutWithDefaultAction
|
||||||
|
|
||||||
|
GMOCK WARNING:
|
||||||
|
FILE:#: Too few actions specified in EXPECT_CALL(foo_, Bar2(_, _))...
|
||||||
|
Expected to be called twice, but has only 1 WillOnce().
|
||||||
|
GMOCK WARNING:
|
||||||
|
FILE:#: Actions ran out in EXPECT_CALL(foo_, Bar2(_, _))...
|
||||||
|
Called 2 times, but only 1 WillOnce() is specified - taking default action specified at:
|
||||||
|
FILE:#:
|
||||||
|
Stack trace:
|
||||||
|
[ OK ] GMockOutputTest.ExplicitActionsRunOutWithDefaultAction
|
||||||
|
[ RUN ] GMockOutputTest.CatchesLeakedMocks
|
||||||
|
[ OK ] GMockOutputTest.CatchesLeakedMocks
|
||||||
|
[ FAILED ] GMockOutputTest.UnexpectedCall
|
||||||
|
[ FAILED ] GMockOutputTest.UnexpectedCallToVoidFunction
|
||||||
|
[ FAILED ] GMockOutputTest.ExcessiveCall
|
||||||
|
[ FAILED ] GMockOutputTest.ExcessiveCallToVoidFunction
|
||||||
|
[ FAILED ] GMockOutputTest.RetiredExpectation
|
||||||
|
[ FAILED ] GMockOutputTest.UnsatisfiedPrerequisite
|
||||||
|
[ FAILED ] GMockOutputTest.UnsatisfiedPrerequisites
|
||||||
|
[ FAILED ] GMockOutputTest.UnsatisfiedWith
|
||||||
|
[ FAILED ] GMockOutputTest.UnsatisfiedExpectation
|
||||||
|
[ FAILED ] GMockOutputTest.MismatchArguments
|
||||||
|
[ FAILED ] GMockOutputTest.MismatchWith
|
||||||
|
[ FAILED ] GMockOutputTest.MismatchArgumentsAndWith
|
||||||
|
[ FAILED ] GMockOutputTest.UnexpectedCallWithDefaultAction
|
||||||
|
[ FAILED ] GMockOutputTest.ExcessiveCallWithDefaultAction
|
||||||
|
|
||||||
|
|
||||||
|
FILE:#: ERROR: this mock object should be deleted but never is. Its address is @0x#.
|
||||||
|
FILE:#: ERROR: this mock object should be deleted but never is. Its address is @0x#.
|
||||||
|
FILE:#: ERROR: this mock object should be deleted but never is. Its address is @0x#.
|
||||||
|
ERROR: 3 leaked mock objects found at program exit.
|
|
@ -0,0 +1,255 @@
|
||||||
|
// 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)
|
||||||
|
|
||||||
|
// Google Mock - a framework for writing C++ mock classes.
|
||||||
|
//
|
||||||
|
// This file tests code in gmock.cc.
|
||||||
|
|
||||||
|
#include "gmock/gmock.h"
|
||||||
|
|
||||||
|
#include <string>
|
||||||
|
#include "gtest/gtest.h"
|
||||||
|
|
||||||
|
using testing::GMOCK_FLAG(verbose);
|
||||||
|
using testing::InitGoogleMock;
|
||||||
|
using testing::internal::g_init_gtest_count;
|
||||||
|
|
||||||
|
// Verifies that calling InitGoogleMock() on argv results in new_argv,
|
||||||
|
// and the gmock_verbose flag's value is set to expected_gmock_verbose.
|
||||||
|
template <typename Char, int M, int N>
|
||||||
|
void TestInitGoogleMock(const Char* (&argv)[M], const Char* (&new_argv)[N],
|
||||||
|
const ::std::string& expected_gmock_verbose) {
|
||||||
|
const ::std::string old_verbose = GMOCK_FLAG(verbose);
|
||||||
|
|
||||||
|
int argc = M;
|
||||||
|
InitGoogleMock(&argc, const_cast<Char**>(argv));
|
||||||
|
ASSERT_EQ(N, argc) << "The new argv has wrong number of elements.";
|
||||||
|
|
||||||
|
for (int i = 0; i < N; i++) {
|
||||||
|
EXPECT_STREQ(new_argv[i], argv[i]);
|
||||||
|
}
|
||||||
|
|
||||||
|
EXPECT_EQ(expected_gmock_verbose, GMOCK_FLAG(verbose).c_str());
|
||||||
|
GMOCK_FLAG(verbose) = old_verbose; // Restores the gmock_verbose flag.
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(InitGoogleMockTest, ParsesInvalidCommandLine) {
|
||||||
|
const char* argv[] = {
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
const char* new_argv[] = {
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(InitGoogleMockTest, ParsesEmptyCommandLine) {
|
||||||
|
const char* argv[] = {
|
||||||
|
"foo.exe",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
const char* new_argv[] = {
|
||||||
|
"foo.exe",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(InitGoogleMockTest, ParsesSingleFlag) {
|
||||||
|
const char* argv[] = {
|
||||||
|
"foo.exe",
|
||||||
|
"--gmock_verbose=info",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
const char* new_argv[] = {
|
||||||
|
"foo.exe",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
TestInitGoogleMock(argv, new_argv, "info");
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(InitGoogleMockTest, ParsesUnrecognizedFlag) {
|
||||||
|
const char* argv[] = {
|
||||||
|
"foo.exe",
|
||||||
|
"--non_gmock_flag=blah",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
const char* new_argv[] = {
|
||||||
|
"foo.exe",
|
||||||
|
"--non_gmock_flag=blah",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(InitGoogleMockTest, ParsesGoogleMockFlagAndUnrecognizedFlag) {
|
||||||
|
const char* argv[] = {
|
||||||
|
"foo.exe",
|
||||||
|
"--non_gmock_flag=blah",
|
||||||
|
"--gmock_verbose=error",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
const char* new_argv[] = {
|
||||||
|
"foo.exe",
|
||||||
|
"--non_gmock_flag=blah",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
TestInitGoogleMock(argv, new_argv, "error");
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(InitGoogleMockTest, CallsInitGoogleTest) {
|
||||||
|
const int old_init_gtest_count = g_init_gtest_count;
|
||||||
|
const char* argv[] = {
|
||||||
|
"foo.exe",
|
||||||
|
"--non_gmock_flag=blah",
|
||||||
|
"--gmock_verbose=error",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
const char* new_argv[] = {
|
||||||
|
"foo.exe",
|
||||||
|
"--non_gmock_flag=blah",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
TestInitGoogleMock(argv, new_argv, "error");
|
||||||
|
EXPECT_EQ(old_init_gtest_count + 1, g_init_gtest_count);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(WideInitGoogleMockTest, ParsesInvalidCommandLine) {
|
||||||
|
const wchar_t* argv[] = {
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
const wchar_t* new_argv[] = {
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(WideInitGoogleMockTest, ParsesEmptyCommandLine) {
|
||||||
|
const wchar_t* argv[] = {
|
||||||
|
L"foo.exe",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
const wchar_t* new_argv[] = {
|
||||||
|
L"foo.exe",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(WideInitGoogleMockTest, ParsesSingleFlag) {
|
||||||
|
const wchar_t* argv[] = {
|
||||||
|
L"foo.exe",
|
||||||
|
L"--gmock_verbose=info",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
const wchar_t* new_argv[] = {
|
||||||
|
L"foo.exe",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
TestInitGoogleMock(argv, new_argv, "info");
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(WideInitGoogleMockTest, ParsesUnrecognizedFlag) {
|
||||||
|
const wchar_t* argv[] = {
|
||||||
|
L"foo.exe",
|
||||||
|
L"--non_gmock_flag=blah",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
const wchar_t* new_argv[] = {
|
||||||
|
L"foo.exe",
|
||||||
|
L"--non_gmock_flag=blah",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(WideInitGoogleMockTest, ParsesGoogleMockFlagAndUnrecognizedFlag) {
|
||||||
|
const wchar_t* argv[] = {
|
||||||
|
L"foo.exe",
|
||||||
|
L"--non_gmock_flag=blah",
|
||||||
|
L"--gmock_verbose=error",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
const wchar_t* new_argv[] = {
|
||||||
|
L"foo.exe",
|
||||||
|
L"--non_gmock_flag=blah",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
TestInitGoogleMock(argv, new_argv, "error");
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(WideInitGoogleMockTest, CallsInitGoogleTest) {
|
||||||
|
const int old_init_gtest_count = g_init_gtest_count;
|
||||||
|
const wchar_t* argv[] = {
|
||||||
|
L"foo.exe",
|
||||||
|
L"--non_gmock_flag=blah",
|
||||||
|
L"--gmock_verbose=error",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
const wchar_t* new_argv[] = {
|
||||||
|
L"foo.exe",
|
||||||
|
L"--non_gmock_flag=blah",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
TestInitGoogleMock(argv, new_argv, "error");
|
||||||
|
EXPECT_EQ(old_init_gtest_count + 1, g_init_gtest_count);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Makes sure Google Mock flags can be accessed in code.
|
||||||
|
TEST(FlagTest, IsAccessibleInCode) {
|
||||||
|
bool dummy = testing::GMOCK_FLAG(catch_leaked_mocks) &&
|
||||||
|
testing::GMOCK_FLAG(verbose) == "";
|
||||||
|
(void)dummy; // Avoids the "unused local variable" warning.
|
||||||
|
}
|
|
@ -0,0 +1,111 @@
|
||||||
|
#!/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++ Mocking Framework."""
|
||||||
|
|
||||||
|
__author__ = 'wan@google.com (Zhanyong Wan)'
|
||||||
|
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
|
||||||
|
|
||||||
|
# Determines path to gtest_test_utils and imports it.
|
||||||
|
SCRIPT_DIR = os.path.dirname(__file__) or '.'
|
||||||
|
|
||||||
|
# isdir resolves symbolic links.
|
||||||
|
gtest_tests_util_dir = os.path.join(SCRIPT_DIR, '../gtest/test')
|
||||||
|
if os.path.isdir(gtest_tests_util_dir):
|
||||||
|
GTEST_TESTS_UTIL_DIR = gtest_tests_util_dir
|
||||||
|
else:
|
||||||
|
GTEST_TESTS_UTIL_DIR = os.path.join(SCRIPT_DIR, '../../gtest/test')
|
||||||
|
|
||||||
|
sys.path.append(GTEST_TESTS_UTIL_DIR)
|
||||||
|
import gtest_test_utils # pylint: disable-msg=C6204
|
||||||
|
|
||||||
|
|
||||||
|
def GetSourceDir():
|
||||||
|
"""Returns the absolute path of the directory where the .py files are."""
|
||||||
|
|
||||||
|
return gtest_test_utils.GetSourceDir()
|
||||||
|
|
||||||
|
|
||||||
|
def GetTestExecutablePath(executable_name):
|
||||||
|
"""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.
|
||||||
|
|
||||||
|
Returns:
|
||||||
|
The absolute path of the test binary.
|
||||||
|
"""
|
||||||
|
|
||||||
|
return gtest_test_utils.GetTestExecutablePath(executable_name)
|
||||||
|
|
||||||
|
|
||||||
|
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
|
||||||
|
|
||||||
|
|
||||||
|
# Suppresses the "Invalid const name" lint complaint
|
||||||
|
# pylint: disable-msg=C6409
|
||||||
|
|
||||||
|
# Exposes Subprocess from gtest_test_utils.
|
||||||
|
Subprocess = gtest_test_utils.Subprocess
|
||||||
|
|
||||||
|
# Exposes TestCase from gtest_test_utils.
|
||||||
|
TestCase = gtest_test_utils.TestCase
|
||||||
|
|
||||||
|
# pylint: enable-msg=C6409
|
||||||
|
|
||||||
|
|
||||||
|
def Main():
|
||||||
|
"""Runs the unit test."""
|
||||||
|
|
||||||
|
gtest_test_utils.Main()
|
Binary file not shown.
|
@ -0,0 +1,130 @@
|
||||||
|
Changes for 1.6.0:
|
||||||
|
|
||||||
|
* New feature: ADD_FAILURE_AT() for reporting a test failure at the
|
||||||
|
given source location -- useful for writing testing utilities.
|
||||||
|
* New feature: the universal value printer is moved from Google Mock
|
||||||
|
to Google Test.
|
||||||
|
* New feature: type parameters and value parameters are reported in
|
||||||
|
the XML report now.
|
||||||
|
* A gtest_disable_pthreads CMake option.
|
||||||
|
* Colored output works in GNU Screen sessions now.
|
||||||
|
* Parameters of value-parameterized tests are now printed in the
|
||||||
|
textual output.
|
||||||
|
* Failures from ad hoc test assertions run before RUN_ALL_TESTS() are
|
||||||
|
now correctly reported.
|
||||||
|
* Arguments of ASSERT_XY and EXPECT_XY no longer need to support << to
|
||||||
|
ostream.
|
||||||
|
* More complete handling of exceptions.
|
||||||
|
* GTEST_ASSERT_XY can be used instead of ASSERT_XY in case the latter
|
||||||
|
name is already used by another library.
|
||||||
|
* --gtest_catch_exceptions is now true by default, allowing a test
|
||||||
|
program to continue after an exception is thrown.
|
||||||
|
* Value-parameterized test fixtures can now derive from Test and
|
||||||
|
WithParamInterface<T> separately, easing conversion of legacy tests.
|
||||||
|
* Death test messages are clearly marked to make them more
|
||||||
|
distinguishable from other messages.
|
||||||
|
* Compatibility fixes for Android, Google Native Client, MinGW, HP UX,
|
||||||
|
PowerPC, Lucid autotools, libCStd, Sun C++, Borland C++ Builder (Code Gear),
|
||||||
|
IBM XL C++ (Visual Age C++), and C++0x.
|
||||||
|
* Bug fixes and implementation clean-ups.
|
||||||
|
* Potentially incompatible changes: disables the harmful 'make install'
|
||||||
|
command in autotools.
|
||||||
|
|
||||||
|
Changes for 1.5.0:
|
||||||
|
|
||||||
|
* New feature: assertions can be safely called in multiple threads
|
||||||
|
where the pthreads library is available.
|
||||||
|
* New feature: predicates used inside EXPECT_TRUE() and friends
|
||||||
|
can now generate custom failure messages.
|
||||||
|
* New feature: Google Test can now be compiled as a DLL.
|
||||||
|
* New feature: fused source files are included.
|
||||||
|
* New feature: prints help when encountering unrecognized Google Test flags.
|
||||||
|
* Experimental feature: CMake build script (requires CMake 2.6.4+).
|
||||||
|
* Experimental feature: the Pump script for meta programming.
|
||||||
|
* double values streamed to an assertion are printed with enough precision
|
||||||
|
to differentiate any two different values.
|
||||||
|
* Google Test now works on Solaris and AIX.
|
||||||
|
* Build and test script improvements.
|
||||||
|
* Bug fixes and implementation clean-ups.
|
||||||
|
|
||||||
|
Potentially breaking changes:
|
||||||
|
|
||||||
|
* Stopped supporting VC++ 7.1 with exceptions disabled.
|
||||||
|
* Dropped support for 'make install'.
|
||||||
|
|
||||||
|
Changes for 1.4.0:
|
||||||
|
|
||||||
|
* New feature: the event listener API
|
||||||
|
* New feature: test shuffling
|
||||||
|
* New feature: the XML report format is closer to junitreport and can
|
||||||
|
be parsed by Hudson now.
|
||||||
|
* New feature: when a test runs under Visual Studio, its failures are
|
||||||
|
integrated in the IDE.
|
||||||
|
* New feature: /MD(d) versions of VC++ projects.
|
||||||
|
* New feature: elapsed time for the tests is printed by default.
|
||||||
|
* New feature: comes with a TR1 tuple implementation such that Boost
|
||||||
|
is no longer needed for Combine().
|
||||||
|
* New feature: EXPECT_DEATH_IF_SUPPORTED macro and friends.
|
||||||
|
* New feature: the Xcode project can now produce static gtest
|
||||||
|
libraries in addition to a framework.
|
||||||
|
* Compatibility fixes for Solaris, Cygwin, minGW, Windows Mobile,
|
||||||
|
Symbian, gcc, and C++Builder.
|
||||||
|
* Bug fixes and implementation clean-ups.
|
||||||
|
|
||||||
|
Changes for 1.3.0:
|
||||||
|
|
||||||
|
* New feature: death tests on Windows, Cygwin, and Mac.
|
||||||
|
* New feature: ability to use Google Test assertions in other testing
|
||||||
|
frameworks.
|
||||||
|
* New feature: ability to run disabled test via
|
||||||
|
--gtest_also_run_disabled_tests.
|
||||||
|
* New feature: the --help flag for printing the usage.
|
||||||
|
* New feature: access to Google Test flag values in user code.
|
||||||
|
* New feature: a script that packs Google Test into one .h and one
|
||||||
|
.cc file for easy deployment.
|
||||||
|
* New feature: support for distributing test functions to multiple
|
||||||
|
machines (requires support from the test runner).
|
||||||
|
* Bug fixes and implementation clean-ups.
|
||||||
|
|
||||||
|
Changes for 1.2.1:
|
||||||
|
|
||||||
|
* Compatibility fixes for Linux IA-64 and IBM z/OS.
|
||||||
|
* Added support for using Boost and other TR1 implementations.
|
||||||
|
* Changes to the build scripts to support upcoming release of Google C++
|
||||||
|
Mocking Framework.
|
||||||
|
* Added Makefile to the distribution package.
|
||||||
|
* Improved build instructions in README.
|
||||||
|
|
||||||
|
Changes for 1.2.0:
|
||||||
|
|
||||||
|
* New feature: value-parameterized tests.
|
||||||
|
* New feature: the ASSERT/EXPECT_(NON)FATAL_FAILURE(_ON_ALL_THREADS)
|
||||||
|
macros.
|
||||||
|
* Changed the XML report format to match JUnit/Ant's.
|
||||||
|
* Added tests to the Xcode project.
|
||||||
|
* Added scons/SConscript for building with SCons.
|
||||||
|
* Added src/gtest-all.cc for building Google Test from a single file.
|
||||||
|
* Fixed compatibility with Solaris and z/OS.
|
||||||
|
* Enabled running Python tests on systems with python 2.3 installed,
|
||||||
|
e.g. Mac OS X 10.4.
|
||||||
|
* Bug fixes.
|
||||||
|
|
||||||
|
Changes for 1.1.0:
|
||||||
|
|
||||||
|
* New feature: type-parameterized tests.
|
||||||
|
* New feature: exception assertions.
|
||||||
|
* New feature: printing elapsed time of tests.
|
||||||
|
* Improved the robustness of death tests.
|
||||||
|
* Added an Xcode project and samples.
|
||||||
|
* Adjusted the output format on Windows to be understandable by Visual Studio.
|
||||||
|
* Minor bug fixes.
|
||||||
|
|
||||||
|
Changes for 1.0.1:
|
||||||
|
|
||||||
|
* Added project files for Visual Studio 7.1.
|
||||||
|
* Fixed issues with compiling on Mac OS X.
|
||||||
|
* Fixed issues with compiling on Cygwin.
|
||||||
|
|
||||||
|
Changes for 1.0.0:
|
||||||
|
|
||||||
|
* Initial Open Source release of Google Test
|
|
@ -0,0 +1,240 @@
|
||||||
|
########################################################################
|
||||||
|
# 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()
|
||||||
|
|
||||||
|
############################################################
|
||||||
|
# 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()
|
|
@ -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>
|
|
@ -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.
|
|
@ -0,0 +1,302 @@
|
||||||
|
# Automake file
|
||||||
|
|
||||||
|
ACLOCAL_AMFLAGS = -I m4
|
||||||
|
|
||||||
|
# Nonstandard package files for distribution
|
||||||
|
EXTRA_DIST = \
|
||||||
|
CHANGES \
|
||||||
|
CONTRIBUTORS \
|
||||||
|
include/gtest/gtest-param-test.h.pump \
|
||||||
|
include/gtest/internal/gtest-param-util-generated.h.pump \
|
||||||
|
include/gtest/internal/gtest-tuple.h.pump \
|
||||||
|
include/gtest/internal/gtest-type-util.h.pump \
|
||||||
|
make/Makefile \
|
||||||
|
scripts/fuse_gtest_files.py \
|
||||||
|
scripts/gen_gtest_pred_impl.py \
|
||||||
|
scripts/pump.py \
|
||||||
|
scripts/test/Makefile
|
||||||
|
|
||||||
|
# gtest source files that we don't compile directly. They are
|
||||||
|
# #included by gtest-all.cc.
|
||||||
|
GTEST_SRC = \
|
||||||
|
src/gtest-death-test.cc \
|
||||||
|
src/gtest-filepath.cc \
|
||||||
|
src/gtest-internal-inl.h \
|
||||||
|
src/gtest-port.cc \
|
||||||
|
src/gtest-printers.cc \
|
||||||
|
src/gtest-test-part.cc \
|
||||||
|
src/gtest-typed-test.cc \
|
||||||
|
src/gtest.cc
|
||||||
|
|
||||||
|
EXTRA_DIST += $(GTEST_SRC)
|
||||||
|
|
||||||
|
# Sample files that we don't compile.
|
||||||
|
EXTRA_DIST += \
|
||||||
|
samples/prime_tables.h \
|
||||||
|
samples/sample2_unittest.cc \
|
||||||
|
samples/sample3_unittest.cc \
|
||||||
|
samples/sample4_unittest.cc \
|
||||||
|
samples/sample5_unittest.cc \
|
||||||
|
samples/sample6_unittest.cc \
|
||||||
|
samples/sample7_unittest.cc \
|
||||||
|
samples/sample8_unittest.cc \
|
||||||
|
samples/sample9_unittest.cc
|
||||||
|
|
||||||
|
# C++ test files that we don't compile directly.
|
||||||
|
EXTRA_DIST += \
|
||||||
|
test/gtest-death-test_ex_test.cc \
|
||||||
|
test/gtest-death-test_test.cc \
|
||||||
|
test/gtest-filepath_test.cc \
|
||||||
|
test/gtest-linked_ptr_test.cc \
|
||||||
|
test/gtest-listener_test.cc \
|
||||||
|
test/gtest-message_test.cc \
|
||||||
|
test/gtest-options_test.cc \
|
||||||
|
test/gtest-param-test2_test.cc \
|
||||||
|
test/gtest-param-test2_test.cc \
|
||||||
|
test/gtest-param-test_test.cc \
|
||||||
|
test/gtest-param-test_test.cc \
|
||||||
|
test/gtest-param-test_test.h \
|
||||||
|
test/gtest-port_test.cc \
|
||||||
|
test/gtest-printers_test.cc \
|
||||||
|
test/gtest-test-part_test.cc \
|
||||||
|
test/gtest-tuple_test.cc \
|
||||||
|
test/gtest-typed-test2_test.cc \
|
||||||
|
test/gtest-typed-test_test.cc \
|
||||||
|
test/gtest-typed-test_test.h \
|
||||||
|
test/gtest-unittest-api_test.cc \
|
||||||
|
test/gtest_break_on_failure_unittest_.cc \
|
||||||
|
test/gtest_catch_exceptions_test_.cc \
|
||||||
|
test/gtest_color_test_.cc \
|
||||||
|
test/gtest_env_var_test_.cc \
|
||||||
|
test/gtest_environment_test.cc \
|
||||||
|
test/gtest_filter_unittest_.cc \
|
||||||
|
test/gtest_help_test_.cc \
|
||||||
|
test/gtest_list_tests_unittest_.cc \
|
||||||
|
test/gtest_main_unittest.cc \
|
||||||
|
test/gtest_no_test_unittest.cc \
|
||||||
|
test/gtest_output_test_.cc \
|
||||||
|
test/gtest_pred_impl_unittest.cc \
|
||||||
|
test/gtest_prod_test.cc \
|
||||||
|
test/gtest_repeat_test.cc \
|
||||||
|
test/gtest_shuffle_test_.cc \
|
||||||
|
test/gtest_sole_header_test.cc \
|
||||||
|
test/gtest_stress_test.cc \
|
||||||
|
test/gtest_throw_on_failure_ex_test.cc \
|
||||||
|
test/gtest_throw_on_failure_test_.cc \
|
||||||
|
test/gtest_uninitialized_test_.cc \
|
||||||
|
test/gtest_unittest.cc \
|
||||||
|
test/gtest_unittest.cc \
|
||||||
|
test/gtest_xml_outfile1_test_.cc \
|
||||||
|
test/gtest_xml_outfile2_test_.cc \
|
||||||
|
test/gtest_xml_output_unittest_.cc \
|
||||||
|
test/production.cc \
|
||||||
|
test/production.h
|
||||||
|
|
||||||
|
# Python tests that we don't run.
|
||||||
|
EXTRA_DIST += \
|
||||||
|
test/gtest_break_on_failure_unittest.py \
|
||||||
|
test/gtest_catch_exceptions_test.py \
|
||||||
|
test/gtest_color_test.py \
|
||||||
|
test/gtest_env_var_test.py \
|
||||||
|
test/gtest_filter_unittest.py \
|
||||||
|
test/gtest_help_test.py \
|
||||||
|
test/gtest_list_tests_unittest.py \
|
||||||
|
test/gtest_output_test.py \
|
||||||
|
test/gtest_output_test_golden_lin.txt \
|
||||||
|
test/gtest_shuffle_test.py \
|
||||||
|
test/gtest_test_utils.py \
|
||||||
|
test/gtest_throw_on_failure_test.py \
|
||||||
|
test/gtest_uninitialized_test.py \
|
||||||
|
test/gtest_xml_outfiles_test.py \
|
||||||
|
test/gtest_xml_output_unittest.py \
|
||||||
|
test/gtest_xml_test_utils.py
|
||||||
|
|
||||||
|
# CMake script
|
||||||
|
EXTRA_DIST += \
|
||||||
|
CMakeLists.txt \
|
||||||
|
cmake/internal_utils.cmake
|
||||||
|
|
||||||
|
# MSVC project files
|
||||||
|
EXTRA_DIST += \
|
||||||
|
msvc/gtest-md.sln \
|
||||||
|
msvc/gtest-md.vcproj \
|
||||||
|
msvc/gtest.sln \
|
||||||
|
msvc/gtest.vcproj \
|
||||||
|
msvc/gtest_main-md.vcproj \
|
||||||
|
msvc/gtest_main.vcproj \
|
||||||
|
msvc/gtest_prod_test-md.vcproj \
|
||||||
|
msvc/gtest_prod_test.vcproj \
|
||||||
|
msvc/gtest_unittest-md.vcproj \
|
||||||
|
msvc/gtest_unittest.vcproj
|
||||||
|
|
||||||
|
# xcode project files
|
||||||
|
EXTRA_DIST += \
|
||||||
|
xcode/Config/DebugProject.xcconfig \
|
||||||
|
xcode/Config/FrameworkTarget.xcconfig \
|
||||||
|
xcode/Config/General.xcconfig \
|
||||||
|
xcode/Config/ReleaseProject.xcconfig \
|
||||||
|
xcode/Config/StaticLibraryTarget.xcconfig \
|
||||||
|
xcode/Config/TestTarget.xcconfig \
|
||||||
|
xcode/Resources/Info.plist \
|
||||||
|
xcode/Scripts/runtests.sh \
|
||||||
|
xcode/Scripts/versiongenerate.py \
|
||||||
|
xcode/gtest.xcodeproj/project.pbxproj
|
||||||
|
|
||||||
|
# xcode sample files
|
||||||
|
EXTRA_DIST += \
|
||||||
|
xcode/Samples/FrameworkSample/Info.plist \
|
||||||
|
xcode/Samples/FrameworkSample/WidgetFramework.xcodeproj/project.pbxproj \
|
||||||
|
xcode/Samples/FrameworkSample/runtests.sh \
|
||||||
|
xcode/Samples/FrameworkSample/widget.cc \
|
||||||
|
xcode/Samples/FrameworkSample/widget.h \
|
||||||
|
xcode/Samples/FrameworkSample/widget_test.cc
|
||||||
|
|
||||||
|
# C++Builder project files
|
||||||
|
EXTRA_DIST += \
|
||||||
|
codegear/gtest.cbproj \
|
||||||
|
codegear/gtest.groupproj \
|
||||||
|
codegear/gtest_all.cc \
|
||||||
|
codegear/gtest_link.cc \
|
||||||
|
codegear/gtest_main.cbproj \
|
||||||
|
codegear/gtest_unittest.cbproj
|
||||||
|
|
||||||
|
# Distribute and install M4 macro
|
||||||
|
m4datadir = $(datadir)/aclocal
|
||||||
|
m4data_DATA = m4/gtest.m4
|
||||||
|
EXTRA_DIST += $(m4data_DATA)
|
||||||
|
|
||||||
|
# We define the global AM_CPPFLAGS as everything we compile includes from these
|
||||||
|
# directories.
|
||||||
|
AM_CPPFLAGS = -I$(srcdir) -I$(srcdir)/include
|
||||||
|
|
||||||
|
# Modifies compiler and linker flags for pthreads compatibility.
|
||||||
|
if HAVE_PTHREADS
|
||||||
|
AM_CXXFLAGS = @PTHREAD_CFLAGS@ -DGTEST_HAS_PTHREAD=1
|
||||||
|
AM_LIBS = @PTHREAD_LIBS@
|
||||||
|
else
|
||||||
|
AM_CXXFLAGS = -DGTEST_HAS_PTHREAD=0
|
||||||
|
endif
|
||||||
|
|
||||||
|
# Build rules for libraries.
|
||||||
|
lib_LTLIBRARIES = lib/libgtest.la lib/libgtest_main.la
|
||||||
|
|
||||||
|
lib_libgtest_la_SOURCES = src/gtest-all.cc
|
||||||
|
|
||||||
|
pkginclude_HEADERS = \
|
||||||
|
include/gtest/gtest-death-test.h \
|
||||||
|
include/gtest/gtest-message.h \
|
||||||
|
include/gtest/gtest-param-test.h \
|
||||||
|
include/gtest/gtest-printers.h \
|
||||||
|
include/gtest/gtest-spi.h \
|
||||||
|
include/gtest/gtest-test-part.h \
|
||||||
|
include/gtest/gtest-typed-test.h \
|
||||||
|
include/gtest/gtest.h \
|
||||||
|
include/gtest/gtest_pred_impl.h \
|
||||||
|
include/gtest/gtest_prod.h
|
||||||
|
|
||||||
|
pkginclude_internaldir = $(pkgincludedir)/internal
|
||||||
|
pkginclude_internal_HEADERS = \
|
||||||
|
include/gtest/internal/gtest-death-test-internal.h \
|
||||||
|
include/gtest/internal/gtest-filepath.h \
|
||||||
|
include/gtest/internal/gtest-internal.h \
|
||||||
|
include/gtest/internal/gtest-linked_ptr.h \
|
||||||
|
include/gtest/internal/gtest-param-util-generated.h \
|
||||||
|
include/gtest/internal/gtest-param-util.h \
|
||||||
|
include/gtest/internal/gtest-port.h \
|
||||||
|
include/gtest/internal/gtest-string.h \
|
||||||
|
include/gtest/internal/gtest-tuple.h \
|
||||||
|
include/gtest/internal/gtest-type-util.h
|
||||||
|
|
||||||
|
lib_libgtest_main_la_SOURCES = src/gtest_main.cc
|
||||||
|
lib_libgtest_main_la_LIBADD = lib/libgtest.la
|
||||||
|
|
||||||
|
# Bulid rules for samples and tests. Automake's naming for some of
|
||||||
|
# these variables isn't terribly obvious, so this is a brief
|
||||||
|
# reference:
|
||||||
|
#
|
||||||
|
# TESTS -- Programs run automatically by "make check"
|
||||||
|
# check_PROGRAMS -- Programs built by "make check" but not necessarily run
|
||||||
|
|
||||||
|
noinst_LTLIBRARIES = samples/libsamples.la
|
||||||
|
|
||||||
|
samples_libsamples_la_SOURCES = \
|
||||||
|
samples/sample1.cc \
|
||||||
|
samples/sample1.h \
|
||||||
|
samples/sample2.cc \
|
||||||
|
samples/sample2.h \
|
||||||
|
samples/sample3-inl.h \
|
||||||
|
samples/sample4.cc \
|
||||||
|
samples/sample4.h
|
||||||
|
|
||||||
|
TESTS=
|
||||||
|
TESTS_ENVIRONMENT = GTEST_SOURCE_DIR="$(srcdir)/test" \
|
||||||
|
GTEST_BUILD_DIR="$(top_builddir)/test"
|
||||||
|
check_PROGRAMS=
|
||||||
|
|
||||||
|
# A simple sample on using gtest.
|
||||||
|
TESTS += samples/sample1_unittest
|
||||||
|
check_PROGRAMS += samples/sample1_unittest
|
||||||
|
samples_sample1_unittest_SOURCES = samples/sample1_unittest.cc
|
||||||
|
samples_sample1_unittest_LDADD = lib/libgtest_main.la \
|
||||||
|
lib/libgtest.la \
|
||||||
|
samples/libsamples.la
|
||||||
|
|
||||||
|
# Another sample. It also verifies that libgtest works.
|
||||||
|
TESTS += samples/sample10_unittest
|
||||||
|
check_PROGRAMS += samples/sample10_unittest
|
||||||
|
samples_sample10_unittest_SOURCES = samples/sample10_unittest.cc
|
||||||
|
samples_sample10_unittest_LDADD = lib/libgtest.la
|
||||||
|
|
||||||
|
# This tests most constructs of gtest and verifies that libgtest_main
|
||||||
|
# and libgtest work.
|
||||||
|
TESTS += test/gtest_all_test
|
||||||
|
check_PROGRAMS += test/gtest_all_test
|
||||||
|
test_gtest_all_test_SOURCES = test/gtest_all_test.cc
|
||||||
|
test_gtest_all_test_LDADD = lib/libgtest_main.la \
|
||||||
|
lib/libgtest.la
|
||||||
|
|
||||||
|
# Tests that fused gtest files compile and work.
|
||||||
|
FUSED_GTEST_SRC = \
|
||||||
|
fused-src/gtest/gtest-all.cc \
|
||||||
|
fused-src/gtest/gtest.h \
|
||||||
|
fused-src/gtest/gtest_main.cc
|
||||||
|
|
||||||
|
TESTS += test/fused_gtest_test
|
||||||
|
check_PROGRAMS += test/fused_gtest_test
|
||||||
|
test_fused_gtest_test_SOURCES = $(FUSED_GTEST_SRC) \
|
||||||
|
samples/sample1.cc samples/sample1_unittest.cc
|
||||||
|
test_fused_gtest_test_CPPFLAGS = -I"$(srcdir)/fused-src"
|
||||||
|
|
||||||
|
# Build rules for putting fused Google Test files into the distribution
|
||||||
|
# package. The user can also create those files by manually running
|
||||||
|
# scripts/fuse_gtest_files.py.
|
||||||
|
$(test_fused_gtest_test_SOURCES): fused-gtest
|
||||||
|
|
||||||
|
fused-gtest: $(pkginclude_HEADERS) $(pkginclude_internal_HEADERS) \
|
||||||
|
$(GTEST_SRC) src/gtest-all.cc src/gtest_main.cc \
|
||||||
|
scripts/fuse_gtest_files.py
|
||||||
|
mkdir -p "$(srcdir)/fused-src"
|
||||||
|
chmod -R u+w "$(srcdir)/fused-src"
|
||||||
|
rm -f "$(srcdir)/fused-src/gtest/gtest-all.cc"
|
||||||
|
rm -f "$(srcdir)/fused-src/gtest/gtest.h"
|
||||||
|
"$(srcdir)/scripts/fuse_gtest_files.py" "$(srcdir)/fused-src"
|
||||||
|
cp -f "$(srcdir)/src/gtest_main.cc" "$(srcdir)/fused-src/gtest/"
|
||||||
|
|
||||||
|
maintainer-clean-local:
|
||||||
|
rm -rf "$(srcdir)/fused-src"
|
||||||
|
|
||||||
|
# Death tests may produce core dumps in the build directory. In case
|
||||||
|
# this happens, clean them to keep distcleancheck happy.
|
||||||
|
CLEANFILES = core
|
||||||
|
|
||||||
|
# Disables 'make install' as installing a compiled version of Google
|
||||||
|
# Test can lead to undefined behavior due to violation of the
|
||||||
|
# One-Definition Rule.
|
||||||
|
|
||||||
|
install-exec-local:
|
||||||
|
echo "'make install' is dangerous and not supported. Instead, see README for how to integrate Google Test into your build system."
|
||||||
|
false
|
||||||
|
|
||||||
|
install-data-local:
|
||||||
|
echo "'make install' is dangerous and not supported. Instead, see README for how to integrate Google Test into your build system."
|
||||||
|
false
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue