diff -Nru mozc-2.17.2116.102+gitfd0f5b34+dfsg/debian/changelog mozc-2.17.2116.102+gitfd0f5b34+dfsg/debian/changelog --- mozc-2.17.2116.102+gitfd0f5b34+dfsg/debian/changelog 2015-09-23 05:38:21.000000000 +0900 +++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/debian/changelog 2016-02-20 18:54:15.000000000 +0900 @@ -1,3 +1,13 @@ +mozc (2.17.2116.102+gitfd0f5b34+dfsg-1ubuntu1) xenial; urgency=medium + + * Merge with Debian (LP: #1547816), remaining changes: + - Drop uim support for main inclusion + - Do not generate shlibs for fcitx + - Run testcases. + * debian/patches/enable-test.patch: added for test. + + -- Ikuya Awashiro Sat, 20 Feb 2016 18:54:02 +0900 + mozc (2.17.2116.102+gitfd0f5b34+dfsg-1) unstable; urgency=medium * New upstream release. diff -Nru mozc-2.17.2116.102+gitfd0f5b34+dfsg/debian/control mozc-2.17.2116.102+gitfd0f5b34+dfsg/debian/control --- mozc-2.17.2116.102+gitfd0f5b34+dfsg/debian/control 2015-09-23 05:38:21.000000000 +0900 +++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/debian/control 2016-02-20 16:27:37.000000000 +0900 @@ -1,12 +1,13 @@ Source: mozc Section: utils Priority: optional -Maintainer: Nobuhiro Iwamatsu +Maintainer: Ubuntu Developers +XSBC-Original-Maintainer: Nobuhiro Iwamatsu Build-Depends: debhelper (>= 9), libibus-1.0-dev (>= 1.4.1) | libibus-dev (>= 1.4.1), pkg-config, libxcb-xfixes0-dev, libgtk2.0-dev, python-dev, gyp (>= 0.1~svn1729-2), protobuf-compiler, - libprotobuf-dev (>= 2.5.0-9), libqt4-dev, libuim-dev, + libprotobuf-dev (>= 2.5.0-9), libqt4-dev, libzinnia-dev, fcitx-libs-dev, gettext, desktop-file-utils, ninja-build Standards-Version: 3.9.6 @@ -43,25 +44,6 @@ . This open-source project originates from Google Japanese Input. -Package: uim-mozc -Architecture: i386 amd64 armel armhf -Depends: ${misc:Depends}, ${shlibs:Depends}, uim-utils (>= 1:1.8.1-2), - mozc-data, mozc-server (= ${binary:Version}) -Recommends: mozc-utils-gui (= ${binary:Version}) -Multi-Arch: same -Description: Mozc engine for uim - Client of the Mozc input method - uim is an input method module library supporting various languages, which - become a frontend for Anthy, SKK, Canna, T-Code, TUT-Code, - Pinyin (Chinese input method), Hangul (Korean input method), - IPA (International Phonetic Alphabet), etc. - Most of the functions are implemented with Scheme, so it's very simple - and flexible. - . - Mozc is a Japanese Input Method Editor (IME) designed for multi-platform - such as Chromium OS, Windows, Mac and Linux. - . - uim-mozc provides client part of the Mozc input method. - Package: fcitx-mozc Architecture: i386 amd64 armel armhf Depends: ${misc:Depends}, ${shlibs:Depends}, fcitx-bin, fcitx-data, fcitx-modules, diff -Nru mozc-2.17.2116.102+gitfd0f5b34+dfsg/debian/patches/enable-test.patch mozc-2.17.2116.102+gitfd0f5b34+dfsg/debian/patches/enable-test.patch --- mozc-2.17.2116.102+gitfd0f5b34+dfsg/debian/patches/enable-test.patch 1970-01-01 09:00:00.000000000 +0900 +++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/debian/patches/enable-test.patch 2016-02-20 18:18:28.000000000 +0900 @@ -0,0 +1,137917 @@ +diff -urN mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/.git mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/.git +--- mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/.git 1970-01-01 09:00:00.000000000 +0900 ++++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/.git 2016-02-20 18:11:22.308832283 +0900 +@@ -0,0 +1 @@ ++gitdir: ../../../.git/modules/src/third_party/gmock +diff -urN mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/CHANGES mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/CHANGES +--- mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/CHANGES 1970-01-01 09:00:00.000000000 +0900 ++++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/CHANGES 2016-02-20 18:11:22.308832283 +0900 +@@ -0,0 +1,126 @@ ++Changes for 1.7.0: ++ ++* All new improvements in Google Test 1.7.0. ++* New feature: matchers DoubleNear(), FloatNear(), ++ NanSensitiveDoubleNear(), NanSensitiveFloatNear(), ++ UnorderedElementsAre(), UnorderedElementsAreArray(), WhenSorted(), ++ WhenSortedBy(), IsEmpty(), and SizeIs(). ++* Improvement: Google Mock can now be built as a DLL. ++* Improvement: when compiled by a C++11 compiler, matchers AllOf() ++ and AnyOf() can accept an arbitrary number of matchers. ++* Improvement: when compiled by a C++11 compiler, matchers ++ ElementsAreArray() can accept an initializer list. ++* Improvement: when exceptions are enabled, a mock method with no ++ default action now throws instead crashing the test. ++* Improvement: added class testing::StringMatchResultListener to aid ++ definition of composite matchers. ++* Improvement: function return types used in MOCK_METHOD*() macros can ++ now contain unprotected commas. ++* Improvement (potentially breaking): EXPECT_THAT() and ASSERT_THAT() ++ are now more strict in ensuring that the value type and the matcher ++ type are compatible, catching potential bugs in tests. ++* Improvement: Pointee() now works on an optional. ++* Improvement: the ElementsAreArray() matcher can now take a vector or ++ iterator range as input, and makes a copy of its input elements ++ before the conversion to a Matcher. ++* Improvement: the Google Mock Generator can now generate mocks for ++ some class templates. ++* Bug fix: mock object destruction triggerred by another mock object's ++ destruction no longer hangs. ++* Improvement: Google Mock Doctor works better with newer Clang and ++ GCC now. ++* Compatibility fixes. ++* Bug/warning fixes. ++ ++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(), ReturnNew(...), and ++ DeleteArg(). ++ * New feature: matchers Key(), Pair(), Args<...>(), AllArgs(), IsNull(), ++ and Contains(). ++ * New feature: utility class MockFunction, useful for checkpoints, etc. ++ * New feature: functions Value(x, m) and SafeMatcherCast(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 +diff -urN mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/CMakeLists.txt mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/CMakeLists.txt +--- mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/CMakeLists.txt 1970-01-01 09:00:00.000000000 +0900 ++++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/CMakeLists.txt 2016-02-20 18:11:22.312832283 +0900 +@@ -0,0 +1,186 @@ ++######################################################################## ++# 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) ++ ++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}") ++ ++# Summary of tuple support for Microsoft Visual Studio: ++# Compiler version(MS) version(cmake) Support ++# ---------- ----------- -------------- ----------------------------- ++# <= VS 2010 <= 10 <= 1600 Use Google Tests's own tuple. ++# VS 2012 11 1700 std::tr1::tuple + _VARIADIC_MAX=10 ++# VS 2013 12 1800 std::tr1::tuple ++if (MSVC AND MSVC_VERSION EQUAL 1700) ++ add_definitions(/D _VARIADIC_MAX=10) ++endif() ++ ++######################################################################## ++# ++# 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}" ++ "${gtest_dir}/src/gtest-all.cc" ++ src/gmock-all.cc) ++ ++cxx_library(gmock_main ++ "${cxx_strict}" ++ "${gtest_dir}/src/gtest-all.cc" ++ src/gmock-all.cc ++ src/gmock_main.cc) ++ ++######################################################################## ++# ++# 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_ex_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_test gmock_main) ++ ++ if (CMAKE_USE_PTHREADS_INIT) ++ cxx_test(gmock_stress_test gmock) ++ endif() ++ ++ # gmock_all_test is commented to save time building and running tests. ++ # Uncomment if necessary. ++ # cxx_test(gmock_all_test gmock_main) ++ ++ ############################################################ ++ # C++ tests built with non-standard compiler flags. ++ ++ 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) ++ ++ if (NOT MSVC OR MSVC_VERSION LESS 1600) # 1600 is Visual Studio 2010. ++ # Visual Studio 2010, 2012, and 2013 define symbols in std::tr1 that ++ # conflict with our own definitions. Therefore using our own tuple does not ++ # work on those compilers. ++ 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_use_own_tuple_test "${cxx_use_own_tuple}" ++ gmock_main_use_own_tuple test/gmock-spec-builders_test.cc) ++ endif() ++ ++ cxx_test_with_flags(gmock-more-actions_no_exception_test "${cxx_no_exception}" ++ gmock_main_no_exception test/gmock-more-actions_test.cc) ++ ++ cxx_test_with_flags(gmock_no_rtti_test "${cxx_no_rtti}" ++ gmock_main_no_rtti test/gmock-spec-builders_test.cc) ++ ++ cxx_shared_library(shared_gmock_main "${cxx_default}" ++ "${gtest_dir}/src/gtest-all.cc" src/gmock-all.cc src/gmock_main.cc) ++ ++ # Tests that a binary can be built with Google Mock as a shared library. On ++ # some system configurations, it may not possible to run the binary without ++ # knowing more details about the system configurations. We do not try to run ++ # this binary. To get a more robust shared library coverage, configure with ++ # -DBUILD_SHARED_LIBS=ON. ++ cxx_executable_with_flags(shared_gmock_test_ "${cxx_default}" ++ shared_gmock_main test/gmock-spec-builders_test.cc) ++ set_target_properties(shared_gmock_test_ ++ PROPERTIES ++ COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1") ++ ++ ############################################################ ++ # Python tests. ++ ++ cxx_executable(gmock_leak_test_ test gmock_main) ++ py_test(gmock_leak_test) ++ ++ cxx_executable(gmock_output_test_ test gmock) ++ py_test(gmock_output_test) ++endif() +diff -urN mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/CONTRIBUTORS mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/CONTRIBUTORS +--- mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/CONTRIBUTORS 1970-01-01 09:00:00.000000000 +0900 ++++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/CONTRIBUTORS 2016-02-20 18:11:22.308832283 +0900 +@@ -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 ++Bogdan Piloca ++Chandler Carruth ++Dave MacLachlan ++David Anderson ++Dean Sturtevant ++Gene Volovich ++Hal Burch ++Jeffrey Yasskin ++Jim Keller ++Joe Walnes ++Jon Wray ++Keir Mierle ++Keith Ray ++Kostya Serebryany ++Lev Makhlis ++Manuel Klimek ++Mario Tanev ++Mark Paskin ++Markus Heule ++Matthew Simmons ++Mike Bland ++Neal Norwitz ++Nermin Ozkiranartli ++Owen Carlsen ++Paneendra Ba ++Paul Menage ++Piotr Kaminski ++Russ Rufer ++Sverre Sundsdal ++Takeshi Yoshino ++Vadim Berman ++Vlad Losev ++Wolfgang Klier ++Zhanyong Wan +diff -urN mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/LICENSE mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/LICENSE +--- mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/LICENSE 1970-01-01 09:00:00.000000000 +0900 ++++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/LICENSE 2016-02-20 18:11:22.308832283 +0900 +@@ -0,0 +1,28 @@ ++Copyright 2008, Google Inc. ++All rights reserved. ++ ++Redistribution and use in source and binary forms, with or without ++modification, are permitted provided that the following conditions are ++met: ++ ++ * Redistributions of source code must retain the above copyright ++notice, this list of conditions and the following disclaimer. ++ * Redistributions in binary form must reproduce the above ++copyright notice, this list of conditions and the following disclaimer ++in the documentation and/or other materials provided with the ++distribution. ++ * Neither the name of Google Inc. nor the names of its ++contributors may be used to endorse or promote products derived from ++this software without specific prior written permission. ++ ++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +diff -urN mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/Makefile.am mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/Makefile.am +--- mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/Makefile.am 1970-01-01 09:00:00.000000000 +0900 ++++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/Makefile.am 2016-02-20 18:11:22.364832283 +0900 +@@ -0,0 +1,220 @@ ++# Automake file ++ ++# Nonstandard package files for distribution. ++EXTRA_DIST = LICENSE ++ ++# 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-more-matchers.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 ++ ++if HAVE_PYTHON ++ # 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" ++endif ++ ++# 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_all_test.cc \ ++ test/gmock-cardinalities_test.cc \ ++ test/gmock_ex_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_stress_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/LICENSE \ ++ 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 ++ ++# Script for diagnosing compiler errors in programs that use Google ++# Mock. ++EXTRA_DIST += scripts/gmock_doctor.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 ++ ++if HAVE_PYTHON ++# 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" ++endif ++ ++# 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 +diff -urN mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/README mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/README +--- mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/README 1970-01-01 09:00:00.000000000 +0900 ++++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/README 2016-02-20 18:11:22.336832283 +0900 +@@ -0,0 +1,369 @@ ++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 repository 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) repository. ++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 and ${GMOCK_DIR}/include ++ ++in the system header search path, and ++ ++ ${GTEST_DIR} and ${GMOCK_DIR} ++ ++in the normal header search path. Assuming a Linux-like system and gcc, ++something like the following will do: ++ ++ g++ -isystem ${GTEST_DIR}/include -I${GTEST_DIR} \ ++ -isystem ${GMOCK_DIR}/include -I${GMOCK_DIR} \ ++ -pthread -c ${GTEST_DIR}/src/gtest-all.cc ++ g++ -isystem ${GTEST_DIR}/include -I${GTEST_DIR} \ ++ -isystem ${GMOCK_DIR}/include -I${GMOCK_DIR} \ ++ -pthread -c ${GMOCK_DIR}/src/gmock-all.cc ++ ar -rv libgmock.a gtest-all.o gmock-all.o ++ ++(We need -pthread as Google Test and Google Mock use threads.) ++ ++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++ -isystem ${GTEST_DIR}/include -isystem ${GMOCK_DIR}/include \ ++ -pthread 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 /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. ++ ++### As a Shared Library (DLL) ### ++ ++Google Mock is compact, so most users can build and link it as a static ++library for the simplicity. Google Mock can be used as a DLL, but the ++same DLL must contain Google Test as well. See Google Test's README ++file for instructions on how to set up necessary compiler settings. ++ ++### Tweaking Google Mock ### ++ ++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! +diff -urN mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/configure.ac mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/configure.ac +--- mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/configure.ac 1970-01-01 09:00:00.000000000 +0900 ++++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/configure.ac 2016-02-20 18:11:22.368832283 +0900 +@@ -0,0 +1,146 @@ ++m4_include(gtest/m4/acx_pthread.m4) ++ ++AC_INIT([Google C++ Mocking Framework], ++ [1.7.0], ++ [googlemock@googlegroups.com], ++ [gmock]) ++ ++# Provide various options to initialize the Autoconf and configure processes. ++AC_PREREQ([2.59]) ++AC_CONFIG_SRCDIR([./LICENSE]) ++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.7.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 +diff -urN mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-actions.h mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-actions.h +--- mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-actions.h 1970-01-01 09:00:00.000000000 +0900 ++++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-actions.h 2016-02-20 18:11:22.316832283 +0900 +@@ -0,0 +1,1205 @@ ++// 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 actions. ++ ++#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ ++#define GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ ++ ++#ifndef _WIN32_WCE ++# include ++#endif ++ ++#include ++#include ++ ++#include "gmock/internal/gmock-internal-utils.h" ++#include "gmock/internal/gmock-port.h" ++ ++#if GTEST_LANG_CXX11 // Defined by gtest-port.h via gmock-port.h. ++#include ++#endif ++ ++namespace testing { ++ ++// To implement an action Foo, define: ++// 1. a class FooAction that implements the ActionInterface interface, and ++// 2. a factory function that creates an Action object from a ++// const FooAction*. ++// ++// The two-level delegation design follows that of Matcher, providing ++// consistency for extension developers. It also eases ownership ++// management as Action objects can now be copied like plain values. ++ ++namespace internal { ++ ++template ++class ActionAdaptor; ++ ++// BuiltInDefaultValueGetter::Get() returns a ++// default-constructed T value. BuiltInDefaultValueGetter::Get() crashes with an error. ++// ++// This primary template is used when kDefaultConstructible is true. ++template ++struct BuiltInDefaultValueGetter { ++ static T Get() { return T(); } ++}; ++template ++struct BuiltInDefaultValueGetter { ++ static T Get() { ++ Assert(false, __FILE__, __LINE__, ++ "Default action undefined for the function return type."); ++ return internal::Invalid(); ++ // The above statement will never be reached, but is required in ++ // order for this function to compile. ++ } ++}; ++ ++// BuiltInDefaultValue::Get() returns the "built-in" default value ++// for type T, which is NULL when T is a raw pointer type, 0 when T is ++// a numeric type, false when T is bool, or "" when T is string or ++// std::string. In addition, in C++11 and above, it turns a ++// default-constructed T value if T is default constructible. For any ++// other type T, the built-in default T value is undefined, and the ++// function will abort the process. ++template ++class BuiltInDefaultValue { ++ public: ++#if GTEST_LANG_CXX11 ++ // This function returns true iff type T has a built-in default value. ++ static bool Exists() { ++ return ::std::is_default_constructible::value; ++ } ++ ++ static T Get() { ++ return BuiltInDefaultValueGetter< ++ T, ::std::is_default_constructible::value>::Get(); ++ } ++ ++#else // GTEST_LANG_CXX11 ++ // This function returns true iff type T has a built-in default value. ++ static bool Exists() { ++ return false; ++ } ++ ++ static T Get() { ++ return BuiltInDefaultValueGetter::Get(); ++ } ++ ++#endif // GTEST_LANG_CXX11 ++}; ++ ++// This partial specialization says that we use the same built-in ++// default value for T and const T. ++template ++class BuiltInDefaultValue { ++ public: ++ static bool Exists() { return BuiltInDefaultValue::Exists(); } ++ static T Get() { return BuiltInDefaultValue::Get(); } ++}; ++ ++// This partial specialization defines the default values for pointer ++// types. ++template ++class BuiltInDefaultValue { ++ public: ++ static bool Exists() { return true; } ++ static T* Get() { return NULL; } ++}; ++ ++// The following specializations define the default values for ++// specific types we care about. ++#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(type, value) \ ++ template <> \ ++ class BuiltInDefaultValue { \ ++ public: \ ++ static bool Exists() { return true; } \ ++ static type Get() { return value; } \ ++ } ++ ++GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(void, ); // NOLINT ++#if GTEST_HAS_GLOBAL_STRING ++GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::string, ""); ++#endif // GTEST_HAS_GLOBAL_STRING ++GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::std::string, ""); ++GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(bool, false); ++GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned char, '\0'); ++GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed char, '\0'); ++GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(char, '\0'); ++ ++// There's no need for a default action for signed wchar_t, as that ++// type is the same as wchar_t for gcc, and invalid for MSVC. ++// ++// There's also no need for a default action for unsigned wchar_t, as ++// that type is the same as unsigned int for gcc, and invalid for ++// MSVC. ++#if GMOCK_WCHAR_T_IS_NATIVE_ ++GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(wchar_t, 0U); // NOLINT ++#endif ++ ++GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned short, 0U); // NOLINT ++GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed short, 0); // NOLINT ++GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned int, 0U); ++GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed int, 0); ++GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long, 0UL); // NOLINT ++GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long, 0L); // NOLINT ++GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(UInt64, 0); ++GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(Int64, 0); ++GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(float, 0); ++GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(double, 0); ++ ++#undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ ++ ++} // namespace internal ++ ++// When an unexpected function call is encountered, Google Mock will ++// let it return a default value if the user has specified one for its ++// return type, or if the return type has a built-in default value; ++// otherwise Google Mock won't know what value to return and will have ++// to abort the process. ++// ++// The DefaultValue class allows a user to specify the ++// default value for a type T that is both copyable and publicly ++// destructible (i.e. anything that can be used as a function return ++// type). The usage is: ++// ++// // Sets the default value for type T to be foo. ++// DefaultValue::Set(foo); ++template ++class DefaultValue { ++ public: ++ // Sets the default value for type T; requires T to be ++ // copy-constructable and have a public destructor. ++ static void Set(T x) { ++ delete producer_; ++ producer_ = new FixedValueProducer(x); ++ } ++ ++ // Provides a factory function to be called to generate the default value. ++ // This method can be used even if T is only move-constructible, but it is not ++ // limited to that case. ++ typedef T (*FactoryFunction)(); ++ static void SetFactory(FactoryFunction factory) { ++ delete producer_; ++ producer_ = new FactoryValueProducer(factory); ++ } ++ ++ // Unsets the default value for type T. ++ static void Clear() { ++ delete producer_; ++ producer_ = NULL; ++ } ++ ++ // Returns true iff the user has set the default value for type T. ++ static bool IsSet() { return producer_ != NULL; } ++ ++ // Returns true if T has a default return value set by the user or there ++ // exists a built-in default value. ++ static bool Exists() { ++ return IsSet() || internal::BuiltInDefaultValue::Exists(); ++ } ++ ++ // Returns the default value for type T if the user has set one; ++ // otherwise returns the built-in default value. Requires that Exists() ++ // is true, which ensures that the return value is well-defined. ++ static T Get() { ++ return producer_ == NULL ? ++ internal::BuiltInDefaultValue::Get() : producer_->Produce(); ++ } ++ ++ private: ++ class ValueProducer { ++ public: ++ virtual ~ValueProducer() {} ++ virtual T Produce() = 0; ++ }; ++ ++ class FixedValueProducer : public ValueProducer { ++ public: ++ explicit FixedValueProducer(T value) : value_(value) {} ++ virtual T Produce() { return value_; } ++ ++ private: ++ const T value_; ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(FixedValueProducer); ++ }; ++ ++ class FactoryValueProducer : public ValueProducer { ++ public: ++ explicit FactoryValueProducer(FactoryFunction factory) ++ : factory_(factory) {} ++ virtual T Produce() { return factory_(); } ++ ++ private: ++ const FactoryFunction factory_; ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(FactoryValueProducer); ++ }; ++ ++ static ValueProducer* producer_; ++}; ++ ++// This partial specialization allows a user to set default values for ++// reference types. ++template ++class DefaultValue { ++ public: ++ // Sets the default value for type T&. ++ static void Set(T& x) { // NOLINT ++ address_ = &x; ++ } ++ ++ // Unsets the default value for type T&. ++ static void Clear() { ++ address_ = NULL; ++ } ++ ++ // Returns true iff the user has set the default value for type T&. ++ static bool IsSet() { return address_ != NULL; } ++ ++ // Returns true if T has a default return value set by the user or there ++ // exists a built-in default value. ++ static bool Exists() { ++ return IsSet() || internal::BuiltInDefaultValue::Exists(); ++ } ++ ++ // Returns the default value for type T& if the user has set one; ++ // otherwise returns the built-in default value if there is one; ++ // otherwise aborts the process. ++ static T& Get() { ++ return address_ == NULL ? ++ internal::BuiltInDefaultValue::Get() : *address_; ++ } ++ ++ private: ++ static T* address_; ++}; ++ ++// This specialization allows DefaultValue::Get() to ++// compile. ++template <> ++class DefaultValue { ++ public: ++ static bool Exists() { return true; } ++ static void Get() {} ++}; ++ ++// Points to the user-set default value for type T. ++template ++typename DefaultValue::ValueProducer* DefaultValue::producer_ = NULL; ++ ++// Points to the user-set default value for type T&. ++template ++T* DefaultValue::address_ = NULL; ++ ++// Implement this interface to define an action for function type F. ++template ++class ActionInterface { ++ public: ++ typedef typename internal::Function::Result Result; ++ typedef typename internal::Function::ArgumentTuple ArgumentTuple; ++ ++ ActionInterface() {} ++ virtual ~ActionInterface() {} ++ ++ // Performs the action. This method is not const, as in general an ++ // action can have side effects and be stateful. For example, a ++ // get-the-next-element-from-the-collection action will need to ++ // remember the current element. ++ virtual Result Perform(const ArgumentTuple& args) = 0; ++ ++ private: ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionInterface); ++}; ++ ++// An Action is a copyable and IMMUTABLE (except by assignment) ++// object that represents an action to be taken when a mock function ++// of type F is called. The implementation of Action is just a ++// linked_ptr to const ActionInterface, so copying is fairly cheap. ++// Don't inherit from Action! ++// ++// You can view an object implementing ActionInterface as a ++// concrete action (including its current state), and an Action ++// object as a handle to it. ++template ++class Action { ++ public: ++ typedef typename internal::Function::Result Result; ++ typedef typename internal::Function::ArgumentTuple ArgumentTuple; ++ ++ // Constructs a null Action. Needed for storing Action objects in ++ // STL containers. ++ Action() : impl_(NULL) {} ++ ++ // Constructs an Action from its implementation. A NULL impl is ++ // used to represent the "do-default" action. ++ explicit Action(ActionInterface* impl) : impl_(impl) {} ++ ++ // Copy constructor. ++ Action(const Action& action) : impl_(action.impl_) {} ++ ++ // This constructor allows us to turn an Action object into an ++ // Action, as long as F's arguments can be implicitly converted ++ // to Func's and Func's return type can be implicitly converted to ++ // F's. ++ template ++ explicit Action(const Action& action); ++ ++ // Returns true iff this is the DoDefault() action. ++ bool IsDoDefault() const { return impl_.get() == NULL; } ++ ++ // Performs the action. Note that this method is const even though ++ // the corresponding method in ActionInterface is not. The reason ++ // is that a const Action means that it cannot be re-bound to ++ // another concrete action, not that the concrete action it binds to ++ // cannot change state. (Think of the difference between a const ++ // pointer and a pointer to const.) ++ Result Perform(const ArgumentTuple& args) const { ++ internal::Assert( ++ !IsDoDefault(), __FILE__, __LINE__, ++ "You are using DoDefault() inside a composite action like " ++ "DoAll() or WithArgs(). This is not supported for technical " ++ "reasons. Please instead spell out the default action, or " ++ "assign the default action to an Action variable and use " ++ "the variable in various places."); ++ return impl_->Perform(args); ++ } ++ ++ private: ++ template ++ friend class internal::ActionAdaptor; ++ ++ internal::linked_ptr > impl_; ++}; ++ ++// The PolymorphicAction class template makes it easy to implement a ++// polymorphic action (i.e. an action that can be used in mock ++// functions of than one type, e.g. Return()). ++// ++// To define a polymorphic action, a user first provides a COPYABLE ++// implementation class that has a Perform() method template: ++// ++// class FooAction { ++// public: ++// template ++// Result Perform(const ArgumentTuple& args) const { ++// // Processes the arguments and returns a result, using ++// // tr1::get(args) to get the N-th (0-based) argument in the tuple. ++// } ++// ... ++// }; ++// ++// Then the user creates the polymorphic action using ++// MakePolymorphicAction(object) where object has type FooAction. See ++// the definition of Return(void) and SetArgumentPointee(value) for ++// complete examples. ++template ++class PolymorphicAction { ++ public: ++ explicit PolymorphicAction(const Impl& impl) : impl_(impl) {} ++ ++ template ++ operator Action() const { ++ return Action(new MonomorphicImpl(impl_)); ++ } ++ ++ private: ++ template ++ class MonomorphicImpl : public ActionInterface { ++ public: ++ typedef typename internal::Function::Result Result; ++ typedef typename internal::Function::ArgumentTuple ArgumentTuple; ++ ++ explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {} ++ ++ virtual Result Perform(const ArgumentTuple& args) { ++ return impl_.template Perform(args); ++ } ++ ++ private: ++ Impl impl_; ++ ++ GTEST_DISALLOW_ASSIGN_(MonomorphicImpl); ++ }; ++ ++ Impl impl_; ++ ++ GTEST_DISALLOW_ASSIGN_(PolymorphicAction); ++}; ++ ++// Creates an Action from its implementation and returns it. The ++// created Action object owns the implementation. ++template ++Action MakeAction(ActionInterface* impl) { ++ return Action(impl); ++} ++ ++// Creates a polymorphic action from its implementation. This is ++// easier to use than the PolymorphicAction constructor as it ++// doesn't require you to explicitly write the template argument, e.g. ++// ++// MakePolymorphicAction(foo); ++// vs ++// PolymorphicAction(foo); ++template ++inline PolymorphicAction MakePolymorphicAction(const Impl& impl) { ++ return PolymorphicAction(impl); ++} ++ ++namespace internal { ++ ++// Allows an Action object to pose as an Action, as long as F2 ++// and F1 are compatible. ++template ++class ActionAdaptor : public ActionInterface { ++ public: ++ typedef typename internal::Function::Result Result; ++ typedef typename internal::Function::ArgumentTuple ArgumentTuple; ++ ++ explicit ActionAdaptor(const Action& from) : impl_(from.impl_) {} ++ ++ virtual Result Perform(const ArgumentTuple& args) { ++ return impl_->Perform(args); ++ } ++ ++ private: ++ const internal::linked_ptr > impl_; ++ ++ GTEST_DISALLOW_ASSIGN_(ActionAdaptor); ++}; ++ ++// Helper struct to specialize ReturnAction to execute a move instead of a copy ++// on return. Useful for move-only types, but could be used on any type. ++template ++struct ByMoveWrapper { ++ explicit ByMoveWrapper(T value) : payload(internal::move(value)) {} ++ T payload; ++}; ++ ++// Implements the polymorphic Return(x) action, which can be used in ++// any function that returns the type of x, regardless of the argument ++// types. ++// ++// Note: The value passed into Return must be converted into ++// Function::Result when this action is cast to Action rather than ++// when that action is performed. This is important in scenarios like ++// ++// MOCK_METHOD1(Method, T(U)); ++// ... ++// { ++// Foo foo; ++// X x(&foo); ++// EXPECT_CALL(mock, Method(_)).WillOnce(Return(x)); ++// } ++// ++// In the example above the variable x holds reference to foo which leaves ++// scope and gets destroyed. If copying X just copies a reference to foo, ++// that copy will be left with a hanging reference. If conversion to T ++// makes a copy of foo, the above code is safe. To support that scenario, we ++// need to make sure that the type conversion happens inside the EXPECT_CALL ++// statement, and conversion of the result of Return to Action is a ++// good place for that. ++// ++template ++class ReturnAction { ++ public: ++ // Constructs a ReturnAction object from the value to be returned. ++ // 'value' is passed by value instead of by const reference in order ++ // to allow Return("string literal") to compile. ++ explicit ReturnAction(R value) : value_(new R(internal::move(value))) {} ++ ++ // This template type conversion operator allows Return(x) to be ++ // used in ANY function that returns x's type. ++ template ++ operator Action() const { ++ // Assert statement belongs here because this is the best place to verify ++ // conditions on F. It produces the clearest error messages ++ // in most compilers. ++ // Impl really belongs in this scope as a local class but can't ++ // because MSVC produces duplicate symbols in different translation units ++ // in this case. Until MS fixes that bug we put Impl into the class scope ++ // and put the typedef both here (for use in assert statement) and ++ // in the Impl class. But both definitions must be the same. ++ typedef typename Function::Result Result; ++ GTEST_COMPILE_ASSERT_( ++ !is_reference::value, ++ use_ReturnRef_instead_of_Return_to_return_a_reference); ++ return Action(new Impl(value_)); ++ } ++ ++ private: ++ // Implements the Return(x) action for a particular function type F. ++ template ++ class Impl : public ActionInterface { ++ public: ++ typedef typename Function::Result Result; ++ typedef typename Function::ArgumentTuple ArgumentTuple; ++ ++ // The implicit cast is necessary when Result has more than one ++ // single-argument constructor (e.g. Result is std::vector) and R ++ // has a type conversion operator template. In that case, value_(value) ++ // won't compile as the compiler doesn't known which constructor of ++ // Result to call. ImplicitCast_ forces the compiler to convert R to ++ // Result without considering explicit constructors, thus resolving the ++ // ambiguity. value_ is then initialized using its copy constructor. ++ explicit Impl(const linked_ptr& value) ++ : value_before_cast_(*value), ++ value_(ImplicitCast_(value_before_cast_)) {} ++ ++ virtual Result Perform(const ArgumentTuple&) { return value_; } ++ ++ private: ++ GTEST_COMPILE_ASSERT_(!is_reference::value, ++ Result_cannot_be_a_reference_type); ++ // We save the value before casting just in case it is being cast to a ++ // wrapper type. ++ R value_before_cast_; ++ Result value_; ++ ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl); ++ }; ++ ++ // Partially specialize for ByMoveWrapper. This version of ReturnAction will ++ // move its contents instead. ++ template ++ class Impl, F> : public ActionInterface { ++ public: ++ typedef typename Function::Result Result; ++ typedef typename Function::ArgumentTuple ArgumentTuple; ++ ++ explicit Impl(const linked_ptr& wrapper) ++ : performed_(false), wrapper_(wrapper) {} ++ ++ virtual Result Perform(const ArgumentTuple&) { ++ GTEST_CHECK_(!performed_) ++ << "A ByMove() action should only be performed once."; ++ performed_ = true; ++ return internal::move(wrapper_->payload); ++ } ++ ++ private: ++ bool performed_; ++ const linked_ptr wrapper_; ++ ++ GTEST_DISALLOW_ASSIGN_(Impl); ++ }; ++ ++ const linked_ptr value_; ++ ++ GTEST_DISALLOW_ASSIGN_(ReturnAction); ++}; ++ ++// Implements the ReturnNull() action. ++class ReturnNullAction { ++ public: ++ // Allows ReturnNull() to be used in any pointer-returning function. In C++11 ++ // this is enforced by returning nullptr, and in non-C++11 by asserting a ++ // pointer type on compile time. ++ template ++ static Result Perform(const ArgumentTuple&) { ++#if GTEST_LANG_CXX11 ++ return nullptr; ++#else ++ GTEST_COMPILE_ASSERT_(internal::is_pointer::value, ++ ReturnNull_can_be_used_to_return_a_pointer_only); ++ return NULL; ++#endif // GTEST_LANG_CXX11 ++ } ++}; ++ ++// Implements the Return() action. ++class ReturnVoidAction { ++ public: ++ // Allows Return() to be used in any void-returning function. ++ template ++ static void Perform(const ArgumentTuple&) { ++ CompileAssertTypesEqual(); ++ } ++}; ++ ++// Implements the polymorphic ReturnRef(x) action, which can be used ++// in any function that returns a reference to the type of x, ++// regardless of the argument types. ++template ++class ReturnRefAction { ++ public: ++ // Constructs a ReturnRefAction object from the reference to be returned. ++ explicit ReturnRefAction(T& ref) : ref_(ref) {} // NOLINT ++ ++ // This template type conversion operator allows ReturnRef(x) to be ++ // used in ANY function that returns a reference to x's type. ++ template ++ operator Action() const { ++ typedef typename Function::Result Result; ++ // Asserts that the function return type is a reference. This ++ // catches the user error of using ReturnRef(x) when Return(x) ++ // should be used, and generates some helpful error message. ++ GTEST_COMPILE_ASSERT_(internal::is_reference::value, ++ use_Return_instead_of_ReturnRef_to_return_a_value); ++ return Action(new Impl(ref_)); ++ } ++ ++ private: ++ // Implements the ReturnRef(x) action for a particular function type F. ++ template ++ class Impl : public ActionInterface { ++ public: ++ typedef typename Function::Result Result; ++ typedef typename Function::ArgumentTuple ArgumentTuple; ++ ++ explicit Impl(T& ref) : ref_(ref) {} // NOLINT ++ ++ virtual Result Perform(const ArgumentTuple&) { ++ return ref_; ++ } ++ ++ private: ++ T& ref_; ++ ++ GTEST_DISALLOW_ASSIGN_(Impl); ++ }; ++ ++ T& ref_; ++ ++ GTEST_DISALLOW_ASSIGN_(ReturnRefAction); ++}; ++ ++// Implements the polymorphic ReturnRefOfCopy(x) action, which can be ++// used in any function that returns a reference to the type of x, ++// regardless of the argument types. ++template ++class ReturnRefOfCopyAction { ++ public: ++ // Constructs a ReturnRefOfCopyAction object from the reference to ++ // be returned. ++ explicit ReturnRefOfCopyAction(const T& value) : value_(value) {} // NOLINT ++ ++ // This template type conversion operator allows ReturnRefOfCopy(x) to be ++ // used in ANY function that returns a reference to x's type. ++ template ++ operator Action() const { ++ typedef typename Function::Result Result; ++ // Asserts that the function return type is a reference. This ++ // catches the user error of using ReturnRefOfCopy(x) when Return(x) ++ // should be used, and generates some helpful error message. ++ GTEST_COMPILE_ASSERT_( ++ internal::is_reference::value, ++ use_Return_instead_of_ReturnRefOfCopy_to_return_a_value); ++ return Action(new Impl(value_)); ++ } ++ ++ private: ++ // Implements the ReturnRefOfCopy(x) action for a particular function type F. ++ template ++ class Impl : public ActionInterface { ++ public: ++ typedef typename Function::Result Result; ++ typedef typename Function::ArgumentTuple ArgumentTuple; ++ ++ explicit Impl(const T& value) : value_(value) {} // NOLINT ++ ++ virtual Result Perform(const ArgumentTuple&) { ++ return value_; ++ } ++ ++ private: ++ T value_; ++ ++ GTEST_DISALLOW_ASSIGN_(Impl); ++ }; ++ ++ const T value_; ++ ++ GTEST_DISALLOW_ASSIGN_(ReturnRefOfCopyAction); ++}; ++ ++// Implements the polymorphic DoDefault() action. ++class DoDefaultAction { ++ public: ++ // This template type conversion operator allows DoDefault() to be ++ // used in any function. ++ template ++ operator Action() const { return Action(NULL); } ++}; ++ ++// Implements the Assign action to set a given pointer referent to a ++// particular value. ++template ++class AssignAction { ++ public: ++ AssignAction(T1* ptr, T2 value) : ptr_(ptr), value_(value) {} ++ ++ template ++ void Perform(const ArgumentTuple& /* args */) const { ++ *ptr_ = value_; ++ } ++ ++ private: ++ T1* const ptr_; ++ const T2 value_; ++ ++ GTEST_DISALLOW_ASSIGN_(AssignAction); ++}; ++ ++#if !GTEST_OS_WINDOWS_MOBILE ++ ++// Implements the SetErrnoAndReturn action to simulate return from ++// various system calls and libc functions. ++template ++class SetErrnoAndReturnAction { ++ public: ++ SetErrnoAndReturnAction(int errno_value, T result) ++ : errno_(errno_value), ++ result_(result) {} ++ template ++ Result Perform(const ArgumentTuple& /* args */) const { ++ errno = errno_; ++ return result_; ++ } ++ ++ private: ++ const int errno_; ++ const T result_; ++ ++ GTEST_DISALLOW_ASSIGN_(SetErrnoAndReturnAction); ++}; ++ ++#endif // !GTEST_OS_WINDOWS_MOBILE ++ ++// Implements the SetArgumentPointee(x) action for any function ++// whose N-th argument (0-based) is a pointer to x's type. The ++// template parameter kIsProto is true iff type A is ProtocolMessage, ++// proto2::Message, or a sub-class of those. ++template ++class SetArgumentPointeeAction { ++ public: ++ // Constructs an action that sets the variable pointed to by the ++ // N-th function argument to 'value'. ++ explicit SetArgumentPointeeAction(const A& value) : value_(value) {} ++ ++ template ++ void Perform(const ArgumentTuple& args) const { ++ CompileAssertTypesEqual(); ++ *::testing::get(args) = value_; ++ } ++ ++ private: ++ const A value_; ++ ++ GTEST_DISALLOW_ASSIGN_(SetArgumentPointeeAction); ++}; ++ ++template ++class SetArgumentPointeeAction { ++ public: ++ // Constructs an action that sets the variable pointed to by the ++ // N-th function argument to 'proto'. Both ProtocolMessage and ++ // proto2::Message have the CopyFrom() method, so the same ++ // implementation works for both. ++ explicit SetArgumentPointeeAction(const Proto& proto) : proto_(new Proto) { ++ proto_->CopyFrom(proto); ++ } ++ ++ template ++ void Perform(const ArgumentTuple& args) const { ++ CompileAssertTypesEqual(); ++ ::testing::get(args)->CopyFrom(*proto_); ++ } ++ ++ private: ++ const internal::linked_ptr proto_; ++ ++ GTEST_DISALLOW_ASSIGN_(SetArgumentPointeeAction); ++}; ++ ++// Implements the InvokeWithoutArgs(f) action. The template argument ++// FunctionImpl is the implementation type of f, which can be either a ++// function pointer or a functor. InvokeWithoutArgs(f) can be used as an ++// Action as long as f's type is compatible with F (i.e. f can be ++// assigned to a tr1::function). ++template ++class InvokeWithoutArgsAction { ++ public: ++ // The c'tor makes a copy of function_impl (either a function ++ // pointer or a functor). ++ explicit InvokeWithoutArgsAction(FunctionImpl function_impl) ++ : function_impl_(function_impl) {} ++ ++ // Allows InvokeWithoutArgs(f) to be used as any action whose type is ++ // compatible with f. ++ template ++ Result Perform(const ArgumentTuple&) { return function_impl_(); } ++ ++ private: ++ FunctionImpl function_impl_; ++ ++ GTEST_DISALLOW_ASSIGN_(InvokeWithoutArgsAction); ++}; ++ ++// Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action. ++template ++class InvokeMethodWithoutArgsAction { ++ public: ++ InvokeMethodWithoutArgsAction(Class* obj_ptr, MethodPtr method_ptr) ++ : obj_ptr_(obj_ptr), method_ptr_(method_ptr) {} ++ ++ template ++ Result Perform(const ArgumentTuple&) const { ++ return (obj_ptr_->*method_ptr_)(); ++ } ++ ++ private: ++ Class* const obj_ptr_; ++ const MethodPtr method_ptr_; ++ ++ GTEST_DISALLOW_ASSIGN_(InvokeMethodWithoutArgsAction); ++}; ++ ++// Implements the IgnoreResult(action) action. ++template ++class IgnoreResultAction { ++ public: ++ explicit IgnoreResultAction(const A& action) : action_(action) {} ++ ++ template ++ operator Action() const { ++ // Assert statement belongs here because this is the best place to verify ++ // conditions on F. It produces the clearest error messages ++ // in most compilers. ++ // Impl really belongs in this scope as a local class but can't ++ // because MSVC produces duplicate symbols in different translation units ++ // in this case. Until MS fixes that bug we put Impl into the class scope ++ // and put the typedef both here (for use in assert statement) and ++ // in the Impl class. But both definitions must be the same. ++ typedef typename internal::Function::Result Result; ++ ++ // Asserts at compile time that F returns void. ++ CompileAssertTypesEqual(); ++ ++ return Action(new Impl(action_)); ++ } ++ ++ private: ++ template ++ class Impl : public ActionInterface { ++ public: ++ typedef typename internal::Function::Result Result; ++ typedef typename internal::Function::ArgumentTuple ArgumentTuple; ++ ++ explicit Impl(const A& action) : action_(action) {} ++ ++ virtual void Perform(const ArgumentTuple& args) { ++ // Performs the action and ignores its result. ++ action_.Perform(args); ++ } ++ ++ private: ++ // Type OriginalFunction is the same as F except that its return ++ // type is IgnoredValue. ++ typedef typename internal::Function::MakeResultIgnoredValue ++ OriginalFunction; ++ ++ const Action action_; ++ ++ GTEST_DISALLOW_ASSIGN_(Impl); ++ }; ++ ++ const A action_; ++ ++ GTEST_DISALLOW_ASSIGN_(IgnoreResultAction); ++}; ++ ++// A ReferenceWrapper object represents a reference to type T, ++// which can be either const or not. It can be explicitly converted ++// from, and implicitly converted to, a T&. Unlike a reference, ++// ReferenceWrapper can be copied and can survive template type ++// inference. This is used to support by-reference arguments in the ++// InvokeArgument(...) action. The idea was from "reference ++// wrappers" in tr1, which we don't have in our source tree yet. ++template ++class ReferenceWrapper { ++ public: ++ // Constructs a ReferenceWrapper object from a T&. ++ explicit ReferenceWrapper(T& l_value) : pointer_(&l_value) {} // NOLINT ++ ++ // Allows a ReferenceWrapper object to be implicitly converted to ++ // a T&. ++ operator T&() const { return *pointer_; } ++ private: ++ T* pointer_; ++}; ++ ++// Allows the expression ByRef(x) to be printed as a reference to x. ++template ++void PrintTo(const ReferenceWrapper& ref, ::std::ostream* os) { ++ T& value = ref; ++ UniversalPrinter::Print(value, os); ++} ++ ++// Does two actions sequentially. Used for implementing the DoAll(a1, ++// a2, ...) action. ++template ++class DoBothAction { ++ public: ++ DoBothAction(Action1 action1, Action2 action2) ++ : action1_(action1), action2_(action2) {} ++ ++ // This template type conversion operator allows DoAll(a1, ..., a_n) ++ // to be used in ANY function of compatible type. ++ template ++ operator Action() const { ++ return Action(new Impl(action1_, action2_)); ++ } ++ ++ private: ++ // Implements the DoAll(...) action for a particular function type F. ++ template ++ class Impl : public ActionInterface { ++ public: ++ typedef typename Function::Result Result; ++ typedef typename Function::ArgumentTuple ArgumentTuple; ++ typedef typename Function::MakeResultVoid VoidResult; ++ ++ Impl(const Action& action1, const Action& action2) ++ : action1_(action1), action2_(action2) {} ++ ++ virtual Result Perform(const ArgumentTuple& args) { ++ action1_.Perform(args); ++ return action2_.Perform(args); ++ } ++ ++ private: ++ const Action action1_; ++ const Action action2_; ++ ++ GTEST_DISALLOW_ASSIGN_(Impl); ++ }; ++ ++ Action1 action1_; ++ Action2 action2_; ++ ++ GTEST_DISALLOW_ASSIGN_(DoBothAction); ++}; ++ ++} // namespace internal ++ ++// An Unused object can be implicitly constructed from ANY value. ++// This is handy when defining actions that ignore some or all of the ++// mock function arguments. For example, given ++// ++// MOCK_METHOD3(Foo, double(const string& label, double x, double y)); ++// MOCK_METHOD3(Bar, double(int index, double x, double y)); ++// ++// instead of ++// ++// double DistanceToOriginWithLabel(const string& label, double x, double y) { ++// return sqrt(x*x + y*y); ++// } ++// double DistanceToOriginWithIndex(int index, double x, double y) { ++// return sqrt(x*x + y*y); ++// } ++// ... ++// EXEPCT_CALL(mock, Foo("abc", _, _)) ++// .WillOnce(Invoke(DistanceToOriginWithLabel)); ++// EXEPCT_CALL(mock, Bar(5, _, _)) ++// .WillOnce(Invoke(DistanceToOriginWithIndex)); ++// ++// you could write ++// ++// // We can declare any uninteresting argument as Unused. ++// double DistanceToOrigin(Unused, double x, double y) { ++// return sqrt(x*x + y*y); ++// } ++// ... ++// EXEPCT_CALL(mock, Foo("abc", _, _)).WillOnce(Invoke(DistanceToOrigin)); ++// EXEPCT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin)); ++typedef internal::IgnoredValue Unused; ++ ++// This constructor allows us to turn an Action object into an ++// Action, as long as To's arguments can be implicitly converted ++// to From's and From's return type cann be implicitly converted to ++// To's. ++template ++template ++Action::Action(const Action& from) ++ : impl_(new internal::ActionAdaptor(from)) {} ++ ++// Creates an action that returns 'value'. 'value' is passed by value ++// instead of const reference - otherwise Return("string literal") ++// will trigger a compiler error about using array as initializer. ++template ++internal::ReturnAction Return(R value) { ++ return internal::ReturnAction(internal::move(value)); ++} ++ ++// Creates an action that returns NULL. ++inline PolymorphicAction ReturnNull() { ++ return MakePolymorphicAction(internal::ReturnNullAction()); ++} ++ ++// Creates an action that returns from a void function. ++inline PolymorphicAction Return() { ++ return MakePolymorphicAction(internal::ReturnVoidAction()); ++} ++ ++// Creates an action that returns the reference to a variable. ++template ++inline internal::ReturnRefAction ReturnRef(R& x) { // NOLINT ++ return internal::ReturnRefAction(x); ++} ++ ++// Creates an action that returns the reference to a copy of the ++// argument. The copy is created when the action is constructed and ++// lives as long as the action. ++template ++inline internal::ReturnRefOfCopyAction ReturnRefOfCopy(const R& x) { ++ return internal::ReturnRefOfCopyAction(x); ++} ++ ++// Modifies the parent action (a Return() action) to perform a move of the ++// argument instead of a copy. ++// Return(ByMove()) actions can only be executed once and will assert this ++// invariant. ++template ++internal::ByMoveWrapper ByMove(R x) { ++ return internal::ByMoveWrapper(internal::move(x)); ++} ++ ++// Creates an action that does the default action for the give mock function. ++inline internal::DoDefaultAction DoDefault() { ++ return internal::DoDefaultAction(); ++} ++ ++// Creates an action that sets the variable pointed by the N-th ++// (0-based) function argument to 'value'. ++template ++PolymorphicAction< ++ internal::SetArgumentPointeeAction< ++ N, T, internal::IsAProtocolMessage::value> > ++SetArgPointee(const T& x) { ++ return MakePolymorphicAction(internal::SetArgumentPointeeAction< ++ N, T, internal::IsAProtocolMessage::value>(x)); ++} ++ ++#if !((GTEST_GCC_VER_ && GTEST_GCC_VER_ < 40000) || GTEST_OS_SYMBIAN) ++// This overload allows SetArgPointee() to accept a string literal. ++// GCC prior to the version 4.0 and Symbian C++ compiler cannot distinguish ++// this overload from the templated version and emit a compile error. ++template ++PolymorphicAction< ++ internal::SetArgumentPointeeAction > ++SetArgPointee(const char* p) { ++ return MakePolymorphicAction(internal::SetArgumentPointeeAction< ++ N, const char*, false>(p)); ++} ++ ++template ++PolymorphicAction< ++ internal::SetArgumentPointeeAction > ++SetArgPointee(const wchar_t* p) { ++ return MakePolymorphicAction(internal::SetArgumentPointeeAction< ++ N, const wchar_t*, false>(p)); ++} ++#endif ++ ++// The following version is DEPRECATED. ++template ++PolymorphicAction< ++ internal::SetArgumentPointeeAction< ++ N, T, internal::IsAProtocolMessage::value> > ++SetArgumentPointee(const T& x) { ++ return MakePolymorphicAction(internal::SetArgumentPointeeAction< ++ N, T, internal::IsAProtocolMessage::value>(x)); ++} ++ ++// Creates an action that sets a pointer referent to a given value. ++template ++PolymorphicAction > Assign(T1* ptr, T2 val) { ++ return MakePolymorphicAction(internal::AssignAction(ptr, val)); ++} ++ ++#if !GTEST_OS_WINDOWS_MOBILE ++ ++// Creates an action that sets errno and returns the appropriate error. ++template ++PolymorphicAction > ++SetErrnoAndReturn(int errval, T result) { ++ return MakePolymorphicAction( ++ internal::SetErrnoAndReturnAction(errval, result)); ++} ++ ++#endif // !GTEST_OS_WINDOWS_MOBILE ++ ++// Various overloads for InvokeWithoutArgs(). ++ ++// Creates an action that invokes 'function_impl' with no argument. ++template ++PolymorphicAction > ++InvokeWithoutArgs(FunctionImpl function_impl) { ++ return MakePolymorphicAction( ++ internal::InvokeWithoutArgsAction(function_impl)); ++} ++ ++// Creates an action that invokes the given method on the given object ++// with no argument. ++template ++PolymorphicAction > ++InvokeWithoutArgs(Class* obj_ptr, MethodPtr method_ptr) { ++ return MakePolymorphicAction( ++ internal::InvokeMethodWithoutArgsAction( ++ obj_ptr, method_ptr)); ++} ++ ++// Creates an action that performs an_action and throws away its ++// result. In other words, it changes the return type of an_action to ++// void. an_action MUST NOT return void, or the code won't compile. ++template ++inline internal::IgnoreResultAction IgnoreResult(const A& an_action) { ++ return internal::IgnoreResultAction(an_action); ++} ++ ++// Creates a reference wrapper for the given L-value. If necessary, ++// you can explicitly specify the type of the reference. For example, ++// suppose 'derived' is an object of type Derived, ByRef(derived) ++// would wrap a Derived&. If you want to wrap a const Base& instead, ++// where Base is a base class of Derived, just write: ++// ++// ByRef(derived) ++template ++inline internal::ReferenceWrapper ByRef(T& l_value) { // NOLINT ++ return internal::ReferenceWrapper(l_value); ++} ++ ++} // namespace testing ++ ++#endif // GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ +diff -urN mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-cardinalities.h mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-cardinalities.h +--- mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-cardinalities.h 1970-01-01 09:00:00.000000000 +0900 ++++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-cardinalities.h 2016-02-20 18:11:22.324832283 +0900 +@@ -0,0 +1,147 @@ ++// 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 ++#include // 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 GTEST_API_ Cardinality { ++ public: ++ // Constructs a null cardinality. Needed for storing Cardinality ++ // objects in STL containers. ++ Cardinality() {} ++ ++ // Constructs a Cardinality from its implementation. ++ explicit Cardinality(const CardinalityInterface* impl) : impl_(impl) {} ++ ++ // Conservative estimate on the lower/upper bound of the number of ++ // calls allowed. ++ int ConservativeLowerBound() const { return impl_->ConservativeLowerBound(); } ++ int ConservativeUpperBound() const { return impl_->ConservativeUpperBound(); } ++ ++ // Returns true 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 impl_; ++}; ++ ++// Creates a cardinality that allows at least n calls. ++GTEST_API_ Cardinality AtLeast(int n); ++ ++// Creates a cardinality that allows at most n calls. ++GTEST_API_ Cardinality AtMost(int n); ++ ++// Creates a cardinality that allows any number of calls. ++GTEST_API_ Cardinality AnyNumber(); ++ ++// Creates a cardinality that allows between min and max calls. ++GTEST_API_ Cardinality Between(int min, int max); ++ ++// Creates a cardinality that allows exactly n calls. ++GTEST_API_ Cardinality Exactly(int n); ++ ++// Creates a cardinality from its implementation. ++inline Cardinality MakeCardinality(const CardinalityInterface* c) { ++ return Cardinality(c); ++} ++ ++} // namespace testing ++ ++#endif // GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_ +diff -urN mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-generated-actions.h mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-generated-actions.h +--- mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-generated-actions.h 1970-01-01 09:00:00.000000000 +0900 ++++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-generated-actions.h 2016-02-20 18:11:22.332832283 +0900 +@@ -0,0 +1,2378 @@ ++// 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 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 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 ++class InvokeHelper; ++ ++template ++class InvokeHelper > { ++ public: ++ template ++ static R Invoke(Function function, const ::testing::tuple<>&) { ++ return function(); ++ } ++ ++ template ++ static R InvokeMethod(Class* obj_ptr, ++ MethodPtr method_ptr, ++ const ::testing::tuple<>&) { ++ return (obj_ptr->*method_ptr)(); ++ } ++}; ++ ++template ++class InvokeHelper > { ++ public: ++ template ++ static R Invoke(Function function, const ::testing::tuple& args) { ++ return function(get<0>(args)); ++ } ++ ++ template ++ static R InvokeMethod(Class* obj_ptr, ++ MethodPtr method_ptr, ++ const ::testing::tuple& args) { ++ return (obj_ptr->*method_ptr)(get<0>(args)); ++ } ++}; ++ ++template ++class InvokeHelper > { ++ public: ++ template ++ static R Invoke(Function function, const ::testing::tuple& args) { ++ return function(get<0>(args), get<1>(args)); ++ } ++ ++ template ++ static R InvokeMethod(Class* obj_ptr, ++ MethodPtr method_ptr, ++ const ::testing::tuple& args) { ++ return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args)); ++ } ++}; ++ ++template ++class InvokeHelper > { ++ public: ++ template ++ static R Invoke(Function function, const ::testing::tuple& args) { ++ return function(get<0>(args), get<1>(args), get<2>(args)); ++ } ++ ++ template ++ static R InvokeMethod(Class* obj_ptr, ++ MethodPtr method_ptr, ++ const ::testing::tuple& args) { ++ return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), ++ get<2>(args)); ++ } ++}; ++ ++template ++class InvokeHelper > { ++ public: ++ template ++ static R Invoke(Function function, const ::testing::tuple& args) { ++ return function(get<0>(args), get<1>(args), get<2>(args), ++ get<3>(args)); ++ } ++ ++ template ++ static R InvokeMethod(Class* obj_ptr, ++ MethodPtr method_ptr, ++ const ::testing::tuple& args) { ++ return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), ++ get<2>(args), get<3>(args)); ++ } ++}; ++ ++template ++class InvokeHelper > { ++ public: ++ template ++ static R Invoke(Function function, const ::testing::tuple& args) { ++ return function(get<0>(args), get<1>(args), get<2>(args), ++ get<3>(args), get<4>(args)); ++ } ++ ++ template ++ static R InvokeMethod(Class* obj_ptr, ++ MethodPtr method_ptr, ++ const ::testing::tuple& args) { ++ return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), ++ get<2>(args), get<3>(args), get<4>(args)); ++ } ++}; ++ ++template ++class InvokeHelper > { ++ public: ++ template ++ static R Invoke(Function function, const ::testing::tuple& args) { ++ return function(get<0>(args), get<1>(args), get<2>(args), ++ get<3>(args), get<4>(args), get<5>(args)); ++ } ++ ++ template ++ static R InvokeMethod(Class* obj_ptr, ++ MethodPtr method_ptr, ++ const ::testing::tuple& args) { ++ return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), ++ get<2>(args), get<3>(args), get<4>(args), get<5>(args)); ++ } ++}; ++ ++template ++class InvokeHelper > { ++ public: ++ template ++ static R Invoke(Function function, const ::testing::tuple& args) { ++ return function(get<0>(args), get<1>(args), get<2>(args), ++ get<3>(args), get<4>(args), get<5>(args), get<6>(args)); ++ } ++ ++ template ++ static R InvokeMethod(Class* obj_ptr, ++ MethodPtr method_ptr, ++ const ::testing::tuple& args) { ++ return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), ++ get<2>(args), get<3>(args), get<4>(args), get<5>(args), ++ get<6>(args)); ++ } ++}; ++ ++template ++class InvokeHelper > { ++ public: ++ template ++ static R Invoke(Function function, const ::testing::tuple& args) { ++ return function(get<0>(args), get<1>(args), get<2>(args), ++ get<3>(args), get<4>(args), get<5>(args), get<6>(args), ++ get<7>(args)); ++ } ++ ++ template ++ static R InvokeMethod(Class* obj_ptr, ++ MethodPtr method_ptr, ++ const ::testing::tuple& args) { ++ return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), ++ get<2>(args), get<3>(args), get<4>(args), get<5>(args), ++ get<6>(args), get<7>(args)); ++ } ++}; ++ ++template ++class InvokeHelper > { ++ public: ++ template ++ static R Invoke(Function function, const ::testing::tuple& args) { ++ return function(get<0>(args), get<1>(args), get<2>(args), ++ get<3>(args), get<4>(args), get<5>(args), get<6>(args), ++ get<7>(args), get<8>(args)); ++ } ++ ++ template ++ static R InvokeMethod(Class* obj_ptr, ++ MethodPtr method_ptr, ++ const ::testing::tuple& args) { ++ return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), ++ get<2>(args), get<3>(args), get<4>(args), get<5>(args), ++ get<6>(args), get<7>(args), get<8>(args)); ++ } ++}; ++ ++template ++class InvokeHelper > { ++ public: ++ template ++ static R Invoke(Function function, const ::testing::tuple& args) { ++ return function(get<0>(args), get<1>(args), get<2>(args), ++ get<3>(args), get<4>(args), get<5>(args), get<6>(args), ++ get<7>(args), get<8>(args), get<9>(args)); ++ } ++ ++ template ++ static R InvokeMethod(Class* obj_ptr, ++ MethodPtr method_ptr, ++ const ::testing::tuple& args) { ++ return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), ++ get<2>(args), get<3>(args), get<4>(args), get<5>(args), ++ get<6>(args), get<7>(args), get<8>(args), get<9>(args)); ++ } ++}; ++ ++// 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::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 ++class CallableHelper { ++ public: ++ // Calls a nullary callable. ++ template ++ 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 ++ static R Call(Function function, A1 a1) { return function(a1); } ++ ++ // Calls a binary callable. ++ template ++ static R Call(Function function, A1 a1, A2 a2) { ++ return function(a1, a2); ++ } ++ ++ // Calls a ternary callable. ++ template ++ static R Call(Function function, A1 a1, A2 a2, A3 a3) { ++ return function(a1, a2, a3); ++ } ++ ++ // Calls a 4-ary callable. ++ template ++ static R Call(Function function, A1 a1, A2 a2, A3 a3, A4 a4) { ++ return function(a1, a2, a3, a4); ++ } ++ ++ // Calls a 5-ary callable. ++ template ++ static R Call(Function function, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { ++ return function(a1, a2, a3, a4, a5); ++ } ++ ++ // Calls a 6-ary callable. ++ template ++ static R Call(Function function, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { ++ return function(a1, a2, a3, a4, a5, a6); ++ } ++ ++ // Calls a 7-ary callable. ++ template ++ static R Call(Function function, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, ++ A7 a7) { ++ return function(a1, a2, a3, a4, a5, a6, a7); ++ } ++ ++ // Calls a 8-ary callable. ++ template ++ static R Call(Function function, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, ++ A7 a7, A8 a8) { ++ return function(a1, a2, a3, a4, a5, a6, a7, a8); ++ } ++ ++ // Calls a 9-ary callable. ++ template ++ static R Call(Function function, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, ++ A7 a7, A8 a8, A9 a9) { ++ return function(a1, a2, a3, a4, a5, a6, a7, a8, a9); ++ } ++ ++ // Calls a 10-ary callable. ++ template ++ static R Call(Function function, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, ++ A7 a7, A8 a8, A9 a9, A10 a10) { ++ return function(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); ++ } ++}; // 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 ::testing::tuple_element::type ++ ++// SelectArgs::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, 0, 3>::type ++// is int(bool, long). ++// ++// SelectArgs::Select(args) ++// returns the selected fields (k1, k2, ..., k_n) of args as a tuple. ++// For example, ++// SelectArgs, 2, 0>::Select( ++// ::testing::make_tuple(true, 'a', 2.5)) ++// returns tuple (2.5, true). ++// ++// The numbers in list k1, k2, ..., k_n must be >= 0, where n can be ++// in the range [0, 10]. Duplicates are allowed and they don't have ++// to be in an ascending or descending order. ++ ++template ++class SelectArgs { ++ public: ++ typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), ++ GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3), ++ GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5), ++ GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7), ++ GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9), ++ GMOCK_FIELD_(ArgumentTuple, k10)); ++ typedef typename Function::ArgumentTuple SelectedArgs; ++ static SelectedArgs Select(const ArgumentTuple& args) { ++ return SelectedArgs(get(args), get(args), get(args), ++ get(args), get(args), get(args), get(args), ++ get(args), get(args), get(args)); ++ } ++}; ++ ++template ++class SelectArgs { ++ public: ++ typedef Result type(); ++ typedef typename Function::ArgumentTuple SelectedArgs; ++ static SelectedArgs Select(const ArgumentTuple& /* args */) { ++ return SelectedArgs(); ++ } ++}; ++ ++template ++class SelectArgs { ++ public: ++ typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1)); ++ typedef typename Function::ArgumentTuple SelectedArgs; ++ static SelectedArgs Select(const ArgumentTuple& args) { ++ return SelectedArgs(get(args)); ++ } ++}; ++ ++template ++class SelectArgs { ++ public: ++ typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), ++ GMOCK_FIELD_(ArgumentTuple, k2)); ++ typedef typename Function::ArgumentTuple SelectedArgs; ++ static SelectedArgs Select(const ArgumentTuple& args) { ++ return SelectedArgs(get(args), get(args)); ++ } ++}; ++ ++template ++class SelectArgs { ++ public: ++ typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), ++ GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3)); ++ typedef typename Function::ArgumentTuple SelectedArgs; ++ static SelectedArgs Select(const ArgumentTuple& args) { ++ return SelectedArgs(get(args), get(args), get(args)); ++ } ++}; ++ ++template ++class SelectArgs { ++ public: ++ typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), ++ GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3), ++ GMOCK_FIELD_(ArgumentTuple, k4)); ++ typedef typename Function::ArgumentTuple SelectedArgs; ++ static SelectedArgs Select(const ArgumentTuple& args) { ++ return SelectedArgs(get(args), get(args), get(args), ++ get(args)); ++ } ++}; ++ ++template ++class SelectArgs { ++ public: ++ typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), ++ GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3), ++ GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5)); ++ typedef typename Function::ArgumentTuple SelectedArgs; ++ static SelectedArgs Select(const ArgumentTuple& args) { ++ return SelectedArgs(get(args), get(args), get(args), ++ get(args), get(args)); ++ } ++}; ++ ++template ++class SelectArgs { ++ public: ++ typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), ++ GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3), ++ GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5), ++ GMOCK_FIELD_(ArgumentTuple, k6)); ++ typedef typename Function::ArgumentTuple SelectedArgs; ++ static SelectedArgs Select(const ArgumentTuple& args) { ++ return SelectedArgs(get(args), get(args), get(args), ++ get(args), get(args), get(args)); ++ } ++}; ++ ++template ++class SelectArgs { ++ public: ++ typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), ++ GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3), ++ GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5), ++ GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7)); ++ typedef typename Function::ArgumentTuple SelectedArgs; ++ static SelectedArgs Select(const ArgumentTuple& args) { ++ return SelectedArgs(get(args), get(args), get(args), ++ get(args), get(args), get(args), get(args)); ++ } ++}; ++ ++template ++class SelectArgs { ++ public: ++ typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), ++ GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3), ++ GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5), ++ GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7), ++ GMOCK_FIELD_(ArgumentTuple, k8)); ++ typedef typename Function::ArgumentTuple SelectedArgs; ++ static SelectedArgs Select(const ArgumentTuple& args) { ++ return SelectedArgs(get(args), get(args), get(args), ++ get(args), get(args), get(args), get(args), ++ get(args)); ++ } ++}; ++ ++template ++class SelectArgs { ++ public: ++ typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), ++ GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3), ++ GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5), ++ GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7), ++ GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9)); ++ typedef typename Function::ArgumentTuple SelectedArgs; ++ static SelectedArgs Select(const ArgumentTuple& args) { ++ return SelectedArgs(get(args), get(args), get(args), ++ get(args), get(args), get(args), get(args), ++ get(args), get(args)); ++ } ++}; ++ ++#undef GMOCK_FIELD_ ++ ++// Implements the WithArgs action. ++template ++class WithArgsAction { ++ public: ++ explicit WithArgsAction(const InnerAction& action) : action_(action) {} ++ ++ template ++ operator Action() const { return MakeAction(new Impl(action_)); } ++ ++ private: ++ template ++ class Impl : public ActionInterface { ++ public: ++ typedef typename Function::Result Result; ++ typedef typename Function::ArgumentTuple ArgumentTuple; ++ ++ explicit Impl(const InnerAction& action) : action_(action) {} ++ ++ virtual Result Perform(const ArgumentTuple& args) { ++ return action_.Perform(SelectArgs::Select(args)); ++ } ++ ++ private: ++ typedef typename SelectArgs::type InnerFunctionType; ++ ++ Action 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 ++class ActionHelper { ++ public: ++ static Result Perform(Impl* impl, const ::testing::tuple<>& args) { ++ return impl->template gmock_PerformImpl<>(args, ExcessiveArg(), ++ ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ++ ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ++ ExcessiveArg()); ++ } ++ ++ template ++ static Result Perform(Impl* impl, const ::testing::tuple& args) { ++ return impl->template gmock_PerformImpl(args, get<0>(args), ++ ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ++ ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ++ ExcessiveArg()); ++ } ++ ++ template ++ static Result Perform(Impl* impl, const ::testing::tuple& args) { ++ return impl->template gmock_PerformImpl(args, get<0>(args), ++ get<1>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ++ ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ++ ExcessiveArg()); ++ } ++ ++ template ++ static Result Perform(Impl* impl, const ::testing::tuple& args) { ++ return impl->template gmock_PerformImpl(args, get<0>(args), ++ get<1>(args), get<2>(args), ExcessiveArg(), ExcessiveArg(), ++ ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ++ ExcessiveArg()); ++ } ++ ++ template ++ static Result Perform(Impl* impl, const ::testing::tuple& args) { ++ return impl->template gmock_PerformImpl(args, get<0>(args), ++ get<1>(args), get<2>(args), get<3>(args), ExcessiveArg(), ++ ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ++ ExcessiveArg()); ++ } ++ ++ template ++ static Result Perform(Impl* impl, const ::testing::tuple& args) { ++ return impl->template gmock_PerformImpl(args, ++ get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args), ++ ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ++ ExcessiveArg()); ++ } ++ ++ template ++ static Result Perform(Impl* impl, const ::testing::tuple& args) { ++ return impl->template gmock_PerformImpl(args, ++ get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args), ++ get<5>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ++ ExcessiveArg()); ++ } ++ ++ template ++ static Result Perform(Impl* impl, const ::testing::tuple& args) { ++ return impl->template gmock_PerformImpl(args, ++ get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args), ++ get<5>(args), get<6>(args), ExcessiveArg(), ExcessiveArg(), ++ ExcessiveArg()); ++ } ++ ++ template ++ static Result Perform(Impl* impl, const ::testing::tuple& args) { ++ return impl->template gmock_PerformImpl(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args), ++ get<4>(args), get<5>(args), get<6>(args), get<7>(args), ExcessiveArg(), ++ ExcessiveArg()); ++ } ++ ++ template ++ static Result Perform(Impl* impl, const ::testing::tuple& args) { ++ return impl->template gmock_PerformImpl(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args), ++ get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args), ++ ExcessiveArg()); ++ } ++ ++ template ++ static Result Perform(Impl* impl, const ::testing::tuple& args) { ++ return impl->template gmock_PerformImpl(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args), ++ get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args), ++ get<9>(args)); ++ } ++}; ++ ++} // namespace internal ++ ++// Various overloads for Invoke(). ++ ++// WithArgs(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. ++template ++inline internal::WithArgsAction ++WithArgs(const InnerAction& action) { ++ return internal::WithArgsAction(action); ++} ++ ++template ++inline internal::WithArgsAction ++WithArgs(const InnerAction& action) { ++ return internal::WithArgsAction(action); ++} ++ ++template ++inline internal::WithArgsAction ++WithArgs(const InnerAction& action) { ++ return internal::WithArgsAction(action); ++} ++ ++template ++inline internal::WithArgsAction ++WithArgs(const InnerAction& action) { ++ return internal::WithArgsAction(action); ++} ++ ++template ++inline internal::WithArgsAction ++WithArgs(const InnerAction& action) { ++ return internal::WithArgsAction(action); ++} ++ ++template ++inline internal::WithArgsAction ++WithArgs(const InnerAction& action) { ++ return internal::WithArgsAction(action); ++} ++ ++template ++inline internal::WithArgsAction ++WithArgs(const InnerAction& action) { ++ return internal::WithArgsAction(action); ++} ++ ++template ++inline internal::WithArgsAction ++WithArgs(const InnerAction& action) { ++ return internal::WithArgsAction(action); ++} ++ ++template ++inline internal::WithArgsAction ++WithArgs(const InnerAction& action) { ++ return internal::WithArgsAction(action); ++} ++ ++template ++inline internal::WithArgsAction ++WithArgs(const InnerAction& action) { ++ return internal::WithArgsAction(action); ++} ++ ++// Creates an action that does actions a1, a2, ..., sequentially in ++// each invocation. ++template ++inline internal::DoBothAction ++DoAll(Action1 a1, Action2 a2) { ++ return internal::DoBothAction(a1, a2); ++} ++ ++template ++inline internal::DoBothAction > ++DoAll(Action1 a1, Action2 a2, Action3 a3) { ++ return DoAll(a1, DoAll(a2, a3)); ++} ++ ++template ++inline internal::DoBothAction > > ++DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4) { ++ return DoAll(a1, DoAll(a2, a3, a4)); ++} ++ ++template ++inline internal::DoBothAction > > > ++DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5) { ++ return DoAll(a1, DoAll(a2, a3, a4, a5)); ++} ++ ++template ++inline internal::DoBothAction > > > > ++DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6) { ++ return DoAll(a1, DoAll(a2, a3, a4, a5, a6)); ++} ++ ++template ++inline internal::DoBothAction > > > > > ++DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6, ++ Action7 a7) { ++ return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7)); ++} ++ ++template ++inline internal::DoBothAction > > > > > > ++DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6, ++ Action7 a7, Action8 a8) { ++ return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8)); ++} ++ ++template ++inline internal::DoBothAction > > > > > > > ++DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6, ++ Action7 a7, Action8 a8, Action9 a9) { ++ return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9)); ++} ++ ++template ++inline internal::DoBothAction > > > > > > > > ++DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6, ++ Action7 a7, Action8 a8, Action9 a9, Action10 a10) { ++ return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9, a10)); ++} ++ ++} // 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_P10 to support ++// multi-parameter actions. ++// ++// For the purpose of typing, you can view ++// ++// ACTION_Pk(Foo, p1, ..., pk) { ... } ++// ++// as shorthand for ++// ++// template ++// FooActionPk Foo(p1_type p1, ..., pk_type pk) { ... } ++// ++// In particular, you can provide the template type arguments ++// explicitly when invoking Foo(), as in Foo(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. 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. ++ ++// An internal macro needed for implementing ACTION*(). ++#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\ ++ const args_type& args GTEST_ATTRIBUTE_UNUSED_, \ ++ arg0_type arg0 GTEST_ATTRIBUTE_UNUSED_, \ ++ arg1_type arg1 GTEST_ATTRIBUTE_UNUSED_, \ ++ arg2_type arg2 GTEST_ATTRIBUTE_UNUSED_, \ ++ arg3_type arg3 GTEST_ATTRIBUTE_UNUSED_, \ ++ arg4_type arg4 GTEST_ATTRIBUTE_UNUSED_, \ ++ arg5_type arg5 GTEST_ATTRIBUTE_UNUSED_, \ ++ arg6_type arg6 GTEST_ATTRIBUTE_UNUSED_, \ ++ arg7_type arg7 GTEST_ATTRIBUTE_UNUSED_, \ ++ arg8_type arg8 GTEST_ATTRIBUTE_UNUSED_, \ ++ arg9_type arg9 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(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(::testing::get(args)); ++// } ++// ... ++// int n; ++// EXPECT_CALL(mock, Foo(_, _)) ++// .WillOnce(DuplicateArg<1, unsigned char>(&n)); ++// ++// To create an instance of an action template, write: ++// ++// ActionName(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(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(x); ++// ++// Are we using a single-template-parameter action where 'bool' refers ++// to the type of x, or are we using a two-template-parameter action ++// where the compiler is asked to infer the type of x? ++// ++// Implementation notes: ++// ++// GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and ++// GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for ++// implementing ACTION_TEMPLATE. The main trick we use is to create ++// new macro invocations when expanding a macro. For example, we have ++// ++// #define ACTION_TEMPLATE(name, template_params, value_params) ++// ... GMOCK_INTERNAL_DECL_##template_params ... ++// ++// which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...) ++// to expand to ++// ++// ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ... ++// ++// Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the ++// preprocessor will continue to expand it to ++// ++// ... typename T ... ++// ++// This technique conforms to the C++ standard and is portable. It ++// allows us to implement action templates using O(N) code, where N is ++// the maximum number of template/value parameters supported. Without ++// using it, we'd have to devote O(N^2) amount of code to implement all ++// combinations of m and n. ++ ++// Declares the template parameters. ++#define GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(kind0, name0) kind0 name0 ++#define GMOCK_INTERNAL_DECL_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \ ++ name1) kind0 name0, kind1 name1 ++#define GMOCK_INTERNAL_DECL_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ ++ kind2, name2) kind0 name0, kind1 name1, kind2 name2 ++#define GMOCK_INTERNAL_DECL_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ ++ kind2, name2, kind3, name3) kind0 name0, kind1 name1, kind2 name2, \ ++ kind3 name3 ++#define GMOCK_INTERNAL_DECL_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ ++ kind2, name2, kind3, name3, kind4, name4) kind0 name0, kind1 name1, \ ++ kind2 name2, kind3 name3, kind4 name4 ++#define GMOCK_INTERNAL_DECL_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ ++ kind2, name2, kind3, name3, kind4, name4, kind5, name5) kind0 name0, \ ++ kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5 ++#define GMOCK_INTERNAL_DECL_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ ++ kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \ ++ name6) kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, \ ++ kind5 name5, kind6 name6 ++#define GMOCK_INTERNAL_DECL_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ ++ kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \ ++ kind7, name7) kind0 name0, kind1 name1, kind2 name2, kind3 name3, \ ++ kind4 name4, kind5 name5, kind6 name6, kind7 name7 ++#define GMOCK_INTERNAL_DECL_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ ++ kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \ ++ kind7, name7, kind8, name8) kind0 name0, kind1 name1, kind2 name2, \ ++ kind3 name3, kind4 name4, kind5 name5, kind6 name6, kind7 name7, \ ++ kind8 name8 ++#define GMOCK_INTERNAL_DECL_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \ ++ name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \ ++ name6, kind7, name7, kind8, name8, kind9, name9) kind0 name0, \ ++ kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5, \ ++ kind6 name6, kind7 name7, kind8 name8, kind9 name9 ++ ++// Lists the template parameters. ++#define GMOCK_INTERNAL_LIST_HAS_1_TEMPLATE_PARAMS(kind0, name0) name0 ++#define GMOCK_INTERNAL_LIST_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \ ++ name1) name0, name1 ++#define GMOCK_INTERNAL_LIST_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ ++ kind2, name2) name0, name1, name2 ++#define GMOCK_INTERNAL_LIST_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ ++ kind2, name2, kind3, name3) name0, name1, name2, name3 ++#define GMOCK_INTERNAL_LIST_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ ++ kind2, name2, kind3, name3, kind4, name4) name0, name1, name2, name3, \ ++ name4 ++#define GMOCK_INTERNAL_LIST_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ ++ kind2, name2, kind3, name3, kind4, name4, kind5, name5) name0, name1, \ ++ name2, name3, name4, name5 ++#define GMOCK_INTERNAL_LIST_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ ++ kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \ ++ name6) name0, name1, name2, name3, name4, name5, name6 ++#define GMOCK_INTERNAL_LIST_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ ++ kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \ ++ kind7, name7) name0, name1, name2, name3, name4, name5, name6, name7 ++#define GMOCK_INTERNAL_LIST_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ ++ kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \ ++ kind7, name7, kind8, name8) name0, name1, name2, name3, name4, name5, \ ++ name6, name7, name8 ++#define GMOCK_INTERNAL_LIST_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \ ++ name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \ ++ name6, kind7, name7, kind8, name8, kind9, name9) name0, name1, name2, \ ++ name3, name4, name5, name6, name7, name8, name9 ++ ++// Declares the types of value parameters. ++#define GMOCK_INTERNAL_DECL_TYPE_AND_0_VALUE_PARAMS() ++#define GMOCK_INTERNAL_DECL_TYPE_AND_1_VALUE_PARAMS(p0) , typename p0##_type ++#define GMOCK_INTERNAL_DECL_TYPE_AND_2_VALUE_PARAMS(p0, p1) , \ ++ typename p0##_type, typename p1##_type ++#define GMOCK_INTERNAL_DECL_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , \ ++ typename p0##_type, typename p1##_type, typename p2##_type ++#define GMOCK_INTERNAL_DECL_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \ ++ typename p0##_type, typename p1##_type, typename p2##_type, \ ++ typename p3##_type ++#define GMOCK_INTERNAL_DECL_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \ ++ typename p0##_type, typename p1##_type, typename p2##_type, \ ++ typename p3##_type, typename p4##_type ++#define GMOCK_INTERNAL_DECL_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \ ++ typename p0##_type, typename p1##_type, typename p2##_type, \ ++ typename p3##_type, typename p4##_type, typename p5##_type ++#define GMOCK_INTERNAL_DECL_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ ++ p6) , typename p0##_type, typename p1##_type, typename p2##_type, \ ++ typename p3##_type, typename p4##_type, typename p5##_type, \ ++ typename p6##_type ++#define GMOCK_INTERNAL_DECL_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ ++ p6, p7) , typename p0##_type, typename p1##_type, typename p2##_type, \ ++ typename p3##_type, typename p4##_type, typename p5##_type, \ ++ typename p6##_type, typename p7##_type ++#define GMOCK_INTERNAL_DECL_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ ++ p6, p7, p8) , typename p0##_type, typename p1##_type, typename p2##_type, \ ++ typename p3##_type, typename p4##_type, typename p5##_type, \ ++ typename p6##_type, typename p7##_type, typename p8##_type ++#define GMOCK_INTERNAL_DECL_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ ++ p6, p7, p8, p9) , typename p0##_type, typename p1##_type, \ ++ typename p2##_type, typename p3##_type, typename p4##_type, \ ++ typename p5##_type, typename p6##_type, typename p7##_type, \ ++ typename p8##_type, typename p9##_type ++ ++// Initializes the value parameters. ++#define GMOCK_INTERNAL_INIT_AND_0_VALUE_PARAMS()\ ++ () ++#define GMOCK_INTERNAL_INIT_AND_1_VALUE_PARAMS(p0)\ ++ (p0##_type gmock_p0) : p0(gmock_p0) ++#define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1)\ ++ (p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), p1(gmock_p1) ++#define GMOCK_INTERNAL_INIT_AND_3_VALUE_PARAMS(p0, p1, p2)\ ++ (p0##_type gmock_p0, p1##_type gmock_p1, \ ++ p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) ++#define GMOCK_INTERNAL_INIT_AND_4_VALUE_PARAMS(p0, p1, p2, p3)\ ++ (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ ++ p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ ++ p3(gmock_p3) ++#define GMOCK_INTERNAL_INIT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)\ ++ (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ ++ p3##_type gmock_p3, p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), \ ++ p2(gmock_p2), p3(gmock_p3), p4(gmock_p4) ++#define GMOCK_INTERNAL_INIT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)\ ++ (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ ++ p3##_type gmock_p3, p4##_type gmock_p4, \ ++ p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ ++ p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) ++#define GMOCK_INTERNAL_INIT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)\ ++ (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ ++ p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ ++ p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ ++ p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6) ++#define GMOCK_INTERNAL_INIT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)\ ++ (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ ++ p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ ++ p6##_type gmock_p6, p7##_type gmock_p7) : p0(gmock_p0), p1(gmock_p1), \ ++ p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \ ++ p7(gmock_p7) ++#define GMOCK_INTERNAL_INIT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ ++ p7, p8)\ ++ (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ ++ p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ ++ p6##_type gmock_p6, p7##_type gmock_p7, \ ++ p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ ++ p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \ ++ p8(gmock_p8) ++#define GMOCK_INTERNAL_INIT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ ++ p7, p8, p9)\ ++ (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ ++ p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ ++ p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \ ++ p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ ++ p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \ ++ p8(gmock_p8), p9(gmock_p9) ++ ++// Declares the fields for storing the value parameters. ++#define GMOCK_INTERNAL_DEFN_AND_0_VALUE_PARAMS() ++#define GMOCK_INTERNAL_DEFN_AND_1_VALUE_PARAMS(p0) p0##_type p0; ++#define GMOCK_INTERNAL_DEFN_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0; \ ++ p1##_type p1; ++#define GMOCK_INTERNAL_DEFN_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0; \ ++ p1##_type p1; p2##_type p2; ++#define GMOCK_INTERNAL_DEFN_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0; \ ++ p1##_type p1; p2##_type p2; p3##_type p3; ++#define GMOCK_INTERNAL_DEFN_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \ ++ p4) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; ++#define GMOCK_INTERNAL_DEFN_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \ ++ p5) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \ ++ p5##_type p5; ++#define GMOCK_INTERNAL_DEFN_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ ++ p6) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \ ++ p5##_type p5; p6##_type p6; ++#define GMOCK_INTERNAL_DEFN_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ ++ p7) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \ ++ p5##_type p5; p6##_type p6; p7##_type p7; ++#define GMOCK_INTERNAL_DEFN_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ ++ p7, p8) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \ ++ p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8; ++#define GMOCK_INTERNAL_DEFN_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ ++ p7, p8, p9) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \ ++ p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8; \ ++ p9##_type p9; ++ ++// Lists the value parameters. ++#define GMOCK_INTERNAL_LIST_AND_0_VALUE_PARAMS() ++#define GMOCK_INTERNAL_LIST_AND_1_VALUE_PARAMS(p0) p0 ++#define GMOCK_INTERNAL_LIST_AND_2_VALUE_PARAMS(p0, p1) p0, p1 ++#define GMOCK_INTERNAL_LIST_AND_3_VALUE_PARAMS(p0, p1, p2) p0, p1, p2 ++#define GMOCK_INTERNAL_LIST_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0, p1, p2, p3 ++#define GMOCK_INTERNAL_LIST_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) p0, p1, \ ++ p2, p3, p4 ++#define GMOCK_INTERNAL_LIST_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) p0, \ ++ p1, p2, p3, p4, p5 ++#define GMOCK_INTERNAL_LIST_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ ++ p6) p0, p1, p2, p3, p4, p5, p6 ++#define GMOCK_INTERNAL_LIST_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ ++ p7) p0, p1, p2, p3, p4, p5, p6, p7 ++#define GMOCK_INTERNAL_LIST_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ ++ p7, p8) p0, p1, p2, p3, p4, p5, p6, p7, p8 ++#define GMOCK_INTERNAL_LIST_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ ++ p7, p8, p9) p0, p1, p2, p3, p4, p5, p6, p7, p8, p9 ++ ++// Lists the value parameter types. ++#define GMOCK_INTERNAL_LIST_TYPE_AND_0_VALUE_PARAMS() ++#define GMOCK_INTERNAL_LIST_TYPE_AND_1_VALUE_PARAMS(p0) , p0##_type ++#define GMOCK_INTERNAL_LIST_TYPE_AND_2_VALUE_PARAMS(p0, p1) , p0##_type, \ ++ p1##_type ++#define GMOCK_INTERNAL_LIST_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , p0##_type, \ ++ p1##_type, p2##_type ++#define GMOCK_INTERNAL_LIST_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \ ++ p0##_type, p1##_type, p2##_type, p3##_type ++#define GMOCK_INTERNAL_LIST_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \ ++ p0##_type, p1##_type, p2##_type, p3##_type, p4##_type ++#define GMOCK_INTERNAL_LIST_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \ ++ p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type ++#define GMOCK_INTERNAL_LIST_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ ++ p6) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, \ ++ p6##_type ++#define GMOCK_INTERNAL_LIST_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ ++ p6, p7) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ ++ p5##_type, p6##_type, p7##_type ++#define GMOCK_INTERNAL_LIST_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ ++ p6, p7, p8) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ ++ p5##_type, p6##_type, p7##_type, p8##_type ++#define GMOCK_INTERNAL_LIST_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ ++ p6, p7, p8, p9) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ ++ p5##_type, p6##_type, p7##_type, p8##_type, p9##_type ++ ++// Declares the value parameters. ++#define GMOCK_INTERNAL_DECL_AND_0_VALUE_PARAMS() ++#define GMOCK_INTERNAL_DECL_AND_1_VALUE_PARAMS(p0) p0##_type p0 ++#define GMOCK_INTERNAL_DECL_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0, \ ++ p1##_type p1 ++#define GMOCK_INTERNAL_DECL_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0, \ ++ p1##_type p1, p2##_type p2 ++#define GMOCK_INTERNAL_DECL_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0, \ ++ p1##_type p1, p2##_type p2, p3##_type p3 ++#define GMOCK_INTERNAL_DECL_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \ ++ p4) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4 ++#define GMOCK_INTERNAL_DECL_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \ ++ p5) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \ ++ p5##_type p5 ++#define GMOCK_INTERNAL_DECL_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ ++ p6) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \ ++ p5##_type p5, p6##_type p6 ++#define GMOCK_INTERNAL_DECL_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ ++ p7) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \ ++ p5##_type p5, p6##_type p6, p7##_type p7 ++#define GMOCK_INTERNAL_DECL_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ ++ p7, p8) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ ++ p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8 ++#define GMOCK_INTERNAL_DECL_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ ++ p7, p8, p9) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ ++ p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \ ++ p9##_type p9 ++ ++// The suffix of the class template implementing the action template. ++#define GMOCK_INTERNAL_COUNT_AND_0_VALUE_PARAMS() ++#define GMOCK_INTERNAL_COUNT_AND_1_VALUE_PARAMS(p0) P ++#define GMOCK_INTERNAL_COUNT_AND_2_VALUE_PARAMS(p0, p1) P2 ++#define GMOCK_INTERNAL_COUNT_AND_3_VALUE_PARAMS(p0, p1, p2) P3 ++#define GMOCK_INTERNAL_COUNT_AND_4_VALUE_PARAMS(p0, p1, p2, p3) P4 ++#define GMOCK_INTERNAL_COUNT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) P5 ++#define GMOCK_INTERNAL_COUNT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) P6 ++#define GMOCK_INTERNAL_COUNT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) P7 ++#define GMOCK_INTERNAL_COUNT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ ++ p7) P8 ++#define GMOCK_INTERNAL_COUNT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ ++ p7, p8) P9 ++#define GMOCK_INTERNAL_COUNT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ ++ p7, p8, p9) P10 ++ ++// The name of the class template implementing the action template. ++#define GMOCK_ACTION_CLASS_(name, value_params)\ ++ GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params) ++ ++#define ACTION_TEMPLATE(name, template_params, value_params)\ ++ template \ ++ class GMOCK_ACTION_CLASS_(name, value_params) {\ ++ public:\ ++ explicit GMOCK_ACTION_CLASS_(name, value_params)\ ++ GMOCK_INTERNAL_INIT_##value_params {}\ ++ template \ ++ class gmock_Impl : public ::testing::ActionInterface {\ ++ public:\ ++ typedef F function_type;\ ++ typedef typename ::testing::internal::Function::Result return_type;\ ++ typedef typename ::testing::internal::Function::ArgumentTuple\ ++ args_type;\ ++ explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}\ ++ virtual return_type Perform(const args_type& args) {\ ++ return ::testing::internal::ActionHelper::\ ++ Perform(this, args);\ ++ }\ ++ template \ ++ return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ ++ arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ ++ arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ ++ arg9_type arg9) const;\ ++ GMOCK_INTERNAL_DEFN_##value_params\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template operator ::testing::Action() const {\ ++ return ::testing::Action(\ ++ new gmock_Impl(GMOCK_INTERNAL_LIST_##value_params));\ ++ }\ ++ GMOCK_INTERNAL_DEFN_##value_params\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\ ++ };\ ++ template \ ++ 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 \ ++ template \ ++ template \ ++ typename ::testing::internal::Function::Result\ ++ GMOCK_ACTION_CLASS_(name, value_params)<\ ++ GMOCK_INTERNAL_LIST_##template_params\ ++ GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl::\ ++ gmock_PerformImpl(\ ++ GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const ++ ++#define ACTION(name)\ ++ class name##Action {\ ++ public:\ ++ name##Action() {}\ ++ template \ ++ class gmock_Impl : public ::testing::ActionInterface {\ ++ public:\ ++ typedef F function_type;\ ++ typedef typename ::testing::internal::Function::Result return_type;\ ++ typedef typename ::testing::internal::Function::ArgumentTuple\ ++ args_type;\ ++ gmock_Impl() {}\ ++ virtual return_type Perform(const args_type& args) {\ ++ return ::testing::internal::ActionHelper::\ ++ Perform(this, args);\ ++ }\ ++ template \ ++ return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ ++ arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ ++ arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ ++ arg9_type arg9) const;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template operator ::testing::Action() const {\ ++ return ::testing::Action(new gmock_Impl());\ ++ }\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##Action);\ ++ };\ ++ inline name##Action name() {\ ++ return name##Action();\ ++ }\ ++ template \ ++ template \ ++ typename ::testing::internal::Function::Result\ ++ name##Action::gmock_Impl::gmock_PerformImpl(\ ++ GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const ++ ++#define ACTION_P(name, p0)\ ++ template \ ++ class name##ActionP {\ ++ public:\ ++ explicit name##ActionP(p0##_type gmock_p0) : p0(gmock_p0) {}\ ++ template \ ++ class gmock_Impl : public ::testing::ActionInterface {\ ++ public:\ ++ typedef F function_type;\ ++ typedef typename ::testing::internal::Function::Result return_type;\ ++ typedef typename ::testing::internal::Function::ArgumentTuple\ ++ args_type;\ ++ explicit gmock_Impl(p0##_type gmock_p0) : p0(gmock_p0) {}\ ++ virtual return_type Perform(const args_type& args) {\ ++ return ::testing::internal::ActionHelper::\ ++ Perform(this, args);\ ++ }\ ++ template \ ++ return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ ++ arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ ++ arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ ++ arg9_type arg9) const;\ ++ p0##_type p0;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template operator ::testing::Action() const {\ ++ return ::testing::Action(new gmock_Impl(p0));\ ++ }\ ++ p0##_type p0;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##ActionP);\ ++ };\ ++ template \ ++ inline name##ActionP name(p0##_type p0) {\ ++ return name##ActionP(p0);\ ++ }\ ++ template \ ++ template \ ++ template \ ++ typename ::testing::internal::Function::Result\ ++ name##ActionP::gmock_Impl::gmock_PerformImpl(\ ++ GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const ++ ++#define ACTION_P2(name, p0, p1)\ ++ template \ ++ class name##ActionP2 {\ ++ public:\ ++ name##ActionP2(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \ ++ p1(gmock_p1) {}\ ++ template \ ++ class gmock_Impl : public ::testing::ActionInterface {\ ++ public:\ ++ typedef F function_type;\ ++ typedef typename ::testing::internal::Function::Result return_type;\ ++ typedef typename ::testing::internal::Function::ArgumentTuple\ ++ args_type;\ ++ gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \ ++ p1(gmock_p1) {}\ ++ virtual return_type Perform(const args_type& args) {\ ++ return ::testing::internal::ActionHelper::\ ++ Perform(this, args);\ ++ }\ ++ template \ ++ return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ ++ arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ ++ arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ ++ arg9_type arg9) const;\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template operator ::testing::Action() const {\ ++ return ::testing::Action(new gmock_Impl(p0, p1));\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##ActionP2);\ ++ };\ ++ template \ ++ inline name##ActionP2 name(p0##_type p0, \ ++ p1##_type p1) {\ ++ return name##ActionP2(p0, p1);\ ++ }\ ++ template \ ++ template \ ++ template \ ++ typename ::testing::internal::Function::Result\ ++ name##ActionP2::gmock_Impl::gmock_PerformImpl(\ ++ GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const ++ ++#define ACTION_P3(name, p0, p1, p2)\ ++ template \ ++ class name##ActionP3 {\ ++ public:\ ++ name##ActionP3(p0##_type gmock_p0, p1##_type gmock_p1, \ ++ p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\ ++ template \ ++ class gmock_Impl : public ::testing::ActionInterface {\ ++ public:\ ++ typedef F function_type;\ ++ typedef typename ::testing::internal::Function::Result return_type;\ ++ typedef typename ::testing::internal::Function::ArgumentTuple\ ++ args_type;\ ++ gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, \ ++ p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\ ++ virtual return_type Perform(const args_type& args) {\ ++ return ::testing::internal::ActionHelper::\ ++ Perform(this, args);\ ++ }\ ++ template \ ++ return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ ++ arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ ++ arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ ++ arg9_type arg9) const;\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template operator ::testing::Action() const {\ ++ return ::testing::Action(new gmock_Impl(p0, p1, p2));\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##ActionP3);\ ++ };\ ++ template \ ++ inline name##ActionP3 name(p0##_type p0, \ ++ p1##_type p1, p2##_type p2) {\ ++ return name##ActionP3(p0, p1, p2);\ ++ }\ ++ template \ ++ template \ ++ template \ ++ typename ::testing::internal::Function::Result\ ++ name##ActionP3::gmock_Impl::gmock_PerformImpl(\ ++ GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const ++ ++#define ACTION_P4(name, p0, p1, p2, p3)\ ++ template \ ++ class name##ActionP4 {\ ++ public:\ ++ name##ActionP4(p0##_type gmock_p0, p1##_type gmock_p1, \ ++ p2##_type gmock_p2, p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), \ ++ p2(gmock_p2), p3(gmock_p3) {}\ ++ template \ ++ class gmock_Impl : public ::testing::ActionInterface {\ ++ public:\ ++ typedef F function_type;\ ++ typedef typename ::testing::internal::Function::Result return_type;\ ++ typedef typename ::testing::internal::Function::ArgumentTuple\ ++ args_type;\ ++ gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ ++ p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ ++ p3(gmock_p3) {}\ ++ virtual return_type Perform(const args_type& args) {\ ++ return ::testing::internal::ActionHelper::\ ++ Perform(this, args);\ ++ }\ ++ template \ ++ return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ ++ arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ ++ arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ ++ arg9_type arg9) const;\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template operator ::testing::Action() const {\ ++ return ::testing::Action(new gmock_Impl(p0, p1, p2, p3));\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##ActionP4);\ ++ };\ ++ template \ ++ inline name##ActionP4 name(p0##_type p0, p1##_type p1, p2##_type p2, \ ++ p3##_type p3) {\ ++ return name##ActionP4(p0, p1, \ ++ p2, p3);\ ++ }\ ++ template \ ++ template \ ++ template \ ++ typename ::testing::internal::Function::Result\ ++ name##ActionP4::gmock_Impl::gmock_PerformImpl(\ ++ GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const ++ ++#define ACTION_P5(name, p0, p1, p2, p3, p4)\ ++ template \ ++ class name##ActionP5 {\ ++ public:\ ++ name##ActionP5(p0##_type gmock_p0, p1##_type gmock_p1, \ ++ p2##_type gmock_p2, p3##_type gmock_p3, \ ++ p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ ++ p3(gmock_p3), p4(gmock_p4) {}\ ++ template \ ++ class gmock_Impl : public ::testing::ActionInterface {\ ++ public:\ ++ typedef F function_type;\ ++ typedef typename ::testing::internal::Function::Result return_type;\ ++ typedef typename ::testing::internal::Function::ArgumentTuple\ ++ args_type;\ ++ gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ ++ p3##_type gmock_p3, p4##_type gmock_p4) : p0(gmock_p0), \ ++ p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), p4(gmock_p4) {}\ ++ virtual return_type Perform(const args_type& args) {\ ++ return ::testing::internal::ActionHelper::\ ++ Perform(this, args);\ ++ }\ ++ template \ ++ return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ ++ arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ ++ arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ ++ arg9_type arg9) const;\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template operator ::testing::Action() const {\ ++ return ::testing::Action(new gmock_Impl(p0, p1, p2, p3, p4));\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##ActionP5);\ ++ };\ ++ template \ ++ inline name##ActionP5 name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ ++ p4##_type p4) {\ ++ return name##ActionP5(p0, p1, p2, p3, p4);\ ++ }\ ++ template \ ++ template \ ++ template \ ++ typename ::testing::internal::Function::Result\ ++ name##ActionP5::gmock_Impl::gmock_PerformImpl(\ ++ GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const ++ ++#define ACTION_P6(name, p0, p1, p2, p3, p4, p5)\ ++ template \ ++ class name##ActionP6 {\ ++ public:\ ++ name##ActionP6(p0##_type gmock_p0, p1##_type gmock_p1, \ ++ p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ ++ p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ ++ p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {}\ ++ template \ ++ class gmock_Impl : public ::testing::ActionInterface {\ ++ public:\ ++ typedef F function_type;\ ++ typedef typename ::testing::internal::Function::Result return_type;\ ++ typedef typename ::testing::internal::Function::ArgumentTuple\ ++ args_type;\ ++ gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ ++ p3##_type gmock_p3, p4##_type gmock_p4, \ ++ p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ ++ p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {}\ ++ virtual return_type Perform(const args_type& args) {\ ++ return ::testing::internal::ActionHelper::\ ++ Perform(this, args);\ ++ }\ ++ template \ ++ return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ ++ arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ ++ arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ ++ arg9_type arg9) const;\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ p5##_type p5;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template operator ::testing::Action() const {\ ++ return ::testing::Action(new gmock_Impl(p0, p1, p2, p3, p4, p5));\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ p5##_type p5;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##ActionP6);\ ++ };\ ++ template \ ++ inline name##ActionP6 name(p0##_type p0, p1##_type p1, p2##_type p2, \ ++ p3##_type p3, p4##_type p4, p5##_type p5) {\ ++ return name##ActionP6(p0, p1, p2, p3, p4, p5);\ ++ }\ ++ template \ ++ template \ ++ template \ ++ typename ::testing::internal::Function::Result\ ++ name##ActionP6::gmock_Impl::gmock_PerformImpl(\ ++ GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const ++ ++#define ACTION_P7(name, p0, p1, p2, p3, p4, p5, p6)\ ++ template \ ++ class name##ActionP7 {\ ++ public:\ ++ name##ActionP7(p0##_type gmock_p0, p1##_type gmock_p1, \ ++ p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ ++ p5##_type gmock_p5, p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), \ ++ p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), \ ++ p6(gmock_p6) {}\ ++ template \ ++ class gmock_Impl : public ::testing::ActionInterface {\ ++ public:\ ++ typedef F function_type;\ ++ typedef typename ::testing::internal::Function::Result return_type;\ ++ typedef typename ::testing::internal::Function::ArgumentTuple\ ++ args_type;\ ++ gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ ++ p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ ++ p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ ++ p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6) {}\ ++ virtual return_type Perform(const args_type& args) {\ ++ return ::testing::internal::ActionHelper::\ ++ Perform(this, args);\ ++ }\ ++ template \ ++ return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ ++ arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ ++ arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ ++ arg9_type arg9) const;\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ p5##_type p5;\ ++ p6##_type p6;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template operator ::testing::Action() const {\ ++ return ::testing::Action(new gmock_Impl(p0, p1, p2, p3, p4, p5, \ ++ p6));\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ p5##_type p5;\ ++ p6##_type p6;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##ActionP7);\ ++ };\ ++ template \ ++ inline name##ActionP7 name(p0##_type p0, p1##_type p1, \ ++ p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \ ++ p6##_type p6) {\ ++ return name##ActionP7(p0, p1, p2, p3, p4, p5, p6);\ ++ }\ ++ template \ ++ template \ ++ template \ ++ typename ::testing::internal::Function::Result\ ++ name##ActionP7::gmock_Impl::gmock_PerformImpl(\ ++ GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const ++ ++#define ACTION_P8(name, p0, p1, p2, p3, p4, p5, p6, p7)\ ++ template \ ++ class name##ActionP8 {\ ++ public:\ ++ name##ActionP8(p0##_type gmock_p0, p1##_type gmock_p1, \ ++ p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ ++ p5##_type gmock_p5, p6##_type gmock_p6, \ ++ p7##_type gmock_p7) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ ++ p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \ ++ p7(gmock_p7) {}\ ++ template \ ++ class gmock_Impl : public ::testing::ActionInterface {\ ++ public:\ ++ typedef F function_type;\ ++ typedef typename ::testing::internal::Function::Result return_type;\ ++ typedef typename ::testing::internal::Function::ArgumentTuple\ ++ args_type;\ ++ gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ ++ p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ ++ p6##_type gmock_p6, p7##_type gmock_p7) : p0(gmock_p0), \ ++ p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), \ ++ p5(gmock_p5), p6(gmock_p6), p7(gmock_p7) {}\ ++ virtual return_type Perform(const args_type& args) {\ ++ return ::testing::internal::ActionHelper::\ ++ Perform(this, args);\ ++ }\ ++ template \ ++ return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ ++ arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ ++ arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ ++ arg9_type arg9) const;\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ p5##_type p5;\ ++ p6##_type p6;\ ++ p7##_type p7;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template operator ::testing::Action() const {\ ++ return ::testing::Action(new gmock_Impl(p0, p1, p2, p3, p4, p5, \ ++ p6, p7));\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ p5##_type p5;\ ++ p6##_type p6;\ ++ p7##_type p7;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##ActionP8);\ ++ };\ ++ template \ ++ inline name##ActionP8 name(p0##_type p0, \ ++ p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \ ++ p6##_type p6, p7##_type p7) {\ ++ return name##ActionP8(p0, p1, p2, p3, p4, p5, \ ++ p6, p7);\ ++ }\ ++ template \ ++ template \ ++ template \ ++ typename ::testing::internal::Function::Result\ ++ name##ActionP8::gmock_Impl::gmock_PerformImpl(\ ++ GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const ++ ++#define ACTION_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8)\ ++ template \ ++ class name##ActionP9 {\ ++ public:\ ++ name##ActionP9(p0##_type gmock_p0, p1##_type gmock_p1, \ ++ p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ ++ p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \ ++ p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ ++ p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \ ++ p8(gmock_p8) {}\ ++ template \ ++ class gmock_Impl : public ::testing::ActionInterface {\ ++ public:\ ++ typedef F function_type;\ ++ typedef typename ::testing::internal::Function::Result return_type;\ ++ typedef typename ::testing::internal::Function::ArgumentTuple\ ++ args_type;\ ++ gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ ++ p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ ++ p6##_type gmock_p6, p7##_type gmock_p7, \ ++ p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ ++ p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \ ++ p7(gmock_p7), p8(gmock_p8) {}\ ++ virtual return_type Perform(const args_type& args) {\ ++ return ::testing::internal::ActionHelper::\ ++ Perform(this, args);\ ++ }\ ++ template \ ++ return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ ++ arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ ++ arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ ++ arg9_type arg9) const;\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ p5##_type p5;\ ++ p6##_type p6;\ ++ p7##_type p7;\ ++ p8##_type p8;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template operator ::testing::Action() const {\ ++ return ::testing::Action(new gmock_Impl(p0, p1, p2, p3, p4, p5, \ ++ p6, p7, p8));\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ p5##_type p5;\ ++ p6##_type p6;\ ++ p7##_type p7;\ ++ p8##_type p8;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##ActionP9);\ ++ };\ ++ template \ ++ inline name##ActionP9 name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ ++ p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \ ++ p8##_type p8) {\ ++ return name##ActionP9(p0, p1, p2, \ ++ p3, p4, p5, p6, p7, p8);\ ++ }\ ++ template \ ++ template \ ++ template \ ++ typename ::testing::internal::Function::Result\ ++ name##ActionP9::gmock_Impl::gmock_PerformImpl(\ ++ GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const ++ ++#define ACTION_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)\ ++ template \ ++ class name##ActionP10 {\ ++ public:\ ++ name##ActionP10(p0##_type gmock_p0, p1##_type gmock_p1, \ ++ p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ ++ p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \ ++ p8##_type gmock_p8, p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), \ ++ p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \ ++ p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {}\ ++ template \ ++ class gmock_Impl : public ::testing::ActionInterface {\ ++ public:\ ++ typedef F function_type;\ ++ typedef typename ::testing::internal::Function::Result return_type;\ ++ typedef typename ::testing::internal::Function::ArgumentTuple\ ++ args_type;\ ++ gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ ++ p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ ++ p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \ ++ p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ ++ p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \ ++ p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {}\ ++ virtual return_type Perform(const args_type& args) {\ ++ return ::testing::internal::ActionHelper::\ ++ Perform(this, args);\ ++ }\ ++ template \ ++ return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ ++ arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ ++ arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ ++ arg9_type arg9) const;\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ p5##_type p5;\ ++ p6##_type p6;\ ++ p7##_type p7;\ ++ p8##_type p8;\ ++ p9##_type p9;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template operator ::testing::Action() const {\ ++ return ::testing::Action(new gmock_Impl(p0, p1, p2, p3, p4, p5, \ ++ p6, p7, p8, p9));\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ p5##_type p5;\ ++ p6##_type p6;\ ++ p7##_type p7;\ ++ p8##_type p8;\ ++ p9##_type p9;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##ActionP10);\ ++ };\ ++ template \ ++ inline name##ActionP10 name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ ++ p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \ ++ p9##_type p9) {\ ++ return name##ActionP10(p0, \ ++ p1, p2, p3, p4, p5, p6, p7, p8, p9);\ ++ }\ ++ template \ ++ template \ ++ template \ ++ typename ::testing::internal::Function::Result\ ++ name##ActionP10::gmock_Impl::gmock_PerformImpl(\ ++ GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const ++ ++namespace testing { ++ ++// The ACTION*() macros trigger warning C4100 (unreferenced formal ++// parameter) in MSVC with -W4. Unfortunately they cannot be fixed in ++// the macro definition, as the warnings are generated when the macro ++// is expanded and macro expansion cannot contain #pragma. Therefore ++// we suppress them here. ++#ifdef _MSC_VER ++# pragma warning(push) ++# pragma warning(disable:4100) ++#endif ++ ++// Various overloads for InvokeArgument(). ++// ++// The InvokeArgument(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. ++ ++ACTION_TEMPLATE(InvokeArgument, ++ HAS_1_TEMPLATE_PARAMS(int, k), ++ AND_0_VALUE_PARAMS()) { ++ return internal::CallableHelper::Call( ++ ::testing::get(args)); ++} ++ ++ACTION_TEMPLATE(InvokeArgument, ++ HAS_1_TEMPLATE_PARAMS(int, k), ++ AND_1_VALUE_PARAMS(p0)) { ++ return internal::CallableHelper::Call( ++ ::testing::get(args), p0); ++} ++ ++ACTION_TEMPLATE(InvokeArgument, ++ HAS_1_TEMPLATE_PARAMS(int, k), ++ AND_2_VALUE_PARAMS(p0, p1)) { ++ return internal::CallableHelper::Call( ++ ::testing::get(args), p0, p1); ++} ++ ++ACTION_TEMPLATE(InvokeArgument, ++ HAS_1_TEMPLATE_PARAMS(int, k), ++ AND_3_VALUE_PARAMS(p0, p1, p2)) { ++ return internal::CallableHelper::Call( ++ ::testing::get(args), p0, p1, p2); ++} ++ ++ACTION_TEMPLATE(InvokeArgument, ++ HAS_1_TEMPLATE_PARAMS(int, k), ++ AND_4_VALUE_PARAMS(p0, p1, p2, p3)) { ++ return internal::CallableHelper::Call( ++ ::testing::get(args), p0, p1, p2, p3); ++} ++ ++ACTION_TEMPLATE(InvokeArgument, ++ HAS_1_TEMPLATE_PARAMS(int, k), ++ AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) { ++ return internal::CallableHelper::Call( ++ ::testing::get(args), p0, p1, p2, p3, p4); ++} ++ ++ACTION_TEMPLATE(InvokeArgument, ++ HAS_1_TEMPLATE_PARAMS(int, k), ++ AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) { ++ return internal::CallableHelper::Call( ++ ::testing::get(args), p0, p1, p2, p3, p4, p5); ++} ++ ++ACTION_TEMPLATE(InvokeArgument, ++ HAS_1_TEMPLATE_PARAMS(int, k), ++ AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) { ++ return internal::CallableHelper::Call( ++ ::testing::get(args), p0, p1, p2, p3, p4, p5, p6); ++} ++ ++ACTION_TEMPLATE(InvokeArgument, ++ HAS_1_TEMPLATE_PARAMS(int, k), ++ AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) { ++ return internal::CallableHelper::Call( ++ ::testing::get(args), p0, p1, p2, p3, p4, p5, p6, p7); ++} ++ ++ACTION_TEMPLATE(InvokeArgument, ++ HAS_1_TEMPLATE_PARAMS(int, k), ++ AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) { ++ return internal::CallableHelper::Call( ++ ::testing::get(args), p0, p1, p2, p3, p4, p5, p6, p7, p8); ++} ++ ++ACTION_TEMPLATE(InvokeArgument, ++ HAS_1_TEMPLATE_PARAMS(int, k), ++ AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) { ++ return internal::CallableHelper::Call( ++ ::testing::get(args), p0, p1, p2, p3, p4, p5, p6, p7, p8, p9); ++} ++ ++// Various overloads for ReturnNew(). ++// ++// The ReturnNew(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. ++ACTION_TEMPLATE(ReturnNew, ++ HAS_1_TEMPLATE_PARAMS(typename, T), ++ AND_0_VALUE_PARAMS()) { ++ return new T(); ++} ++ ++ACTION_TEMPLATE(ReturnNew, ++ HAS_1_TEMPLATE_PARAMS(typename, T), ++ AND_1_VALUE_PARAMS(p0)) { ++ return new T(p0); ++} ++ ++ACTION_TEMPLATE(ReturnNew, ++ HAS_1_TEMPLATE_PARAMS(typename, T), ++ AND_2_VALUE_PARAMS(p0, p1)) { ++ return new T(p0, p1); ++} ++ ++ACTION_TEMPLATE(ReturnNew, ++ HAS_1_TEMPLATE_PARAMS(typename, T), ++ AND_3_VALUE_PARAMS(p0, p1, p2)) { ++ return new T(p0, p1, p2); ++} ++ ++ACTION_TEMPLATE(ReturnNew, ++ HAS_1_TEMPLATE_PARAMS(typename, T), ++ AND_4_VALUE_PARAMS(p0, p1, p2, p3)) { ++ return new T(p0, p1, p2, p3); ++} ++ ++ACTION_TEMPLATE(ReturnNew, ++ HAS_1_TEMPLATE_PARAMS(typename, T), ++ AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) { ++ return new T(p0, p1, p2, p3, p4); ++} ++ ++ACTION_TEMPLATE(ReturnNew, ++ HAS_1_TEMPLATE_PARAMS(typename, T), ++ AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) { ++ return new T(p0, p1, p2, p3, p4, p5); ++} ++ ++ACTION_TEMPLATE(ReturnNew, ++ HAS_1_TEMPLATE_PARAMS(typename, T), ++ AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) { ++ return new T(p0, p1, p2, p3, p4, p5, p6); ++} ++ ++ACTION_TEMPLATE(ReturnNew, ++ HAS_1_TEMPLATE_PARAMS(typename, T), ++ AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) { ++ return new T(p0, p1, p2, p3, p4, p5, p6, p7); ++} ++ ++ACTION_TEMPLATE(ReturnNew, ++ HAS_1_TEMPLATE_PARAMS(typename, T), ++ AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) { ++ return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8); ++} ++ ++ACTION_TEMPLATE(ReturnNew, ++ HAS_1_TEMPLATE_PARAMS(typename, T), ++ AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) { ++ return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9); ++} ++ ++#ifdef _MSC_VER ++# pragma warning(pop) ++#endif ++ ++} // namespace testing ++ ++#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ +diff -urN mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-generated-actions.h.pump mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-generated-actions.h.pump +--- mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-generated-actions.h.pump 1970-01-01 09:00:00.000000000 +0900 ++++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-generated-actions.h.pump 2016-02-20 18:11:22.328832283 +0900 +@@ -0,0 +1,814 @@ ++$$ -*- 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 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 ++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 gets = [[$for j, [[get<$(j - 1)>(args)]]]] ++template ++class InvokeHelper > { ++ public: ++ template ++ static R Invoke(Function function, const ::testing::tuple<$as>&$args) { ++ return function($gets); ++ } ++ ++ template ++ static R InvokeMethod(Class* obj_ptr, ++ MethodPtr method_ptr, ++ const ::testing::tuple<$as>&$args) { ++ 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::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 ++class CallableHelper { ++ public: ++ // Calls a nullary callable. ++ template ++ 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 ++ 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 ++ 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 ::testing::tuple_element::type ++ ++$range i 1..n ++ ++// SelectArgs::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, 0, 3>::type ++// is int(bool, long). ++// ++// SelectArgs::Select(args) ++// returns the selected fields (k1, k2, ..., k_n) of args as a tuple. ++// For example, ++// SelectArgs, 2, 0>::Select( ++// ::testing::make_tuple(true, 'a', 2.5)) ++// returns 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 ++class SelectArgs { ++ public: ++ typedef Result type($for i, [[GMOCK_FIELD_(ArgumentTuple, k$i)]]); ++ typedef typename Function::ArgumentTuple SelectedArgs; ++ static SelectedArgs Select(const ArgumentTuple& args) { ++ return SelectedArgs($for i, [[get(args)]]); ++ } ++}; ++ ++ ++$for i [[ ++$range j 1..n ++$range j1 1..i-1 ++template ++class SelectArgs { ++ public: ++ typedef Result type($for j1, [[GMOCK_FIELD_(ArgumentTuple, k$j1)]]); ++ typedef typename Function::ArgumentTuple SelectedArgs; ++ static SelectedArgs Select(const ArgumentTuple& [[]] ++$if i == 1 [[/* args */]] $else [[args]]) { ++ return SelectedArgs($for j1, [[get(args)]]); ++ } ++}; ++ ++ ++]] ++#undef GMOCK_FIELD_ ++ ++$var ks = [[$for i, [[k$i]]]] ++ ++// Implements the WithArgs action. ++template ++class WithArgsAction { ++ public: ++ explicit WithArgsAction(const InnerAction& action) : action_(action) {} ++ ++ template ++ operator Action() const { return MakeAction(new Impl(action_)); } ++ ++ private: ++ template ++ class Impl : public ActionInterface { ++ public: ++ typedef typename Function::Result Result; ++ typedef typename Function::ArgumentTuple ArgumentTuple; ++ ++ explicit Impl(const InnerAction& action) : action_(action) {} ++ ++ virtual Result Perform(const ArgumentTuple& args) { ++ return action_.Perform(SelectArgs::Select(args)); ++ } ++ ++ private: ++ typedef typename SelectArgs::type InnerFunctionType; ++ ++ Action 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 ++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 ::testing::tuple<$As>& args) { ++ return impl->template gmock_PerformImpl<$As>(args, $arg_list); ++ } ++ ++]] ++}; ++ ++} // namespace internal ++ ++// Various overloads for Invoke(). ++ ++// WithArgs(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 ++WithArgs(const InnerAction& action) { ++ return internal::WithArgsAction(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 ++$range k 1..i-1 ++ ++inline $for k [[internal::DoBothAction]] ++ ++DoAll(Action1 a1$Aas) { ++$if i==2 [[ ++ ++ return internal::DoBothAction(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 ++// FooActionPk Foo(p1_type p1, ..., pk_type pk) { ... } ++// ++// In particular, you can provide the template type arguments ++// explicitly when invoking Foo(), as in Foo(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. 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(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(::testing::get(args)); ++// } ++// ... ++// int n; ++// EXPECT_CALL(mock, Foo(_, _)) ++// .WillOnce(DuplicateArg<1, unsigned char>(&n)); ++// ++// To create an instance of an action template, write: ++// ++// ActionName(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(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(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 \ ++ class GMOCK_ACTION_CLASS_(name, value_params) {\ ++ public:\ ++ explicit GMOCK_ACTION_CLASS_(name, value_params)\ ++ GMOCK_INTERNAL_INIT_##value_params {}\ ++ template \ ++ class gmock_Impl : public ::testing::ActionInterface {\ ++ public:\ ++ typedef F function_type;\ ++ typedef typename ::testing::internal::Function::Result return_type;\ ++ typedef typename ::testing::internal::Function::ArgumentTuple\ ++ args_type;\ ++ explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}\ ++ virtual return_type Perform(const args_type& args) {\ ++ return ::testing::internal::ActionHelper::\ ++ 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 operator ::testing::Action() const {\ ++ return ::testing::Action(\ ++ new gmock_Impl(GMOCK_INTERNAL_LIST_##value_params));\ ++ }\ ++ GMOCK_INTERNAL_DEFN_##value_params\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\ ++ };\ ++ template \ ++ 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 \ ++ template \ ++ template \ ++ typename ::testing::internal::Function::Result\ ++ GMOCK_ACTION_CLASS_(name, value_params)<\ ++ GMOCK_INTERNAL_LIST_##template_params\ ++ GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl::\ ++ gmock_PerformImpl(\ ++ GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const ++ ++$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:\ ++ [[$if i==1 [[explicit ]]]]$class_name($ctor_param_list)$inits {}\ ++ template \ ++ class gmock_Impl : public ::testing::ActionInterface {\ ++ public:\ ++ typedef F function_type;\ ++ typedef typename ::testing::internal::Function::Result return_type;\ ++ typedef typename ::testing::internal::Function::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::\ ++ 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 operator ::testing::Action() const {\ ++ return ::testing::Action(new gmock_Impl($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 \ ++ template <$typename_arg_types>\ ++ typename ::testing::internal::Function::Result\ ++ $class_name$param_types::gmock_Impl::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. ++ ++ ++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(). ++// ++// The InvokeArgument(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::Call( ++ ::testing::get(args)$for j [[, p$j]]); ++} ++ ++]] ++ ++// Various overloads for ReturnNew(). ++// ++// The ReturnNew(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_ +diff -urN mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-generated-function-mockers.h mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-generated-function-mockers.h +--- mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-generated-function-mockers.h 1970-01-01 09:00:00.000000000 +0900 ++++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-generated-function-mockers.h 2016-02-20 18:11:22.336832283 +0900 +@@ -0,0 +1,1095 @@ ++// 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" ++ ++#if GTEST_HAS_STD_FUNCTION_ ++# include ++#endif ++ ++namespace testing { ++namespace internal { ++ ++template ++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 ++class FunctionMocker; ++ ++template ++class FunctionMocker : public ++ internal::FunctionMockerBase { ++ public: ++ typedef R F(); ++ typedef typename internal::Function::ArgumentTuple ArgumentTuple; ++ ++ MockSpec& 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 ++class FunctionMocker : public ++ internal::FunctionMockerBase { ++ public: ++ typedef R F(A1); ++ typedef typename internal::Function::ArgumentTuple ArgumentTuple; ++ ++ MockSpec& With(const Matcher& m1) { ++ this->current_spec().SetMatchers(::testing::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 ++class FunctionMocker : public ++ internal::FunctionMockerBase { ++ public: ++ typedef R F(A1, A2); ++ typedef typename internal::Function::ArgumentTuple ArgumentTuple; ++ ++ MockSpec& With(const Matcher& m1, const Matcher& m2) { ++ this->current_spec().SetMatchers(::testing::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 ++class FunctionMocker : public ++ internal::FunctionMockerBase { ++ public: ++ typedef R F(A1, A2, A3); ++ typedef typename internal::Function::ArgumentTuple ArgumentTuple; ++ ++ MockSpec& With(const Matcher& m1, const Matcher& m2, ++ const Matcher& m3) { ++ this->current_spec().SetMatchers(::testing::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 ++class FunctionMocker : public ++ internal::FunctionMockerBase { ++ public: ++ typedef R F(A1, A2, A3, A4); ++ typedef typename internal::Function::ArgumentTuple ArgumentTuple; ++ ++ MockSpec& With(const Matcher& m1, const Matcher& m2, ++ const Matcher& m3, const Matcher& m4) { ++ this->current_spec().SetMatchers(::testing::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 ++class FunctionMocker : public ++ internal::FunctionMockerBase { ++ public: ++ typedef R F(A1, A2, A3, A4, A5); ++ typedef typename internal::Function::ArgumentTuple ArgumentTuple; ++ ++ MockSpec& With(const Matcher& m1, const Matcher& m2, ++ const Matcher& m3, const Matcher& m4, const Matcher& m5) { ++ this->current_spec().SetMatchers(::testing::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 ++class FunctionMocker : public ++ internal::FunctionMockerBase { ++ public: ++ typedef R F(A1, A2, A3, A4, A5, A6); ++ typedef typename internal::Function::ArgumentTuple ArgumentTuple; ++ ++ MockSpec& With(const Matcher& m1, const Matcher& m2, ++ const Matcher& m3, const Matcher& m4, const Matcher& m5, ++ const Matcher& m6) { ++ this->current_spec().SetMatchers(::testing::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 ++class FunctionMocker : public ++ internal::FunctionMockerBase { ++ public: ++ typedef R F(A1, A2, A3, A4, A5, A6, A7); ++ typedef typename internal::Function::ArgumentTuple ArgumentTuple; ++ ++ MockSpec& With(const Matcher& m1, const Matcher& m2, ++ const Matcher& m3, const Matcher& m4, const Matcher& m5, ++ const Matcher& m6, const Matcher& m7) { ++ this->current_spec().SetMatchers(::testing::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 ++class FunctionMocker : public ++ internal::FunctionMockerBase { ++ public: ++ typedef R F(A1, A2, A3, A4, A5, A6, A7, A8); ++ typedef typename internal::Function::ArgumentTuple ArgumentTuple; ++ ++ MockSpec& With(const Matcher& m1, const Matcher& m2, ++ const Matcher& m3, const Matcher& m4, const Matcher& m5, ++ const Matcher& m6, const Matcher& m7, const Matcher& m8) { ++ this->current_spec().SetMatchers(::testing::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 ++class FunctionMocker : public ++ internal::FunctionMockerBase { ++ public: ++ typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9); ++ typedef typename internal::Function::ArgumentTuple ArgumentTuple; ++ ++ MockSpec& With(const Matcher& m1, const Matcher& m2, ++ const Matcher& m3, const Matcher& m4, const Matcher& m5, ++ const Matcher& m6, const Matcher& m7, const Matcher& m8, ++ const Matcher& m9) { ++ this->current_spec().SetMatchers(::testing::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 ++class FunctionMocker : public ++ internal::FunctionMockerBase { ++ public: ++ typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10); ++ typedef typename internal::Function::ArgumentTuple ArgumentTuple; ++ ++ MockSpec& With(const Matcher& m1, const Matcher& m2, ++ const Matcher& m3, const Matcher& m4, const Matcher& m5, ++ const Matcher& m6, const Matcher& m7, const Matcher& m8, ++ const Matcher& m9, const Matcher& m10) { ++ this->current_spec().SetMatchers(::testing::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; ++ ++// GMOCK_RESULT_(tn, F) expands to the result type of function type F. ++// We define this as a variadic macro in case F contains unprotected ++// commas (the same reason that we use variadic macros in other places ++// in this file). ++// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! ++#define GMOCK_RESULT_(tn, ...) \ ++ tn ::testing::internal::Function<__VA_ARGS__>::Result ++ ++// The type of argument N of the given function type. ++// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! ++#define GMOCK_ARG_(tn, N, ...) \ ++ tn ::testing::internal::Function<__VA_ARGS__>::Argument##N ++ ++// The matcher type for argument N of the given function type. ++// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! ++#define GMOCK_MATCHER_(tn, N, ...) \ ++ const ::testing::Matcher& ++ ++// 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, ...) \ ++ GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ ++ ) constness { \ ++ GTEST_COMPILE_ASSERT_((::testing::tuple_size< \ ++ tn ::testing::internal::Function<__VA_ARGS__>::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<__VA_ARGS__>& \ ++ gmock_##Method() constness { \ ++ GMOCK_MOCKER_(0, constness, Method).RegisterOwner(this); \ ++ return GMOCK_MOCKER_(0, constness, Method).With(); \ ++ } \ ++ mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(0, constness, \ ++ Method) ++ ++// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! ++#define GMOCK_METHOD1_(tn, constness, ct, Method, ...) \ ++ GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ ++ GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1) constness { \ ++ GTEST_COMPILE_ASSERT_((::testing::tuple_size< \ ++ tn ::testing::internal::Function<__VA_ARGS__>::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<__VA_ARGS__>& \ ++ gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1) constness { \ ++ GMOCK_MOCKER_(1, constness, Method).RegisterOwner(this); \ ++ return GMOCK_MOCKER_(1, constness, Method).With(gmock_a1); \ ++ } \ ++ mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(1, constness, \ ++ Method) ++ ++// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! ++#define GMOCK_METHOD2_(tn, constness, ct, Method, ...) \ ++ GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ ++ GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \ ++ GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2) constness { \ ++ GTEST_COMPILE_ASSERT_((::testing::tuple_size< \ ++ tn ::testing::internal::Function<__VA_ARGS__>::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<__VA_ARGS__>& \ ++ gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ ++ GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2) constness { \ ++ GMOCK_MOCKER_(2, constness, Method).RegisterOwner(this); \ ++ return GMOCK_MOCKER_(2, constness, Method).With(gmock_a1, gmock_a2); \ ++ } \ ++ mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(2, constness, \ ++ Method) ++ ++// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! ++#define GMOCK_METHOD3_(tn, constness, ct, Method, ...) \ ++ GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ ++ GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \ ++ GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \ ++ GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3) constness { \ ++ GTEST_COMPILE_ASSERT_((::testing::tuple_size< \ ++ tn ::testing::internal::Function<__VA_ARGS__>::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<__VA_ARGS__>& \ ++ gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ ++ GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ ++ GMOCK_MATCHER_(tn, 3, __VA_ARGS__) 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<__VA_ARGS__> GMOCK_MOCKER_(3, constness, \ ++ Method) ++ ++// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! ++#define GMOCK_METHOD4_(tn, constness, ct, Method, ...) \ ++ GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ ++ GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \ ++ GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \ ++ GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \ ++ GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4) constness { \ ++ GTEST_COMPILE_ASSERT_((::testing::tuple_size< \ ++ tn ::testing::internal::Function<__VA_ARGS__>::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<__VA_ARGS__>& \ ++ gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ ++ GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ ++ GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \ ++ GMOCK_MATCHER_(tn, 4, __VA_ARGS__) 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<__VA_ARGS__> GMOCK_MOCKER_(4, constness, \ ++ Method) ++ ++// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! ++#define GMOCK_METHOD5_(tn, constness, ct, Method, ...) \ ++ GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ ++ GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \ ++ GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \ ++ GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \ ++ GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \ ++ GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5) constness { \ ++ GTEST_COMPILE_ASSERT_((::testing::tuple_size< \ ++ tn ::testing::internal::Function<__VA_ARGS__>::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<__VA_ARGS__>& \ ++ gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ ++ GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ ++ GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \ ++ GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \ ++ GMOCK_MATCHER_(tn, 5, __VA_ARGS__) 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<__VA_ARGS__> GMOCK_MOCKER_(5, constness, \ ++ Method) ++ ++// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! ++#define GMOCK_METHOD6_(tn, constness, ct, Method, ...) \ ++ GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ ++ GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \ ++ GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \ ++ GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \ ++ GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \ ++ GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \ ++ GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6) constness { \ ++ GTEST_COMPILE_ASSERT_((::testing::tuple_size< \ ++ tn ::testing::internal::Function<__VA_ARGS__>::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<__VA_ARGS__>& \ ++ gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ ++ GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ ++ GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \ ++ GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \ ++ GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \ ++ GMOCK_MATCHER_(tn, 6, __VA_ARGS__) 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<__VA_ARGS__> GMOCK_MOCKER_(6, constness, \ ++ Method) ++ ++// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! ++#define GMOCK_METHOD7_(tn, constness, ct, Method, ...) \ ++ GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ ++ GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \ ++ GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \ ++ GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \ ++ GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \ ++ GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \ ++ GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \ ++ GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7) constness { \ ++ GTEST_COMPILE_ASSERT_((::testing::tuple_size< \ ++ tn ::testing::internal::Function<__VA_ARGS__>::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<__VA_ARGS__>& \ ++ gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ ++ GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ ++ GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \ ++ GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \ ++ GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \ ++ GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \ ++ GMOCK_MATCHER_(tn, 7, __VA_ARGS__) 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<__VA_ARGS__> GMOCK_MOCKER_(7, constness, \ ++ Method) ++ ++// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! ++#define GMOCK_METHOD8_(tn, constness, ct, Method, ...) \ ++ GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ ++ GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \ ++ GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \ ++ GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \ ++ GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \ ++ GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \ ++ GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \ ++ GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, \ ++ GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8) constness { \ ++ GTEST_COMPILE_ASSERT_((::testing::tuple_size< \ ++ tn ::testing::internal::Function<__VA_ARGS__>::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<__VA_ARGS__>& \ ++ gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ ++ GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ ++ GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \ ++ GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \ ++ GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \ ++ GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \ ++ GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \ ++ GMOCK_MATCHER_(tn, 8, __VA_ARGS__) 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<__VA_ARGS__> GMOCK_MOCKER_(8, constness, \ ++ Method) ++ ++// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! ++#define GMOCK_METHOD9_(tn, constness, ct, Method, ...) \ ++ GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ ++ GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \ ++ GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \ ++ GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \ ++ GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \ ++ GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \ ++ GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \ ++ GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, \ ++ GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8, \ ++ GMOCK_ARG_(tn, 9, __VA_ARGS__) gmock_a9) constness { \ ++ GTEST_COMPILE_ASSERT_((::testing::tuple_size< \ ++ tn ::testing::internal::Function<__VA_ARGS__>::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<__VA_ARGS__>& \ ++ gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ ++ GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ ++ GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \ ++ GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \ ++ GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \ ++ GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \ ++ GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \ ++ GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8, \ ++ GMOCK_MATCHER_(tn, 9, __VA_ARGS__) 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<__VA_ARGS__> GMOCK_MOCKER_(9, constness, \ ++ Method) ++ ++// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! ++#define GMOCK_METHOD10_(tn, constness, ct, Method, ...) \ ++ GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ ++ GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \ ++ GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \ ++ GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \ ++ GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \ ++ GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \ ++ GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \ ++ GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, \ ++ GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8, \ ++ GMOCK_ARG_(tn, 9, __VA_ARGS__) gmock_a9, \ ++ GMOCK_ARG_(tn, 10, __VA_ARGS__) gmock_a10) constness { \ ++ GTEST_COMPILE_ASSERT_((::testing::tuple_size< \ ++ tn ::testing::internal::Function<__VA_ARGS__>::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<__VA_ARGS__>& \ ++ gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ ++ GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ ++ GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \ ++ GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \ ++ GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \ ++ GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \ ++ GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \ ++ GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8, \ ++ GMOCK_MATCHER_(tn, 9, __VA_ARGS__) gmock_a9, \ ++ GMOCK_MATCHER_(tn, 10, \ ++ __VA_ARGS__) 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<__VA_ARGS__> GMOCK_MOCKER_(10, constness, \ ++ Method) ++ ++#define MOCK_METHOD0(m, ...) GMOCK_METHOD0_(, , , m, __VA_ARGS__) ++#define MOCK_METHOD1(m, ...) GMOCK_METHOD1_(, , , m, __VA_ARGS__) ++#define MOCK_METHOD2(m, ...) GMOCK_METHOD2_(, , , m, __VA_ARGS__) ++#define MOCK_METHOD3(m, ...) GMOCK_METHOD3_(, , , m, __VA_ARGS__) ++#define MOCK_METHOD4(m, ...) GMOCK_METHOD4_(, , , m, __VA_ARGS__) ++#define MOCK_METHOD5(m, ...) GMOCK_METHOD5_(, , , m, __VA_ARGS__) ++#define MOCK_METHOD6(m, ...) GMOCK_METHOD6_(, , , m, __VA_ARGS__) ++#define MOCK_METHOD7(m, ...) GMOCK_METHOD7_(, , , m, __VA_ARGS__) ++#define MOCK_METHOD8(m, ...) GMOCK_METHOD8_(, , , m, __VA_ARGS__) ++#define MOCK_METHOD9(m, ...) GMOCK_METHOD9_(, , , m, __VA_ARGS__) ++#define MOCK_METHOD10(m, ...) GMOCK_METHOD10_(, , , m, __VA_ARGS__) ++ ++#define MOCK_CONST_METHOD0(m, ...) GMOCK_METHOD0_(, const, , m, __VA_ARGS__) ++#define MOCK_CONST_METHOD1(m, ...) GMOCK_METHOD1_(, const, , m, __VA_ARGS__) ++#define MOCK_CONST_METHOD2(m, ...) GMOCK_METHOD2_(, const, , m, __VA_ARGS__) ++#define MOCK_CONST_METHOD3(m, ...) GMOCK_METHOD3_(, const, , m, __VA_ARGS__) ++#define MOCK_CONST_METHOD4(m, ...) GMOCK_METHOD4_(, const, , m, __VA_ARGS__) ++#define MOCK_CONST_METHOD5(m, ...) GMOCK_METHOD5_(, const, , m, __VA_ARGS__) ++#define MOCK_CONST_METHOD6(m, ...) GMOCK_METHOD6_(, const, , m, __VA_ARGS__) ++#define MOCK_CONST_METHOD7(m, ...) GMOCK_METHOD7_(, const, , m, __VA_ARGS__) ++#define MOCK_CONST_METHOD8(m, ...) GMOCK_METHOD8_(, const, , m, __VA_ARGS__) ++#define MOCK_CONST_METHOD9(m, ...) GMOCK_METHOD9_(, const, , m, __VA_ARGS__) ++#define MOCK_CONST_METHOD10(m, ...) GMOCK_METHOD10_(, const, , m, __VA_ARGS__) ++ ++#define MOCK_METHOD0_T(m, ...) GMOCK_METHOD0_(typename, , , m, __VA_ARGS__) ++#define MOCK_METHOD1_T(m, ...) GMOCK_METHOD1_(typename, , , m, __VA_ARGS__) ++#define MOCK_METHOD2_T(m, ...) GMOCK_METHOD2_(typename, , , m, __VA_ARGS__) ++#define MOCK_METHOD3_T(m, ...) GMOCK_METHOD3_(typename, , , m, __VA_ARGS__) ++#define MOCK_METHOD4_T(m, ...) GMOCK_METHOD4_(typename, , , m, __VA_ARGS__) ++#define MOCK_METHOD5_T(m, ...) GMOCK_METHOD5_(typename, , , m, __VA_ARGS__) ++#define MOCK_METHOD6_T(m, ...) GMOCK_METHOD6_(typename, , , m, __VA_ARGS__) ++#define MOCK_METHOD7_T(m, ...) GMOCK_METHOD7_(typename, , , m, __VA_ARGS__) ++#define MOCK_METHOD8_T(m, ...) GMOCK_METHOD8_(typename, , , m, __VA_ARGS__) ++#define MOCK_METHOD9_T(m, ...) GMOCK_METHOD9_(typename, , , m, __VA_ARGS__) ++#define MOCK_METHOD10_T(m, ...) GMOCK_METHOD10_(typename, , , m, __VA_ARGS__) ++ ++#define MOCK_CONST_METHOD0_T(m, ...) \ ++ GMOCK_METHOD0_(typename, const, , m, __VA_ARGS__) ++#define MOCK_CONST_METHOD1_T(m, ...) \ ++ GMOCK_METHOD1_(typename, const, , m, __VA_ARGS__) ++#define MOCK_CONST_METHOD2_T(m, ...) \ ++ GMOCK_METHOD2_(typename, const, , m, __VA_ARGS__) ++#define MOCK_CONST_METHOD3_T(m, ...) \ ++ GMOCK_METHOD3_(typename, const, , m, __VA_ARGS__) ++#define MOCK_CONST_METHOD4_T(m, ...) \ ++ GMOCK_METHOD4_(typename, const, , m, __VA_ARGS__) ++#define MOCK_CONST_METHOD5_T(m, ...) \ ++ GMOCK_METHOD5_(typename, const, , m, __VA_ARGS__) ++#define MOCK_CONST_METHOD6_T(m, ...) \ ++ GMOCK_METHOD6_(typename, const, , m, __VA_ARGS__) ++#define MOCK_CONST_METHOD7_T(m, ...) \ ++ GMOCK_METHOD7_(typename, const, , m, __VA_ARGS__) ++#define MOCK_CONST_METHOD8_T(m, ...) \ ++ GMOCK_METHOD8_(typename, const, , m, __VA_ARGS__) ++#define MOCK_CONST_METHOD9_T(m, ...) \ ++ GMOCK_METHOD9_(typename, const, , m, __VA_ARGS__) ++#define MOCK_CONST_METHOD10_T(m, ...) \ ++ GMOCK_METHOD10_(typename, const, , m, __VA_ARGS__) ++ ++#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD0_(, , ct, m, __VA_ARGS__) ++#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD1_(, , ct, m, __VA_ARGS__) ++#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD2_(, , ct, m, __VA_ARGS__) ++#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD3_(, , ct, m, __VA_ARGS__) ++#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD4_(, , ct, m, __VA_ARGS__) ++#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD5_(, , ct, m, __VA_ARGS__) ++#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD6_(, , ct, m, __VA_ARGS__) ++#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD7_(, , ct, m, __VA_ARGS__) ++#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD8_(, , ct, m, __VA_ARGS__) ++#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD9_(, , ct, m, __VA_ARGS__) ++#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD10_(, , ct, m, __VA_ARGS__) ++ ++#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD0_(, const, ct, m, __VA_ARGS__) ++#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD1_(, const, ct, m, __VA_ARGS__) ++#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD2_(, const, ct, m, __VA_ARGS__) ++#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD3_(, const, ct, m, __VA_ARGS__) ++#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD4_(, const, ct, m, __VA_ARGS__) ++#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD5_(, const, ct, m, __VA_ARGS__) ++#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD6_(, const, ct, m, __VA_ARGS__) ++#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD7_(, const, ct, m, __VA_ARGS__) ++#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD8_(, const, ct, m, __VA_ARGS__) ++#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD9_(, const, ct, m, __VA_ARGS__) ++#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD10_(, const, ct, m, __VA_ARGS__) ++ ++#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD0_(typename, , ct, m, __VA_ARGS__) ++#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD1_(typename, , ct, m, __VA_ARGS__) ++#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD2_(typename, , ct, m, __VA_ARGS__) ++#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD3_(typename, , ct, m, __VA_ARGS__) ++#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD4_(typename, , ct, m, __VA_ARGS__) ++#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD5_(typename, , ct, m, __VA_ARGS__) ++#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD6_(typename, , ct, m, __VA_ARGS__) ++#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD7_(typename, , ct, m, __VA_ARGS__) ++#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD8_(typename, , ct, m, __VA_ARGS__) ++#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD9_(typename, , ct, m, __VA_ARGS__) ++#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD10_(typename, , ct, m, __VA_ARGS__) ++ ++#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD0_(typename, const, ct, m, __VA_ARGS__) ++#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD1_(typename, const, ct, m, __VA_ARGS__) ++#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD2_(typename, const, ct, m, __VA_ARGS__) ++#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD3_(typename, const, ct, m, __VA_ARGS__) ++#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD4_(typename, const, ct, m, __VA_ARGS__) ++#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD5_(typename, const, ct, m, __VA_ARGS__) ++#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD6_(typename, const, ct, m, __VA_ARGS__) ++#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD7_(typename, const, ct, m, __VA_ARGS__) ++#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD8_(typename, const, ct, m, __VA_ARGS__) ++#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD9_(typename, const, ct, m, __VA_ARGS__) ++#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD10_(typename, const, ct, m, __VA_ARGS__) ++ ++// A MockFunction 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 check; ++// { ++// InSequence s; ++// ++// EXPECT_CALL(mock, Bar("a")); ++// EXPECT_CALL(check, Call("1")); ++// EXPECT_CALL(check, Call("2")); ++// EXPECT_CALL(mock, Bar("a")); ++// } ++// Foo(1); ++// check.Call("1"); ++// Foo(2); ++// check.Call("2"); ++// Foo(3); ++// } ++// ++// The expectation spec says that the first Bar("a") must happen ++// before check point "1", the second Bar("a") must happen after check ++// point "2", and nothing should happen between the two check ++// points. The explicit check points make it easy to tell which ++// Bar("a") is called by which call to Foo(). ++// ++// MockFunction can also be used to exercise code that accepts ++// std::function callbacks. To do so, use AsStdFunction() method ++// to create std::function proxy forwarding to original object's Call. ++// Example: ++// ++// TEST(FooTest, RunsCallbackWithBarArgument) { ++// MockFunction callback; ++// EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1)); ++// Foo(callback.AsStdFunction()); ++// } ++template ++class MockFunction; ++ ++template ++class MockFunction { ++ public: ++ MockFunction() {} ++ ++ MOCK_METHOD0_T(Call, R()); ++ ++#if GTEST_HAS_STD_FUNCTION_ ++ std::function AsStdFunction() { ++ return [this]() { ++ return this->Call(); ++ }; ++ } ++#endif // GTEST_HAS_STD_FUNCTION_ ++ ++ private: ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); ++}; ++ ++template ++class MockFunction { ++ public: ++ MockFunction() {} ++ ++ MOCK_METHOD1_T(Call, R(A0)); ++ ++#if GTEST_HAS_STD_FUNCTION_ ++ std::function AsStdFunction() { ++ return [this](A0 a0) { ++ return this->Call(a0); ++ }; ++ } ++#endif // GTEST_HAS_STD_FUNCTION_ ++ ++ private: ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); ++}; ++ ++template ++class MockFunction { ++ public: ++ MockFunction() {} ++ ++ MOCK_METHOD2_T(Call, R(A0, A1)); ++ ++#if GTEST_HAS_STD_FUNCTION_ ++ std::function AsStdFunction() { ++ return [this](A0 a0, A1 a1) { ++ return this->Call(a0, a1); ++ }; ++ } ++#endif // GTEST_HAS_STD_FUNCTION_ ++ ++ private: ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); ++}; ++ ++template ++class MockFunction { ++ public: ++ MockFunction() {} ++ ++ MOCK_METHOD3_T(Call, R(A0, A1, A2)); ++ ++#if GTEST_HAS_STD_FUNCTION_ ++ std::function AsStdFunction() { ++ return [this](A0 a0, A1 a1, A2 a2) { ++ return this->Call(a0, a1, a2); ++ }; ++ } ++#endif // GTEST_HAS_STD_FUNCTION_ ++ ++ private: ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); ++}; ++ ++template ++class MockFunction { ++ public: ++ MockFunction() {} ++ ++ MOCK_METHOD4_T(Call, R(A0, A1, A2, A3)); ++ ++#if GTEST_HAS_STD_FUNCTION_ ++ std::function AsStdFunction() { ++ return [this](A0 a0, A1 a1, A2 a2, A3 a3) { ++ return this->Call(a0, a1, a2, a3); ++ }; ++ } ++#endif // GTEST_HAS_STD_FUNCTION_ ++ ++ private: ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); ++}; ++ ++template ++class MockFunction { ++ public: ++ MockFunction() {} ++ ++ MOCK_METHOD5_T(Call, R(A0, A1, A2, A3, A4)); ++ ++#if GTEST_HAS_STD_FUNCTION_ ++ std::function AsStdFunction() { ++ return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { ++ return this->Call(a0, a1, a2, a3, a4); ++ }; ++ } ++#endif // GTEST_HAS_STD_FUNCTION_ ++ ++ private: ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); ++}; ++ ++template ++class MockFunction { ++ public: ++ MockFunction() {} ++ ++ MOCK_METHOD6_T(Call, R(A0, A1, A2, A3, A4, A5)); ++ ++#if GTEST_HAS_STD_FUNCTION_ ++ std::function AsStdFunction() { ++ return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { ++ return this->Call(a0, a1, a2, a3, a4, a5); ++ }; ++ } ++#endif // GTEST_HAS_STD_FUNCTION_ ++ ++ private: ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); ++}; ++ ++template ++class MockFunction { ++ public: ++ MockFunction() {} ++ ++ MOCK_METHOD7_T(Call, R(A0, A1, A2, A3, A4, A5, A6)); ++ ++#if GTEST_HAS_STD_FUNCTION_ ++ std::function AsStdFunction() { ++ return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { ++ return this->Call(a0, a1, a2, a3, a4, a5, a6); ++ }; ++ } ++#endif // GTEST_HAS_STD_FUNCTION_ ++ ++ private: ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); ++}; ++ ++template ++class MockFunction { ++ public: ++ MockFunction() {} ++ ++ MOCK_METHOD8_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7)); ++ ++#if GTEST_HAS_STD_FUNCTION_ ++ std::function AsStdFunction() { ++ return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { ++ return this->Call(a0, a1, a2, a3, a4, a5, a6, a7); ++ }; ++ } ++#endif // GTEST_HAS_STD_FUNCTION_ ++ ++ private: ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); ++}; ++ ++template ++class MockFunction { ++ public: ++ MockFunction() {} ++ ++ MOCK_METHOD9_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8)); ++ ++#if GTEST_HAS_STD_FUNCTION_ ++ std::function AsStdFunction() { ++ return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, ++ A8 a8) { ++ return this->Call(a0, a1, a2, a3, a4, a5, a6, a7, a8); ++ }; ++ } ++#endif // GTEST_HAS_STD_FUNCTION_ ++ ++ private: ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); ++}; ++ ++template ++class MockFunction { ++ public: ++ MockFunction() {} ++ ++ MOCK_METHOD10_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)); ++ ++#if GTEST_HAS_STD_FUNCTION_ ++ std::function AsStdFunction() { ++ return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, ++ A8 a8, A9 a9) { ++ return this->Call(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); ++ }; ++ } ++#endif // GTEST_HAS_STD_FUNCTION_ ++ ++ private: ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); ++}; ++ ++} // namespace testing ++ ++#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_ +diff -urN mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-generated-function-mockers.h.pump mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-generated-function-mockers.h.pump +--- mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-generated-function-mockers.h.pump 1970-01-01 09:00:00.000000000 +0900 ++++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-generated-function-mockers.h.pump 2016-02-20 18:11:22.316832283 +0900 +@@ -0,0 +1,291 @@ ++$$ -*- 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" ++ ++#if GTEST_HAS_STD_FUNCTION_ ++# include ++#endif ++ ++namespace testing { ++namespace internal { ++ ++template ++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 ++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& m$j]]]] ++template ++class FunctionMocker : public ++ internal::FunctionMockerBase { ++ public: ++ typedef R F($As); ++ typedef typename internal::Function::ArgumentTuple ArgumentTuple; ++ ++ MockSpec& With($matchers) { ++ ++$if i >= 1 [[ ++ this->current_spec().SetMatchers(::testing::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; ++ ++// GMOCK_RESULT_(tn, F) expands to the result type of function type F. ++// We define this as a variadic macro in case F contains unprotected ++// commas (the same reason that we use variadic macros in other places ++// in this file). ++// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! ++#define GMOCK_RESULT_(tn, ...) \ ++ tn ::testing::internal::Function<__VA_ARGS__>::Result ++ ++// The type of argument N of the given function type. ++// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! ++#define GMOCK_ARG_(tn, N, ...) \ ++ tn ::testing::internal::Function<__VA_ARGS__>::Argument##N ++ ++// The matcher type for argument N of the given function type. ++// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! ++#define GMOCK_MATCHER_(tn, N, ...) \ ++ const ::testing::Matcher& ++ ++// 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, $j, __VA_ARGS__) gmock_a$j]]]] ++$var as = [[$for j, [[gmock_a$j]]]] ++$var matcher_as = [[$for j, \ ++ [[GMOCK_MATCHER_(tn, $j, __VA_ARGS__) gmock_a$j]]]] ++// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! ++#define GMOCK_METHOD$i[[]]_(tn, constness, ct, Method, ...) \ ++ GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ ++ $arg_as) constness { \ ++ GTEST_COMPILE_ASSERT_((::testing::tuple_size< \ ++ tn ::testing::internal::Function<__VA_ARGS__>::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<__VA_ARGS__>& \ ++ gmock_##Method($matcher_as) constness { \ ++ GMOCK_MOCKER_($i, constness, Method).RegisterOwner(this); \ ++ return GMOCK_MOCKER_($i, constness, Method).With($as); \ ++ } \ ++ mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_($i, constness, Method) ++ ++ ++]] ++$for i [[ ++#define MOCK_METHOD$i(m, ...) GMOCK_METHOD$i[[]]_(, , , m, __VA_ARGS__) ++ ++]] ++ ++ ++$for i [[ ++#define MOCK_CONST_METHOD$i(m, ...) GMOCK_METHOD$i[[]]_(, const, , m, __VA_ARGS__) ++ ++]] ++ ++ ++$for i [[ ++#define MOCK_METHOD$i[[]]_T(m, ...) GMOCK_METHOD$i[[]]_(typename, , , m, __VA_ARGS__) ++ ++]] ++ ++ ++$for i [[ ++#define MOCK_CONST_METHOD$i[[]]_T(m, ...) \ ++ GMOCK_METHOD$i[[]]_(typename, const, , m, __VA_ARGS__) ++ ++]] ++ ++ ++$for i [[ ++#define MOCK_METHOD$i[[]]_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD$i[[]]_(, , ct, m, __VA_ARGS__) ++ ++]] ++ ++ ++$for i [[ ++#define MOCK_CONST_METHOD$i[[]]_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD$i[[]]_(, const, ct, m, __VA_ARGS__) ++ ++]] ++ ++ ++$for i [[ ++#define MOCK_METHOD$i[[]]_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD$i[[]]_(typename, , ct, m, __VA_ARGS__) ++ ++]] ++ ++ ++$for i [[ ++#define MOCK_CONST_METHOD$i[[]]_T_WITH_CALLTYPE(ct, m, ...) \ ++ GMOCK_METHOD$i[[]]_(typename, const, ct, m, __VA_ARGS__) ++ ++]] ++ ++// A MockFunction 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 check; ++// { ++// InSequence s; ++// ++// EXPECT_CALL(mock, Bar("a")); ++// EXPECT_CALL(check, Call("1")); ++// EXPECT_CALL(check, Call("2")); ++// EXPECT_CALL(mock, Bar("a")); ++// } ++// Foo(1); ++// check.Call("1"); ++// Foo(2); ++// check.Call("2"); ++// Foo(3); ++// } ++// ++// The expectation spec says that the first Bar("a") must happen ++// before check point "1", the second Bar("a") must happen after check ++// point "2", and nothing should happen between the two check ++// points. The explicit check points make it easy to tell which ++// Bar("a") is called by which call to Foo(). ++// ++// MockFunction can also be used to exercise code that accepts ++// std::function callbacks. To do so, use AsStdFunction() method ++// to create std::function proxy forwarding to original object's Call. ++// Example: ++// ++// TEST(FooTest, RunsCallbackWithBarArgument) { ++// MockFunction callback; ++// EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1)); ++// Foo(callback.AsStdFunction()); ++// } ++template ++class MockFunction; ++ ++ ++$for i [[ ++$range j 0..i-1 ++$var ArgTypes = [[$for j, [[A$j]]]] ++$var ArgNames = [[$for j, [[a$j]]]] ++$var ArgDecls = [[$for j, [[A$j a$j]]]] ++template ++class MockFunction { ++ public: ++ MockFunction() {} ++ ++ MOCK_METHOD$i[[]]_T(Call, R($ArgTypes)); ++ ++#if GTEST_HAS_STD_FUNCTION_ ++ std::function AsStdFunction() { ++ return [this]($ArgDecls) { ++ return this->Call($ArgNames); ++ }; ++ } ++#endif // GTEST_HAS_STD_FUNCTION_ ++ ++ private: ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); ++}; ++ ++ ++]] ++} // namespace testing ++ ++#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_ +diff -urN mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-generated-matchers.h mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-generated-matchers.h +--- mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-generated-matchers.h 1970-01-01 09:00:00.000000000 +0900 ++++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-generated-matchers.h 2016-02-20 18:11:22.324832283 +0900 +@@ -0,0 +1,2179 @@ ++// This file was GENERATED by command: ++// pump.py gmock-generated-matchers.h.pump ++// 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. ++ ++// 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 ++#include ++#include ++#include ++#include "gmock/gmock-matchers.h" ++ ++namespace testing { ++namespace internal { ++ ++// The type of the i-th (0-based) field of Tuple. ++#define GMOCK_FIELD_TYPE_(Tuple, i) \ ++ typename ::testing::tuple_element::type ++ ++// TupleFields 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, 2, 0>, we have: ++// ++// type is tuple, and ++// GetSelectedFields(make_tuple(true, 'a', 42)) is (42, true). ++ ++template ++class TupleFields; ++ ++// This generic version is used when there are 10 selectors. ++template ++class TupleFields { ++ public: ++ typedef ::testing::tuple type; ++ static type GetSelectedFields(const Tuple& t) { ++ return type(get(t), get(t), get(t), get(t), get(t), ++ get(t), get(t), get(t), get(t), get(t)); ++ } ++}; ++ ++// The following specialization is used for 0 ~ 9 selectors. ++ ++template ++class TupleFields { ++ public: ++ typedef ::testing::tuple<> type; ++ static type GetSelectedFields(const Tuple& /* t */) { ++ return type(); ++ } ++}; ++ ++template ++class TupleFields { ++ public: ++ typedef ::testing::tuple type; ++ static type GetSelectedFields(const Tuple& t) { ++ return type(get(t)); ++ } ++}; ++ ++template ++class TupleFields { ++ public: ++ typedef ::testing::tuple type; ++ static type GetSelectedFields(const Tuple& t) { ++ return type(get(t), get(t)); ++ } ++}; ++ ++template ++class TupleFields { ++ public: ++ typedef ::testing::tuple type; ++ static type GetSelectedFields(const Tuple& t) { ++ return type(get(t), get(t), get(t)); ++ } ++}; ++ ++template ++class TupleFields { ++ public: ++ typedef ::testing::tuple type; ++ static type GetSelectedFields(const Tuple& t) { ++ return type(get(t), get(t), get(t), get(t)); ++ } ++}; ++ ++template ++class TupleFields { ++ public: ++ typedef ::testing::tuple type; ++ static type GetSelectedFields(const Tuple& t) { ++ return type(get(t), get(t), get(t), get(t), get(t)); ++ } ++}; ++ ++template ++class TupleFields { ++ public: ++ typedef ::testing::tuple type; ++ static type GetSelectedFields(const Tuple& t) { ++ return type(get(t), get(t), get(t), get(t), get(t), ++ get(t)); ++ } ++}; ++ ++template ++class TupleFields { ++ public: ++ typedef ::testing::tuple type; ++ static type GetSelectedFields(const Tuple& t) { ++ return type(get(t), get(t), get(t), get(t), get(t), ++ get(t), get(t)); ++ } ++}; ++ ++template ++class TupleFields { ++ public: ++ typedef ::testing::tuple type; ++ static type GetSelectedFields(const Tuple& t) { ++ return type(get(t), get(t), get(t), get(t), get(t), ++ get(t), get(t), get(t)); ++ } ++}; ++ ++template ++class TupleFields { ++ public: ++ typedef ::testing::tuple type; ++ static type GetSelectedFields(const Tuple& t) { ++ return type(get(t), get(t), get(t), get(t), get(t), ++ get(t), get(t), get(t), get(t)); ++ } ++}; ++ ++#undef GMOCK_FIELD_TYPE_ ++ ++// Implements the Args() matcher. ++template ++class ArgsMatcherImpl : public MatcherInterface { ++ public: ++ // ArgsTuple may have top-level const or reference modifiers. ++ typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple; ++ typedef typename internal::TupleFields::type SelectedArgs; ++ typedef Matcher MonomorphicInnerMatcher; ++ ++ template ++ explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher) ++ : inner_matcher_(SafeMatcherCast(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::GetSelectedFields(args); ++ } ++ ++ // Prints the indices of the selected fields. ++ static void PrintIndices(::std::ostream* os) { ++ *os << "whose fields ("; ++ const int indices[10] = { k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 }; ++ for (int i = 0; i < 10; i++) { ++ if (indices[i] < 0) ++ break; ++ ++ if (i >= 1) ++ *os << ", "; ++ ++ *os << "#" << indices[i]; ++ } ++ *os << ") "; ++ } ++ ++ const MonomorphicInnerMatcher inner_matcher_; ++ ++ GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl); ++}; ++ ++template ++class ArgsMatcher { ++ public: ++ explicit ArgsMatcher(const InnerMatcher& inner_matcher) ++ : inner_matcher_(inner_matcher) {} ++ ++ template ++ operator Matcher() const { ++ return MakeMatcher(new ArgsMatcherImpl(inner_matcher_)); ++ } ++ ++ private: ++ const InnerMatcher inner_matcher_; ++ ++ GTEST_DISALLOW_ASSIGN_(ArgsMatcher); ++}; ++ ++// A set of metafunctions for computing the result type of AllOf. ++// AllOf(m1, ..., mN) returns ++// AllOfResultN::type. ++ ++// Although AllOf isn't defined for one argument, AllOfResult1 is defined ++// to simplify the implementation. ++template ++struct AllOfResult1 { ++ typedef M1 type; ++}; ++ ++template ++struct AllOfResult2 { ++ typedef BothOfMatcher< ++ typename AllOfResult1::type, ++ typename AllOfResult1::type ++ > type; ++}; ++ ++template ++struct AllOfResult3 { ++ typedef BothOfMatcher< ++ typename AllOfResult1::type, ++ typename AllOfResult2::type ++ > type; ++}; ++ ++template ++struct AllOfResult4 { ++ typedef BothOfMatcher< ++ typename AllOfResult2::type, ++ typename AllOfResult2::type ++ > type; ++}; ++ ++template ++struct AllOfResult5 { ++ typedef BothOfMatcher< ++ typename AllOfResult2::type, ++ typename AllOfResult3::type ++ > type; ++}; ++ ++template ++struct AllOfResult6 { ++ typedef BothOfMatcher< ++ typename AllOfResult3::type, ++ typename AllOfResult3::type ++ > type; ++}; ++ ++template ++struct AllOfResult7 { ++ typedef BothOfMatcher< ++ typename AllOfResult3::type, ++ typename AllOfResult4::type ++ > type; ++}; ++ ++template ++struct AllOfResult8 { ++ typedef BothOfMatcher< ++ typename AllOfResult4::type, ++ typename AllOfResult4::type ++ > type; ++}; ++ ++template ++struct AllOfResult9 { ++ typedef BothOfMatcher< ++ typename AllOfResult4::type, ++ typename AllOfResult5::type ++ > type; ++}; ++ ++template ++struct AllOfResult10 { ++ typedef BothOfMatcher< ++ typename AllOfResult5::type, ++ typename AllOfResult5::type ++ > type; ++}; ++ ++// A set of metafunctions for computing the result type of AnyOf. ++// AnyOf(m1, ..., mN) returns ++// AnyOfResultN::type. ++ ++// Although AnyOf isn't defined for one argument, AnyOfResult1 is defined ++// to simplify the implementation. ++template ++struct AnyOfResult1 { ++ typedef M1 type; ++}; ++ ++template ++struct AnyOfResult2 { ++ typedef EitherOfMatcher< ++ typename AnyOfResult1::type, ++ typename AnyOfResult1::type ++ > type; ++}; ++ ++template ++struct AnyOfResult3 { ++ typedef EitherOfMatcher< ++ typename AnyOfResult1::type, ++ typename AnyOfResult2::type ++ > type; ++}; ++ ++template ++struct AnyOfResult4 { ++ typedef EitherOfMatcher< ++ typename AnyOfResult2::type, ++ typename AnyOfResult2::type ++ > type; ++}; ++ ++template ++struct AnyOfResult5 { ++ typedef EitherOfMatcher< ++ typename AnyOfResult2::type, ++ typename AnyOfResult3::type ++ > type; ++}; ++ ++template ++struct AnyOfResult6 { ++ typedef EitherOfMatcher< ++ typename AnyOfResult3::type, ++ typename AnyOfResult3::type ++ > type; ++}; ++ ++template ++struct AnyOfResult7 { ++ typedef EitherOfMatcher< ++ typename AnyOfResult3::type, ++ typename AnyOfResult4::type ++ > type; ++}; ++ ++template ++struct AnyOfResult8 { ++ typedef EitherOfMatcher< ++ typename AnyOfResult4::type, ++ typename AnyOfResult4::type ++ > type; ++}; ++ ++template ++struct AnyOfResult9 { ++ typedef EitherOfMatcher< ++ typename AnyOfResult4::type, ++ typename AnyOfResult5::type ++ > type; ++}; ++ ++template ++struct AnyOfResult10 { ++ typedef EitherOfMatcher< ++ typename AnyOfResult5::type, ++ typename AnyOfResult5::type ++ > type; ++}; ++ ++} // namespace internal ++ ++// Args(a_matcher) matches a tuple if the selected ++// fields of it matches a_matcher. C++ doesn't support default ++// arguments for function templates, so we have to overload it. ++template ++inline internal::ArgsMatcher ++Args(const InnerMatcher& matcher) { ++ return internal::ArgsMatcher(matcher); ++} ++ ++template ++inline internal::ArgsMatcher ++Args(const InnerMatcher& matcher) { ++ return internal::ArgsMatcher(matcher); ++} ++ ++template ++inline internal::ArgsMatcher ++Args(const InnerMatcher& matcher) { ++ return internal::ArgsMatcher(matcher); ++} ++ ++template ++inline internal::ArgsMatcher ++Args(const InnerMatcher& matcher) { ++ return internal::ArgsMatcher(matcher); ++} ++ ++template ++inline internal::ArgsMatcher ++Args(const InnerMatcher& matcher) { ++ return internal::ArgsMatcher(matcher); ++} ++ ++template ++inline internal::ArgsMatcher ++Args(const InnerMatcher& matcher) { ++ return internal::ArgsMatcher(matcher); ++} ++ ++template ++inline internal::ArgsMatcher ++Args(const InnerMatcher& matcher) { ++ return internal::ArgsMatcher(matcher); ++} ++ ++template ++inline internal::ArgsMatcher ++Args(const InnerMatcher& matcher) { ++ return internal::ArgsMatcher(matcher); ++} ++ ++template ++inline internal::ArgsMatcher ++Args(const InnerMatcher& matcher) { ++ return internal::ArgsMatcher(matcher); ++} ++ ++template ++inline internal::ArgsMatcher ++Args(const InnerMatcher& matcher) { ++ return internal::ArgsMatcher(matcher); ++} ++ ++template ++inline internal::ArgsMatcher ++Args(const InnerMatcher& matcher) { ++ return internal::ArgsMatcher(matcher); ++} ++ ++// ElementsAre(e_1, e_2, ... e_n) matches an STL-style container with ++// n 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 ++// 10 arguments. ++// ++// The use of DecayArray in the implementation allows ElementsAre() ++// to accept string literals, whose type is const char[N], but we ++// want to treat them as const char*. ++// ++// 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::ElementsAreMatcher< ++ ::testing::tuple<> > ++ElementsAre() { ++ typedef ::testing::tuple<> Args; ++ return internal::ElementsAreMatcher(Args()); ++} ++ ++template ++inline internal::ElementsAreMatcher< ++ ::testing::tuple< ++ typename internal::DecayArray::type> > ++ElementsAre(const T1& e1) { ++ typedef ::testing::tuple< ++ typename internal::DecayArray::type> Args; ++ return internal::ElementsAreMatcher(Args(e1)); ++} ++ ++template ++inline internal::ElementsAreMatcher< ++ ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> > ++ElementsAre(const T1& e1, const T2& e2) { ++ typedef ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> Args; ++ return internal::ElementsAreMatcher(Args(e1, e2)); ++} ++ ++template ++inline internal::ElementsAreMatcher< ++ ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> > ++ElementsAre(const T1& e1, const T2& e2, const T3& e3) { ++ typedef ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> Args; ++ return internal::ElementsAreMatcher(Args(e1, e2, e3)); ++} ++ ++template ++inline internal::ElementsAreMatcher< ++ ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> > ++ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4) { ++ typedef ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> Args; ++ return internal::ElementsAreMatcher(Args(e1, e2, e3, e4)); ++} ++ ++template ++inline internal::ElementsAreMatcher< ++ ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> > ++ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, ++ const T5& e5) { ++ typedef ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> Args; ++ return internal::ElementsAreMatcher(Args(e1, e2, e3, e4, e5)); ++} ++ ++template ++inline internal::ElementsAreMatcher< ++ ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> > ++ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, ++ const T5& e5, const T6& e6) { ++ typedef ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> Args; ++ return internal::ElementsAreMatcher(Args(e1, e2, e3, e4, e5, e6)); ++} ++ ++template ++inline internal::ElementsAreMatcher< ++ ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> > ++ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, ++ const T5& e5, const T6& e6, const T7& e7) { ++ typedef ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> Args; ++ return internal::ElementsAreMatcher(Args(e1, e2, e3, e4, e5, e6, e7)); ++} ++ ++template ++inline internal::ElementsAreMatcher< ++ ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> > ++ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, ++ const T5& e5, const T6& e6, const T7& e7, const T8& e8) { ++ typedef ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> Args; ++ return internal::ElementsAreMatcher(Args(e1, e2, e3, e4, e5, e6, e7, ++ e8)); ++} ++ ++template ++inline internal::ElementsAreMatcher< ++ ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> > ++ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, ++ const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9) { ++ typedef ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> Args; ++ return internal::ElementsAreMatcher(Args(e1, e2, e3, e4, e5, e6, e7, ++ e8, e9)); ++} ++ ++template ++inline internal::ElementsAreMatcher< ++ ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> > ++ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, ++ const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9, ++ const T10& e10) { ++ typedef ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> Args; ++ return internal::ElementsAreMatcher(Args(e1, e2, e3, e4, e5, e6, e7, ++ e8, e9, e10)); ++} ++ ++// UnorderedElementsAre(e_1, e_2, ..., e_n) is an ElementsAre extension ++// that matches n elements in any order. We support up to n=10 arguments. ++ ++inline internal::UnorderedElementsAreMatcher< ++ ::testing::tuple<> > ++UnorderedElementsAre() { ++ typedef ::testing::tuple<> Args; ++ return internal::UnorderedElementsAreMatcher(Args()); ++} ++ ++template ++inline internal::UnorderedElementsAreMatcher< ++ ::testing::tuple< ++ typename internal::DecayArray::type> > ++UnorderedElementsAre(const T1& e1) { ++ typedef ::testing::tuple< ++ typename internal::DecayArray::type> Args; ++ return internal::UnorderedElementsAreMatcher(Args(e1)); ++} ++ ++template ++inline internal::UnorderedElementsAreMatcher< ++ ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> > ++UnorderedElementsAre(const T1& e1, const T2& e2) { ++ typedef ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> Args; ++ return internal::UnorderedElementsAreMatcher(Args(e1, e2)); ++} ++ ++template ++inline internal::UnorderedElementsAreMatcher< ++ ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> > ++UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3) { ++ typedef ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> Args; ++ return internal::UnorderedElementsAreMatcher(Args(e1, e2, e3)); ++} ++ ++template ++inline internal::UnorderedElementsAreMatcher< ++ ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> > ++UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4) { ++ typedef ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> Args; ++ return internal::UnorderedElementsAreMatcher(Args(e1, e2, e3, e4)); ++} ++ ++template ++inline internal::UnorderedElementsAreMatcher< ++ ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> > ++UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, ++ const T5& e5) { ++ typedef ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> Args; ++ return internal::UnorderedElementsAreMatcher(Args(e1, e2, e3, e4, e5)); ++} ++ ++template ++inline internal::UnorderedElementsAreMatcher< ++ ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> > ++UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, ++ const T5& e5, const T6& e6) { ++ typedef ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> Args; ++ return internal::UnorderedElementsAreMatcher(Args(e1, e2, e3, e4, e5, ++ e6)); ++} ++ ++template ++inline internal::UnorderedElementsAreMatcher< ++ ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> > ++UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, ++ const T5& e5, const T6& e6, const T7& e7) { ++ typedef ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> Args; ++ return internal::UnorderedElementsAreMatcher(Args(e1, e2, e3, e4, e5, ++ e6, e7)); ++} ++ ++template ++inline internal::UnorderedElementsAreMatcher< ++ ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> > ++UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, ++ const T5& e5, const T6& e6, const T7& e7, const T8& e8) { ++ typedef ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> Args; ++ return internal::UnorderedElementsAreMatcher(Args(e1, e2, e3, e4, e5, ++ e6, e7, e8)); ++} ++ ++template ++inline internal::UnorderedElementsAreMatcher< ++ ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> > ++UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, ++ const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9) { ++ typedef ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> Args; ++ return internal::UnorderedElementsAreMatcher(Args(e1, e2, e3, e4, e5, ++ e6, e7, e8, e9)); ++} ++ ++template ++inline internal::UnorderedElementsAreMatcher< ++ ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> > ++UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, ++ const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9, ++ const T10& e10) { ++ typedef ::testing::tuple< ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type, ++ typename internal::DecayArray::type> Args; ++ return internal::UnorderedElementsAreMatcher(Args(e1, e2, e3, e4, e5, ++ e6, e7, e8, e9, e10)); ++} ++ ++// 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. ++ ++template ++inline typename internal::AllOfResult2::type ++AllOf(M1 m1, M2 m2) { ++ return typename internal::AllOfResult2::type( ++ m1, ++ m2); ++} ++ ++template ++inline typename internal::AllOfResult3::type ++AllOf(M1 m1, M2 m2, M3 m3) { ++ return typename internal::AllOfResult3::type( ++ m1, ++ ::testing::AllOf(m2, m3)); ++} ++ ++template ++inline typename internal::AllOfResult4::type ++AllOf(M1 m1, M2 m2, M3 m3, M4 m4) { ++ return typename internal::AllOfResult4::type( ++ ::testing::AllOf(m1, m2), ++ ::testing::AllOf(m3, m4)); ++} ++ ++template ++inline typename internal::AllOfResult5::type ++AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) { ++ return typename internal::AllOfResult5::type( ++ ::testing::AllOf(m1, m2), ++ ::testing::AllOf(m3, m4, m5)); ++} ++ ++template ++inline typename internal::AllOfResult6::type ++AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) { ++ return typename internal::AllOfResult6::type( ++ ::testing::AllOf(m1, m2, m3), ++ ::testing::AllOf(m4, m5, m6)); ++} ++ ++template ++inline typename internal::AllOfResult7::type ++AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) { ++ return typename internal::AllOfResult7::type( ++ ::testing::AllOf(m1, m2, m3), ++ ::testing::AllOf(m4, m5, m6, m7)); ++} ++ ++template ++inline typename internal::AllOfResult8::type ++AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) { ++ return typename internal::AllOfResult8::type( ++ ::testing::AllOf(m1, m2, m3, m4), ++ ::testing::AllOf(m5, m6, m7, m8)); ++} ++ ++template ++inline typename internal::AllOfResult9::type ++AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) { ++ return typename internal::AllOfResult9::type( ++ ::testing::AllOf(m1, m2, m3, m4), ++ ::testing::AllOf(m5, m6, m7, m8, m9)); ++} ++ ++template ++inline typename internal::AllOfResult10::type ++AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) { ++ return typename internal::AllOfResult10::type( ++ ::testing::AllOf(m1, m2, m3, m4, m5), ++ ::testing::AllOf(m6, m7, m8, m9, m10)); ++} ++ ++// 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. ++ ++template ++inline typename internal::AnyOfResult2::type ++AnyOf(M1 m1, M2 m2) { ++ return typename internal::AnyOfResult2::type( ++ m1, ++ m2); ++} ++ ++template ++inline typename internal::AnyOfResult3::type ++AnyOf(M1 m1, M2 m2, M3 m3) { ++ return typename internal::AnyOfResult3::type( ++ m1, ++ ::testing::AnyOf(m2, m3)); ++} ++ ++template ++inline typename internal::AnyOfResult4::type ++AnyOf(M1 m1, M2 m2, M3 m3, M4 m4) { ++ return typename internal::AnyOfResult4::type( ++ ::testing::AnyOf(m1, m2), ++ ::testing::AnyOf(m3, m4)); ++} ++ ++template ++inline typename internal::AnyOfResult5::type ++AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) { ++ return typename internal::AnyOfResult5::type( ++ ::testing::AnyOf(m1, m2), ++ ::testing::AnyOf(m3, m4, m5)); ++} ++ ++template ++inline typename internal::AnyOfResult6::type ++AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) { ++ return typename internal::AnyOfResult6::type( ++ ::testing::AnyOf(m1, m2, m3), ++ ::testing::AnyOf(m4, m5, m6)); ++} ++ ++template ++inline typename internal::AnyOfResult7::type ++AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) { ++ return typename internal::AnyOfResult7::type( ++ ::testing::AnyOf(m1, m2, m3), ++ ::testing::AnyOf(m4, m5, m6, m7)); ++} ++ ++template ++inline typename internal::AnyOfResult8::type ++AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) { ++ return typename internal::AnyOfResult8::type( ++ ::testing::AnyOf(m1, m2, m3, m4), ++ ::testing::AnyOf(m5, m6, m7, m8)); ++} ++ ++template ++inline typename internal::AnyOfResult9::type ++AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) { ++ return typename internal::AnyOfResult9::type( ++ ::testing::AnyOf(m1, m2, m3, m4), ++ ::testing::AnyOf(m5, m6, m7, m8, m9)); ++} ++ ++template ++inline typename internal::AnyOfResult10::type ++AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) { ++ return typename internal::AnyOfResult10::type( ++ ::testing::AnyOf(m1, m2, m3, m4, m5), ++ ::testing::AnyOf(m6, m7, m8, m9, m10)); ++} ++ ++} // namespace testing ++ ++ ++// 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_P10 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 ++// FooMatcherPk ++// 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(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. 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. ++ ++#define MATCHER(name, description)\ ++ class name##Matcher {\ ++ public:\ ++ template \ ++ class gmock_Impl : public ::testing::MatcherInterface {\ ++ public:\ ++ gmock_Impl()\ ++ {}\ ++ 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);\ ++ }\ ++ 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(\ ++ ::testing::tuple<>()));\ ++ }\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template \ ++ operator ::testing::Matcher() const {\ ++ return ::testing::Matcher(\ ++ new gmock_Impl());\ ++ }\ ++ name##Matcher() {\ ++ }\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##Matcher);\ ++ };\ ++ inline name##Matcher name() {\ ++ return name##Matcher();\ ++ }\ ++ template \ ++ bool name##Matcher::gmock_Impl::MatchAndExplain(\ ++ arg_type arg, \ ++ ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ ++ const ++ ++#define MATCHER_P(name, p0, description)\ ++ template \ ++ class name##MatcherP {\ ++ public:\ ++ template \ ++ class gmock_Impl : public ::testing::MatcherInterface {\ ++ public:\ ++ explicit gmock_Impl(p0##_type gmock_p0)\ ++ : p0(gmock_p0) {}\ ++ 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);\ ++ }\ ++ p0##_type p0;\ ++ 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(\ ++ ::testing::tuple(p0)));\ ++ }\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template \ ++ operator ::testing::Matcher() const {\ ++ return ::testing::Matcher(\ ++ new gmock_Impl(p0));\ ++ }\ ++ explicit name##MatcherP(p0##_type gmock_p0) : p0(gmock_p0) {\ ++ }\ ++ p0##_type p0;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##MatcherP);\ ++ };\ ++ template \ ++ inline name##MatcherP name(p0##_type p0) {\ ++ return name##MatcherP(p0);\ ++ }\ ++ template \ ++ template \ ++ bool name##MatcherP::gmock_Impl::MatchAndExplain(\ ++ arg_type arg, \ ++ ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ ++ const ++ ++#define MATCHER_P2(name, p0, p1, description)\ ++ template \ ++ class name##MatcherP2 {\ ++ public:\ ++ template \ ++ class gmock_Impl : public ::testing::MatcherInterface {\ ++ public:\ ++ gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1)\ ++ : p0(gmock_p0), p1(gmock_p1) {}\ ++ 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);\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ 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(\ ++ ::testing::tuple(p0, p1)));\ ++ }\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template \ ++ operator ::testing::Matcher() const {\ ++ return ::testing::Matcher(\ ++ new gmock_Impl(p0, p1));\ ++ }\ ++ name##MatcherP2(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \ ++ p1(gmock_p1) {\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##MatcherP2);\ ++ };\ ++ template \ ++ inline name##MatcherP2 name(p0##_type p0, \ ++ p1##_type p1) {\ ++ return name##MatcherP2(p0, p1);\ ++ }\ ++ template \ ++ template \ ++ bool name##MatcherP2::gmock_Impl::MatchAndExplain(\ ++ arg_type arg, \ ++ ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ ++ const ++ ++#define MATCHER_P3(name, p0, p1, p2, description)\ ++ template \ ++ class name##MatcherP3 {\ ++ public:\ ++ template \ ++ class gmock_Impl : public ::testing::MatcherInterface {\ ++ public:\ ++ gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2)\ ++ : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\ ++ 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);\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ 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(\ ++ ::testing::tuple(p0, p1, \ ++ p2)));\ ++ }\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template \ ++ operator ::testing::Matcher() const {\ ++ return ::testing::Matcher(\ ++ new gmock_Impl(p0, p1, p2));\ ++ }\ ++ name##MatcherP3(p0##_type gmock_p0, p1##_type gmock_p1, \ ++ p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##MatcherP3);\ ++ };\ ++ template \ ++ inline name##MatcherP3 name(p0##_type p0, \ ++ p1##_type p1, p2##_type p2) {\ ++ return name##MatcherP3(p0, p1, p2);\ ++ }\ ++ template \ ++ template \ ++ bool name##MatcherP3::gmock_Impl::MatchAndExplain(\ ++ arg_type arg, \ ++ ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ ++ const ++ ++#define MATCHER_P4(name, p0, p1, p2, p3, description)\ ++ template \ ++ class name##MatcherP4 {\ ++ public:\ ++ template \ ++ class gmock_Impl : public ::testing::MatcherInterface {\ ++ public:\ ++ gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ ++ p3##_type gmock_p3)\ ++ : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3) {}\ ++ 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);\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ 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(\ ++ ::testing::tuple(p0, p1, p2, p3)));\ ++ }\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template \ ++ operator ::testing::Matcher() const {\ ++ return ::testing::Matcher(\ ++ new gmock_Impl(p0, p1, p2, p3));\ ++ }\ ++ name##MatcherP4(p0##_type gmock_p0, p1##_type gmock_p1, \ ++ p2##_type gmock_p2, p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), \ ++ p2(gmock_p2), p3(gmock_p3) {\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##MatcherP4);\ ++ };\ ++ template \ ++ inline name##MatcherP4 name(p0##_type p0, p1##_type p1, p2##_type p2, \ ++ p3##_type p3) {\ ++ return name##MatcherP4(p0, \ ++ p1, p2, p3);\ ++ }\ ++ template \ ++ template \ ++ bool name##MatcherP4::gmock_Impl::MatchAndExplain(\ ++ arg_type arg, \ ++ ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ ++ const ++ ++#define MATCHER_P5(name, p0, p1, p2, p3, p4, description)\ ++ template \ ++ class name##MatcherP5 {\ ++ public:\ ++ template \ ++ class gmock_Impl : public ::testing::MatcherInterface {\ ++ public:\ ++ gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ ++ p3##_type gmock_p3, p4##_type gmock_p4)\ ++ : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \ ++ p4(gmock_p4) {}\ ++ 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);\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ 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(\ ++ ::testing::tuple(p0, p1, p2, p3, p4)));\ ++ }\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template \ ++ operator ::testing::Matcher() const {\ ++ return ::testing::Matcher(\ ++ new gmock_Impl(p0, p1, p2, p3, p4));\ ++ }\ ++ name##MatcherP5(p0##_type gmock_p0, p1##_type gmock_p1, \ ++ p2##_type gmock_p2, p3##_type gmock_p3, \ ++ p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ ++ p3(gmock_p3), p4(gmock_p4) {\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##MatcherP5);\ ++ };\ ++ template \ ++ inline name##MatcherP5 name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ ++ p4##_type p4) {\ ++ return name##MatcherP5(p0, p1, p2, p3, p4);\ ++ }\ ++ template \ ++ template \ ++ bool name##MatcherP5::gmock_Impl::MatchAndExplain(\ ++ arg_type arg, \ ++ ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ ++ const ++ ++#define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description)\ ++ template \ ++ class name##MatcherP6 {\ ++ public:\ ++ template \ ++ class gmock_Impl : public ::testing::MatcherInterface {\ ++ public:\ ++ gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ ++ p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5)\ ++ : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \ ++ p4(gmock_p4), p5(gmock_p5) {}\ ++ 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);\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ p5##_type p5;\ ++ 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(\ ++ ::testing::tuple(p0, p1, p2, p3, p4, p5)));\ ++ }\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template \ ++ operator ::testing::Matcher() const {\ ++ return ::testing::Matcher(\ ++ new gmock_Impl(p0, p1, p2, p3, p4, p5));\ ++ }\ ++ name##MatcherP6(p0##_type gmock_p0, p1##_type gmock_p1, \ ++ p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ ++ p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ ++ p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ p5##_type p5;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##MatcherP6);\ ++ };\ ++ template \ ++ inline name##MatcherP6 name(p0##_type p0, p1##_type p1, p2##_type p2, \ ++ p3##_type p3, p4##_type p4, p5##_type p5) {\ ++ return name##MatcherP6(p0, p1, p2, p3, p4, p5);\ ++ }\ ++ template \ ++ template \ ++ bool name##MatcherP6::gmock_Impl::MatchAndExplain(\ ++ arg_type arg, \ ++ ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ ++ const ++ ++#define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description)\ ++ template \ ++ class name##MatcherP7 {\ ++ public:\ ++ template \ ++ class gmock_Impl : public ::testing::MatcherInterface {\ ++ public:\ ++ gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ ++ p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ ++ p6##_type gmock_p6)\ ++ : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \ ++ p4(gmock_p4), p5(gmock_p5), p6(gmock_p6) {}\ ++ 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);\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ p5##_type p5;\ ++ p6##_type p6;\ ++ 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(\ ++ ::testing::tuple(p0, p1, p2, p3, p4, p5, \ ++ p6)));\ ++ }\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template \ ++ operator ::testing::Matcher() const {\ ++ return ::testing::Matcher(\ ++ new gmock_Impl(p0, p1, p2, p3, p4, p5, p6));\ ++ }\ ++ name##MatcherP7(p0##_type gmock_p0, p1##_type gmock_p1, \ ++ p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ ++ p5##_type gmock_p5, p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), \ ++ p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), \ ++ p6(gmock_p6) {\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ p5##_type p5;\ ++ p6##_type p6;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##MatcherP7);\ ++ };\ ++ template \ ++ inline name##MatcherP7 name(p0##_type p0, p1##_type p1, \ ++ p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \ ++ p6##_type p6) {\ ++ return name##MatcherP7(p0, p1, p2, p3, p4, p5, p6);\ ++ }\ ++ template \ ++ template \ ++ bool name##MatcherP7::gmock_Impl::MatchAndExplain(\ ++ arg_type arg, \ ++ ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ ++ const ++ ++#define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description)\ ++ template \ ++ class name##MatcherP8 {\ ++ public:\ ++ template \ ++ class gmock_Impl : public ::testing::MatcherInterface {\ ++ public:\ ++ gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ ++ p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ ++ p6##_type gmock_p6, p7##_type gmock_p7)\ ++ : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \ ++ p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7) {}\ ++ 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);\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ p5##_type p5;\ ++ p6##_type p6;\ ++ p7##_type p7;\ ++ 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(\ ++ ::testing::tuple(p0, p1, p2, \ ++ p3, p4, p5, p6, p7)));\ ++ }\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template \ ++ operator ::testing::Matcher() const {\ ++ return ::testing::Matcher(\ ++ new gmock_Impl(p0, p1, p2, p3, p4, p5, p6, p7));\ ++ }\ ++ name##MatcherP8(p0##_type gmock_p0, p1##_type gmock_p1, \ ++ p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ ++ p5##_type gmock_p5, p6##_type gmock_p6, \ ++ p7##_type gmock_p7) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ ++ p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \ ++ p7(gmock_p7) {\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ p5##_type p5;\ ++ p6##_type p6;\ ++ p7##_type p7;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##MatcherP8);\ ++ };\ ++ template \ ++ inline name##MatcherP8 name(p0##_type p0, \ ++ p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \ ++ p6##_type p6, p7##_type p7) {\ ++ return name##MatcherP8(p0, p1, p2, p3, p4, p5, \ ++ p6, p7);\ ++ }\ ++ template \ ++ template \ ++ bool name##MatcherP8::gmock_Impl::MatchAndExplain(\ ++ arg_type arg, \ ++ ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ ++ const ++ ++#define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description)\ ++ template \ ++ class name##MatcherP9 {\ ++ public:\ ++ template \ ++ class gmock_Impl : public ::testing::MatcherInterface {\ ++ public:\ ++ gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ ++ p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ ++ p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8)\ ++ : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \ ++ p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \ ++ p8(gmock_p8) {}\ ++ 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);\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ p5##_type p5;\ ++ p6##_type p6;\ ++ p7##_type p7;\ ++ p8##_type p8;\ ++ 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(\ ++ ::testing::tuple(p0, p1, p2, p3, p4, p5, p6, p7, p8)));\ ++ }\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template \ ++ operator ::testing::Matcher() const {\ ++ return ::testing::Matcher(\ ++ new gmock_Impl(p0, p1, p2, p3, p4, p5, p6, p7, p8));\ ++ }\ ++ name##MatcherP9(p0##_type gmock_p0, p1##_type gmock_p1, \ ++ p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ ++ p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \ ++ p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ ++ p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \ ++ p8(gmock_p8) {\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ p5##_type p5;\ ++ p6##_type p6;\ ++ p7##_type p7;\ ++ p8##_type p8;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##MatcherP9);\ ++ };\ ++ template \ ++ inline name##MatcherP9 name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ ++ p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \ ++ p8##_type p8) {\ ++ return name##MatcherP9(p0, p1, p2, \ ++ p3, p4, p5, p6, p7, p8);\ ++ }\ ++ template \ ++ template \ ++ bool name##MatcherP9::gmock_Impl::MatchAndExplain(\ ++ arg_type arg, \ ++ ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ ++ const ++ ++#define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description)\ ++ template \ ++ class name##MatcherP10 {\ ++ public:\ ++ template \ ++ class gmock_Impl : public ::testing::MatcherInterface {\ ++ public:\ ++ gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ ++ p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ ++ p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \ ++ p9##_type gmock_p9)\ ++ : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \ ++ p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \ ++ p8(gmock_p8), p9(gmock_p9) {}\ ++ 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);\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ p5##_type p5;\ ++ p6##_type p6;\ ++ p7##_type p7;\ ++ p8##_type p8;\ ++ p9##_type p9;\ ++ 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(\ ++ ::testing::tuple(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)));\ ++ }\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template \ ++ operator ::testing::Matcher() const {\ ++ return ::testing::Matcher(\ ++ new gmock_Impl(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9));\ ++ }\ ++ name##MatcherP10(p0##_type gmock_p0, p1##_type gmock_p1, \ ++ p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ ++ p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \ ++ p8##_type gmock_p8, p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), \ ++ p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \ ++ p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {\ ++ }\ ++ p0##_type p0;\ ++ p1##_type p1;\ ++ p2##_type p2;\ ++ p3##_type p3;\ ++ p4##_type p4;\ ++ p5##_type p5;\ ++ p6##_type p6;\ ++ p7##_type p7;\ ++ p8##_type p8;\ ++ p9##_type p9;\ ++ private:\ ++ GTEST_DISALLOW_ASSIGN_(name##MatcherP10);\ ++ };\ ++ template \ ++ inline name##MatcherP10 name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ ++ p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \ ++ p9##_type p9) {\ ++ return name##MatcherP10(p0, \ ++ p1, p2, p3, p4, p5, p6, p7, p8, p9);\ ++ }\ ++ template \ ++ template \ ++ bool name##MatcherP10::gmock_Impl::MatchAndExplain(\ ++ arg_type arg, \ ++ ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ ++ const ++ ++#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_ +diff -urN mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-generated-matchers.h.pump mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-generated-matchers.h.pump +--- mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-generated-matchers.h.pump 1970-01-01 09:00:00.000000000 +0900 ++++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-generated-matchers.h.pump 2016-02-20 18:11:22.332832283 +0900 +@@ -0,0 +1,672 @@ ++$$ -*- 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 ++#include ++#include ++#include ++#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 ::testing::tuple_element::type ++ ++// TupleFields 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, 2, 0>, we have: ++// ++// type is tuple, and ++// GetSelectedFields(make_tuple(true, 'a', 42)) is (42, true). ++ ++template ++class TupleFields; ++ ++// This generic version is used when there are $n selectors. ++template ++class TupleFields { ++ public: ++ typedef ::testing::tuple<$for i, [[GMOCK_FIELD_TYPE_(Tuple, k$i)]]> type; ++ static type GetSelectedFields(const Tuple& t) { ++ return type($for i, [[get(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 TupleFields { ++ public: ++ typedef ::testing::tuple<$for j, [[GMOCK_FIELD_TYPE_(Tuple, k$j)]]> type; ++ static type GetSelectedFields(const Tuple& $if i==0 [[/* t */]] $else [[t]]) { ++ return type($for j, [[get(t)]]); ++ } ++}; ++ ++]] ++ ++#undef GMOCK_FIELD_TYPE_ ++ ++// Implements the Args() matcher. ++ ++$var ks = [[$for i, [[k$i]]]] ++template ++class ArgsMatcherImpl : public MatcherInterface { ++ public: ++ // ArgsTuple may have top-level const or reference modifiers. ++ typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple; ++ typedef typename internal::TupleFields::type SelectedArgs; ++ typedef Matcher MonomorphicInnerMatcher; ++ ++ template ++ explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher) ++ : inner_matcher_(SafeMatcherCast(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::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 ArgsMatcher { ++ public: ++ explicit ArgsMatcher(const InnerMatcher& inner_matcher) ++ : inner_matcher_(inner_matcher) {} ++ ++ template ++ operator Matcher() const { ++ return MakeMatcher(new ArgsMatcherImpl(inner_matcher_)); ++ } ++ ++ private: ++ const InnerMatcher inner_matcher_; ++ ++ GTEST_DISALLOW_ASSIGN_(ArgsMatcher); ++}; ++ ++// A set of metafunctions for computing the result type of AllOf. ++// AllOf(m1, ..., mN) returns ++// AllOfResultN::type. ++ ++// Although AllOf isn't defined for one argument, AllOfResult1 is defined ++// to simplify the implementation. ++template ++struct AllOfResult1 { ++ typedef M1 type; ++}; ++ ++$range i 1..n ++ ++$range i 2..n ++$for i [[ ++$range j 2..i ++$var m = i/2 ++$range k 1..m ++$range t m+1..i ++ ++template ++struct AllOfResult$i { ++ typedef BothOfMatcher< ++ typename AllOfResult$m<$for k, [[M$k]]>::type, ++ typename AllOfResult$(i-m)<$for t, [[M$t]]>::type ++ > type; ++}; ++ ++]] ++ ++// A set of metafunctions for computing the result type of AnyOf. ++// AnyOf(m1, ..., mN) returns ++// AnyOfResultN::type. ++ ++// Although AnyOf isn't defined for one argument, AnyOfResult1 is defined ++// to simplify the implementation. ++template ++struct AnyOfResult1 { ++ typedef M1 type; ++}; ++ ++$range i 1..n ++ ++$range i 2..n ++$for i [[ ++$range j 2..i ++$var m = i/2 ++$range k 1..m ++$range t m+1..i ++ ++template ++struct AnyOfResult$i { ++ typedef EitherOfMatcher< ++ typename AnyOfResult$m<$for k, [[M$k]]>::type, ++ typename AnyOfResult$(i-m)<$for t, [[M$t]]>::type ++ > type; ++}; ++ ++]] ++ ++} // namespace internal ++ ++// Args(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 ++Args(const InnerMatcher& matcher) { ++ return internal::ArgsMatcher(matcher); ++} ++ ++ ++]] ++// ElementsAre(e_1, e_2, ... e_n) matches an STL-style container with ++// n 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. ++// ++// The use of DecayArray in the implementation allows ElementsAre() ++// to accept string literals, whose type is const char[N], but we ++// want to treat them as const char*. ++// ++// 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). ++ ++$range i 0..n ++$for i [[ ++ ++$range j 1..i ++ ++$if i>0 [[ ++ ++template <$for j, [[typename T$j]]> ++]] ++ ++inline internal::ElementsAreMatcher< ++ ::testing::tuple< ++$for j, [[ ++ ++ typename internal::DecayArray::type]]> > ++ElementsAre($for j, [[const T$j& e$j]]) { ++ typedef ::testing::tuple< ++$for j, [[ ++ ++ typename internal::DecayArray::type]]> Args; ++ return internal::ElementsAreMatcher(Args($for j, [[e$j]])); ++} ++ ++]] ++ ++// UnorderedElementsAre(e_1, e_2, ..., e_n) is an ElementsAre extension ++// that matches n elements in any order. We support up to n=$n arguments. ++ ++$range i 0..n ++$for i [[ ++ ++$range j 1..i ++ ++$if i>0 [[ ++ ++template <$for j, [[typename T$j]]> ++]] ++ ++inline internal::UnorderedElementsAreMatcher< ++ ::testing::tuple< ++$for j, [[ ++ ++ typename internal::DecayArray::type]]> > ++UnorderedElementsAre($for j, [[const T$j& e$j]]) { ++ typedef ::testing::tuple< ++$for j, [[ ++ ++ typename internal::DecayArray::type]]> Args; ++ return internal::UnorderedElementsAreMatcher(Args($for j, [[e$j]])); ++} ++ ++]] ++ ++// 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 ++$var m = i/2 ++$range k 1..m ++$range t m+1..i ++ ++template <$for j, [[typename M$j]]> ++inline typename internal::AllOfResult$i<$for j, [[M$j]]>::type ++AllOf($for j, [[M$j m$j]]) { ++ return typename internal::AllOfResult$i<$for j, [[M$j]]>::type( ++ $if m == 1 [[m1]] $else [[::testing::AllOf($for k, [[m$k]])]], ++ $if m+1 == i [[m$i]] $else [[::testing::AllOf($for t, [[m$t]])]]); ++} ++ ++]] ++ ++// 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 ++$var m = i/2 ++$range k 1..m ++$range t m+1..i ++ ++template <$for j, [[typename M$j]]> ++inline typename internal::AnyOfResult$i<$for j, [[M$j]]>::type ++AnyOf($for j, [[M$j m$j]]) { ++ return typename internal::AnyOfResult$i<$for j, [[M$j]]>::type( ++ $if m == 1 [[m1]] $else [[::testing::AnyOf($for k, [[m$k]])]], ++ $if m+1 == i [[m$i]] $else [[::testing::AnyOf($for t, [[m$t]])]]); ++} ++ ++]] ++ ++} // 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 ++// FooMatcherPk ++// 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(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. 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 \ ++ class gmock_Impl : public ::testing::MatcherInterface {\ ++ 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(\ ++ ::testing::tuple<$for j, [[p$j##_type]]>($for j, [[p$j]])));\ ++ }\ ++ GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ ++ };\ ++ template \ ++ operator ::testing::Matcher() const {\ ++ return ::testing::Matcher(\ ++ new gmock_Impl($params));\ ++ }\ ++ [[$if i==1 [[explicit ]]]]$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 \ ++ bool $class_name$param_types::gmock_Impl::MatchAndExplain(\ ++ arg_type arg, \ ++ ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ ++ const ++]] ++ ++ ++#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_ +diff -urN mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-generated-nice-strict.h mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-generated-nice-strict.h +--- mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-generated-nice-strict.h 1970-01-01 09:00:00.000000000 +0900 ++++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-generated-nice-strict.h 2016-02-20 18:11:22.328832283 +0900 +@@ -0,0 +1,397 @@ ++// This file was GENERATED by command: ++// pump.py gmock-generated-nice-strict.h.pump ++// 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, NaggyMock, and StrictMock. ++// ++// Given a mock class MockFoo that is created using Google Mock, ++// NiceMock is a subclass of MockFoo that allows ++// uninteresting calls (i.e. calls to mock methods that have no ++// EXPECT_CALL specs), NaggyMock is a subclass of MockFoo ++// that prints a warning when an uninteresting call occurs, and ++// StrictMock is a subclass of MockFoo that treats all ++// uninteresting calls as errors. ++// ++// Currently a mock is naggy by default, so MockFoo and ++// NaggyMock behave like the same. However, we will soon ++// switch the default behavior of mocks to be nice, as that in general ++// leads to more maintainable tests. When that happens, MockFoo will ++// stop behaving like NaggyMock and start behaving like ++// NiceMock. ++// ++// NiceMock, NaggyMock, and StrictMock "inherit" the constructors of ++// their respective base class, with up-to 10 arguments. Therefore ++// you can write NiceMock(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, NaggyMock, ++// and StrictMock only works for mock methods defined using ++// the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class. ++// If a mock method is defined in a base class of MockFoo, the "nice" ++// or "strict" modifier may not affect it, depending on the compiler. ++// In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT ++// supported. ++// ++// 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 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_(this)); ++ } ++ ++ // C++ doesn't (yet) allow inheritance of constructors, so we have ++ // to define it for each arity. ++ template ++ explicit NiceMock(const A1& a1) : MockClass(a1) { ++ ::testing::Mock::AllowUninterestingCalls( ++ internal::ImplicitCast_(this)); ++ } ++ template ++ NiceMock(const A1& a1, const A2& a2) : MockClass(a1, a2) { ++ ::testing::Mock::AllowUninterestingCalls( ++ internal::ImplicitCast_(this)); ++ } ++ ++ template ++ NiceMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) { ++ ::testing::Mock::AllowUninterestingCalls( ++ internal::ImplicitCast_(this)); ++ } ++ ++ template ++ NiceMock(const A1& a1, const A2& a2, const A3& a3, ++ const A4& a4) : MockClass(a1, a2, a3, a4) { ++ ::testing::Mock::AllowUninterestingCalls( ++ internal::ImplicitCast_(this)); ++ } ++ ++ template ++ 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_(this)); ++ } ++ ++ template ++ 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_(this)); ++ } ++ ++ template ++ 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_(this)); ++ } ++ ++ template ++ 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_(this)); ++ } ++ ++ template ++ 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_(this)); ++ } ++ ++ template ++ 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_(this)); ++ } ++ ++ virtual ~NiceMock() { ++ ::testing::Mock::UnregisterCallReaction( ++ internal::ImplicitCast_(this)); ++ } ++ ++ private: ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock); ++}; ++ ++template ++class NaggyMock : 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. ++ NaggyMock() { ++ ::testing::Mock::WarnUninterestingCalls( ++ internal::ImplicitCast_(this)); ++ } ++ ++ // C++ doesn't (yet) allow inheritance of constructors, so we have ++ // to define it for each arity. ++ template ++ explicit NaggyMock(const A1& a1) : MockClass(a1) { ++ ::testing::Mock::WarnUninterestingCalls( ++ internal::ImplicitCast_(this)); ++ } ++ template ++ NaggyMock(const A1& a1, const A2& a2) : MockClass(a1, a2) { ++ ::testing::Mock::WarnUninterestingCalls( ++ internal::ImplicitCast_(this)); ++ } ++ ++ template ++ NaggyMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) { ++ ::testing::Mock::WarnUninterestingCalls( ++ internal::ImplicitCast_(this)); ++ } ++ ++ template ++ NaggyMock(const A1& a1, const A2& a2, const A3& a3, ++ const A4& a4) : MockClass(a1, a2, a3, a4) { ++ ::testing::Mock::WarnUninterestingCalls( ++ internal::ImplicitCast_(this)); ++ } ++ ++ template ++ NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4, ++ const A5& a5) : MockClass(a1, a2, a3, a4, a5) { ++ ::testing::Mock::WarnUninterestingCalls( ++ internal::ImplicitCast_(this)); ++ } ++ ++ template ++ NaggyMock(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::WarnUninterestingCalls( ++ internal::ImplicitCast_(this)); ++ } ++ ++ template ++ NaggyMock(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::WarnUninterestingCalls( ++ internal::ImplicitCast_(this)); ++ } ++ ++ template ++ NaggyMock(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::WarnUninterestingCalls( ++ internal::ImplicitCast_(this)); ++ } ++ ++ template ++ NaggyMock(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::WarnUninterestingCalls( ++ internal::ImplicitCast_(this)); ++ } ++ ++ template ++ NaggyMock(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::WarnUninterestingCalls( ++ internal::ImplicitCast_(this)); ++ } ++ ++ virtual ~NaggyMock() { ++ ::testing::Mock::UnregisterCallReaction( ++ internal::ImplicitCast_(this)); ++ } ++ ++ private: ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock); ++}; ++ ++template ++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_(this)); ++ } ++ ++ // C++ doesn't (yet) allow inheritance of constructors, so we have ++ // to define it for each arity. ++ template ++ explicit StrictMock(const A1& a1) : MockClass(a1) { ++ ::testing::Mock::FailUninterestingCalls( ++ internal::ImplicitCast_(this)); ++ } ++ template ++ StrictMock(const A1& a1, const A2& a2) : MockClass(a1, a2) { ++ ::testing::Mock::FailUninterestingCalls( ++ internal::ImplicitCast_(this)); ++ } ++ ++ template ++ StrictMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) { ++ ::testing::Mock::FailUninterestingCalls( ++ internal::ImplicitCast_(this)); ++ } ++ ++ template ++ StrictMock(const A1& a1, const A2& a2, const A3& a3, ++ const A4& a4) : MockClass(a1, a2, a3, a4) { ++ ::testing::Mock::FailUninterestingCalls( ++ internal::ImplicitCast_(this)); ++ } ++ ++ template ++ 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_(this)); ++ } ++ ++ template ++ 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_(this)); ++ } ++ ++ template ++ 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_(this)); ++ } ++ ++ template ++ 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_(this)); ++ } ++ ++ template ++ 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_(this)); ++ } ++ ++ template ++ 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_(this)); ++ } ++ ++ virtual ~StrictMock() { ++ ::testing::Mock::UnregisterCallReaction( ++ internal::ImplicitCast_(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, ++// NaggyMock, and StrictMock cannot be nested. ++ ++template ++class NiceMock >; ++template ++class NiceMock >; ++template ++class NiceMock >; ++ ++template ++class NaggyMock >; ++template ++class NaggyMock >; ++template ++class NaggyMock >; ++ ++template ++class StrictMock >; ++template ++class StrictMock >; ++template ++class StrictMock >; ++ ++} // namespace testing ++ ++#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_ +diff -urN mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-generated-nice-strict.h.pump mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-generated-nice-strict.h.pump +--- mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-generated-nice-strict.h.pump 1970-01-01 09:00:00.000000000 +0900 ++++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-generated-nice-strict.h.pump 2016-02-20 18:11:22.336832283 +0900 +@@ -0,0 +1,161 @@ ++$$ -*- 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, NaggyMock, and StrictMock. ++// ++// Given a mock class MockFoo that is created using Google Mock, ++// NiceMock is a subclass of MockFoo that allows ++// uninteresting calls (i.e. calls to mock methods that have no ++// EXPECT_CALL specs), NaggyMock is a subclass of MockFoo ++// that prints a warning when an uninteresting call occurs, and ++// StrictMock is a subclass of MockFoo that treats all ++// uninteresting calls as errors. ++// ++// Currently a mock is naggy by default, so MockFoo and ++// NaggyMock behave like the same. However, we will soon ++// switch the default behavior of mocks to be nice, as that in general ++// leads to more maintainable tests. When that happens, MockFoo will ++// stop behaving like NaggyMock and start behaving like ++// NiceMock. ++// ++// NiceMock, NaggyMock, and StrictMock "inherit" the constructors of ++// their respective base class, with up-to $n arguments. Therefore ++// you can write NiceMock(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, NaggyMock, ++// and StrictMock only works for mock methods defined using ++// the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class. ++// If a mock method is defined in a base class of MockFoo, the "nice" ++// or "strict" modifier may not affect it, depending on the compiler. ++// In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT ++// supported. ++// ++// 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 { ++ ++$range kind 0..2 ++$for kind [[ ++ ++$var clazz=[[$if kind==0 [[NiceMock]] ++ $elif kind==1 [[NaggyMock]] ++ $else [[StrictMock]]]] ++ ++$var method=[[$if kind==0 [[AllowUninterestingCalls]] ++ $elif kind==1 [[WarnUninterestingCalls]] ++ $else [[FailUninterestingCalls]]]] ++ ++template ++class $clazz : 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. ++ $clazz() { ++ ::testing::Mock::$method( ++ internal::ImplicitCast_(this)); ++ } ++ ++ // C++ doesn't (yet) allow inheritance of constructors, so we have ++ // to define it for each arity. ++ template ++ explicit $clazz(const A1& a1) : MockClass(a1) { ++ ::testing::Mock::$method( ++ internal::ImplicitCast_(this)); ++ } ++ ++$range i 2..n ++$for i [[ ++$range j 1..i ++ template <$for j, [[typename A$j]]> ++ $clazz($for j, [[const A$j& a$j]]) : MockClass($for j, [[a$j]]) { ++ ::testing::Mock::$method( ++ internal::ImplicitCast_(this)); ++ } ++ ++ ++]] ++ virtual ~$clazz() { ++ ::testing::Mock::UnregisterCallReaction( ++ internal::ImplicitCast_(this)); ++ } ++ ++ private: ++ GTEST_DISALLOW_COPY_AND_ASSIGN_($clazz); ++}; ++ ++]] ++ ++// 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, ++// NaggyMock, and StrictMock cannot be nested. ++ ++template ++class NiceMock >; ++template ++class NiceMock >; ++template ++class NiceMock >; ++ ++template ++class NaggyMock >; ++template ++class NaggyMock >; ++template ++class NaggyMock >; ++ ++template ++class StrictMock >; ++template ++class StrictMock >; ++template ++class StrictMock >; ++ ++} // namespace testing ++ ++#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_ +diff -urN mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-matchers.h mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-matchers.h +--- mozc-2.17.2116.102+gitfd0f5b34+dfsg.orig/src/third_party/gmock/include/gmock/gmock-matchers.h 1970-01-01 09:00:00.000000000 +0900 ++++ mozc-2.17.2116.102+gitfd0f5b34+dfsg/src/third_party/gmock/include/gmock/gmock-matchers.h 2016-02-20 18:11:22.316832283 +0900 +@@ -0,0 +1,4387 @@ ++// 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 argument matchers. More ++// matchers can be defined by the user implementing the ++// MatcherInterface interface if necessary. ++ ++#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ ++#define GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ ++ ++#include ++#include ++#include ++#include ++#include // NOLINT ++#include ++#include ++#include ++#include ++ ++#include "gmock/internal/gmock-internal-utils.h" ++#include "gmock/internal/gmock-port.h" ++#include "gtest/gtest.h" ++ ++#if GTEST_HAS_STD_INITIALIZER_LIST_ ++# include // NOLINT -- must be after gtest.h ++#endif ++ ++namespace testing { ++ ++// To implement a matcher Foo for type T, define: ++// 1. a class FooMatcherImpl that implements the ++// MatcherInterface interface, and ++// 2. a factory function that creates a Matcher object from a ++// FooMatcherImpl*. ++// ++// The two-level delegation design makes it possible to allow a user ++// to write "v" instead of "Eq(v)" where a Matcher is expected, which ++// is impossible if we pass matchers by pointers. It also eases ++// ownership management as Matcher objects can now be copied like ++// plain values. ++ ++// MatchResultListener is an abstract class. Its << operator can be ++// used by a matcher to explain why a value matches or doesn't match. ++// ++// TODO(wan@google.com): add method ++// bool InterestedInWhy(bool result) const; ++// to indicate whether the listener is interested in why the match ++// result is 'result'. ++class MatchResultListener { ++ public: ++ // Creates a listener object with the given underlying ostream. The ++ // listener does not own the ostream, and does not dereference it ++ // in the constructor or destructor. ++ explicit MatchResultListener(::std::ostream* os) : stream_(os) {} ++ virtual ~MatchResultListener() = 0; // Makes this class abstract. ++ ++ // Streams x to the underlying ostream; does nothing if the ostream ++ // is NULL. ++ template ++ MatchResultListener& operator<<(const T& x) { ++ if (stream_ != NULL) ++ *stream_ << x; ++ return *this; ++ } ++ ++ // Returns the underlying ostream. ++ ::std::ostream* stream() { return stream_; } ++ ++ // Returns true iff the listener is interested in an explanation of ++ // the match result. A matcher's MatchAndExplain() method can use ++ // this information to avoid generating the explanation when no one ++ // intends to hear it. ++ bool IsInterested() const { return stream_ != NULL; } ++ ++ private: ++ ::std::ostream* const stream_; ++ ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(MatchResultListener); ++}; ++ ++inline MatchResultListener::~MatchResultListener() { ++} ++ ++// An instance of a subclass of this knows how to describe itself as a ++// matcher. ++class MatcherDescriberInterface { ++ public: ++ virtual ~MatcherDescriberInterface() {} ++ ++ // Describes this matcher to an ostream. The function should print ++ // a verb phrase that describes the property a value matching this ++ // matcher should have. The subject of the verb phrase is the value ++ // being matched. For example, the DescribeTo() method of the Gt(7) ++ // matcher prints "is greater than 7". ++ virtual void DescribeTo(::std::ostream* os) const = 0; ++ ++ // Describes the negation of this matcher to an ostream. For ++ // example, if the description of this matcher is "is greater than ++ // 7", the negated description could be "is not greater than 7". ++ // You are not required to override this when implementing ++ // MatcherInterface, but it is highly advised so that your matcher ++ // can produce good error messages. ++ virtual void DescribeNegationTo(::std::ostream* os) const { ++ *os << "not ("; ++ DescribeTo(os); ++ *os << ")"; ++ } ++}; ++ ++// The implementation of a matcher. ++template ++class MatcherInterface : public MatcherDescriberInterface { ++ public: ++ // Returns true iff the matcher matches x; also explains the match ++ // result to 'listener' if necessary (see the next paragraph), in ++ // the form of a non-restrictive relative clause ("which ...", ++ // "whose ...", etc) that describes x. For example, the ++ // MatchAndExplain() method of the Pointee(...) matcher should ++ // generate an explanation like "which points to ...". ++ // ++ // Implementations of MatchAndExplain() should add an explanation of ++ // the match result *if and only if* they can provide additional ++ // information that's not already present (or not obvious) in the ++ // print-out of x and the matcher's description. Whether the match ++ // succeeds is not a factor in deciding whether an explanation is ++ // needed, as sometimes the caller needs to print a failure message ++ // when the match succeeds (e.g. when the matcher is used inside ++ // Not()). ++ // ++ // For example, a "has at least 10 elements" matcher should explain ++ // what the actual element count is, regardless of the match result, ++ // as it is useful information to the reader; on the other hand, an ++ // "is empty" matcher probably only needs to explain what the actual ++ // size is when the match fails, as it's redundant to say that the ++ // size is 0 when the value is already known to be empty. ++ // ++ // You should override this method when defining a new matcher. ++ // ++ // It's the responsibility of the caller (Google Mock) to guarantee ++ // that 'listener' is not NULL. This helps to simplify a matcher's ++ // implementation when it doesn't care about the performance, as it ++ // can talk to 'listener' without checking its validity first. ++ // However, in order to implement dummy listeners efficiently, ++ // listener->stream() may be NULL. ++ virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0; ++ ++ // Inherits these methods from MatcherDescriberInterface: ++ // virtual void DescribeTo(::std::ostream* os) const = 0; ++ // virtual void DescribeNegationTo(::std::ostream* os) const; ++}; ++ ++// A match result listener that stores the explanation in a string. ++class StringMatchResultListener : public MatchResultListener { ++ public: ++ StringMatchResultListener() : MatchResultListener(&ss_) {} ++ ++ // Returns the explanation accumulated so far. ++ internal::string str() const { return ss_.str(); } ++ ++ // Clears the explanation accumulated so far. ++ void Clear() { ss_.str(""); } ++ ++ private: ++ ::std::stringstream ss_; ++ ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(StringMatchResultListener); ++}; ++ ++namespace internal { ++ ++struct AnyEq { ++ template ++ bool operator()(const A& a, const B& b) const { return a == b; } ++}; ++struct AnyNe { ++ template ++ bool operator()(const A& a, const B& b) const { return a != b; } ++}; ++struct AnyLt { ++ template ++ bool operator()(const A& a, const B& b) const { return a < b; } ++}; ++struct AnyGt { ++ template ++ bool operator()(const A& a, const B& b) const { return a > b; } ++}; ++struct AnyLe { ++ template ++ bool operator()(const A& a, const B& b) const { return a <= b; } ++}; ++struct AnyGe { ++ template ++ bool operator()(const A& a, const B& b) const { return a >= b; } ++}; ++ ++// A match result listener that ignores the explanation. ++class DummyMatchResultListener : public MatchResultListener { ++ public: ++ DummyMatchResultListener() : MatchResultListener(NULL) {} ++ ++ private: ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(DummyMatchResultListener); ++}; ++ ++// A match result listener that forwards the explanation to a given ++// ostream. The difference between this and MatchResultListener is ++// that the former is concrete. ++class StreamMatchResultListener : public MatchResultListener { ++ public: ++ explicit StreamMatchResultListener(::std::ostream* os) ++ : MatchResultListener(os) {} ++ ++ private: ++ GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamMatchResultListener); ++}; ++ ++// An internal class for implementing Matcher, which will derive ++// from it. We put functionalities common to all Matcher ++// specializations here to avoid code duplication. ++template ++class MatcherBase { ++ public: ++ // Returns true iff the matcher matches x; also explains the match ++ // result to 'listener'. ++ bool MatchAndExplain(T x, MatchResultListener* listener) const { ++ return impl_->MatchAndExplain(x, listener); ++ } ++ ++ // Returns true iff this matcher matches x. ++ bool Matches(T x) const { ++ DummyMatchResultListener dummy; ++ return MatchAndExplain(x, &dummy); ++ } ++ ++ // Describes this matcher to an ostream. ++ void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); } ++ ++ // Describes the negation of this matcher to an ostream. ++ void DescribeNegationTo(::std::ostream* os) const { ++ impl_->DescribeNegationTo(os); ++ } ++ ++ // Explains why x matches, or doesn't match, the matcher. ++ void ExplainMatchResultTo(T x, ::std::ostream* os) const { ++ StreamMatchResultListener listener(os); ++ MatchAndExplain(x, &listener); ++ } ++ ++ // Returns the describer for this matcher object; retains ownership ++ // of the describer, which is only guaranteed to be alive when ++ // this matcher object is alive. ++ const MatcherDescriberInterface* GetDescriber() const { ++ return impl_.get(); ++ } ++ ++ protected: ++ MatcherBase() {} ++ ++ // Constructs a matcher from its implementation. ++ explicit MatcherBase(const MatcherInterface* impl) ++ : impl_(impl) {} ++ ++ virtual ~MatcherBase() {} ++ ++ private: ++ // shared_ptr (util/gtl/shared_ptr.h) and linked_ptr have similar ++ // interfaces. The former dynamically allocates a chunk of memory ++ // to hold the reference count, while the latter tracks all ++ // references using a circular linked list without allocating ++ // memory. It has been observed that linked_ptr performs better in ++ // typical scenarios. However, shared_ptr can out-perform ++ // linked_ptr when there are many more uses of the copy constructor ++ // than the default constructor. ++ // ++ // If performance becomes a problem, we should see if using ++ // shared_ptr helps. ++ ::testing::internal::linked_ptr > impl_; ++}; ++ ++} // namespace internal ++ ++// A Matcher is a copyable and IMMUTABLE (except by assignment) ++// object that can check whether a value of type T matches. The ++// implementation of Matcher is just a linked_ptr to const ++// MatcherInterface, so copying is fairly cheap. Don't inherit ++// from Matcher! ++template ++class Matcher : public internal::MatcherBase { ++ public: ++ // Constructs a null matcher. Needed for storing Matcher objects in STL ++ // containers. A default-constructed matcher is not yet initialized. You ++ // cannot use it until a valid value has been assigned to it. ++ Matcher() {} ++ ++ // Constructs a matcher from its implementation. ++ explicit Matcher(const MatcherInterface* impl) ++ : internal::MatcherBase(impl) {} ++ ++ // Implicit constructor here allows people to write ++ // EXPECT_CALL(foo, Bar(5)) instead of EXPECT_CALL(foo, Bar(Eq(5))) sometimes ++ Matcher(T value); // NOLINT ++}; ++ ++// The following two specializations allow the user to write str ++// instead of Eq(str) and "foo" instead of Eq("foo") when a string ++// matcher is expected. ++template <> ++class GTEST_API_ Matcher ++ : public internal::MatcherBase { ++ public: ++ Matcher() {} ++ ++ explicit Matcher(const MatcherInterface* impl) ++ : internal::MatcherBase(impl) {} ++ ++ // Allows the user to write str instead of Eq(str) sometimes, where ++ // str is a string object. ++ Matcher(const internal::string& s); // NOLINT ++ ++ // Allows the user to write "foo" instead of Eq("foo") sometimes. ++ Matcher(const char* s); // NOLINT ++}; ++ ++template <> ++class GTEST_API_ Matcher ++ : public internal::MatcherBase { ++ public: ++ Matcher() {} ++ ++ explicit Matcher(const MatcherInterface* impl) ++ : internal::MatcherBase(impl) {} ++ ++ // Allows the user to write str instead of Eq(str) sometimes, where ++ // str is a string object. ++ Matcher(const internal::string& s); // NOLINT ++ ++ // Allows the user to write "foo" instead of Eq("foo") sometimes. ++ Matcher(const char* s); // NOLINT ++}; ++ ++#if GTEST_HAS_STRING_PIECE_ ++// The following two specializations allow the user to write str ++// instead of Eq(str) and "foo" instead of Eq("foo") when a StringPiece ++// matcher is expected. ++template <> ++class GTEST_API_ Matcher ++ : public internal::MatcherBase { ++ public: ++ Matcher() {} ++ ++ explicit Matcher(const MatcherInterface* impl) ++ : internal::MatcherBase(impl) {} ++ ++ // Allows the user to write str instead of Eq(str) sometimes, where ++ // str is a string object. ++ Matcher(const internal::string& s); // NOLINT ++ ++ // Allows the user to write "foo" instead of Eq("foo") sometimes. ++ Matcher(const char* s); // NOLINT ++ ++ // Allows the user to pass StringPieces directly. ++ Matcher(StringPiece s); // NOLINT ++}; ++ ++template <> ++class GTEST_API_ Matcher ++ : public internal::MatcherBase { ++ public: ++ Matcher() {} ++ ++ explicit Matcher(const MatcherInterface* impl) ++ : internal::MatcherBase(impl) {} ++ ++ // Allows the user to write str instead of Eq(str) sometimes, where ++ // str is a string object. ++ Matcher(const internal::string& s); // NOLINT ++ ++ // Allows the user to write "foo" instead of Eq("foo") sometimes. ++ Matcher(const char* s); // NOLINT ++ ++ // Allows the user to pass StringPieces directly. ++ Matcher(StringPiece s); // NOLINT ++}; ++#endif // GTEST_HAS_STRING_PIECE_ ++ ++// The PolymorphicMatcher class template makes it easy to implement a ++// polymorphic matcher (i.e. a matcher that can match values of more ++// than one type, e.g. Eq(n) and NotNull()). ++// ++// To define a polymorphic matcher, a user should provide an Impl ++// class that has a DescribeTo() method and a DescribeNegationTo() ++// method, and define a member function (or member function template) ++// ++// bool MatchAndExplain(const Value& value, ++// MatchResultListener* listener) const; ++// ++// See the definition of NotNull() for a complete example. ++template ++class PolymorphicMatcher { ++ public: ++ explicit PolymorphicMatcher(const Impl& an_impl) : impl_(an_impl) {} ++ ++ // Returns a mutable reference to the underlying matcher ++ // implementation object. ++ Impl& mutable_impl() { return impl_; } ++ ++ // Returns an immutable reference to the underlying matcher ++ // implementation object. ++ const Impl& impl() const { return impl_; } ++ ++ template ++ operator Matcher() const { ++ return Matcher(new MonomorphicImpl(impl_)); ++ } ++ ++ private: ++ template ++ class MonomorphicImpl : public MatcherInterface { ++ public: ++ explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {} ++ ++ virtual void DescribeTo(::std::ostream* os) const { ++ impl_.DescribeTo(os); ++ } ++ ++ virtual void DescribeNegationTo(::std::ostream* os) const { ++ impl_.DescribeNegationTo(os); ++ } ++ ++ virtual bool MatchAndExplain(T x, MatchResultListener* listener) const { ++ return impl_.MatchAndExplain(x, listener); ++ } ++ ++ private: ++ const Impl impl_; ++ ++ GTEST_DISALLOW_ASSIGN_(MonomorphicImpl); ++ }; ++ ++ Impl impl_; ++ ++ GTEST_DISALLOW_ASSIGN_(PolymorphicMatcher); ++}; ++ ++// Creates a matcher from its implementation. This is easier to use ++// than the Matcher constructor as it doesn't require you to ++// explicitly write the template argument, e.g. ++// ++// MakeMatcher(foo); ++// vs ++// Matcher(foo); ++template ++inline Matcher MakeMatcher(const MatcherInterface* impl) { ++ return Matcher(impl); ++} ++ ++// Creates a polymorphic matcher from its implementation. This is ++// easier to use than the PolymorphicMatcher constructor as it ++// doesn't require you to explicitly write the template argument, e.g. ++// ++// MakePolymorphicMatcher(foo); ++// vs ++// PolymorphicMatcher(foo); ++template ++inline PolymorphicMatcher MakePolymorphicMatcher(const Impl& impl) { ++ return PolymorphicMatcher(impl); ++} ++ ++// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION ++// and MUST NOT BE USED IN USER CODE!!! ++namespace internal { ++ ++// The MatcherCastImpl class template is a helper for implementing ++// MatcherCast(). We need this helper in order to partially ++// specialize the implementation of MatcherCast() (C++ allows ++// class/struct templates to be partially specialized, but not ++// function templates.). ++ ++// This general version is used when MatcherCast()'s argument is a ++// polymorphic matcher (i.e. something that can be converted to a ++// Matcher but is not one yet; for example, Eq(value)) or a value (for ++// example, "hello"). ++template ++class MatcherCastImpl { ++ public: ++ static Matcher Cast(const M& polymorphic_matcher_or_value) { ++ // M can be a polymorhic matcher, in which case we want to use ++ // its conversion operator to create Matcher. Or it can be a value ++ // that should be passed to the Matcher's constructor. ++ // ++ // We can't call Matcher(polymorphic_matcher_or_value) when M is a ++ // polymorphic matcher because it'll be ambiguous if T has an implicit ++ // constructor from M (this usually happens when T has an implicit ++ // constructor from any type). ++ // ++ // It won't work to unconditionally implict_cast ++ // polymorphic_matcher_or_value to Matcher because it won't trigger ++ // a user-defined conversion from M to T if one exists (assuming M is ++ // a value). ++ return CastImpl( ++ polymorphic_matcher_or_value, ++ BooleanConstant< ++ internal::ImplicitlyConvertible >::value>()); ++ } ++ ++ private: ++ static Matcher CastImpl(const M& value, BooleanConstant) { ++ // M can't be implicitly converted to Matcher, so M isn't a polymorphic ++ // matcher. It must be a value then. Use direct initialization to create ++ // a matcher. ++ return Matcher(ImplicitCast_(value)); ++ } ++ ++ static Matcher CastImpl(const M& polymorphic_matcher_or_value, ++ BooleanConstant) { ++ // M is implicitly convertible to Matcher, which means that either ++ // M is a polymorhpic matcher or Matcher has an implicit constructor ++ // from M. In both cases using the implicit conversion will produce a ++ // matcher. ++ // ++ // Even if T has an implicit constructor from M, it won't be called because ++ // creating Matcher would require a chain of two user-defined conversions ++ // (first to create T from M and then to create Matcher from T). ++ return polymorphic_matcher_or_value; ++ } ++}; ++ ++// This more specialized version is used when MatcherCast()'s argument ++// is already a Matcher. This only compiles when type T can be ++// statically converted to type U. ++template ++class MatcherCastImpl > { ++ public: ++ static Matcher Cast(const Matcher& source_matcher) { ++ return Matcher(new Impl(source_matcher)); ++ } ++ ++ private: ++ class Impl : public MatcherInterface { ++ public: ++ explicit Impl(const Matcher& source_matcher) ++ : source_matcher_(source_matcher) {} ++ ++ // We delegate the matching logic to the source matcher. ++ virtual bool MatchAndExplain(T x, MatchResultListener* listener) const { ++ return source_matcher_.MatchAndExplain(static_cast(x), listener); ++ } ++ ++ virtual void DescribeTo(::std::ostream* os) const { ++ source_matcher_.DescribeTo(os); ++ } ++ ++ virtual void DescribeNegationTo(::std::ostream* os) const { ++ source_matcher_.DescribeNegationTo(os); ++ } ++ ++ private: ++ const Matcher source_matcher_; ++ ++ GTEST_DISALLOW_ASSIGN_(Impl); ++ }; ++}; ++ ++// This even more specialized version is used for efficiently casting ++// a matcher to its own type. ++template ++class MatcherCastImpl > { ++ public: ++ static Matcher Cast(const Matcher& matcher) { return matcher; } ++}; ++ ++} // namespace internal ++ ++// In order to be safe and clear, casting between different matcher ++// types is done explicitly via MatcherCast(m), which takes a ++// matcher m and returns a Matcher. It compiles only when T can be ++// statically converted to the argument type of m. ++template ++inline Matcher MatcherCast(const M& matcher) { ++ return internal::MatcherCastImpl::Cast(matcher); ++} ++ ++// Implements SafeMatcherCast(). ++// ++// We use an intermediate class to do the actual safe casting as Nokia's ++// Symbian compiler cannot decide between ++// template ... (M) and ++// template ... (const Matcher&) ++// for function templates but can for member function templates. ++template ++class SafeMatcherCastImpl { ++ public: ++ // This overload handles polymorphic matchers and values only since ++ // monomorphic matchers are handled by the next one. ++ template ++ static inline Matcher Cast(const M& polymorphic_matcher_or_value) { ++ return internal::MatcherCastImpl::Cast(polymorphic_matcher_or_value); ++ } ++ ++ // This overload handles monomorphic matchers. ++ // ++ // In general, if type T can be implicitly converted to type U, we can ++ // safely convert a Matcher to a Matcher (i.e. Matcher is ++ // contravariant): just keep a copy of the original Matcher, convert the ++ // argument from type T to U, and then pass it to the underlying Matcher. ++ // The only exception is when U is a reference and T is not, as the ++ // underlying Matcher may be interested in the argument's address, which ++ // is not preserved in the conversion from T to U. ++ template ++ static inline Matcher Cast(const Matcher& matcher) { ++ // Enforce that T can be implicitly converted to U. ++ GTEST_COMPILE_ASSERT_((internal::ImplicitlyConvertible::value), ++ T_must_be_implicitly_convertible_to_U); ++ // Enforce that we are not converting a non-reference type T to a reference ++ // type U. ++ GTEST_COMPILE_ASSERT_( ++ internal::is_reference::value || !internal::is_reference::value, ++ cannot_convert_non_referentce_arg_to_reference); ++ // In case both T and U are arithmetic types, enforce that the ++ // conversion is not lossy. ++ typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT; ++ typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU; ++ const bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther; ++ const bool kUIsOther = GMOCK_KIND_OF_(RawU) == internal::kOther; ++ GTEST_COMPILE_ASSERT_( ++ kTIsOther || kUIsOther || ++ (internal::LosslessArithmeticConvertible::value), ++ conversion_of_arithmetic_types_must_be_lossless); ++ return MatcherCast(matcher); ++ } ++}; ++ ++template ++inline Matcher SafeMatcherCast(const M& polymorphic_matcher) { ++ return SafeMatcherCastImpl::Cast(polymorphic_matcher); ++} ++ ++// A() returns a matcher that matches any value of type T. ++template ++Matcher A(); ++ ++// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION ++// and MUST NOT BE USED IN USER CODE!!! ++namespace internal { ++ ++// If the explanation is not empty, prints it to the ostream. ++inline void PrintIfNotEmpty(const internal::string& explanation, ++ ::std::ostream* os) { ++ if (explanation != "" && os != NULL) { ++ *os << ", " << explanation; ++ } ++} ++ ++// Returns true if the given type name is easy to read by a human. ++// This is used to decide whether printing the type of a value might ++// be helpful. ++inline bool IsReadableTypeName(const string& type_name) { ++ // We consider a type name readable if it's short or doesn't contain ++ // a template or function type. ++ return (type_name.length() <= 20 || ++ type_name.find_first_of("<(") == string::npos); ++} ++ ++// Matches the value against the given matcher, prints the value and explains ++// the match result to the listener. Returns the match result. ++// 'listener' must not be NULL. ++// Value cannot be passed by const reference, because some matchers take a ++// non-const argument. ++template ++bool MatchPrintAndExplain(Value& value, const Matcher& matcher, ++ MatchResultListener* listener) { ++ if (!listener->IsInterested()) { ++ // If the listener is not interested, we do not need to construct the ++ // inner explanation. ++ return matcher.Matches(value); ++ } ++ ++ StringMatchResultListener inner_listener; ++ const bool match = matcher.MatchAndExplain(value, &inner_listener); ++ ++ UniversalPrint(value, listener->stream()); ++#if GTEST_HAS_RTTI ++ const string& type_name = GetTypeName(); ++ if (IsReadableTypeName(type_name)) ++ *listener->stream() << " (of type " << type_name << ")"; ++#endif ++ PrintIfNotEmpty(inner_listener.str(), listener->stream()); ++ ++ return match; ++} ++ ++// An internal helper class for doing compile-time loop on a tuple's ++// fields. ++template ++class TuplePrefix { ++ public: ++ // TuplePrefix::Matches(matcher_tuple, value_tuple) returns true ++ // iff the first N fields of matcher_tuple matches the first N ++ // fields of value_tuple, respectively. ++ template ++ static bool Matches(const MatcherTuple& matcher_tuple, ++ const ValueTuple& value_tuple) { ++ return TuplePrefix::Matches(matcher_tuple, value_tuple) ++ && get(matcher_tuple).Matches(get(value_tuple)); ++ } ++ ++ // TuplePrefix::ExplainMatchFailuresTo(matchers, values, os) ++ // describes failures in matching the first N fields of matchers ++ // against the first N fields of values. If there is no failure, ++ // nothing will be streamed to os. ++ template ++ static void ExplainMatchFailuresTo(const MatcherTuple& matchers, ++ const ValueTuple& values, ++ ::std::ostream* os) { ++ // First, describes failures in the first N - 1 fields. ++ TuplePrefix::ExplainMatchFailuresTo(matchers, values, os); ++ ++ // Then describes the failure (if any) in the (N - 1)-th (0-based) ++ // field. ++ typename tuple_element::type matcher = ++ get(matchers); ++ typedef typename tuple_element::type Value; ++ Value value = get(values); ++ StringMatchResultListener listener; ++ if (!matcher.MatchAndExplain(value, &listener)) { ++ // TODO(wan): include in the message the name of the parameter ++ // as used in MOCK_METHOD*() when possible. ++ *os << " Expected arg #" << N - 1 << ": "; ++ get(matchers).DescribeTo(os); ++ *os << "\n Actual: "; ++ // We remove the reference in type Value to prevent the ++ // universal printer from printing the address of value, which ++ // isn't interesting to the user most of the time. The ++ // matcher's MatchAndExplain() method handles the case when ++ // the address is interesting. ++ internal::UniversalPrint(value, os); ++ PrintIfNotEmpty(listener.str(), os); ++ *os << "\n"; ++ } ++ } ++}; ++ ++// The base case. ++template <> ++class TuplePrefix<0> { ++ public: ++ template ++ static bool Matches(const MatcherTuple& /* matcher_tuple */, ++ const ValueTuple& /* value_tuple */) { ++ return true; ++ } ++ ++ template ++ static void ExplainMatchFailuresTo(const MatcherTuple& /* matchers */, ++ const ValueTuple& /* values */, ++ ::std::ostream* /* os */) {} ++}; ++ ++// TupleMatches(matcher_tuple, value_tuple) returns true iff all ++// matchers in matcher_tuple match the corresponding fields in ++// value_tuple. It is a compiler error if matcher_tuple and ++// value_tuple have different number of fields or incompatible field ++// types. ++template ++bool TupleMatches(const MatcherTuple& matcher_tuple, ++ const ValueTuple& value_tuple) { ++ // Makes sure that matcher_tuple and value_tuple have the same ++ // number of fields. ++ GTEST_COMPILE_ASSERT_(tuple_size::value == ++ tuple_size::value, ++ matcher_and_value_have_different_numbers_of_fields); ++ return TuplePrefix::value>:: ++ Matches(matcher_tuple, value_tuple); ++} ++ ++// Describes failures in matching matchers against values. If there ++// is no failure, nothing will be streamed to os. ++template ++void ExplainMatchFailureTupleTo(const MatcherTuple& matchers, ++ const ValueTuple& values, ++ ::std::ostream* os) { ++ TuplePrefix::value>::ExplainMatchFailuresTo( ++ matchers, values, os); ++} ++ ++// TransformTupleValues and its helper. ++// ++// TransformTupleValuesHelper hides the internal machinery that ++// TransformTupleValues uses to implement a tuple traversal. ++template ++class TransformTupleValuesHelper { ++ private: ++ typedef ::testing::tuple_size TupleSize; ++ ++ public: ++ // For each member of tuple 't', taken in order, evaluates '*out++ = f(t)'. ++ // Returns the final value of 'out' in case the caller needs it. ++ static OutIter Run(Func f, const Tuple& t, OutIter out) { ++ return IterateOverTuple()(f, t, out); ++ } ++ ++ private: ++ template ++ struct IterateOverTuple { ++ OutIter operator() (Func f, const Tup& t, OutIter out) const { ++ *out++ = f(::testing::get(t)); ++ return IterateOverTuple()(f, t, out); ++ } ++ }; ++ template ++ struct IterateOverTuple { ++ OutIter operator() (Func /* f */, const Tup& /* t */, OutIter out) const { ++ return out; ++ } ++ }; ++}; ++ ++// Successively invokes 'f(element)' on each element of the tuple 't', ++// appending each result to the 'out' iterator. Returns the final value ++// of 'out'. ++template ++OutIter TransformTupleValues(Func f, const Tuple& t, OutIter out) { ++ return TransformTupleValuesHelper::Run(f, t, out); ++} ++ ++// Implements A(). ++template ++class AnyMatcherImpl : public MatcherInterface { ++ public: ++ virtual bool MatchAndExplain( ++ T /* x */, MatchResultListener* /* listener */) const { return true; } ++ virtual void DescribeTo(::std::ostream* os) const { *os << "is anything"; } ++ virtual void DescribeNegationTo(::std::ostream* os) const { ++ // This is mostly for completeness' safe, as it's not very useful ++ // to write Not(A()). However we cannot completely rule out ++ // such a possibility, and it doesn't hurt to be prepared. ++ *os << "never matches"; ++ } ++}; ++ ++// Implements _, a matcher that matches any value of any ++// type. This is a polymorphic matcher, so we need a template type ++// conversion operator to make it appearing as a Matcher for any ++// type T. ++class AnythingMatcher { ++ public: ++ template ++ operator Matcher() const { return A(); } ++}; ++ ++// Implements a matcher that compares a given value with a ++// pre-supplied value using one of the ==, <=, <, etc, operators. The ++// two values being compared don't have to have the same type. ++// ++// The matcher defined here is polymorphic (for example, Eq(5) can be ++// used to match an int, a short, a double, etc). Therefore we use ++// a template type conversion operator in the implementation. ++// ++// The following template definition assumes that the Rhs parameter is ++// a "bare" type (i.e. neither 'const T' nor 'T&'). ++template ++class ComparisonBase { ++ public: ++ explicit ComparisonBase(const Rhs& rhs) : rhs_(rhs) {} ++ template ++ operator Matcher() const { ++ return MakeMatcher(new Impl(rhs_)); ++ } ++ ++ private: ++ template ++ class Impl : public MatcherInterface { ++ public: ++ explicit Impl(const Rhs& rhs) : rhs_(rhs) {} ++ virtual bool MatchAndExplain( ++ Lhs lhs, MatchResultListener* /* listener */) const { ++ return Op()(lhs, rhs_); ++ } ++ virtual void DescribeTo(::std::ostream* os) const { ++ *os << D::Desc() << " "; ++ UniversalPrint(rhs_, os); ++ } ++ virtual void DescribeNegationTo(::std::ostream* os) const { ++ *os << D::NegatedDesc() << " "; ++ UniversalPrint(rhs_, os); ++ } ++ private: ++ Rhs rhs_; ++ GTEST_DISALLOW_ASSIGN_(Impl); ++ }; ++ Rhs rhs_; ++ GTEST_DISALLOW_ASSIGN_(ComparisonBase); ++}; ++ ++template ++class EqMatcher : public ComparisonBase, Rhs, AnyEq> { ++ public: ++ explicit EqMatcher(const Rhs& rhs) ++ : ComparisonBase, Rhs, AnyEq>(rhs) { } ++ static const char* Desc() { return "is equal to"; } ++ static const char* NegatedDesc() { return "isn't equal to"; } ++}; ++template ++class NeMatcher : public ComparisonBase, Rhs, AnyNe> { ++ public: ++ explicit NeMatcher(const Rhs& rhs) ++ : ComparisonBase, Rhs, AnyNe>(rhs) { } ++ static const char* Desc() { return "isn't equal to"; } ++ static const char* NegatedDesc() { return "is equal to"; } ++}; ++template ++class LtMatcher : public ComparisonBase, Rhs, AnyLt> { ++ public: ++ explicit LtMatcher(const Rhs& rhs) ++ : ComparisonBase, Rhs, AnyLt>(rhs) { } ++ static const char* Desc() { return "is <"; } ++ static const char* NegatedDesc() { return "isn't <"; } ++}; ++template ++class GtMatcher : public ComparisonBase, Rhs, AnyGt> { ++ public: ++ explicit GtMatcher(const Rhs& rhs) ++ : ComparisonBase, Rhs, AnyGt>(rhs) { } ++ static const char* Desc() { return "is >"; } ++ static const char* NegatedDesc() { return "isn't >"; } ++}; ++template ++class LeMatcher : public ComparisonBase, Rhs, AnyLe> { ++ public: ++ explicit LeMatcher(const Rhs& rhs) ++ : ComparisonBase, Rhs, AnyLe>(rhs) { } ++ static const char* Desc() { return "is <="; } ++ static const char* NegatedDesc() { return "isn't <="; } ++}; ++template ++class GeMatcher : public ComparisonBase, Rhs, AnyGe> { ++ public: ++ explicit GeMatcher(const Rhs& rhs) ++ : ComparisonBase, Rhs, AnyGe>(rhs) { } ++ static const char* Desc() { return "is >="; } ++ static const char* NegatedDesc() { return "isn't >="; } ++}; ++ ++// Implements the polymorphic IsNull() matcher, which matches any raw or smart ++// pointer that is NULL. ++class IsNullMatcher { ++ public: ++ template ++ bool MatchAndExplain(const Pointer& p, ++ MatchResultListener* /* listener */) const { ++ return GetRawPointer(p) == NULL; ++ } ++ ++ void DescribeTo(::std::ostream* os) const { *os << "is NULL"; } ++ void DescribeNegationTo(::std::ostream* os) const { ++ *os << "isn't NULL"; ++ } ++}; ++ ++// Implements the polymorphic NotNull() matcher, which matches any raw or smart ++// pointer that is not NULL. ++class NotNullMatcher { ++ public: ++ template ++ bool MatchAndExplain(const Pointer& p, ++ MatchResultListener* /* listener */) const { ++ return GetRawPointer(p) != NULL; ++ } ++ ++ void DescribeTo(::std::ostream* os) const { *os << "isn't NULL"; } ++ void DescribeNegationTo(::std::ostream* os) const { ++ *os << "is NULL"; ++ } ++}; ++ ++// Ref(variable) matches any argument that is a reference to ++// 'variable'. This matcher is polymorphic as it can match any ++// super type of the type of 'variable'. ++// ++// The RefMatcher template class implements Ref(variable). It can ++// only be instantiated with a reference type. This prevents a user ++// from mistakenly using Ref(x) to match a non-reference function ++// argument. For example, the following will righteously cause a ++// compiler error: ++// ++// int n; ++// Matcher m1 = Ref(n); // This won't compile. ++// Matcher m2 = Ref(n); // This will compile. ++template ++class RefMatcher; ++ ++template ++class RefMatcher { ++ // Google Mock is a generic framework and thus needs to support ++ // mocking any function types, including those that take non-const ++ // reference arguments. Therefore the template parameter T (and ++ // Super below) can be instantiated to either a const type or a ++ // non-const type. ++ public: ++ // RefMatcher() takes a T& instead of const T&, as we want the ++ // compiler to catch using Ref(const_value) as a matcher for a ++ // non-const reference. ++ explicit RefMatcher(T& x) : object_(x) {} // NOLINT ++ ++ template ++ operator Matcher() const { ++ // By passing object_ (type T&) to Impl(), which expects a Super&, ++ // we make sure that Super is a super type of T. In particular, ++ // this catches using Ref(const_value) as a matcher for a ++ // non-const reference, as you cannot implicitly convert a const ++ // reference to a non-const reference. ++ return MakeMatcher(new Impl(object_)); ++ } ++ ++ private: ++ template ++ class Impl : public MatcherInterface { ++ public: ++ explicit Impl(Super& x) : object_(x) {} // NOLINT ++ ++ // MatchAndExplain() takes a Super& (as opposed to const Super&) ++ // in order to match the interface MatcherInterface. ++ virtual bool MatchAndExplain( ++ Super& x, MatchResultListener* listener) const { ++ *listener << "which is located @" << static_cast(&x); ++ return &x == &object_; ++ } ++ ++ virtual void DescribeTo(::std::ostream* os) const { ++ *os << "references the variable "; ++ UniversalPrinter::Print(object_, os); ++ } ++ ++ virtual void DescribeNegationTo(::std::ostream* os) const { ++ *os << "does not reference the variable "; ++ UniversalPrinter::Print(object_, os); ++ } ++ ++ private: ++ const Super& object_; ++ ++ GTEST_DISALLOW_ASSIGN_(Impl); ++ }; ++ ++ T& object_; ++ ++ GTEST_DISALLOW_ASSIGN_(RefMatcher); ++}; ++ ++// Polymorphic helper functions for narrow and wide string matchers. ++inline bool CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) { ++ return String::CaseInsensitiveCStringEquals(lhs, rhs); ++} ++ ++inline bool CaseInsensitiveCStringEquals(const wchar_t* lhs, ++ const wchar_t* rhs) { ++ return String::CaseInsensitiveWideCStringEquals(lhs, rhs); ++} ++ ++// String comparison for narrow or wide strings that can have embedded NUL ++// characters. ++template ++bool CaseInsensitiveStringEquals(const StringType& s1, ++ const StringType& s2) { ++ // Are the heads equal? ++ if (!CaseInsensitiveCStringEquals(s1.c_str(), s2.c_str())) { ++ return false; ++ } ++ ++ // Skip the equal heads. ++ const typename StringType::value_type nul = 0; ++ const size_t i1 = s1.find(nul), i2 = s2.find(nul); ++ ++ // Are we at the end of either s1 or s2? ++ if (i1 == StringType::npos || i2 == StringType::npos) { ++ return i1 == i2; ++ } ++ ++ // Are the tails equal? ++ return CaseInsensitiveStringEquals(s1.substr(i1 + 1), s2.substr(i2 + 1)); ++} ++ ++// String matchers. ++ ++// Implements equality-based string matchers like StrEq, StrCaseNe, and etc. ++template ++class StrEqualityMatcher { ++ public: ++ StrEqualityMatcher(const StringType& str, bool expect_eq, ++ bool case_sensitive) ++ : string_(str), expect_eq_(expect_eq), case_sensitive_(case_sensitive) {} ++ ++ // Accepts pointer types, particularly: ++ // const char* ++ // char* ++ // const wchar_t* ++ // wchar_t* ++ template ++ bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { ++ if (s == NULL) { ++ return !expect_eq_; ++ } ++ return MatchAndExplain(StringType(s), listener); ++ } ++ ++ // Matches anything that can convert to StringType. ++ // ++ // This is a template, not just a plain function with const StringType&, ++ // because StringPiece has some interfering non-explicit constructors. ++ template ++ bool MatchAndExplain(const MatcheeStringType& s, ++ MatchResultListener* /* listener */) const { ++ const StringType& s2(s); ++ const bool eq = case_sensitive_ ? s2 == string_ : ++ CaseInsensitiveStringEquals(s2, string_); ++ return expect_eq_ == eq; ++ } ++ ++ void DescribeTo(::std::ostream* os) const { ++ DescribeToHelper(expect_eq_, os); ++ } ++ ++ void DescribeNegationTo(::std::ostream* os) const { ++ DescribeToHelper(!expect_eq_, os); ++ } ++ ++ private: ++ void DescribeToHelper(bool expect_eq, ::std::ostream* os) const { ++ *os << (expect_eq ? "is " : "isn't "); ++ *os << "equal to "; ++ if (!case_sensitive_) { ++ *os << "(ignoring case) "; ++ } ++ UniversalPrint(string_, os); ++ } ++ ++ const StringType string_; ++ const bool expect_eq_; ++ const bool case_sensitive_; ++ ++ GTEST_DISALLOW_ASSIGN_(StrEqualityMatcher); ++}; ++ ++// Implements the polymorphic HasSubstr(substring) matcher, which ++// can be used as a Matcher as long as T can be converted to a ++// string. ++template ++class HasSubstrMatcher { ++ public: ++ explicit HasSubstrMatcher(const StringType& substring) ++ : substring_(substring) {} ++ ++ // Accepts pointer types, particularly: ++ // const char* ++ // char* ++ // const wchar_t* ++ // wchar_t* ++ template ++ bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { ++ return s != NULL && MatchAndExplain(StringType(s), listener); ++ } ++ ++ // Matches anything that can convert to StringType. ++ // ++ // This is a template, not just a plain function with const StringType&, ++ // because StringPiece has some interfering non-explicit constructors. ++ template ++ bool MatchAndExplain(const MatcheeStringType& s, ++ MatchResultListener* /* listener */) const { ++ const StringType& s2(s); ++ return s2.find(substring_) != StringType::npos; ++ } ++ ++ // Describes what this matcher matches. ++ void DescribeTo(::std::ostream* os) const { ++ *os << "has substring "; ++ UniversalPrint(substring_, os); ++ } ++ ++ void DescribeNegationTo(::std::ostream* os) const { ++ *os << "has no substring "; ++ UniversalPrint(substring_, os); ++ } ++ ++ private: ++ const StringType substring_; ++ ++ GTEST_DISALLOW_ASSIGN_(HasSubstrMatcher); ++}; ++ ++// Implements the polymorphic StartsWith(substring) matcher, which ++// can be used as a Matcher as long as T can be converted to a ++// string. ++template ++class StartsWithMatcher { ++ public: ++ explicit StartsWithMatcher(const StringType& prefix) : prefix_(prefix) { ++ } ++ ++ // Accepts pointer types, particularly: ++ // const char* ++ // char* ++ // const wchar_t* ++ // wchar_t* ++ template ++ bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { ++ return s != NULL && MatchAndExplain(StringType(s), listener); ++ } ++ ++ // Matches anything that can convert to StringType. ++ // ++ // This is a template, not just a plain function with const StringType&, ++ // because StringPiece has some interfering non-explicit constructors. ++ template ++ bool MatchAndExplain(const MatcheeStringType& s, ++ MatchResultListener* /* listener */) const { ++ const StringType& s2(s); ++ return s2.length() >= prefix_.length() && ++ s2.substr(0, prefix_.length()) == prefix_; ++ } ++ ++ void DescribeTo(::std::ostream* os) const { ++ *os << "starts with "; ++ UniversalPrint(prefix_, os); ++ } ++ ++ void DescribeNegationTo(::std::ostream* os) const { ++ *os << "doesn't start with "; ++ UniversalPrint(prefix_, os); ++ } ++ ++ private: ++ const StringType prefix_; ++ ++ GTEST_DISALLOW_ASSIGN_(StartsWithMatcher); ++}; ++ ++// Implements the polymorphic EndsWith(substring) matcher, which ++// can be used as a Matcher as long as T can be converted to a ++// string. ++template ++class EndsWithMatcher { ++ public: ++ explicit EndsWithMatcher(const StringType& suffix) : suffix_(suffix) {} ++ ++ // Accepts pointer types, particularly: ++ // const char* ++ // char* ++ // const wchar_t* ++ // wchar_t* ++ template ++ bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { ++ return s != NULL && MatchAndExplain(StringType(s), listener); ++ } ++ ++ // Matches anything that can convert to StringType. ++ // ++ // This is a template, not just a plain function with const StringType&, ++ // because StringPiece has some interfering non-explicit constructors. ++ template ++ bool MatchAndExplain(const MatcheeStringType& s, ++ MatchResultListener* /* listener */) const { ++ const StringType& s2(s); ++ return s2.length() >= suffix_.length() && ++ s2.substr(s2.length() - suffix_.length()) == suffix_; ++ } ++ ++ void DescribeTo(::std::ostream* os) const { ++ *os << "ends with "; ++ UniversalPrint(suffix_, os); ++ } ++ ++ void DescribeNegationTo(::std::ostream* os) const { ++ *os << "doesn't end with "; ++ UniversalPrint(suffix_, os); ++ } ++ ++ private: ++ const StringType suffix_; ++ ++ GTEST_DISALLOW_ASSIGN_(EndsWithMatcher); ++}; ++ ++// Implements polymorphic matchers MatchesRegex(regex) and ++// ContainsRegex(regex), which can be used as a Matcher as long as ++// T can be converted to a string. ++class MatchesRegexMatcher { ++ public: ++ MatchesRegexMatcher(const RE* regex, bool full_match) ++ : regex_(regex), full_match_(full_match) {} ++ ++ // Accepts pointer types, particularly: ++ // const char* ++ // char* ++ // const wchar_t* ++ // wchar_t* ++ template ++ bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { ++ return s != NULL && MatchAndExplain(internal::string(s), listener); ++ } ++ ++ // Matches anything that can convert to internal::string. ++ // ++ // This is a template, not just a plain function with const internal::string&, ++ // because StringPiece has some interfering non-explicit constructors. ++ template ++ bool MatchAndExplain(const MatcheeStringType& s, ++ MatchResultListener* /* listener */) const { ++ const internal::string& s2(s); ++ return full_match_ ? RE::FullMatch(s2, *regex_) : ++ RE::PartialMatch(s2, *regex_); ++ } ++ ++ void DescribeTo(::std::ostream* os) const { ++ *os << (full_match_ ? "matches" : "contains") ++ << " regular expression "; ++ UniversalPrinter::Print(regex_->pattern(), os); ++ } ++ ++ void DescribeNegationTo(::std::ostream* os) const { ++ *os << "doesn't " << (full_match_ ? "match" : "contain") ++ << " regular expression "; ++ UniversalPrinter::Print(regex_->pattern(), os); ++ } ++ ++ private: ++ const internal::linked_ptr regex_; ++ const bool full_match_; ++ ++ GTEST_DISALLOW_ASSIGN_(MatchesRegexMatcher); ++}; ++ ++// Implements a matcher that compares the two fields of a 2-tuple ++// using one of the ==, <=, <, etc, operators. The two fields being ++// compared don't have to have the same type. ++// ++// The matcher defined here is polymorphic (for example, Eq() can be ++// used to match a tuple, a tuple, ++// etc). Therefore we use a template type conversion operator in the ++// implementation. ++template ++class PairMatchBase { ++ public: ++ template ++ operator Matcher< ::testing::tuple >() const { ++ return MakeMatcher(new Impl< ::testing::tuple >); ++ } ++ template ++ operator Matcher&>() const { ++ return MakeMatcher(new Impl&>); ++ } ++ ++ private: ++ static ::std::ostream& GetDesc(::std::ostream& os) { // NOLINT ++ return os << D::Desc(); ++ } ++ ++ template ++ class Impl : public MatcherInterface { ++ public: ++ virtual bool MatchAndExplain( ++ Tuple args, ++ MatchResultListener* /* listener */) const { ++ return Op()(::testing::get<0>(args), ::testing::get<1>(args)); ++ } ++ virtual void DescribeTo(::std::ostream* os) const { ++ *os << "are " << GetDesc; ++ } ++ virtual void DescribeNegationTo(::std::ostream* os) const { ++ *os << "aren't " << GetDesc; ++ } ++ }; ++}; ++ ++class Eq2Matcher : public PairMatchBase { ++ public: ++ static const char* Desc() { return "an equal pair"; } ++}; ++class Ne2Matcher : public PairMatchBase { ++ public: ++ static const char* Desc() { return "an unequal pair"; } ++}; ++class Lt2Matcher : public PairMatchBase { ++ public: ++ static const char* Desc() { return "a pair where the first < the second"; } ++}; ++class Gt2Matcher : public PairMatchBase { ++ public: ++ static const char* Desc() { return "a pair where the first > the second"; } ++}; ++class Le2Matcher : public PairMatchBase { ++ public: ++ static const char* Desc() { return "a pair where the first <= the second"; } ++}; ++class Ge2Matcher : public PairMatchBase { ++ public: ++ static const char* Desc() { return "a pair where the first >= the second"; } ++}; ++ ++// Implements the Not(...) matcher for a particular argument type T. ++// We do not nest it inside the NotMatcher class template, as that ++// will prevent different instantiations of NotMatcher from sharing ++// the same NotMatcherImpl class. ++template ++class NotMatcherImpl : public MatcherInterface { ++ public: ++ explicit NotMatcherImpl(const Matcher& matcher) ++ : matcher_(matcher) {} ++ ++ virtual bool MatchAndExplain(T x, MatchResultListener* listener) const { ++ return !matcher_.MatchAndExplain(x, listener); ++ } ++ ++ virtual void DescribeTo(::std::ostream* os) const { ++ matcher_.DescribeNegationTo(os); ++ } ++ ++ virtual void DescribeNegationTo(::std::ostream* os) const { ++ matcher_.DescribeTo(os); ++ } ++ ++ private: ++ const Matcher matcher_; ++ ++ GTEST_DISALLOW_ASSIGN_(NotMatcherImpl); ++}; ++ ++// Implements the Not(m) matcher, which matches a value that doesn't ++// match matcher m. ++template ++class NotMatcher { ++ public: ++ explicit NotMatcher(InnerMatcher matcher) : matcher_(matcher) {} ++ ++ // This template type conversion operator allows Not(m) to be used ++ // to match any type m can match. ++ template ++ operator Matcher() const { ++ return Matcher(new NotMatcherImpl(SafeMatcherCast(matcher_))); ++ } ++ ++ private: ++ InnerMatcher matcher_; ++ ++ GTEST_DISALLOW_ASSIGN_(NotMatcher); ++}; ++ ++// Implements the AllOf(m1, m2) matcher for a particular argument type ++// T. We do not nest it inside the BothOfMatcher class template, as ++// that will prevent different instantiations of BothOfMatcher from ++// sharing the same BothOfMatcherImpl class. ++template ++class BothOfMatcherImpl : public MatcherInterface { ++ public: ++ BothOfMatcherImpl(const Matcher& matcher1, const Matcher& matcher2) ++ : matcher1_(matcher1), matcher2_(matcher2) {} ++ ++ virtual void DescribeTo(::std::ostream* os) const { ++ *os << "("; ++ matcher1_.DescribeTo(os); ++ *os << ") and ("; ++ matcher2_.DescribeTo(os); ++ *os << ")"; ++ } ++ ++ virtual void DescribeNegationTo(::std::ostream* os) const { ++ *os << "("; ++ matcher1_.DescribeNegationTo(os); ++ *os << ") or ("; ++ matcher2_.DescribeNegationTo(os); ++ *os << ")"; ++ } ++ ++ virtual bool MatchAndExplain(T x, MatchResultListener* listener) const { ++ // If either matcher1_ or matcher2_ doesn't match x, we only need ++ // to explain why one of them fails. ++ StringMatchResultListener listener1; ++ if (!matcher1_.MatchAndExplain(x, &listener1)) { ++ *listener << listener1.str(); ++ return false; ++ } ++ ++ StringMatchResultListener listener2; ++ if (!matcher2_.MatchAndExplain(x, &listener2)) { ++ *listener << listener2.str(); ++ return false; ++ } ++ ++ // Otherwise we need to explain why *both* of them match. ++ const internal::string s1 = listener1.str(); ++ const internal::string s2 = listener2.str(); ++ ++ if (s1 == "") { ++ *listener << s2; ++ } else { ++ *listener << s1; ++ if (s2 != "") { ++ *listener << ", and " << s2; ++ } ++ } ++ return true; ++ } ++ ++ private: ++ const Matcher matcher1_; ++ const Matcher matcher2_; ++ ++ GTEST_DISALLOW_ASSIGN_(BothOfMatcherImpl); ++}; ++ ++#if GTEST_LANG_CXX11 ++// MatcherList provides mechanisms for storing a variable number of matchers in ++// a list structure (ListType) and creating a combining matcher from such a ++// list. ++// The template is defined recursively using the following template paramters: ++// * kSize is the length of the MatcherList. ++// * Head is the type of the first matcher of the list. ++// * Tail denotes the types of the remaining matchers of the list. ++template ++struct MatcherList { ++ typedef MatcherList MatcherListTail; ++ typedef ::std::pair ListType; ++ ++ // BuildList stores variadic type values in a nested pair structure. ++ // Example: ++ // MatcherList<3, int, string, float>::BuildList(5, "foo", 2.0) will return ++ // the corresponding result of type pair>. ++ static ListType BuildList(const Head& matcher, const Tail&... tail) { ++ return ListType(matcher, MatcherListTail::BuildList(tail...)); ++ } ++ ++ // CreateMatcher creates a Matcher from a given list of matchers (built ++ // by BuildList()). CombiningMatcher is used to combine the matchers of the ++ // list. CombiningMatcher must implement MatcherInterface and have a ++ // constructor taking two Matchers as input. ++ template class CombiningMatcher> ++ static Matcher CreateMatcher(const ListType& matchers) { ++ return Matcher(new CombiningMatcher( ++ SafeMatcherCast(matchers.first), ++ MatcherListTail::template CreateMatcher( ++ matchers.second))); ++ } ++}; ++ ++// The following defines the base case for the recursive definition of ++// MatcherList. ++template ++struct MatcherList<2, Matcher1, Matcher2> { ++ typedef ::std::pair ListType; ++ ++ static ListType BuildList(const Matcher1& matcher1, ++ const Matcher2& matcher2) { ++ return ::std::pair(matcher1, matcher2); ++ } ++ ++ template class CombiningMatcher> ++ static Matcher CreateMatcher(const ListType& matchers) { ++ return Matcher(new CombiningMatcher( ++ SafeMatcherCast(matchers.first), ++ SafeMatcherCast(matchers.second))); ++ } ++}; ++ ++// VariadicMatcher is used for the variadic implementation of ++// AllOf(m_1, m_2, ...) and AnyOf(m_1, m_2, ...). ++// CombiningMatcher is used to recursively combine the provided matchers ++// (of type Args...). ++template