diff --git a/.clang-format b/.clang-format deleted file mode 100644 index 69c1f29..0000000 --- a/.clang-format +++ /dev/null @@ -1,152 +0,0 @@ ---- -Language: Cpp -# BasedOnStyle: Mozilla -AccessModifierOffset: -4 -AlignAfterOpenBracket: Align -AlignConsecutiveMacros: false -AlignConsecutiveAssignments: false -AlignConsecutiveDeclarations: false -AlignEscapedNewlines: Left -AlignOperands: true -AlignTrailingComments: true -AllowAllArgumentsOnNextLine: true -AllowAllConstructorInitializersOnNextLine: true -AllowAllParametersOfDeclarationOnNextLine: false -AllowShortBlocksOnASingleLine: Never -AllowShortCaseLabelsOnASingleLine: false -AllowShortFunctionsOnASingleLine: Inline -AllowShortLambdasOnASingleLine: All -AllowShortIfStatementsOnASingleLine: Never -AllowShortLoopsOnASingleLine: false -AlwaysBreakAfterDefinitionReturnType: None -AlwaysBreakAfterReturnType: None -AlwaysBreakBeforeMultilineStrings: false -AlwaysBreakTemplateDeclarations: Yes -BinPackArguments: false -BinPackParameters: false -BraceWrapping: - AfterCaseLabel: true - AfterClass: true - AfterControlStatement: true - AfterEnum: true - AfterFunction: true - AfterNamespace: false - AfterObjCDeclaration: true - AfterStruct: true - AfterUnion: true - AfterExternBlock: true - BeforeCatch: false - BeforeElse: false - IndentBraces: false - SplitEmptyFunction: false - SplitEmptyRecord: false - SplitEmptyNamespace: false -BreakBeforeBinaryOperators: None -BreakBeforeBraces: Custom -BreakBeforeInheritanceComma: false -BreakInheritanceList: AfterColon -BreakBeforeTernaryOperators: true -BreakConstructorInitializersBeforeComma: false -BreakConstructorInitializers: BeforeColon -BreakAfterJavaFieldAnnotations: false -BreakStringLiterals: true -ColumnLimit: 120 -CommentPragmas: '^ IWYU pragma:' -CompactNamespaces: true -ConstructorInitializerAllOnOneLineOrOnePerLine: false -ConstructorInitializerIndentWidth: 4 -ContinuationIndentWidth: 2 -Cpp11BracedListStyle: false -DeriveLineEnding: true -DerivePointerAlignment: false -DisableFormat: false -ExperimentalAutoDetectBinPacking: false -FixNamespaceComments: true -ForEachMacros: - - foreach - - Q_FOREACH - - BOOST_FOREACH -IncludeBlocks: Preserve -IncludeCategories: - - Regex: ' /etc/apt/trusted.gpg.d/git-core_ubuntu_ppa.gpg - for i in {1..${NET_RETRY_COUNT:-5}}; do sudo -E add-apt-repository -y ppa:git-core/ppa && break || sleep 10; done - curl -sSL --retry ${NET_RETRY_COUNT:-5} 'https://apt.kitware.com/keys/kitware-archive-latest.asc' | sudo gpg --dearmor > /etc/apt/trusted.gpg.d/kitware-archive-latest.gpg - for i in {1..${NET_RETRY_COUNT:-5}}; do sudo -E add-apt-repository -y "deb https://apt.kitware.com/ubuntu/ $(lsb_release -cs) main" && break || sleep 10; done - apt-get -o Acquire::Retries=$NET_RETRY_COUNT update - apt-get -o Acquire::Retries=$NET_RETRY_COUNT install -y g++ git cmake - git config --global pack.threads 0 - git config --global --add safe.directory "$GITHUB_WORKSPACE" # Avoid ownership issues of repo in container - - - uses: actions/checkout@v4 - with: - # For coverage builds fetch the whole history, else only 1 commit using a 'fake ternary' - fetch-depth: ${{ matrix.coverage && '0' || '1' }} - - # Checking out Boost and all its submodules takes ages... - - name: Cache Boost - uses: actions/cache@v4 - with: - path: boost-root - key: boost-${{matrix.boostBranch}} - - name: Checkout Boost - uses: actions/checkout@v4 - with: - repository: boostorg/boost - ref: ${{matrix.boostBranch}} - submodules: true - path: boost-root - persist-credentials: false - - - name: Install packages and setup env - run: | - B2_TOOLSET=${{matrix.toolset}} - if [[ ! "${{matrix.os}}" == "windows-"* ]]; then - sudo apt-get -o Acquire::Retries=$NET_RETRY_COUNT update - CXX=${{matrix.compiler}} - CXX="${CXX/gcc-/g++-}" - # Package names are g++-* and clang-*, so set this before correcting CXX for Clang - pkgs="$CXX xsltproc docbook-xsl docbook-xml lcov ccache" - sudo apt-get -o Acquire::Retries=$NET_RETRY_COUNT install -y $pkgs - CXX="ccache ${CXX/clang-/clang++-}" - echo "CXX=$CXX" >> $GITHUB_ENV - echo "CC=${{matrix.compiler}}" >> $GITHUB_ENV - if [[ -z $B2_TOOLSET ]]; then - if [[ "$CXX" =~ clang ]]; then - B2_TOOLSET=clang - else - B2_TOOLSET=gcc - fi - fi - [[ -z $CXX ]] || echo "using $B2_TOOLSET : : $CXX ;" > ~/user-config.jam - fi - echo "B2_TOOLSET=$B2_TOOLSET" >> $GITHUB_ENV - - B2_FLAGS+=" --toolset=$B2_TOOLSET cxxstd=${{matrix.cxxstd}}" - if [[ "${{matrix.coverage}}" == "yes" ]]; then - B2_FLAGS+=" cxxflags=--coverage linkflags=--coverage" - fi - echo "B2_FLAGS=$B2_FLAGS" >> $GITHUB_ENV - - # Move the Boost root to a sibling folder - mv boost-root .. - echo "BOOST_ROOT=${{github.workspace}}/../boost-root" >> $GITHUB_ENV - - - name: Cache ccache - uses: hendrikmuhs/ccache-action@v1 - if: startsWith(matrix.os, 'ubuntu') - with: - key: ${{matrix.os}}-${{matrix.compiler}}-${{matrix.boostBranch}} - - - name: Prepare boost - working-directory: ${{env.BOOST_ROOT}} - run: ./bootstrap.sh && ./b2 headers - - - name: Boost build - run: | - ./b2 "$GITHUB_WORKSPACE/test" -q $B2_FLAGS -j3 - ./b2 "$GITHUB_WORKSPACE/doc//mock_examples" -q $B2_FLAGS "$@" - working-directory: ${{env.BOOST_ROOT}} - - - name: Run inspect check - run: ./b2 "$GITHUB_WORKSPACE/test//inspect" -q $B2_FLAGS - working-directory: ${{env.BOOST_ROOT}} - - - name: Build doc - if: startsWith(matrix.os, 'ubuntu') - run: scripts/build_doc.sh $B2_FLAGS -j3 - - - name: Collect coverage - if: matrix.coverage - run: | - lcov --version - lcov --gcov-tool=gcov-8 --directory "$GITHUB_WORKSPACE/test" --capture --output-file all.info - # dump a summary on the console - lcov --list all.info - # Limit to our files (header-only in this case) - lcov --extract all.info "$GITHUB_WORKSPACE/include/*" --output-file coverage.info - # Output what was collected - lcov --list coverage.info - - name: Upload coverage - if: matrix.coverage - uses: coverallsapp/github-action@master - with: - path-to-lcov: ${{github.workspace}}/coverage.info - github-token: ${{secrets.GITHUB_TOKEN}} - - - name: Build required boost libs - working-directory: ${{env.BOOST_ROOT}} - run: | - ./b2 --toolset=$B2_TOOLSET --with-test --with-thread --with-chrono --with-system --with-atomic --with-date_time -a -j3 - # Add lib folder to LD_LIBRARY_PATH, so the tests can load them - echo "LD_LIBRARY_PATH=$PWD/stage/lib:$LD_LIBRARY_PATH" >> $GITHUB_ENV - - - name: CMake build - run: | - mkdir build && cd build - CXX_STANDARD="${{matrix.cxxstd}}" - if [[ "${{matrix.os}}" == "windows-"* ]]; then - extra_args=() - else - extra_args=(-DCMAKE_CXX_COMPILER_LAUNCHER=ccache) - fi - if [[ -n "${{matrix.generator}}" ]]; then - extra_args+=(-G "${{matrix.generator}}") - fi - if [[ "${{matrix.generator}}" == "MinGW"* ]]; then - extra_args+=(-DCMAKE_CXX_FLAGS="-Wa,-mbig-obj") - fi - echo "Using extra args: ${extra_args[*]}" - cmake .. -DCMAKE_BUILD_TYPE=Debug -DBoost_ROOT="$BOOST_ROOT/stage" -DCMAKE_CXX_STANDARD="${CXX_STANDARD##*,}" "${extra_args[@]}" -DCMAKE_VERBOSE_MAKEFILE=ON -DBoost_DEBUG=ON -DBoost_VERBOSE=ON - cmake --build . --config Debug --parallel 3 - ctest --output-on-failure --build-config Debug - - - name: Cleanup Boost folder to reduce cache usage - if: ${{ always() }} - working-directory: ${{env.BOOST_ROOT}} - run: git clean -fxd diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml deleted file mode 100644 index a0b79ae..0000000 --- a/.github/workflows/release.yml +++ /dev/null @@ -1,63 +0,0 @@ -# Copyright 2020-2025 Alexander Grund -# Distributed under the Boost Software License, Version 1.0. -# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt) - -name: Release - -on: - push: - branches: [main] - tags: ['v*'] - -jobs: - release: - name: Create Release - runs-on: ubuntu-latest - env: - BOOST_VERSION: 1.87.0 - BOOST_ROOT: ${{github.workspace}}/dependencies/boost - steps: - - uses: actions/checkout@v4 - - uses: actions/checkout@v4 - with: - repository: boostorg/boost - ref: boost-${{env.BOOST_VERSION}} - path: ${{env.BOOST_ROOT}} - fetch-depth: 1 - - name: Prepare boost - working-directory: ${{env.BOOST_ROOT}} - run: | - git submodule update --init --jobs 3 tools/boostdep tools/quickbook tools/boostbook - python tools/boostdep/depinst/depinst.py --exclude test --git_args '--jobs 3' ../tools/quickbook - ./bootstrap.sh || (cat bootstrap.log && false) - - name: Install dependencies - run: sudo apt-get install xsltproc docbook-xsl docbook-xml - - name: Create documentation - run: scripts/build_doc.sh -j3 - - name: Package documentation - run: tar -czvf turtle_doc.tar.gz html - working-directory: doc - # This runs only when actual tags are created - - name: Create Release - if: startsWith(github.ref, 'refs/tags/') - id: create_release - uses: actions/create-release@v1 - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - with: - tag_name: ${{ github.ref }} - release_name: Release ${{ github.ref }} - body: | - C++ mock object library for Boost - draft: true - prerelease: false - - name: Upload docs - if: startsWith(github.ref, 'refs/tags/') - uses: actions/upload-release-asset@v1.0.1 - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - with: - upload_url: ${{ steps.create_release.outputs.upload_url }} - asset_path: doc/turtle_doc.tar.gz - asset_name: turtle_doc.tar.gz - asset_content_type: application/tar.gz diff --git a/.gitignore b/.gitignore index f094525..02e5fb3 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,4 @@ .vscode bin out -/build -__build +build/xsl diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..e775d7b --- /dev/null +++ b/.travis.yml @@ -0,0 +1,99 @@ +# Use, modification, and distribution are +# subject to the Boost Software License, Version 1.0. (See accompanying +# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +# +# Copyright Antony Polukhin 2014. + +# +# See https://svn.boost.org/trac/boost/wiki/TravisCoverals for description of this file +# and how it can be used with Boost libraries. +# + +sudo: false +language: cpp + +branches: + only: + - master + +env: + - CXX_STANDARD=c++17 BRANCH_TO_TEST=master + - CXX_STANDARD=c++14 BRANCH_TO_TEST=master + - CXX_STANDARD=c++11 BRANCH_TO_TEST=master + - CXX_STANDARD=c++11 BRANCH_TO_TEST=boost-1.58.0 + - CXX_STANDARD=c++98 BRANCH_TO_TEST=boost-1.58.0 + - CXX_STANDARD=c++11 BRANCH_TO_TEST=boost-1.59.0 + - CXX_STANDARD=c++98 BRANCH_TO_TEST=boost-1.59.0 + - CXX_STANDARD=c++11 BRANCH_TO_TEST=boost-1.67.0 + - CXX_STANDARD=c++98 BRANCH_TO_TEST=boost-1.67.0 + +compiler: + - clang + - gcc + +addons: + apt: + sources: + - ubuntu-toolchain-r-test + - llvm-toolchain-precise + packages: + - gcc-5 + - g++-5 + - clang-5.0 + - lld-5.0 + - xsltproc + - docbook-xsl + - docbook-xml + +before_install: + - DOCBOOK_XSL_DIR=/usr/share/xml/docbook/stylesheet/docbook-xsl + - DOCBOOK_DTD_DIR=/usr/share/xml/docbook/schema/dtd/4.2 + + - sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-5 60 --slave /usr/bin/g++ g++ /usr/bin/g++-5 + - gcc --version + + # Set this to the name of your Boost library + # Autodetect library name by using the following code: - PROJECT_TO_TEST=$(basename $(pwd)) + - PROJECT_TO_TEST=$(basename $(pwd)) + + # Files, which coverage results must be ignored (files from other projects). Example: - IGNORE_COVERAGE='*/boost/progress.hpp */filesystem/src/path.cpp' + - IGNORE_COVERAGE='*/boost-local/*' + + # From this point and below code is same for all the Boost libs + # Cloning Boost libraries (fast nondeep cloning) + - PROJECT_DIR=`pwd` + - git --version + - BOOST=$HOME/boost-local + - git clone -b $BRANCH_TO_TEST https://github.com/boostorg/boost.git $BOOST + - cd $BOOST + - git submodule update --init --merge + - ./bootstrap.sh + - ./b2 headers + +script: + - cd $PROJECT_DIR/build + - export BOOST_ROOT=$BOOST + # `--coverage` flags required to generate coverage info for Coveralls + - ./build.sh --toolset=$CC "cxxflags=-std=$CXX_STANDARD -Wno-unused-local-typedefs -Wno-unused-function -Wno-deprecated-declarations --coverage" "linkflags=--coverage" + +after_success: + - COVERALS_DIR=$PROJECT_DIR/coverals + + # Copying Coveralls data to a separate folder + - mkdir -p $COVERALS_DIR + - find ../test/bin/ -name "*.gcda" -exec cp "{}" $COVERALS_DIR/ \; + - find ../test/bin/ -name "*.gcno" -exec cp "{}" $COVERALS_DIR/ \; + + # Preparing Coveralls data by + # ... installing the tools + - sudo apt-get install -qq python-yaml lcov + # ... changing data format to a readable one + - lcov --directory $COVERALS_DIR --base-directory /home/travis/build/mat007/turtle/test --capture --output-file $COVERALS_DIR/coverage.info + + # ... erasing /test/ /example/ folder data + - lcov --remove $COVERALS_DIR/coverage.info "/usr*" "/test/*" $IGNORE_COVERAGE "tests/*" "*/doc/examples/*" -o $COVERALS_DIR/coverage.info + + # Sending data to Coveralls + - cd $PROJECT_DIR + - gem install coveralls-lcov + - coveralls-lcov coverals/coverage.info diff --git a/CMakeLists.txt b/CMakeLists.txt deleted file mode 100644 index c232f78..0000000 --- a/CMakeLists.txt +++ /dev/null @@ -1,83 +0,0 @@ -# Copyright 2019-2025 Alexander Grund -# Distributed under the Boost Software License, Version 1.0. -# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt - -cmake_minimum_required(VERSION 3.16..3.20) -project(turtle VERSION 2.0.0 LANGUAGES CXX) - -if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR) - set(IS_ROOT_PROJECT ON) - include(CTest) -else() - set(IS_ROOT_PROJECT OFF) -endif() - -option(TURTLE_INSTALL "Enable to add install target" ${IS_ROOT_PROJECT}) - -# Default boost libs are static on windows and dynamic on linux -if(WIN32 AND NOT DEFINED Boost_USE_STATIC_LIBS) - set(Boost_USE_STATIC_LIBS ON) -endif() - -# Allows boost to be build by parent project -if(NOT TARGET Boost::boost) - find_package(Boost 1.58 REQUIRED) -endif() - -set(MOCK_VERSION "\"${PROJECT_VERSION}\"") -set(_turtleVersionFile ${CMAKE_CURRENT_BINARY_DIR}/include/turtle/version.hpp) -configure_file(version.hpp.cmake ${_turtleVersionFile} @ONLY) - -add_library(turtle INTERFACE) -add_library(turtle::turtle ALIAS turtle) -target_include_directories(turtle INTERFACE $) -target_compile_features(turtle INTERFACE cxx_std_14) - -target_link_libraries(turtle INTERFACE Boost::boost Boost::disable_autolinking) - -if(NOT CMAKE_VERSION VERSION_LESS 3.19) - file(GLOB _turtleHeaders include/turtle/*.hpp) - file(GLOB _turtleHeadersDetail include/turtle/detail/*.hpp) - source_group(turtle FILES ${_turtleHeaders} ${_turtleVersionFile}) - source_group(turtle/detail FILES ${_turtleHeadersDetail}) - target_sources(turtle PRIVATE ${_turtleHeaders} ${_turtleVersionFile} ${_turtleHeadersDetail}) -endif() - -if(BUILD_TESTING) - add_subdirectory(test) -endif() - -if(TURTLE_INSTALL) - include(GNUInstallDirs) - include(CMakePackageConfigHelpers) - - target_include_directories(turtle INTERFACE $) - - install(TARGETS turtle - EXPORT ${PROJECT_NAME}Targets - RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} - LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} - ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} - ) - install(DIRECTORY include/ ${CMAKE_CURRENT_BINARY_DIR}/include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) - - set(configFile ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake) - set(versionFile ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake) - set(configInstallDestination lib/cmake/${PROJECT_NAME}) - - configure_package_config_file( - ${PROJECT_SOURCE_DIR}/Config.cmake.in - ${configFile} - INSTALL_DESTINATION ${configInstallDestination} - ) - - write_basic_package_version_file(${versionFile} COMPATIBILITY SameMajorVersion ARCH_INDEPENDENT) - - install(FILES ${configFile} ${versionFile} DESTINATION ${configInstallDestination}) - - install( - EXPORT ${PROJECT_NAME}Targets - NAMESPACE "turtle::" - DESTINATION ${configInstallDestination} - ) -endif() diff --git a/Config.cmake.in b/Config.cmake.in deleted file mode 100644 index 883b8bd..0000000 --- a/Config.cmake.in +++ /dev/null @@ -1,8 +0,0 @@ -@PACKAGE_INIT@ - -include(CMakeFindDependencyMacro) -find_dependency(Boost 1.58) - -include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake") - -check_required_components("@PROJECT_NAME@") diff --git a/Jamfile.v2 b/Jamfile.v2 new file mode 100644 index 0000000..a373100 --- /dev/null +++ b/Jamfile.v2 @@ -0,0 +1,28 @@ +# Copyright Rene Rivera 2007. +# +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt) + +# Usage: +# +# bjam [options | properties | targets] +# +# Options: +# +# --boost= The directory of a Boost source tree. +# Default; BOOST env var (if found) +# Default; ../boost (if found) +# +# --boost-build= +# The directory for the Boost.Build v2 files. +# Default; BOOST_BUILD_PATH env var (if found) +# Default; BOOST_BUILD env var (if found) +# Default; /tools/build/v2 (if found) + +#~ If we have the Boost sources we can use the project... + +if [ GLOB $(BOOST) : [ modules.peek project : JAMFILE ] ] +{ + use-project /boost : $(BOOST) ; +} diff --git a/Jamroot.jam b/Jamroot.jam index df7f2f9..8797198 100644 --- a/Jamroot.jam +++ b/Jamroot.jam @@ -6,11 +6,9 @@ import modules ; -if BOOST_ROOT -{ - local boost = [ modules.peek : BOOST_ROOT ] ; +local boost = [ modules.peek : BOOST ] ; - project mock : requirements $(boost) ; +project mock : requirements $(boost) . ; - #use-project /boost : $(boost) ; -} +# This seems to prevent some Boost.Build errors that otherwise occur :-( +use-project /boost : $(boost) ; diff --git a/README.md b/README.md index d205f36..a926488 100644 --- a/README.md +++ b/README.md @@ -4,10 +4,6 @@ Distributed under the [Boost Software License, Version 1.0](http://boost.org/LICENSE_1_0.txt). -[![CI](https://github.com/mat007/turtle/actions/workflows/ci.yml/badge.svg)](https://github.com/mat007/turtle/actions/workflows/ci.yml) +[![Build Status](https://travis-ci.org/mat007/turtle.svg)](https://travis-ci.org/mat007/turtle) [![Build status](https://ci.appveyor.com/api/projects/status/459hvqkb5rts4hw7?svg=true)](https://ci.appveyor.com/project/mat007/turtle) [![Coverage Status](https://coveralls.io/repos/mat007/turtle/badge.png)](https://coveralls.io/r/mat007/turtle) - -Boost and a C++14 compatible compiler is required. - -More information in the [documentation](http://turtle.sourceforge.net). diff --git a/appveyor.yml b/appveyor.yml index c02348d..f20a17e 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -2,97 +2,53 @@ # subject to the Boost Software License, Version 1.0. (See accompanying # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) # -# Copyright 2015 Mathieu Champlon -# Copyright 2020-2025 Alexander Grund +# Copyright Mathieu Champlon 2015. skip_branch_with_pr: true branches: only: - - main + - master environment: - global: - ADDRESS_MODEL: 32,64 - VARIANT: debug,release - matrix: - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015 - BOOST: 1_65_1 + BOOST: 1_60_0 TOOLSET: msvc-14.0 - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 BOOST: 1_65_1 TOOLSET: msvc-14.1 + CXX_STANDARD: 14 - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 - BOOST: 1_69_0 + BOOST: 1_67_0 TOOLSET: msvc-14.1 - CXX_STANDARD: 14,17 - ADDRESS_MODEL: 64 - VARIANT: debug - - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022 - BOOST: 1_83_0 - TOOLSET: msvc-14.3 - CXX_STANDARD: 14,17,20 - ADDRESS_MODEL: 64 - VARIANT: debug - - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022 - BOOST: 1_86_0 - TOOLSET: msvc-14.3 - CXX_STANDARD: 14,17 - ADDRESS_MODEL: 64 - VARIANT: debug - - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022 - BOOST: 1_86_0 - TOOLSET: msvc-14.3 - CXX_STANDARD: 20 + CXX_STANDARD: 14 + # CXX_STANDARD: 17 - # CMake builds - - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015 - BOOST: 1_65_1 - CMAKE: true - - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019 - BOOST: 1_83_0 - CMAKE: true - - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022 - BOOST: 1_86_0 - CMAKE: true +platform: + - 32 + - 64 + +configuration: + - debug + - release install: - - appveyor-retry powershell Invoke-WebRequest http://www.oasis-open.org/docbook/xml/4.2/docbook-xml-4.2.zip -OutFile docbook-xml.zip - - appveyor-retry powershell Invoke-WebRequest https://github.com/docbook/xslt10-stylesheets/releases/download/release/1.79.2/docbook-xsl-1.79.2.zip -OutFile docbook-xsl.zip - - 7z x -oC:\Boost\share\docbook-xml docbook-xml.zip - - 7z x -oC:\Boost\share docbook-xsl.zip - - mkdir %APPVEYOR_BUILD_FOLDER%\bin - - cd %APPVEYOR_BUILD_FOLDER%\bin - - appveyor-retry powershell Invoke-WebRequest https://www.zlatkovic.com/pub/libxml/iconv-1.9.2.win32.zip -OutFile iconv.zip + - cd C:\projects\turtle\doc + - appveyor-retry powershell Invoke-WebRequest ftp://ftp.zlatkovic.com/libxml/iconv-1.9.2.win32.zip -OutFile iconv.zip - 7z e iconv.zip iconv.dll -r - - appveyor-retry powershell Invoke-WebRequest https://www.zlatkovic.com/pub/libxml/libxml2-2.7.8.win32.zip -OutFile libxml2.zip + - appveyor-retry powershell Invoke-WebRequest ftp://ftp.zlatkovic.com/libxml/libxml2-2.7.8.win32.zip -OutFile libxml2.zip - 7z e libxml2.zip libxml2.dll -r - - appveyor-retry powershell Invoke-WebRequest https://www.zlatkovic.com/pub/libxml/libxslt-1.1.26.win32.zip -OutFile libxslt.zip + - appveyor-retry powershell Invoke-WebRequest ftp://ftp.zlatkovic.com/libxml/libxslt-1.1.26.win32.zip -OutFile libxslt.zip - 7z e libxslt.zip libexslt.dll libxslt.dll xsltproc.exe -r - - appveyor-retry powershell Invoke-WebRequest https://www.zlatkovic.com/pub/libxml/zlib-1.2.5.win32.zip -OutFile zlib.zip + - appveyor-retry powershell Invoke-WebRequest ftp://ftp.zlatkovic.com/libxml/zlib-1.2.5.win32.zip -OutFile zlib.zip - 7z e zlib.zip zlib1.dll -r - xsltproc -V build_script: - - set PATH=%PATH%;%APPVEYOR_BUILD_FOLDER%\bin - set BOOST_ROOT=C:\Libraries\boost_%BOOST% - cd %BOOST_ROOT% - call bootstrap.bat - - cd %APPVEYOR_BUILD_FOLDER% - - if NOT "%CXX_STANDARD%"=="" set CXX_FLAGS=cxxstd=%CXX_STANDARD% - - set BUILD_ARGS=address-model=%ADDRESS_MODEL% variant=%VARIANT% - - set BOOST_TEST_LOG_LEVEL=all - - call scripts\build.bat --toolset=%TOOLSET% %CXX_FLAGS% -j3 - -for: - - matrix: - only: [CMAKE: true] - install: true - build_script: - - set BOOST_ROOT=C:\Libraries\boost_%BOOST% - - cd %APPVEYOR_BUILD_FOLDER% - - mkdir build && cd build - - cmake .. -DCMAKE_BUILD_TYPE=Debug - - cmake --build . --config Debug - - ctest --output-on-failure --build-config Debug + - cd C:\projects\turtle\build + - if NOT "%CXX_STANDARD%"=="" set CXX_FLAGS=cxxflags=/std:c++%CXX_STANDARD% + - call build.bat --toolset=%TOOLSET% address-model=%PLATFORM% %CXX_FLAGS% --build-type=complete %CONFIGURATION% diff --git a/doc/boostbook/xsl/navbar.xsl b/build/boostbook/xsl/navbar.xsl similarity index 100% rename from doc/boostbook/xsl/navbar.xsl rename to build/boostbook/xsl/navbar.xsl diff --git a/build/build.bat b/build/build.bat new file mode 100644 index 0000000..2ae058b --- /dev/null +++ b/build/build.bat @@ -0,0 +1,29 @@ +@echo off + +rem Copyright (C) 2015 Mathieu Champlon +rem +rem Distributed under the Boost Software License, Version 1.0. +rem (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) + +setlocal + +rem error if BOOST_ROOT not set +set BOOST=%BOOST_ROOT% + +pushd ..\test +%BOOST%\b2.exe -q %* +popd +if errorlevel 1 exit /b %ERRORLEVEL% + +set BOOSTBOOK_DIR=..\bin\turtle\boostbook +xcopy /Y /S /Q /I %BOOST%\tools\boostbook\xsl %BOOSTBOOK_DIR%\xsl +xcopy /Y /S /Q /I %BOOST%\tools\boostbook\dtd %BOOSTBOOK_DIR%\dtd +xcopy /Y /S /Q /I boostbook %BOOSTBOOK_DIR% +xcopy /Y /S /Q /I %BOOST%\doc\src\boostbook.css ..\doc\html +xcopy /Y /S /Q /I %BOOST%\doc\src\images\*.png ..\doc\html\images +xcopy /Y /S /Q /I %BOOST%\doc\src\images\callouts\*.png ..\doc\html\images\callouts +if errorlevel 1 exit /b %ERRORLEVEL% +pushd ..\doc +%BOOST%\b2.exe -q %* +popd +if errorlevel 1 exit /b %ERRORLEVEL% diff --git a/build/build.properties b/build/build.properties new file mode 100644 index 0000000..623180f --- /dev/null +++ b/build/build.properties @@ -0,0 +1 @@ +extensions = headers,check,run diff --git a/build/build.sh b/build/build.sh new file mode 100755 index 0000000..a525c9e --- /dev/null +++ b/build/build.sh @@ -0,0 +1,32 @@ +#!/bin/sh + +# Copyright (C) 2015 Mathieu Champlon +# +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) + +copy() +{ + for dir; do true; done + mkdir -p $dir + cp $@ +} + +set -ex + +export BOOST=$BOOST_ROOT + +cd ../test +$BOOST/b2 -q "$@" +cd ../build + +export BOOSTBOOK_DIR=../bin/turtle/boostbook +copy -r "$BOOST"/tools/boostbook/xsl $BOOSTBOOK_DIR +copy -r "$BOOST"/tools/boostbook/dtd $BOOSTBOOK_DIR +copy -r boostbook/* $BOOSTBOOK_DIR +copy "$BOOST"/doc/src/boostbook.css ../doc/html +copy "$BOOST"/doc/src/images/*.png ../doc/html/images +copy "$BOOST"/doc/src/images/callouts/*.png ../doc/html/images/callouts +cd ../doc +$BOOST/b2 -q "$@" +cd ../build diff --git a/build/build.xml b/build/build.xml new file mode 100644 index 0000000..b2201f8 --- /dev/null +++ b/build/build.xml @@ -0,0 +1,115 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/build/clang/Dockerfile b/build/clang/Dockerfile new file mode 100644 index 0000000..fd3a65b --- /dev/null +++ b/build/clang/Dockerfile @@ -0,0 +1,17 @@ +# $ docker build --platform=linux -f clang/Dockerfile -t turtle-clang . +FROM buildpack-deps:stretch +RUN apt-get update && apt-get install -y xsltproc docbook-xsl docbook-xml && apt-get autoremove && apt-get clean +ENV DOCBOOK_XSL_DIR=/usr/share/xml/docbook/stylesheet/docbook-xsl \ + DOCBOOK_DTD_DIR=/usr/share/xml/docbook/schema/dtd/4.2 \ + BOOST_ROOT=/home/dev/cpp/boost/ +# wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key|apt-key add - && \ +RUN echo "deb http://apt.llvm.org/stretch/ llvm-toolchain-stretch-5.0 main" >> /etc/apt/sources.list && \ + apt-get update && \ + apt-get install -y --allow-unauthenticated clang-5.0 lld-5.0 libc++1 && \ + apt-get autoremove && \ + apt-get clean && \ + update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-5.0 100 && \ + update-alternatives --install /usr/bin/clang clang /usr/bin/clang-5.0 100 +RUN echo 'cd /home/dev/cpp/turtle/build' >> ~/.bashrc +# $ docker run --platform=linux --rm -v C:/dev:/home/dev -m 32g -it turtle-clang +# ./build.sh --toolset=clang "cxxflags=-std=c++17 -stdlib=libc++ -Wno-unused-variable" diff --git a/build/gcc/Dockerfile b/build/gcc/Dockerfile new file mode 100644 index 0000000..5d1a4d8 --- /dev/null +++ b/build/gcc/Dockerfile @@ -0,0 +1,9 @@ +# $ docker build -f Dockerfile -t turtle-gcc . +FROM gcc +RUN apt-get update && apt-get install -y xsltproc docbook-xsl docbook-xml && apt-get autoremove && apt-get clean +ENV DOCBOOK_XSL_DIR=/usr/share/xml/docbook/stylesheet/docbook-xsl \ + DOCBOOK_DTD_DIR=/usr/share/xml/docbook/schema/dtd/4.2 \ + BOOST_ROOT=/home/dev/cpp/boost/ +RUN echo 'cd /home/dev/cpp/turtle/build' >> ~/.bashrc +# $ docker run --platform=linux --rm -v C:/dev:/home/dev -m 16g -it turtle-gcc +# ./build.sh --toolset=gcc "cxxflags=-std=c++17 -Wno-noexcept-type -Wno-unused-variable -Wno-unused-function -Wno-deprecated-declarations" diff --git a/build/vc100/.gitignore b/build/vc100/.gitignore new file mode 100644 index 0000000..dd990f3 --- /dev/null +++ b/build/vc100/.gitignore @@ -0,0 +1,7 @@ +.vs +*.db +*.ipch +*.opendb +*.opensdf +*.sdf +*.suo diff --git a/build/vc100/turtle.sln b/build/vc100/turtle.sln new file mode 100644 index 0000000..5e18ba2 --- /dev/null +++ b/build/vc100/turtle.sln @@ -0,0 +1,35 @@ +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual Studio 2010 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "turtle", "turtle.vcxproj", "{831F2DEE-1E35-4533-A3B2-12C01BA8DA1D}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "turtle_test", "turtle_test.vcxproj", "{74810A2A-33D8-47D6-9A50-71261F1683F5}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + debug|Win32 = debug|Win32 + debug|x64 = debug|x64 + release|Win32 = release|Win32 + release|x64 = release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {831F2DEE-1E35-4533-A3B2-12C01BA8DA1D}.debug|Win32.ActiveCfg = debug|Win32 + {831F2DEE-1E35-4533-A3B2-12C01BA8DA1D}.debug|Win32.Build.0 = debug|Win32 + {831F2DEE-1E35-4533-A3B2-12C01BA8DA1D}.debug|x64.ActiveCfg = debug|x64 + {831F2DEE-1E35-4533-A3B2-12C01BA8DA1D}.debug|x64.Build.0 = debug|x64 + {831F2DEE-1E35-4533-A3B2-12C01BA8DA1D}.release|Win32.ActiveCfg = release|Win32 + {831F2DEE-1E35-4533-A3B2-12C01BA8DA1D}.release|Win32.Build.0 = release|Win32 + {831F2DEE-1E35-4533-A3B2-12C01BA8DA1D}.release|x64.ActiveCfg = release|x64 + {831F2DEE-1E35-4533-A3B2-12C01BA8DA1D}.release|x64.Build.0 = release|x64 + {74810A2A-33D8-47D6-9A50-71261F1683F5}.debug|Win32.ActiveCfg = debug|Win32 + {74810A2A-33D8-47D6-9A50-71261F1683F5}.debug|Win32.Build.0 = debug|Win32 + {74810A2A-33D8-47D6-9A50-71261F1683F5}.debug|x64.ActiveCfg = debug|x64 + {74810A2A-33D8-47D6-9A50-71261F1683F5}.debug|x64.Build.0 = debug|x64 + {74810A2A-33D8-47D6-9A50-71261F1683F5}.release|Win32.ActiveCfg = release|Win32 + {74810A2A-33D8-47D6-9A50-71261F1683F5}.release|Win32.Build.0 = release|Win32 + {74810A2A-33D8-47D6-9A50-71261F1683F5}.release|x64.ActiveCfg = release|x64 + {74810A2A-33D8-47D6-9A50-71261F1683F5}.release|x64.Build.0 = release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/build/vc100/turtle.vcxproj b/build/vc100/turtle.vcxproj new file mode 100644 index 0000000..cf3d8da --- /dev/null +++ b/build/vc100/turtle.vcxproj @@ -0,0 +1,196 @@ + + + + + debug + Win32 + + + debug + x64 + + + release + Win32 + + + release + x64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + {831F2DEE-1E35-4533-A3B2-12C01BA8DA1D} + + + + StaticLibrary + + + StaticLibrary + + + StaticLibrary + + + StaticLibrary + + + + + + + + + + + + + + + + + + + <_ProjectFileVersion>10.0.30319.1 + ../../out/vc100/$(Configuration)/libraries/$(ProjectName)\ + ../../out/vc100_x64/$(Configuration)/libraries/$(ProjectName)\ + ../../out/vc100/$(Configuration)/libraries/$(ProjectName)\ + ../../out/vc100_x64/$(Configuration)/libraries/$(ProjectName)\ + ../../out/vc100/$(Configuration)/libraries/$(ProjectName)\ + ../../out/vc100_x64/$(Configuration)/libraries/$(ProjectName)\ + ../../out/vc100/$(Configuration)/libraries/$(ProjectName)\ + ../../out/vc100_x64/$(Configuration)/libraries/$(ProjectName)\ + + + C:\dev\home\boost;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include; + + + C:\dev\home\boost;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include; + + + C:\dev\home\boost;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include; + + + C:\dev\home\boost;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include; + + + + /Zm179 %(AdditionalOptions) + Disabled + $(IntDir); ../../include; ../../src/libraries; ../../src/libraries/$(ProjectName);%(AdditionalIncludeDirectories) + WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions) + EnableFastChecks + MultiThreadedDebugDLL + Use + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir)$(ProjectName).pdb + Level4 + ProgramDatabase + + + $(OutDir)$(ProjectName)d.lib + $(OutDir) ; ../../lib/vc100;%(AdditionalLibraryDirectories) + + + + + /Zm179 %(AdditionalOptions) + Disabled + $(IntDir); ../../include; ../../src/libraries; ../../src/libraries/$(ProjectName);%(AdditionalIncludeDirectories) + WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions) + EnableFastChecks + MultiThreadedDebugDLL + Use + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir)$(ProjectName).pdb + Level4 + ProgramDatabase + + + $(OutDir)$(ProjectName)d.lib + $(OutDir) ; ../../lib/vc100_x64;%(AdditionalLibraryDirectories) + + + + + /Zm176 %(AdditionalOptions) + $(IntDir); ../../include; ../../src/libraries; ../../src/libraries/$(ProjectName);%(AdditionalIncludeDirectories) + WIN32; NDEBUG;_WINDOWS;%(PreprocessorDefinitions) + MultiThreadedDLL + Use + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir)$(ProjectName).pdb + Level4 + ProgramDatabase + + + $(OutDir)$(ProjectName).lib + $(OutDir) ; ../../lib/vc100;%(AdditionalLibraryDirectories) + + + + + /Zm176 %(AdditionalOptions) + $(IntDir); ../../include; ../../src/libraries; ../../src/libraries/$(ProjectName);%(AdditionalIncludeDirectories) + WIN32; NDEBUG;_WINDOWS;%(PreprocessorDefinitions) + MultiThreadedDLL + Use + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir)$(ProjectName).pdb + Level4 + ProgramDatabase + + + $(OutDir)$(ProjectName).lib + $(OutDir) ; ../../lib/vc100_x64;%(AdditionalLibraryDirectories) + + + + + + \ No newline at end of file diff --git a/build/vc100/turtle.vcxproj.filters b/build/vc100/turtle.vcxproj.filters new file mode 100644 index 0000000..f3f1f04 --- /dev/null +++ b/build/vc100/turtle.vcxproj.filters @@ -0,0 +1,131 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {b9cb2ff2-1351-456d-985e-cb0dd3f4e12d} + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files + + + \ No newline at end of file diff --git a/build/vc100/turtle.vcxproj.user b/build/vc100/turtle.vcxproj.user new file mode 100644 index 0000000..695b5c7 --- /dev/null +++ b/build/vc100/turtle.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/build/vc100/turtle_bench.vcxproj b/build/vc100/turtle_bench.vcxproj new file mode 100644 index 0000000..c6f73fd --- /dev/null +++ b/build/vc100/turtle_bench.vcxproj @@ -0,0 +1,192 @@ + + + + + debug + Win32 + + + debug + x64 + + + release + Win32 + + + release + x64 + + + + + + + + + + + + + + + {2D607783-30B9-46DE-81E2-28513B31D5D2} + + + + Application + + + Application + + + Application + + + Application + + + + + + + + + + + + + + + + + + + <_ProjectFileVersion>10.0.30319.1 + ../../out/applications/$(ProjectName)/vc100/$(Configuration)\ + ../../out/applications/$(ProjectName)/vc100_x64/$(Configuration)\ + ../../out/applications/$(ProjectName)/vc100/$(Configuration)\ + ../../out/applications/$(ProjectName)/vc100_x64/$(Configuration)\ + ../../out/applications/$(ProjectName)/vc100/$(Configuration)\ + ../../out/applications/$(ProjectName)/vc100_x64/$(Configuration)\ + ../../out/applications/$(ProjectName)/vc100/$(Configuration)\ + ../../out/applications/$(ProjectName)/vc100_x64/$(Configuration)\ + $(ProjectName) + $(ProjectName) + $(ProjectName) + $(ProjectName) + + + + Disabled + ../..; ../../include;%(AdditionalIncludeDirectories) + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + EnableFastChecks + MultiThreadedDebugDLL + true + + + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir) + $(IntDir) + $(IntDir)$(ProjectName).pdb + Level4 + true + ProgramDatabase + + + %(AdditionalDependencies) + $(OutDir)$(ProjectName).exe + $(OutDir);%(AdditionalLibraryDirectories) + true + Console + + + + + Disabled + ../..; ../../include;%(AdditionalIncludeDirectories) + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + EnableFastChecks + MultiThreadedDebugDLL + true + + + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir) + $(IntDir) + $(IntDir)$(ProjectName).pdb + Level4 + true + ProgramDatabase + + + %(AdditionalDependencies) + $(OutDir)$(ProjectName).exe + $(OutDir);%(AdditionalLibraryDirectories) + true + Console + + + + + MaxSpeed + ../..; ../../include;%(AdditionalIncludeDirectories) + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + Default + MultiThreadedDLL + true + + + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir) + $(IntDir) + $(IntDir)$(ProjectName).pdb + Level4 + true + ProgramDatabase + + + %(AdditionalDependencies) + $(OutDir)$(ProjectName).exe + $(OutDir);%(AdditionalLibraryDirectories) + true + Console + false + + + + + MaxSpeed + ../..; ../../include;%(AdditionalIncludeDirectories) + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + Default + MultiThreadedDLL + true + + + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir) + $(IntDir) + $(IntDir)$(ProjectName).pdb + Level4 + true + ProgramDatabase + + + %(AdditionalDependencies) + $(OutDir)$(ProjectName).exe + $(OutDir);%(AdditionalLibraryDirectories) + true + Console + false + + + + + + \ No newline at end of file diff --git a/build/vc100/turtle_bench.vcxproj.filters b/build/vc100/turtle_bench.vcxproj.filters new file mode 100644 index 0000000..8fc23e0 --- /dev/null +++ b/build/vc100/turtle_bench.vcxproj.filters @@ -0,0 +1,38 @@ + + + + + {0ddf67a0-6350-4b1a-ad9f-0648d3985709} + cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx;h;hpp;hxx;hm;inl;inc;xsd + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + \ No newline at end of file diff --git a/build/vc100/turtle_bench.vcxproj.user b/build/vc100/turtle_bench.vcxproj.user new file mode 100644 index 0000000..695b5c7 --- /dev/null +++ b/build/vc100/turtle_bench.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/build/vc100/turtle_test.vcxproj b/build/vc100/turtle_test.vcxproj new file mode 100644 index 0000000..9f1272f --- /dev/null +++ b/build/vc100/turtle_test.vcxproj @@ -0,0 +1,238 @@ + + + + + debug + Win32 + + + debug + x64 + + + release + Win32 + + + release + x64 + + + + + + + + + + + + + + + + + + + + BOOST_AUTO_TEST_MAIN;WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + BOOST_AUTO_TEST_MAIN;WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + + + + + + + + + + + {74810A2A-33D8-47D6-9A50-71261F1683F5} + turtle_test + + + + Application + + + Application + + + Application + + + Application + + + + + + + + + + + + + + + + + + + <_ProjectFileVersion>10.0.30319.1 + ../../out/vc100/$(Configuration)/tests/$(ProjectName)\ + ../../out/vc100_x64/$(Configuration)/tests/$(ProjectName)\ + ../../out/vc100/$(Configuration)/tests/$(ProjectName)\ + ../../out/vc100_x64/$(Configuration)/tests/$(ProjectName)\ + ../../out/vc100/$(Configuration)/tests/$(ProjectName)\ + ../../out/vc100_x64/$(Configuration)/tests/$(ProjectName)\ + ../../out/vc100/$(Configuration)/tests/$(ProjectName)\ + ../../out/vc100_x64/$(Configuration)/tests/$(ProjectName)\ + + + C:\dev\home\boost;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include; + C:\dev\home\boost\stage\lib;$(VCInstallDir)lib;$(VCInstallDir)atlmfc\lib;$(WindowsSdkDir)lib;$(FrameworkSDKDir)\lib + + + C:\dev\home\boost;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include; + C:\dev\home\boost\stage\lib;$(VCInstallDir)lib;$(VCInstallDir)atlmfc\lib;$(WindowsSdkDir)lib;$(FrameworkSDKDir)\lib + + + C:\dev\home\boost;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include; + C:\dev\home\boost\stage\lib;$(VCInstallDir)lib\amd64;$(VCInstallDir)atlmfc\lib\amd64;$(WindowsSdkDir)lib\x64; + + + C:\dev\home\boost;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include; + C:\dev\home\boost\stage\lib;$(VCInstallDir)lib\amd64;$(VCInstallDir)atlmfc\lib\amd64;$(WindowsSdkDir)lib\x64; + + + + /Zm172 %(AdditionalOptions) + Disabled + ../../include;%(AdditionalIncludeDirectories) + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + EnableFastChecks + MultiThreadedDebugDLL + true + + + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir) + $(IntDir) + $(IntDir)$(ProjectName).pdb + Level4 + true + ProgramDatabase + + + %(AdditionalDependencies) + $(OutDir)$(ProjectName).exe + ../../lib/vc100;%(AdditionalLibraryDirectories) + true + Console + + + "$(TargetDir)$(TargetName).exe" --result_code=no --report_level=no --log_level=warning + + + + + + /Zm172 %(AdditionalOptions) + Disabled + ../../include;%(AdditionalIncludeDirectories) + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + EnableFastChecks + MultiThreadedDebugDLL + true + + + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir) + $(IntDir) + $(IntDir)$(ProjectName).pdb + Level4 + true + ProgramDatabase + + + %(AdditionalDependencies) + $(OutDir)$(ProjectName).exe + ../../lib/vc100;%(AdditionalLibraryDirectories) + true + Console + + + "$(TargetDir)$(TargetName).exe" --result_code=no --report_level=no --log_level=warning + + + + + /Zm162 %(AdditionalOptions) + MaxSpeed + ../../include;%(AdditionalIncludeDirectories) + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + Default + MultiThreadedDLL + true + + + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir) + $(IntDir) + $(IntDir)$(ProjectName).pdb + Level4 + true + ProgramDatabase + + + %(AdditionalDependencies) + $(OutDir)$(ProjectName).exe + ../../lib/vc100;%(AdditionalLibraryDirectories) + true + Console + + + "$(TargetDir)$(TargetName).exe" --result_code=no --report_level=no --log_level=warning + + + + + + /Zm162 %(AdditionalOptions) + MaxSpeed + ../../include;%(AdditionalIncludeDirectories) + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + Default + MultiThreadedDLL + true + + + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir) + $(IntDir) + $(IntDir)$(ProjectName).pdb + Level4 + true + ProgramDatabase + + + %(AdditionalDependencies) + $(OutDir)$(ProjectName).exe + ../../lib/vc100;%(AdditionalLibraryDirectories) + true + Console + + + "$(TargetDir)$(TargetName).exe" --result_code=no --report_level=no --log_level=warning + + + + + + \ No newline at end of file diff --git a/build/vc100/turtle_test.vcxproj.filters b/build/vc100/turtle_test.vcxproj.filters new file mode 100644 index 0000000..de84e75 --- /dev/null +++ b/build/vc100/turtle_test.vcxproj.filters @@ -0,0 +1,79 @@ + + + + + {7b7d91a4-7b1e-441a-ac3f-2f93e73ae2ac} + cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx;h;hpp;hxx;hm;inl;inc;xsd + + + {214599f8-6837-4d60-96ae-b913798819ae} + + + + + Source Files + + + Source Files + + + Source Files + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + \ No newline at end of file diff --git a/build/vc100/turtle_test.vcxproj.user b/build/vc100/turtle_test.vcxproj.user new file mode 100644 index 0000000..695b5c7 --- /dev/null +++ b/build/vc100/turtle_test.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/build/vc140/.gitignore b/build/vc140/.gitignore new file mode 100644 index 0000000..dd990f3 --- /dev/null +++ b/build/vc140/.gitignore @@ -0,0 +1,7 @@ +.vs +*.db +*.ipch +*.opendb +*.opensdf +*.sdf +*.suo diff --git a/build/vc140/turtle.sln b/build/vc140/turtle.sln new file mode 100644 index 0000000..873405c --- /dev/null +++ b/build/vc140/turtle.sln @@ -0,0 +1,35 @@ +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual Studio 2010 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "turtle", "turtle.vcxproj", "{831F2DEE-1E35-4533-A3B2-12C01BA8DA1D}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "turtle_test", "turtle_test.vcxproj", "{74810A2A-33D8-47D6-9A50-71261F1683F5}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + debug|Win32 = debug|Win32 + debug|x64 = debug|x64 + release|Win32 = release|Win32 + release|x64 = release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {831F2DEE-1E35-4533-A3B2-12C01BA8DA1D}.debug|Win32.ActiveCfg = debug|Win32 + {831F2DEE-1E35-4533-A3B2-12C01BA8DA1D}.debug|Win32.Build.0 = debug|Win32 + {831F2DEE-1E35-4533-A3B2-12C01BA8DA1D}.debug|x64.ActiveCfg = debug|x64 + {831F2DEE-1E35-4533-A3B2-12C01BA8DA1D}.debug|x64.Build.0 = debug|x64 + {831F2DEE-1E35-4533-A3B2-12C01BA8DA1D}.release|Win32.ActiveCfg = release|Win32 + {831F2DEE-1E35-4533-A3B2-12C01BA8DA1D}.release|Win32.Build.0 = release|Win32 + {831F2DEE-1E35-4533-A3B2-12C01BA8DA1D}.release|x64.ActiveCfg = release|x64 + {831F2DEE-1E35-4533-A3B2-12C01BA8DA1D}.release|x64.Build.0 = release|x64 + {74810A2A-33D8-47D6-9A50-71261F1683F5}.debug|Win32.ActiveCfg = debug|Win32 + {74810A2A-33D8-47D6-9A50-71261F1683F5}.debug|Win32.Build.0 = debug|Win32 + {74810A2A-33D8-47D6-9A50-71261F1683F5}.debug|x64.ActiveCfg = debug|x64 + {74810A2A-33D8-47D6-9A50-71261F1683F5}.debug|x64.Build.0 = debug|x64 + {74810A2A-33D8-47D6-9A50-71261F1683F5}.release|Win32.ActiveCfg = release|Win32 + {74810A2A-33D8-47D6-9A50-71261F1683F5}.release|Win32.Build.0 = release|Win32 + {74810A2A-33D8-47D6-9A50-71261F1683F5}.release|x64.ActiveCfg = release|x64 + {74810A2A-33D8-47D6-9A50-71261F1683F5}.release|x64.Build.0 = release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/build/vc140/turtle.vcxproj b/build/vc140/turtle.vcxproj new file mode 100644 index 0000000..fc32e63 --- /dev/null +++ b/build/vc140/turtle.vcxproj @@ -0,0 +1,196 @@ + + + + + debug + Win32 + + + debug + x64 + + + release + Win32 + + + release + x64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + {831F2DEE-1E35-4533-A3B2-12C01BA8DA1D} + + + + StaticLibrary + + + StaticLibrary + + + StaticLibrary + + + StaticLibrary + + + + + + + + + + + + + + + + + + + <_ProjectFileVersion>10.0.30319.1 + ../../out/vc140/$(Configuration)/libraries/$(ProjectName)\ + ../../out/vc140_x64/$(Configuration)/libraries/$(ProjectName)\ + ../../out/vc140/$(Configuration)/libraries/$(ProjectName)\ + ../../out/vc140_x64/$(Configuration)/libraries/$(ProjectName)\ + ../../out/vc140/$(Configuration)/libraries/$(ProjectName)\ + ../../out/vc140_x64/$(Configuration)/libraries/$(ProjectName)\ + ../../out/vc140/$(Configuration)/libraries/$(ProjectName)\ + ../../out/vc140_x64/$(Configuration)/libraries/$(ProjectName)\ + + + C:\dev\home\boost;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include; + + + C:\dev\home\boost;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include; + + + C:\dev\home\boost;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include; + + + C:\dev\home\boost;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include; + + + + /Zm179 %(AdditionalOptions) + Disabled + $(IntDir); ../../include; ../../src/libraries; ../../src/libraries/$(ProjectName);%(AdditionalIncludeDirectories) + WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions) + EnableFastChecks + MultiThreadedDebugDLL + Use + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir)$(ProjectName).pdb + Level4 + ProgramDatabase + + + $(OutDir)$(ProjectName)d.lib + $(OutDir) ; ../../lib/vc140;%(AdditionalLibraryDirectories) + + + + + /Zm179 %(AdditionalOptions) + Disabled + $(IntDir); ../../include; ../../src/libraries; ../../src/libraries/$(ProjectName);%(AdditionalIncludeDirectories) + WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions) + EnableFastChecks + MultiThreadedDebugDLL + Use + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir)$(ProjectName).pdb + Level4 + ProgramDatabase + + + $(OutDir)$(ProjectName)d.lib + $(OutDir) ; ../../lib/vc140_x64;%(AdditionalLibraryDirectories) + + + + + /Zm176 %(AdditionalOptions) + $(IntDir); ../../include; ../../src/libraries; ../../src/libraries/$(ProjectName);%(AdditionalIncludeDirectories) + WIN32; NDEBUG;_WINDOWS;%(PreprocessorDefinitions) + MultiThreadedDLL + Use + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir)$(ProjectName).pdb + Level4 + ProgramDatabase + + + $(OutDir)$(ProjectName).lib + $(OutDir) ; ../../lib/vc140;%(AdditionalLibraryDirectories) + + + + + /Zm176 %(AdditionalOptions) + $(IntDir); ../../include; ../../src/libraries; ../../src/libraries/$(ProjectName);%(AdditionalIncludeDirectories) + WIN32; NDEBUG;_WINDOWS;%(PreprocessorDefinitions) + MultiThreadedDLL + Use + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir)$(ProjectName).pdb + Level4 + ProgramDatabase + + + $(OutDir)$(ProjectName).lib + $(OutDir) ; ../../lib/vc140_x64;%(AdditionalLibraryDirectories) + + + + + + \ No newline at end of file diff --git a/build/vc140/turtle.vcxproj.filters b/build/vc140/turtle.vcxproj.filters new file mode 100644 index 0000000..ff0b69a --- /dev/null +++ b/build/vc140/turtle.vcxproj.filters @@ -0,0 +1,131 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {b9cb2ff2-1351-456d-985e-cb0dd3f4e12d} + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files + + + \ No newline at end of file diff --git a/build/vc140/turtle.vcxproj.user b/build/vc140/turtle.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/build/vc140/turtle.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/build/vc140/turtle_bench.vcxproj b/build/vc140/turtle_bench.vcxproj new file mode 100644 index 0000000..af19166 --- /dev/null +++ b/build/vc140/turtle_bench.vcxproj @@ -0,0 +1,192 @@ + + + + + debug + Win32 + + + debug + x64 + + + release + Win32 + + + release + x64 + + + + + + + + + + + + + + + {2D607783-30B9-46DE-81E2-28513B31D5D2} + + + + Application + + + Application + + + Application + + + Application + + + + + + + + + + + + + + + + + + + <_ProjectFileVersion>10.0.30319.1 + ../../out/applications/$(ProjectName)/vc140/$(Configuration)\ + ../../out/applications/$(ProjectName)/vc140_x64/$(Configuration)\ + ../../out/applications/$(ProjectName)/vc140/$(Configuration)\ + ../../out/applications/$(ProjectName)/vc140_x64/$(Configuration)\ + ../../out/applications/$(ProjectName)/vc140/$(Configuration)\ + ../../out/applications/$(ProjectName)/vc140_x64/$(Configuration)\ + ../../out/applications/$(ProjectName)/vc140/$(Configuration)\ + ../../out/applications/$(ProjectName)/vc140_x64/$(Configuration)\ + $(ProjectName) + $(ProjectName) + $(ProjectName) + $(ProjectName) + + + + Disabled + ../..; ../../include;%(AdditionalIncludeDirectories) + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + EnableFastChecks + MultiThreadedDebugDLL + true + + + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir) + $(IntDir) + $(IntDir)$(ProjectName).pdb + Level4 + true + ProgramDatabase + + + %(AdditionalDependencies) + $(OutDir)$(ProjectName).exe + $(OutDir);%(AdditionalLibraryDirectories) + true + Console + + + + + Disabled + ../..; ../../include;%(AdditionalIncludeDirectories) + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + EnableFastChecks + MultiThreadedDebugDLL + true + + + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir) + $(IntDir) + $(IntDir)$(ProjectName).pdb + Level4 + true + ProgramDatabase + + + %(AdditionalDependencies) + $(OutDir)$(ProjectName).exe + $(OutDir);%(AdditionalLibraryDirectories) + true + Console + + + + + MaxSpeed + ../..; ../../include;%(AdditionalIncludeDirectories) + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + Default + MultiThreadedDLL + true + + + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir) + $(IntDir) + $(IntDir)$(ProjectName).pdb + Level4 + true + ProgramDatabase + + + %(AdditionalDependencies) + $(OutDir)$(ProjectName).exe + $(OutDir);%(AdditionalLibraryDirectories) + true + Console + false + + + + + MaxSpeed + ../..; ../../include;%(AdditionalIncludeDirectories) + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + Default + MultiThreadedDLL + true + + + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir) + $(IntDir) + $(IntDir)$(ProjectName).pdb + Level4 + true + ProgramDatabase + + + %(AdditionalDependencies) + $(OutDir)$(ProjectName).exe + $(OutDir);%(AdditionalLibraryDirectories) + true + Console + false + + + + + + \ No newline at end of file diff --git a/build/vc140/turtle_bench.vcxproj.filters b/build/vc140/turtle_bench.vcxproj.filters new file mode 100644 index 0000000..0d3e15d --- /dev/null +++ b/build/vc140/turtle_bench.vcxproj.filters @@ -0,0 +1,38 @@ + + + + + {0ddf67a0-6350-4b1a-ad9f-0648d3985709} + cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx;h;hpp;hxx;hm;inl;inc;xsd + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + \ No newline at end of file diff --git a/build/vc140/turtle_bench.vcxproj.user b/build/vc140/turtle_bench.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/build/vc140/turtle_bench.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/build/vc140/turtle_test.vcxproj b/build/vc140/turtle_test.vcxproj new file mode 100644 index 0000000..6a07ae1 --- /dev/null +++ b/build/vc140/turtle_test.vcxproj @@ -0,0 +1,241 @@ + + + + + debug + Win32 + + + debug + x64 + + + release + Win32 + + + release + x64 + + + + + + + + + + + + + + + + + + + + BOOST_AUTO_TEST_MAIN;WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + BOOST_AUTO_TEST_MAIN;WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + + + + + + + + + + + {74810A2A-33D8-47D6-9A50-71261F1683F5} + turtle_test + 8.1 + + + + Application + v140 + + + Application + v140 + + + Application + v140 + + + Application + v140 + + + + + + + + + + + + + + + + + + + <_ProjectFileVersion>10.0.30319.1 + ../../out/vc140/$(Configuration)/tests/$(ProjectName)\ + ../../out/vc140_x64/$(Configuration)/tests/$(ProjectName)\ + ../../out/vc140/$(Configuration)/tests/$(ProjectName)\ + ../../out/vc140_x64/$(Configuration)/tests/$(ProjectName)\ + ../../out/vc140/$(Configuration)/tests/$(ProjectName)\ + ../../out/vc140_x64/$(Configuration)/tests/$(ProjectName)\ + ../../out/vc140/$(Configuration)/tests/$(ProjectName)\ + ../../out/vc140_x64/$(Configuration)/tests/$(ProjectName)\ + + + C:\dev\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;$(UniversalCRT_IncludePath); + C:\dev\lib\vc140;$(VCInstallDir)lib;$(VCInstallDir)atlmfc\lib;$(WindowsSdkDir)lib;$(FrameworkSDKDir)\lib + + + C:\dev\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;$(UniversalCRT_IncludePath); + C:\dev\lib\vc140;$(VCInstallDir)lib;$(VCInstallDir)atlmfc\lib;$(WindowsSdkDir)lib;$(FrameworkSDKDir)\lib + + + C:\dev\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;$(IncludePath); + C:\dev\lib\vc140_x64;$(VCInstallDir)lib\amd64;$(VCInstallDir)atlmfc\lib\amd64;$(WindowsSdkDir)lib\x64;$(LibraryPath); + + + C:\dev\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;$(IncludePath); + C:\dev\lib\vc140_x64;$(VCInstallDir)lib\amd64;$(VCInstallDir)atlmfc\lib\amd64;$(WindowsSdkDir)lib\x64;$(LibraryPath); + + + + /Zm172 %(AdditionalOptions) + Disabled + ../../include;%(AdditionalIncludeDirectories) + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + EnableFastChecks + MultiThreadedDebugDLL + true + + + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir) + $(IntDir) + $(IntDir)$(ProjectName).pdb + Level4 + true + ProgramDatabase + + + %(AdditionalDependencies) + $(OutDir)$(ProjectName).exe + ../../lib/vc140;%(AdditionalLibraryDirectories) + true + Console + + + "$(TargetDir)$(TargetName).exe" --result_code=no --report_level=no --log_level=warning + + + + + /Zm172 %(AdditionalOptions) + Disabled + ../../include;%(AdditionalIncludeDirectories) + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + EnableFastChecks + MultiThreadedDebugDLL + true + + + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir) + $(IntDir) + $(IntDir)$(ProjectName).pdb + Level4 + true + ProgramDatabase + + + %(AdditionalDependencies) + $(OutDir)$(ProjectName).exe + ../../lib/vc140;%(AdditionalLibraryDirectories) + true + Console + + + "$(TargetDir)$(TargetName).exe" --result_code=no --report_level=no --log_level=warning + + + + + /Zm162 %(AdditionalOptions) + MaxSpeed + ../../include;%(AdditionalIncludeDirectories) + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + Default + MultiThreadedDLL + true + + + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir) + $(IntDir) + $(IntDir)$(ProjectName).pdb + Level4 + true + ProgramDatabase + + + %(AdditionalDependencies) + $(OutDir)$(ProjectName).exe + ../../lib/vc140;%(AdditionalLibraryDirectories) + true + Console + + + "$(TargetDir)$(TargetName).exe" --result_code=no --report_level=no --log_level=warning + + + + + /Zm162 %(AdditionalOptions) + MaxSpeed + ../../include;%(AdditionalIncludeDirectories) + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + Default + MultiThreadedDLL + true + + + $(ProjectName)_pch.h + $(IntDir)$(ProjectName).pch + $(IntDir) + $(IntDir) + $(IntDir)$(ProjectName).pdb + Level4 + true + ProgramDatabase + + + %(AdditionalDependencies) + $(OutDir)$(ProjectName).exe + ../../lib/vc140;%(AdditionalLibraryDirectories) + true + Console + + + "$(TargetDir)$(TargetName).exe" --result_code=no --report_level=no --log_level=warning + + + + + + \ No newline at end of file diff --git a/build/vc140/turtle_test.vcxproj.filters b/build/vc140/turtle_test.vcxproj.filters new file mode 100644 index 0000000..a37b36a --- /dev/null +++ b/build/vc140/turtle_test.vcxproj.filters @@ -0,0 +1,79 @@ + + + + + {7b7d91a4-7b1e-441a-ac3f-2f93e73ae2ac} + cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx;h;hpp;hxx;hm;inl;inc;xsd + + + {214599f8-6837-4d60-96ae-b913798819ae} + + + + + Source Files + + + Source Files + + + Source Files + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files\detail + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + \ No newline at end of file diff --git a/build/vc140/turtle_test.vcxproj.user b/build/vc140/turtle_test.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/build/vc140/turtle_test.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/version.hpp.cmake b/build/version.hpp similarity index 83% rename from version.hpp.cmake rename to build/version.hpp index d9c8a24..2dfeecc 100644 --- a/version.hpp.cmake +++ b/build/version.hpp @@ -7,4 +7,3 @@ // http://www.boost.org/LICENSE_1_0.txt) #define MOCK_VERSION @MOCK_VERSION@ -#define TURTLE_VERSION "@turtle_VERSION@" diff --git a/doc/Jamfile.jam b/doc/Jamfile.jam index 9800cf0..bf5b54d 100644 --- a/doc/Jamfile.jam +++ b/doc/Jamfile.jam @@ -1,3 +1,5 @@ +# Boost.Mock +# # Copyright Mathieu Champlon 2012 # # Distributed under the Boost Software License version 1.0. (See @@ -44,15 +46,7 @@ project example rule compile-examples { - local examples ; - for name in [ glob example/*.cpp ] - { - local compile-target = [ compile $(name) ] ; - explicit $(compile-target) ; - examples += $(compile-target) ; - } - return $(examples) ; + for name in [ glob example/*.cpp ] { compile $(name) ; } } alias mock_examples : [ compile-examples ] ; -explicit mock_examples ; diff --git a/doc/acknowledgements.qbk b/doc/acknowledgements.qbk index 4326cf4..9a2f5d2 100644 --- a/doc/acknowledgements.qbk +++ b/doc/acknowledgements.qbk @@ -7,11 +7,6 @@ [section Acknowledgements] -Many thanks to: -* Adrien Gervaise -* Silvin Lubecki -* Takatoshi Kondo -* Ovanes Markarian -* Alexander Grund +Many thanks to Adrien Gervaise, Silvin Lubecki, Takatoshi Kondo and Ovanes Markarian ! [endsect] diff --git a/doc/changelog.qbk b/doc/changelog.qbk index e659c1c..bd93db4 100644 --- a/doc/changelog.qbk +++ b/doc/changelog.qbk @@ -7,29 +7,8 @@ [section Changelog] -[section 2.0.0] -Released 29 September 2024 - -* Allow auto-deducing signature in `MOCK_METHOD_(NON_)CONST` -* Replaced Boost facilities with std:: equivalents where existing in C++14 -* Removed MOCK_*_TPL as they are no longer required, use the non _TPL variant even for templates -* Added MOCK_PROTECT_SIGNATURE to pass function signatures with commas in the return type -* Remove support for protecting function signatures via BOOST_IDENTITY_TYPE, use MOCK_PROTECT_SIGNATURE instead -* Add support for unlimited number of arguments and sequences making MOCK_MAX_ARGS and MOCK_MAX_SEQUENCES superflous - -[endsect] - -[section 1.3.2] -Released 19 June 2020 - -* Removed boost deprecation warnings -* Fixed various compiler warnings -* Added CMake build files - -[endsect] - -[section 1.3.1] -Released 7 March 2019 +[section unreleased] +Not yet released * Fixed mocking of a function returning a reference for gcc 4.1 * Added MOCK_NO_AUTO_PTR to deactivate std::auto_ptr support diff --git a/doc/customization.qbk b/doc/customization.qbk index 69e1835..577ed88 100644 --- a/doc/customization.qbk +++ b/doc/customization.qbk @@ -98,7 +98,7 @@ The purpose of the 'near' template function is to : * remove the burden of specifying the template parameter when instantiating near_constraint * wrap the constraint in a mock::constraint so that it plays nicely with !, && and ||. -The use of mock::unwrap_ref provides support for passing arguments as references with std::ref and std::cref and delaying their initialization, for instance : +The use of boost::unwrap_ref provides support for passing arguments as references with boost::ref and boost::cref and delaying their initialization, for instance : [near_constraint_cref_test] @@ -110,6 +110,24 @@ For more information about the serialization operator and the use of mock::forma [endsect] +[section Number of arguments] + +The maximum number of arguments a mocked method can have is defined by MOCK_MAX_ARGS. +By default this value is set to 9, but if needed it can be changed before including the library : + +[max_args] + +This means methods with up to 20 arguments will then be accepted. + +The mock object library uses several boost libraries and will adjust some of their constants if they haven't already been defined : + +* Boost.Function with BOOST_FUNCTION_MAX_ARGS required at MOCK_MAX_ARGS or higher +* Boost.FunctionTypes with BOOST_FT_MAX_ARITY required at MOCK_MAX_ARGS + 1 or higher + +A compilation error will happen if one of those constants is already defined too low. + +[endsect] + [section Test framework integration] By default the library expects to be used in conjunction with Boost.Test e.g. : diff --git a/doc/example/calculator.hpp b/doc/example/calculator.hpp index bfbb7a9..23aff87 100644 --- a/doc/example/calculator.hpp +++ b/doc/example/calculator.hpp @@ -9,17 +9,15 @@ #ifndef CALCULATOR #define CALCULATOR -#include "view.hpp" +class view; //[ calculator class calculator { - view& v; - public: - calculator(view& v) : v(v) {} + calculator( view& v ); - void add(int a, int b) { v.display(a + b); } // the result will be sent to the view 'v' + void add( int a, int b ); // the result will be sent to the view 'v' }; //] diff --git a/doc/example/customization.cpp b/doc/example/customization.cpp index dae9ccb..30f69c3 100644 --- a/doc/example/customization.cpp +++ b/doc/example/customization.cpp @@ -12,146 +12,137 @@ //] #include "calculator.hpp" #include "mock_view.hpp" -#include //[ mock_stream_user_type -namespace user_namespace { -struct user_type -{}; - -inline mock::stream& operator<<(mock::stream& s, const user_type&) +namespace user_namespace { - return s << "user_type"; + struct user_type + {}; + + inline mock::stream& operator<<( mock::stream& s, const user_type& ) + { + return s << "user_type"; + } } -} // namespace user_namespace //] -namespace custom_constraint_free_function_test { +namespace custom_constraint_free_function_test +{ //[ custom_constraint_free_function -bool custom_constraint(int actual) +bool custom_constraint( int actual ) { return actual == 42; } //] //[ custom_constraint_free_function_test -BOOST_AUTO_TEST_CASE(forty_one_plus_one_is_forty_two_free_function) +BOOST_AUTO_TEST_CASE( forty_one_plus_one_is_forty_two ) { mock_view v; - calculator c(v); - MOCK_EXPECT(v.display).with(&custom_constraint); - c.add(41, 1); -} + calculator c( v ); + MOCK_EXPECT( v.display ).with( &custom_constraint ); + c.add( 41, 1 ); + } //] -} // namespace custom_constraint_free_function_test +} -namespace custom_constraint_functor_test { +namespace custom_constraint_functor_test +{ //[ custom_constraint_functor struct custom_constraint { - friend bool operator==(int actual, const custom_constraint&) { return actual == 42; } + friend bool operator==( int actual, const custom_constraint& ) + { + return actual == 42; + } - friend std::ostream& operator<<(std::ostream& s, const custom_constraint&) { return s << "_ == 42"; } + friend std::ostream& operator<<( std::ostream& s, const custom_constraint& ) + { + return s << "_ == 42"; + } }; //] //[ custom_constraint_functor_test -BOOST_AUTO_TEST_CASE(forty_one_plus_one_is_forty_two_custom_constraint) +BOOST_AUTO_TEST_CASE( forty_one_plus_one_is_forty_two ) { mock_view v; - calculator c(v); - MOCK_EXPECT(v.display).with(custom_constraint()); - c.add(41, 1); + calculator c( v ); + MOCK_EXPECT( v.display ).with( custom_constraint() ); + c.add( 41, 1 ); } //] -} // namespace custom_constraint_functor_test +} //[ near_constraint -template +template< typename Expected > struct near_constraint { - near_constraint(Expected expected, Expected threshold) : expected_(expected), threshold_(threshold) {} + near_constraint( Expected expected, Expected threshold ) + : expected_( expected ) + , threshold_( threshold ) + {} - template - bool operator()(Actual actual) const + template< typename Actual > + bool operator()( Actual actual ) const { - return std::abs(actual - mock::unwrap_ref(expected_)) <= mock::unwrap_ref(threshold_); + return std::abs( actual - boost::unwrap_ref( expected_ ) ) + < boost::unwrap_ref( threshold_ ); } - friend std::ostream& operator<<(std::ostream& s, const near_constraint& c) + friend std::ostream& operator<<( std::ostream& s, const near_constraint& c ) { - return s << "near( " << mock::format(c.expected_) << ", " << mock::format(c.threshold_) << " )"; + return s << "near( " << mock::format( c.expected_ ) + << ", " << mock::format( c.threshold_ ) << " )"; } Expected expected_, threshold_; }; -template -mock::constraint> near(Expected expected, Expected threshold) +template< typename Expected > +mock::constraint< near_constraint< Expected > > near( Expected expected, Expected threshold ) { - return near_constraint(expected, threshold); + return near_constraint< Expected >( expected, threshold ); } //] -namespace near_constraint_test { +namespace near_constraint_test +{ //[ near_constraint_test -BOOST_AUTO_TEST_CASE(forty_one_plus_one_is_forty_two_plus_or_minus_one_near) +BOOST_AUTO_TEST_CASE( forty_one_plus_one_is_forty_two_plus_or_minus_one ) { - mock_view v; - calculator c(v); - MOCK_EXPECT(v.display).with(near(42, 1)); - c.add(41, 1); + mock_view v; + calculator c( v ); + MOCK_EXPECT( v.display ).with( near( 42, 1 ) ); + c.add( 41, 1 ); } //] -} // namespace near_constraint_test +} -namespace near_constraint_cref_test { +namespace near_constraint_cref_test +{ //[ near_constraint_cref_test -BOOST_AUTO_TEST_CASE(forty_one_plus_one_is_forty_two_plus_or_minus_one_near_cref) +BOOST_AUTO_TEST_CASE( forty_one_plus_one_is_forty_two_plus_or_minus_one ) { - mock_view v; - calculator c(v); - int expected = 0, threshold = 0; - MOCK_EXPECT(v.display).with(near(std::cref(expected), std::cref(threshold))); - expected = 42; - threshold = 1; - c.add(41, 1); + mock_view v; + calculator c( v ); + int expected, threshold; + MOCK_EXPECT( v.display ).with( near( boost::cref( expected ), boost::cref( threshold ) ) ); + expected = 42; + threshold = 1; + c.add( 41, 1 ); } //] - -// Example of a "strong type" float -struct float_wrapper -{ - float value; - float_wrapper(float value) : value(value) {} - operator float() const { return value; } - friend std::ostream& operator<<(std::ostream& s, const float_wrapper& f) { return s << f.value; } -}; - -BOOST_AUTO_TEST_CASE(near_constraint_works_with_with_float_wrapper_and_cref) -{ - mock_view v; - calculator c(v); - float_wrapper expected = 0, threshold = 0; - // This works even without the unwrap_ref - MOCK_EXPECT(v.display).once().with(near(expected, threshold)); - // This requires 2 implicit conversion: from reference_wrapper to float_wrapper, then to float - // so unwrap_ref in near is required as C++ allows only 1 implicit conversion - MOCK_EXPECT(v.display).once().with(near(std::cref(expected), std::cref(threshold))); - expected = 42; - threshold = 1; - c.add(0, 0); - c.add(41, 1); } -} // namespace near_constraint_cref_test -#if defined(__GNUC__) -# pragma GCC diagnostic push -# pragma GCC diagnostic ignored "-Wunused-parameter" -#endif +#undef MOCK_MAX_ARGS +//[ max_args +#define MOCK_MAX_ARGS 20 +#include +//] //[ custom_policy -template +template< typename Result > struct custom_policy { static Result abort() @@ -159,27 +150,23 @@ struct custom_policy // Notify the test framework that an error occurs which makes it impossible to continue the test. // This should most likely throw an exception of some kind. } - template - static void fail(const char* message, const Context& context, const char* file = "unknown location", int line = 0) + template< typename Context > + static void fail( const char* message, const Context& context, const char* file = "unknown location", int line = 0 ) { // Notify the test framework that an unexpected call has occurred. } - template - static void call(const Context& context, const char* file, int line) + template< typename Context > + static void call( const Context& context, const char* file, int line ) { // Notify the test framework that an expectation has been fulfilled. } - static void pass(const char* file, int line) + static void pass( const char* file, int line ) { // Notify the test framework that the test execution merely passed the given code location. } }; //] -#if defined(__GNUC__) -# pragma GCC diagnostic pop -#endif - #undef MOCK_ERROR_POLICY //[ define_custom_policy #define MOCK_ERROR_POLICY custom_policy diff --git a/doc/example/getting_started.cpp b/doc/example/getting_started.cpp index fa89366..ff732c4 100644 --- a/doc/example/getting_started.cpp +++ b/doc/example/getting_started.cpp @@ -6,203 +6,124 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) -#include -#include -#include - -std::function error_handler_abort; -std::function error_handler_pass; -std::function error_handler_call; -std::function error_handler_fail; - -template -struct configurable_mock_error -{ - static Result abort() - { - error_handler_abort(); - return Result(); - } - - static void pass(const char* file, int line) { error_handler_pass(file, line); } - - template - static void call(const Context& context, const char* file, int line) - { - std::stringstream s; - s << context; - error_handler_call(s.str(), file, line); - } - - template - static void fail(const char* message, const Context& context, const char* file = "", int line = 0) - { - std::stringstream s; - s << context; - error_handler_fail(message, s.str(), file, line); - } -}; - -#define MOCK_ERROR_POLICY configurable_mock_error -#define MOCK_USE_BOOST_TEST - //[ prerequisite +#define BOOST_AUTO_TEST_MAIN +#include #include -#include //] #include "calculator.hpp" #include "mock_view.hpp" -struct Fixture +namespace phases { - Fixture() - { - error_handler_abort = mock::error::abort; - error_handler_pass = mock::error::pass; - error_handler_call = mock::error::call; - error_handler_fail = mock::error::fail; - } -}; - -BOOST_FIXTURE_TEST_SUITE(GettingStarted, Fixture) - -namespace phases { //[ phases -BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero) +BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero ) { - mock_view v; // create mock objects - calculator c(v); // create object under test - MOCK_EXPECT(v.display).once().with(0); // configure mock objects - c.add(0, 0); // exercise object under test -} // verify mock objects + mock_view v; // create mock objects + calculator c( v ); // create object under test + MOCK_EXPECT( v.display ).once().with( 0 ); // configure mock objects + c.add( 0, 0 ); // exercise object under test +} // verify mock objects //] -} // namespace phases +} -namespace verify_reset { +namespace verify_reset +{ //[ verify_reset -BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero_reset) +BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero ) { mock_view v; - calculator c(v); - MOCK_EXPECT(v.display).once().with(0); - c.add(0, 0); - MOCK_VERIFY(v.display); // verify all expectations are fulfilled for the 'display' method - mock::verify(v); // verify all expectations are fulfilled for all methods of 'v' - mock::verify(); // verify all expectations are fulfilled for all existing mock objects - MOCK_RESET(v.display); // reset all expectations for the 'display' method - mock::reset(v); // reset all expectations for all methods of 'v' - mock::reset(); // reset all expectations for all existing mock objects -} // automatically verify all expectations are fulfilled for all mock objects going out of scope + calculator c( v ); + MOCK_EXPECT( v.display ).once().with( 0 ); + c.add( 0, 0 ); + MOCK_VERIFY( v.display ); // verify all expectations are fulfilled for the 'display' method + mock::verify( v ); // verify all expectations are fulfilled for all methods of 'v' + mock::verify(); // verify all expectations are fulfilled for all existing mock objects + MOCK_RESET( v.display ); // reset all expectations for the 'display' method + mock::reset( v ); // reset all expectations for all methods of 'v' + mock::reset(); // reset all expectations for all existing mock objects +} // automatically verify all expectations are fulfilled for all mock objects going out of scope //] -} // namespace verify_reset +} -namespace expectations { +namespace expectations +{ //[ expectations -BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero_expect) +BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero ) { mock_view v; - calculator c(v); - MOCK_EXPECT(v.display).once().with(0); // this call must occur once (and only once) - MOCK_EXPECT(v.display).with(1); // this call can occur any number of times (including never) - c.add(0, 0); + calculator c( v ); + MOCK_EXPECT( v.display ).once().with( 0 ); // this call must occur once (and only once) + MOCK_EXPECT( v.display ).with( 1 ); // this call can occur any number of times (including never) + c.add( 0, 0 ); } //] -} // namespace expectations +} -namespace sequence { +namespace sequence +{ //[ sequence -BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero_then_1_plus_0_is_1) +BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero ) { mock_view v; - calculator c(v); + calculator c( v ); mock::sequence s; - MOCK_EXPECT(v.display).once().with(0).in(s); // add this expectation to the sequence - MOCK_EXPECT(v.display).with(1).in(s); // add this expectation to the sequence after the previous call - c.add(0, 0); - c.add(1, 0); + MOCK_EXPECT( v.display ).once().with( 0 ).in( s ); // add this expectation to the sequence + MOCK_EXPECT( v.display ).with( 1 ).in( s ); // add this expectation to the sequence after the previous call + c.add( 0, 0 ); + c.add( 1, 0 ); } //] -} // namespace sequence +} -namespace several_sequences { +namespace several_sequences +{ //[ several_sequences -BOOST_AUTO_TEST_CASE(add_several_numbers_in_sequences) +BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero ) { mock_view v; - calculator c(v); + calculator c( v ); mock::sequence s1, s2; - MOCK_EXPECT(v.display).once().with(0).in(s1); - MOCK_EXPECT(v.display).once().with(1).in(s2); - MOCK_EXPECT(v.display).with(2).in(s1, s2); // add this expectation to both sequences after the previous calls - c.add(0, 0); - c.add(1, 0); - c.add(1, 1); - c.add(2, 0); + MOCK_EXPECT( v.display ).once().with( 0 ).in( s1 ); + MOCK_EXPECT( v.display ).once().with( 1 ).in( s2 ); + MOCK_EXPECT( v.display ).with( 2 ).in( s1, s2 ); // add this expectation to both sequences after the previous calls + c.add( 0, 0 ); + c.add( 1, 0 ); + c.add( 1, 1 ); + c.add( 2, 0 ); } //] -} // namespace several_sequences -BOOST_AUTO_TEST_SUITE_END() +} -namespace action { +namespace action +{ //[ action_view class view { public: - virtual bool display(int result) = 0; // returns a boolean + virtual bool display( int result ) = 0; // returns a boolean }; //] -MOCK_BASE_CLASS(mock_view, view) +MOCK_BASE_CLASS( mock_view, view ) { - MOCK_METHOD(display, 1) + MOCK_METHOD( display, 1 ) }; class calculator { - view& v; - public: - calculator(view& v) : v(v) {} + calculator( view& v ); - void add(int a, int b) { v.display(a + b); } + void add( int a, int b ); }; - -struct CatchFailureFixture : Fixture -{ - static bool aborted; - static std::string fail_msg; - - static void abort() { aborted = true; } - static void fail(const std::string& message, const std::string&, const char* = "", int = 0) { fail_msg = message; } - CatchFailureFixture() - { - error_handler_abort = abort; - error_handler_fail = fail; - } - void assert_failure(const std::string& required_message) - { - BOOST_CHECK(aborted); - BOOST_CHECK(fail_msg.find(required_message) != std::string::npos); - } -}; -bool CatchFailureFixture::aborted = false; -std::string CatchFailureFixture::fail_msg; - -struct AssertMissingAction : CatchFailureFixture -{ - void teardown() { assert_failure("missing action"); } -}; - -BOOST_FIXTURE_TEST_SUITE(MissingReturnActionSuite, AssertMissingAction) //[ action_test -BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero_with_action) +BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero ) { - mock_view v; - calculator c(v); - MOCK_EXPECT(v.display).once().with(0); // missing returns( true ) - c.add(0, 0); + mock_view v; + calculator c( v ); + MOCK_EXPECT( v.display ).once().with( 0 ); // missing returns( true ) + c.add( 0, 0 ); } //] -} // namespace action - -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/doc/example/limitations_comma_in_macro.cpp b/doc/example/limitations_comma_in_macro.cpp new file mode 100644 index 0000000..c19ebdf --- /dev/null +++ b/doc/example/limitations_comma_in_macro.cpp @@ -0,0 +1,48 @@ +// http://turtle.sourceforge.net +// +// Copyright Mathieu Champlon 2014 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#define BOOST_AUTO_TEST_MAIN +#include +#include + +namespace +{ +//[ limitations_comma_in_macro_problem + template< typename T1, typename T2 > + struct my_base_class + {}; +//] +} + +namespace limitations_comma_in_macro_solution_1 +{ +//[ limitations_comma_in_macro_solution_1 + typedef my_base_class< int, int > my_base_type; + + MOCK_BASE_CLASS( my_mock, my_base_type ) + {}; +//] +} + +namespace limitations_comma_in_macro_solution_2 +{ +//[ limitations_comma_in_macro_solution_2 + template< typename T1, typename T2 > + MOCK_BASE_CLASS( my_mock, my_base_class< T1 BOOST_PP_COMMA() T2 > ) + {}; +//] +} + +namespace limitations_comma_in_macro_solution_3 +{ +//[ limitations_comma_in_macro_solution_3 + template< typename T1, typename T2 > + struct my_mock : my_base_class< T1, T2 >, mock::object + {}; +//] +} diff --git a/doc/example/limitations_const_parameter_warning.cpp b/doc/example/limitations_const_parameter_warning.cpp index 8f0de3b..531bba2 100644 --- a/doc/example/limitations_const_parameter_warning.cpp +++ b/doc/example/limitations_const_parameter_warning.cpp @@ -6,46 +6,45 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) +#define BOOST_AUTO_TEST_MAIN +#include #include -#include -namespace { +namespace +{ //[ limitations_const_parameter_warning_problem -class base -{ -public: - virtual void method(const int) = 0; -}; + class base + { + public: + virtual void method( const int ) = 0; + }; +//] +} + +namespace limitations_const_parameter_warning_explanation +{ +//[ limitations_const_parameter_warning_explanation + class derived : public base + { + public: + virtual void method( const int ); + }; + + void derived::method( int ) + {} +//] +} + +namespace limitations_const_parameter_warning_solution +{ +//[ limitations_const_parameter_warning_solution + MOCK_BASE_CLASS( mock_base, base ) + { + void method( const int i ) + { + method_stub( i ); + } + MOCK_METHOD( method_stub, 1, void( int ), method ) + }; //] -} // namespace - -namespace limitations_const_parameter_warning_explanation { -//[ limitations_const_parameter_warning_explanation -class derived : public base -{ -public: - virtual void method(const int); -}; - -void derived::method(int) {} -//] -} // namespace limitations_const_parameter_warning_explanation - -namespace { -//[ limitations_const_parameter_warning_solution -MOCK_BASE_CLASS(mock_base, base) -{ - void method(const int i) { method_stub(i); } - MOCK_METHOD(method_stub, 1, void(int), method) -}; -//] -} // namespace - -BOOST_AUTO_TEST_CASE(check_method_stub_is_called) -{ - mock_base b; - MOCK_EXPECT(b.method).once().with(1); - // Example user code taking a base* (or smart pointer variant) - auto callMethod = [](base* bPtr) { bPtr->method(1); }; - callMethod(&b); } diff --git a/doc/example/limitations_literal_zero.cpp b/doc/example/limitations_literal_zero.cpp index c838d23..463f4ea 100644 --- a/doc/example/limitations_literal_zero.cpp +++ b/doc/example/limitations_literal_zero.cpp @@ -6,34 +6,38 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) +#define BOOST_AUTO_TEST_MAIN +#include #include -#include -namespace { +namespace +{ //[ limitations_literal_zero_problem -class base -{ -public: - virtual void method(int* i) = 0; -}; + class base + { + public: + virtual void method( int* i ) = 0; + }; -MOCK_BASE_CLASS(mock_base, base) -{ - MOCK_METHOD(method, 1) -}; + MOCK_BASE_CLASS( mock_base, base ) + { + MOCK_METHOD( method, 1 ) + }; //] -} // namespace +} -BOOST_AUTO_TEST_CASE(literal_zero) +BOOST_AUTO_TEST_CASE( literal_zero ) { mock_base m; - //[ limitations_literal_zero_solution_1 - MOCK_EXPECT(m.method).with(mock::equal(0)); // this compiles - //] - //[ limitations_literal_zero_solution_2 - MOCK_EXPECT(m.method).with(mock::negate); - //] - //[ limitations_literal_zero_solution_3 - MOCK_EXPECT(m.method).with(nullptr); - //] +//[ limitations_literal_zero_solution_1 + MOCK_EXPECT( m.method ).with( mock::equal< int* >( 0 ) ); // this compiles +//] +//[ limitations_literal_zero_solution_2 + MOCK_EXPECT( m.method ).with( mock::negate ); +//] +#ifdef MOCK_NULLPTR +//[ limitations_literal_zero_solution_3 + MOCK_EXPECT( m.method ).with( nullptr ); +//] +#endif } diff --git a/doc/example/limitations_non_virtual_method.cpp b/doc/example/limitations_non_virtual_method.cpp index 01c92d3..b6f0457 100644 --- a/doc/example/limitations_non_virtual_method.cpp +++ b/doc/example/limitations_non_virtual_method.cpp @@ -6,8 +6,9 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) +#define BOOST_AUTO_TEST_MAIN +#include #include -#include //[ limitations_non_virtual_method_problem class base @@ -19,15 +20,8 @@ public: //] //[ limitations_non_virtual_method_problem_2 -MOCK_BASE_CLASS(mock_base, base) +MOCK_BASE_CLASS( mock_base, base ) { - MOCK_METHOD(method, 0) + MOCK_METHOD( method, 0 ) }; //] - -BOOST_AUTO_TEST_CASE(method_not_called_through_base) -{ - mock_base b; - MOCK_EXPECT(b.method).never(); - static_cast(&b)->method(); // Doesn't call the mocked method as asserted above -} diff --git a/doc/example/limitations_protected_private_method.cpp b/doc/example/limitations_protected_private_method.cpp index ed969d1..327cf2a 100644 --- a/doc/example/limitations_protected_private_method.cpp +++ b/doc/example/limitations_protected_private_method.cpp @@ -6,41 +6,27 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) +#define BOOST_AUTO_TEST_MAIN +#include #include -#include -namespace { -//[ limitations_protected_private_method_problem -class base +namespace { -public: - void call() +//[ limitations_protected_private_method_problem + class base { - method_1(); - method_2(); - } - -protected: - virtual void method_1() = 0; - -private: - virtual void method_2() = 0; -}; + private: + virtual void method_1() = 0; + private: + virtual void method_2() = 0; + }; //] //[ limitations_protected_private_method_solution -MOCK_BASE_CLASS(mock_base, base) -{ - MOCK_METHOD(method_1, 0, void()) - MOCK_METHOD(method_2, 0, void()) -}; + MOCK_BASE_CLASS( mock_base, base ) + { + MOCK_METHOD( method_1, 0, void() ) + MOCK_METHOD( method_2, 0, void() ) + }; //] -} // namespace - -BOOST_AUTO_TEST_CASE(mocked_methods_are_called) -{ - mock_base b; - MOCK_EXPECT(b.method_1).once(); - MOCK_EXPECT(b.method_2).once(); - static_cast(&b)->call(); } diff --git a/doc/example/limitations_template_base_class_method.cpp b/doc/example/limitations_template_base_class_method.cpp index e026a25..5b5461b 100644 --- a/doc/example/limitations_template_base_class_method.cpp +++ b/doc/example/limitations_template_base_class_method.cpp @@ -6,33 +6,29 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) +#define BOOST_AUTO_TEST_MAIN +#include #include -#include -namespace { +namespace +{ //[ limitations_template_base_class_method_problem -template -class base -{ -public: - virtual ~base() = default; + template< typename T > + class base + { + public: + virtual ~base() + {} - virtual void method() = 0; -}; + virtual void method() = 0; + }; //] - + //[ limitations_template_base_class_method_solution -template -MOCK_BASE_CLASS(mock_base, base) -{ - MOCK_METHOD(method, 0, void()) -}; + template< typename T > + MOCK_BASE_CLASS( mock_base, base< T > ) + { + MOCK_METHOD( method, 1, void() ) + }; //] -} // namespace - -BOOST_AUTO_TEST_CASE(call_method_from_templated_class) -{ - mock_base b; - MOCK_EXPECT(b.method).once(); - static_cast*>(&b)->method(); } diff --git a/doc/example/limitations_template_method.cpp b/doc/example/limitations_template_method.cpp index 3ca0629..c5c0fa7 100644 --- a/doc/example/limitations_template_method.cpp +++ b/doc/example/limitations_template_method.cpp @@ -6,90 +6,78 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) +#define BOOST_AUTO_TEST_MAIN +#include #include -#include -namespace limitations_template_method_problem { +namespace limitations_template_method_problem +{ //[ limitations_template_method_problem -class concept_class +class concept { public: - template - void method(T t); + template< typename T > + void method( T t ) + {} }; -template -void function_under_test(T t) // T is supposed to model the previous concept +template< typename T > +void function_under_test( T t ) // T is supposed to model the previous concept { - t.method(42); - t.method("string"); + t.method( 42 ); + t.method( "string" ); } //] - + //[ limitations_template_method_solution -MOCK_CLASS(mock_concept) +MOCK_CLASS( mock_concept ) { - MOCK_METHOD(method, 1, void(int), method_int) - MOCK_METHOD(method, 1, void(const char*), method_string) + MOCK_METHOD( method, 1, void( int ), method_int ) + MOCK_METHOD( method, 1, void( const char* ), method_string ) }; //] - -BOOST_AUTO_TEST_CASE(mocked_templated_methods_are_called) -{ - mock_concept b; - MOCK_EXPECT(b.method_int).once().with(42); - MOCK_EXPECT(b.method_string).once().with(mock::equal(std::string("string"))); - function_under_test(b); } -} // namespace limitations_template_method_problem -namespace limitations_template_method_problem_2 { +namespace limitations_template_method_problem_2 +{ //[ limitations_template_method_problem_2 -class concept_class +class concept { public: - template + template< typename T > T create() { return T(); } }; -template -void function_under_test(T t) // T is supposed to model the previous concept +template< typename T > +void function_under_test( T t ) // T is supposed to model the previous concept { - t.template create(); - t.template create(); + t.template create< int >(); + t.template create< std::string >(); } //] - + //[ limitations_template_method_solution_2 -MOCK_CLASS(mock_concept) +MOCK_CLASS( mock_concept ) { - template + template< typename T > T create(); - MOCK_METHOD(create_int, 0, int(), create_int) - MOCK_METHOD(create_string, 0, std::string(), create_string) + MOCK_METHOD( create_int, 0, int(), create_int ) + MOCK_METHOD( create_string, 0, std::string(), create_string ) }; template<> -int mock_concept::create() +int mock_concept::create< int >() { return create_int(); } template<> -std::string mock_concept::create() +std::string mock_concept::create< std::string >() { return create_string(); } //] - -BOOST_AUTO_TEST_CASE(dispatch_methods_are_called) -{ - mock_concept b; - MOCK_EXPECT(b.create_int).once().returns(0); - MOCK_EXPECT(b.create_string).once().returns(""); - function_under_test(b); } -} // namespace limitations_template_method_problem_2 diff --git a/doc/example/limitations_throw_specifier.cpp b/doc/example/limitations_throw_specifier.cpp index 5c1e872..01e70fe 100644 --- a/doc/example/limitations_throw_specifier.cpp +++ b/doc/example/limitations_throw_specifier.cpp @@ -6,31 +6,30 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) +#define BOOST_AUTO_TEST_MAIN +#include #include -#include -namespace { -//[ limitations_throw_specifier_problem -struct base_class +namespace { - virtual ~base_class() = default; +//[ limitations_throw_specifier_problem + struct base_class + { + virtual ~base_class() + {} - virtual void method() throw() = 0; -}; + virtual void method() throw (); + }; //] //[ limitations_throw_specifier_solution -MOCK_BASE_CLASS(mock_class, base_class) -{ - void method() throw() override { method_proxy(); } - MOCK_METHOD(method_proxy, 0, void(), method) -}; + MOCK_BASE_CLASS( mock_class, base_class ) + { + void method() throw () + { + method_proxy(); + } + MOCK_METHOD( method_proxy, 0, void(), method ) + }; //] -} // namespace - -BOOST_AUTO_TEST_CASE(call_method_proxy) -{ - mock_class b; - MOCK_EXPECT(b.method).once(); - static_cast(&b)->method(); } diff --git a/doc/example/mock_view.hpp b/doc/example/mock_view.hpp index b2ba52a..0633ae5 100644 --- a/doc/example/mock_view.hpp +++ b/doc/example/mock_view.hpp @@ -9,14 +9,14 @@ #ifndef MOCK_VIEW #define MOCK_VIEW -#include "view.hpp" #include +#include "view.hpp" //[ mock_view -MOCK_BASE_CLASS(mock_view, view) // declare a 'mock_view' class implementing 'view' +MOCK_BASE_CLASS( mock_view, view ) // declare a 'mock_view' class implementing 'view' { - MOCK_METHOD(display, 1) // implement the 'display' method from 'view' (taking 1 argument) + MOCK_METHOD( display, 1 ) // implement the 'display' method from 'view' (taking 1 argument) }; - //] +//] #endif // MOCK_VIEW diff --git a/doc/example/motivation.cpp b/doc/example/motivation.cpp index 100e3cb..9aef368 100644 --- a/doc/example/motivation.cpp +++ b/doc/example/motivation.cpp @@ -6,41 +6,41 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) +#define BOOST_AUTO_TEST_MAIN +#include +#include #include "calculator.hpp" #include "mock_view.hpp" -#include -#include -namespace simple { +namespace simple +{ //[ simple_calculator class calculator { public: - int add(int a, int b); + int add( int a, int b ); }; //] -int calculator::add(int a, int b) -{ - return a + b; -} - //[ simple_zero_plus_zero_is_zero -BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero) +BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero ) { calculator c; - BOOST_CHECK_EQUAL(0, c.add(0, 0)); + BOOST_CHECK_EQUAL( 0, c.add( 0, 0 ) ); } //] -} // namespace simple +} -namespace without_mock_object { +namespace without_mock_object +{ //[ my_view class my_view : public view { public: - my_view() : called(false) {} - virtual void display(int result) + my_view() + : called( false ) + {} + virtual void display( int result ) { called = true; value = result; @@ -51,26 +51,26 @@ public: //] //[ zero_plus_zero_is_zero_without_mock_object -BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero_without_mock_object) +BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero ) { my_view v; - calculator c(v); - c.add(0, 0); - BOOST_REQUIRE(v.called); - BOOST_CHECK_EQUAL(0, v.value); + calculator c( v ); + c.add( 0, 0 ); + BOOST_REQUIRE( v.called ); + BOOST_CHECK_EQUAL( 0, v.value ); } //] -} // namespace without_mock_object +} -namespace with_mock_object { +namespace with_mock_object +{ //[ zero_plus_zero_is_zero_with_mock_object -BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero_with_mock_object) +BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero ) { mock_view v; - calculator c(v); - MOCK_EXPECT(v.display).once().with( - 0); // expect the 'display' method to be called once (and only once) with a parameter value equal to 0 - c.add(0, 0); + calculator c( v ); + MOCK_EXPECT( v.display ).once().with( 0 ); // expect the 'display' method to be called once (and only once) with a parameter value equal to 0 + c.add( 0, 0 ); } //] -} // namespace with_mock_object +} diff --git a/doc/example/patterns_async_call.cpp b/doc/example/patterns_async_call.cpp index 5d18946..e1b2a60 100644 --- a/doc/example/patterns_async_call.cpp +++ b/doc/example/patterns_async_call.cpp @@ -7,66 +7,67 @@ // http://www.boost.org/LICENSE_1_0.txt) //[ async_call_problem -namespace mock_test { -class base_class +namespace { -public: - virtual void method() = 0; -}; + class base_class + { + public: + virtual void method() = 0; + }; -class my_class -{ - base_class& b; + class my_class + { + public: + explicit my_class( base_class& ); -public: - explicit my_class(base_class&); - - void flush(); // repetitively calling this method will in turn call base_class::method at some point -}; -} // namespace mock_test + void flush(); // repetitively calling this method will in turn call base_class::method at some point + }; +} //] -namespace mock_test { -my_class::my_class(base_class& b) : b(b) {} -void my_class::flush() -{ - static int counter = 7; - if(--counter == 0) - b.method(); -} -} // namespace mock_test - //[ async_call_solution -#include -#include +#define BOOST_AUTO_TEST_MAIN +#include +#include #include +#include -namespace mock_test { -template -void check(bool& condition, F flush, int attempts = 100, int sleep = 100) +namespace { - while(!condition && attempts > 0) + template< typename F > + void check( bool& condition, F flush, int attempts = 100, int sleep = 100 ) { - --attempts; - boost::this_thread::sleep(boost::posix_time::milliseconds(sleep)); - flush(); + while( !condition && attempts > 0 ) + { + --attempts; + boost::this_thread::sleep( boost::posix_time::milliseconds( sleep ) ); + flush(); + } + } + + MOCK_BASE_CLASS( mock_base_class, base_class ) + { + MOCK_METHOD( method, 0 ) + }; + void set_bool(bool& b) + { + b = true; } } -MOCK_BASE_CLASS(mock_base_class, base_class) -{ - MOCK_METHOD(method, 0) -}; - -BOOST_AUTO_TEST_CASE(method_is_called) +BOOST_AUTO_TEST_CASE( method_is_called ) { mock_base_class m; - my_class c(m); + my_class c( m ); bool done = false; - MOCK_EXPECT(m.method).once().calls([&done]() { done = true; }); - check(done, [&c]() { c.flush(); }); // just wait on done, flushing from time to time + // when method is called it will set done to true + // Note: Boost 1.57 introduced a bug preventing usage of the lambda with clang in C++98 + // See: https://svn.boost.org/trac10/ticket/10785 +#if defined(BOOST_CLANG) && (BOOST_VERSION >= 105700) + MOCK_EXPECT( m.method ).once().calls( boost::bind(&set_bool, done) ); +#else + MOCK_EXPECT( m.method ).once().calls( boost::lambda::var( done ) = true ); +#endif + check( done, boost::bind( &my_class::flush, &c ) ); // just wait on done, flushing from time to time } - -} // namespace mock_test - //] diff --git a/doc/example/patterns_invoke_functor.cpp b/doc/example/patterns_invoke_functor.cpp index f22b32a..f4d281d 100644 --- a/doc/example/patterns_invoke_functor.cpp +++ b/doc/example/patterns_invoke_functor.cpp @@ -6,61 +6,39 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) -// Intentionally duplicate to have complete examples and minimal user visible, yet tested test code -#include - -static void someFunctor(int newValue); //[ invoke_functor_problem -#include +#include -class base_class +namespace { -public: - virtual void method(const std::function& functor) = 0; -}; + class base_class + { + public: + virtual void method( const boost::function< void( int ) >& functor ) = 0; + }; -// the function will call 'method' with a functor to be applied -void function(base_class& c) -{ - c.method(someFunctor); + void function( base_class& ); // the function will call 'method' with a functor to be applied } //] -// Some test-only code to verify what is described -static int receivedValue = 0; -static void someFunctor(int newValue) -{ - receivedValue = newValue; -} -// Check that the functor was called with 42 -struct CheckReceivedValue -{ - void teardown() - { - BOOST_CHECK(receivedValue == 42); // functor was called and received the value 42 - } -}; -// And force using it w/o showing that in the docs -#undef BOOST_AUTO_TEST_CASE -#define BOOST_AUTO_TEST_CASE(name) BOOST_FIXTURE_TEST_CASE(name, CheckReceivedValue) - //[ invoke_functor_solution +#define BOOST_AUTO_TEST_MAIN +#include +#include #include -#include -namespace { -MOCK_BASE_CLASS(mock_class, base_class) +namespace { - MOCK_METHOD(method, 1) -}; -} // namespace + MOCK_BASE_CLASS( mock_class, base_class ) + { + MOCK_METHOD( method, 1 ) + }; +} -BOOST_AUTO_TEST_CASE(how_to_invoke_a_functor_passed_as_parameter_of_a_mock_method) +BOOST_AUTO_TEST_CASE( how_to_invoke_a_functor_passed_as_parameter_of_a_mock_method ) { mock_class mock; - MOCK_EXPECT(mock.method).calls([](const auto& functor) { - functor(42); - }); // whenever 'method' is called, invoke the functor with 42 - function(mock); + MOCK_EXPECT( mock.method ).calls( boost::bind( boost::apply< void >(), _1, 42 ) ); // whenever 'method' is called, invoke the functor with 42 + function( mock ); } //] diff --git a/doc/example/patterns_quick_constraint.cpp b/doc/example/patterns_quick_constraint.cpp index 959dc78..a331bdc 100644 --- a/doc/example/patterns_quick_constraint.cpp +++ b/doc/example/patterns_quick_constraint.cpp @@ -7,50 +7,49 @@ // http://www.boost.org/LICENSE_1_0.txt) //[ quick_constraint_problem +#define BOOST_AUTO_TEST_MAIN +#include #include -#include #include -namespace { -class my_class +namespace { -public: - explicit my_class(int data) : data_(data) {} - int data_; -}; + class my_class + { + public: + explicit my_class( int data ) + : data_( data ) + {} + int data_; + }; -std::ostream& operator<<(std::ostream& os, const my_class& c) // my_class is serializable to an std::ostream -{ - return os << "my_class( " << c.data_ << " )"; + std::ostream& operator<<( std::ostream& os, const my_class& c ) // my_class is serializable to an std::ostream + { + return os << "my_class( " << c.data_ << " )"; + } + + MOCK_CLASS( my_mock ) + { + MOCK_METHOD( method, 1, void( const my_class& ) ) // how to simply write a custom constraint ? + }; } - -MOCK_CLASS(my_mock) -{ - MOCK_METHOD(method, 1, void(const my_class&)) // how to simply write a custom constraint ? -}; -} // namespace //] //[ quick_constraint_solution -#include +#include namespace // in the same namespace as 'my_class' { -bool operator==(const my_class& actual, - const std::string& expected) // the first part of the trick is to compare to a string -{ - std::ostringstream s; - s << actual; - return s.str() == expected; -} -} // namespace + bool operator==( const my_class& actual, const std::string& expected ) // the first part of the trick is to compare to a string + { + return boost::lexical_cast< std::string >( actual ) == expected; + } +} // mock -BOOST_AUTO_TEST_CASE(method_is_called) +BOOST_AUTO_TEST_CASE( method_is_called ) { my_mock mock; - MOCK_EXPECT(mock.method) - .once() - .with("my_class( 42 )"); // the second part of the trick is to express the constraint as a string - mock.method(my_class(42)); + MOCK_EXPECT( mock.method ).once().with( "my_class( 42 )" ); // the second part of the trick is to express the constraint as a string + mock.method( my_class( 42 ) ); } //] diff --git a/doc/example/patterns_retrieve_cref.cpp b/doc/example/patterns_retrieve_cref.cpp index 86d5345..8be3e9a 100644 --- a/doc/example/patterns_retrieve_cref.cpp +++ b/doc/example/patterns_retrieve_cref.cpp @@ -7,59 +7,44 @@ // http://www.boost.org/LICENSE_1_0.txt) //[ retrieve_cref_problem -namespace { -class base_class +namespace { -public: - virtual void method(int value) = 0; -}; + class base_class + { + public: + virtual void method( int value ) = 0; + }; -class my_class -{ -public: - explicit my_class(base_class&); + class my_class + { + public: + explicit my_class( base_class& ); - void process(); // the processing will call 'method' two times with the same value, but we don't know what value - // beforehand -}; -} // namespace + void process(); // the processing will call 'method' two times with the same value, but we don't know what value beforehand + }; +} //] -namespace { -static base_class* global_b = nullptr; -my_class::my_class(base_class& b) -{ - global_b = &b; -} -void my_class::process() -{ - int secret_value = 42; - global_b->method(secret_value); - global_b->method(secret_value); -} -} // namespace - //[ retrieve_cref_solution +#define BOOST_AUTO_TEST_MAIN +#include #include -#include -namespace { -MOCK_BASE_CLASS(mock_base_class, base_class) +namespace { - MOCK_METHOD(method, 1) -}; -} // namespace + MOCK_BASE_CLASS( mock_base_class, base_class ) + { + MOCK_METHOD( method, 1 ) + }; +} -BOOST_AUTO_TEST_CASE(method_is_called_two_times_with_the_same_value) +BOOST_AUTO_TEST_CASE( method_is_called_two_times_with_the_same_value ) { mock_base_class mock; - my_class c(mock); + my_class c( mock ); int value; - MOCK_EXPECT(mock.method).once().with(mock::retrieve(value)); // on first call retrieve the value, this expectation - // takes precedence because it can never fail - MOCK_EXPECT(mock.method) - .once() - .with(std::cref(value)); // on second call compare the previously retrieved value with the newly received one + MOCK_EXPECT( mock.method ).once().with( mock::retrieve( value ) ); // on first call retrieve the value, this expectation takes precedence because it can never fail + MOCK_EXPECT( mock.method ).once().with( boost::cref( value ) ); // on second call compare the previously retrieved value with the newly received one c.process(); } //] diff --git a/doc/example/patterns_static_objects.cpp b/doc/example/patterns_static_objects.cpp index 0d6d82c..c385fbc 100644 --- a/doc/example/patterns_static_objects.cpp +++ b/doc/example/patterns_static_objects.cpp @@ -6,42 +6,35 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) -#include - -// Used to make this test file pass. Define to 0 to see other tests fail -#define MOCK_MAKE_TEST_PASS 1 - -#if MOCK_MAKE_TEST_PASS -# undef BOOST_AUTO_TEST_CASE -# define BOOST_AUTO_TEST_CASE(name) BOOST_FIXTURE_TEST_CASE(name, mock::cleanup) -#endif - //[ static_objects_problem +#define BOOST_AUTO_TEST_MAIN +#include #include -#include #include -namespace { -struct my_class +namespace { - my_class(int i) : i_(i) {} + struct my_class + { + my_class( int i ) + : i_( i ) + {} - int i_; -}; + int i_; + }; -std::ostream& operator<<(std::ostream& os, const my_class* c) -{ - return os << "my_class " << c->i_; // the 'c' pointer must be valid when logging + std::ostream& operator<<( std::ostream& os, const my_class* c ) + { + return os << "my_class " << c->i_; // the 'c' pointer must be valid when logging + } + + MOCK_FUNCTION( f, 1, void( my_class* ) ) // being static 'f' outlive the test case } -MOCK_FUNCTION(f, 1, void(my_class*)) // being static 'f' outlives the test case -} // namespace - -BOOST_AUTO_TEST_CASE(static_objects_problem) +BOOST_AUTO_TEST_CASE( static_objects_problem ) { - my_class c(42); - MOCK_EXPECT(f).once().with( - &c); // the set expectation will also outlive the test case and leak into other test cases using 'f' + my_class c( 42 ); + MOCK_EXPECT( f ).once().with( &c ); // the set expectation will also outlive the test case and leak into other test cases using 'f' } // the 'c' instance goes out of scope and the '&c' pointer becomes dangling //] @@ -50,28 +43,25 @@ struct fixture { ~fixture() { - mock::reset(); // the use of a fixture ensures the reset will prevent the expectations from leaking into other - // test cases + mock::reset(); // the use of a fixture ensures the reset will prevent the expectations from leaking into other test cases } }; -BOOST_FIXTURE_TEST_CASE(static_object_partial_solution, fixture) +BOOST_FIXTURE_TEST_CASE( static_object_partial_solution, fixture ) { - my_class c(42); - MOCK_EXPECT(f).once().with(&c); - f(&c); + my_class c( 42 ); + MOCK_EXPECT( f ).once().with( &c ); + f( &c ); mock::verify(); // verify the expectations before local objects are destroyed and before the fixture resets them } //] //[ static_objects_solution -BOOST_FIXTURE_TEST_CASE( - static_objects_solution, - mock::cleanup) // actually the library includes a ready to use fixture just like the one described +BOOST_FIXTURE_TEST_CASE( static_objects_solution, mock::cleanup ) // actually the library includes a ready to use fixture just like the one described { - my_class c(42); - MOCK_EXPECT(f).once().with(&c); - f(&c); + my_class c( 42 ); + MOCK_EXPECT( f ).once().with( &c ); + f( &c ); mock::verify(); } //] diff --git a/doc/example/rationale.cpp b/doc/example/rationale.cpp index 6d4f937..170e7e7 100644 --- a/doc/example/rationale.cpp +++ b/doc/example/rationale.cpp @@ -6,30 +6,15 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) +#include #include "calculator.hpp" #include "mock_view.hpp" -#include -#include -#include -#include -#include - -// Dummy to detect if the assertion unexpectedly succeeded to test what is explained -#undef BOOST_CHECK_THROW -#define BOOST_CHECK_THROW(expr, exc) \ - try \ - { \ - expr; \ - } catch(const exc&) \ - { \ - std::cerr << "Exception thrown but should not"; \ - } //[ overflow_throws -BOOST_AUTO_TEST_CASE(overflow_throws) +BOOST_AUTO_TEST_CASE( overflow_throws ) { mock_view v; - calculator c(v); - BOOST_CHECK_THROW(c.add((std::numeric_limits::max)(), 1), std::exception); + calculator c( v ); + BOOST_CHECK_THROW( c.add( (std::numeric_limits< int >::max)(), 1 ), std::exception ); } //] diff --git a/doc/example/reference.cpp b/doc/example/reference.cpp index 33d71b5..bb2c4d6 100644 --- a/doc/example/reference.cpp +++ b/doc/example/reference.cpp @@ -6,913 +6,966 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) +#define BOOST_AUTO_TEST_MAIN +#include #include -#include -namespace class_example_1 { +namespace class_example_1 +{ //[ class_example_1 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) {}; -BOOST_AUTO_TEST_CASE(demonstrates_instantiating_a_mock_class) +BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_mock_class ) { mock_class c; } //] -} // namespace class_example_1 +} -namespace class_example_2 { +namespace class_example_2 +{ //[ class_example_2 -template -MOCK_CLASS(mock_class) +template< typename T > +MOCK_CLASS( mock_class ) {}; -BOOST_AUTO_TEST_CASE(demonstrates_instantiating_a_template_mock_class) +BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_template_mock_class ) { - mock_class c; + mock_class< int > c; } //] -} // namespace class_example_2 +} -namespace class_example_3 { +namespace class_example_3 +{ //[ class_example_3 struct base_class {}; -MOCK_BASE_CLASS(mock_class, base_class) +MOCK_BASE_CLASS( mock_class, base_class ) {}; -BOOST_AUTO_TEST_CASE(demonstrates_instantiating_a_derived_mock_class) +BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_derived_mock_class ) { mock_class c; } //] -} // namespace class_example_3 +} -namespace class_example_4 { +namespace class_example_4 +{ //[ class_example_4 -template +template< typename T > struct base_class {}; -template -MOCK_BASE_CLASS(mock_class, base_class) +template< typename T > +MOCK_BASE_CLASS( mock_class, base_class< T > ) {}; -BOOST_AUTO_TEST_CASE(demonstrates_instantiating_a_template_derived_mock_class) +BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_template_derived_mock_class ) { - mock_class c; + mock_class< int > c; } //] -} // namespace class_example_4 +} -namespace class_example_5 { +namespace class_example_5 +{ //[ class_example_5 struct name : mock::object // equivalent to using MOCK_CLASS {}; //] -} // namespace class_example_5 +} -namespace class_example_6 { +namespace class_example_6 +{ //[ class_example_6 -template +template< typename T > struct name : mock::object // equivalent to using MOCK_CLASS {}; //] -} // namespace class_example_6 +} -namespace class_example_7 { +namespace class_example_7 +{ //[ class_example_7 class base {}; struct name : base, mock::object // equivalent to using MOCK_BASE_CLASS { - // this is required for the shortest form of MOCK_METHOD to work when not using MOCK_BASE_CLASS - using base_type = base; + typedef base base_type; // this is required for the shortest form of MOCK_METHOD to work when not using MOCK_BASE_CLASS }; //] -} // namespace class_example_7 +} -namespace class_example_8 { +namespace class_example_8 +{ //[ class_example_8 -template +template< typename T > struct base {}; -template -struct name : base, mock::object +template< typename T > +struct name : base< T >, mock::object { - using base_type = base; + typedef base< T > base_type; }; //] -} // namespace class_example_8 +} -namespace member_function_example_1 { +namespace member_function_example_1 +{ //[ member_function_example_1 struct base_class { - virtual ~base_class() = default; - virtual void method(int) = 0; + virtual ~base_class() + {} + virtual void method( int ) = 0; }; -MOCK_BASE_CLASS(mock_class, base_class) +MOCK_BASE_CLASS( mock_class, base_class ) { - MOCK_METHOD(method, 1) // only possible when referring unambiguously to a base class method + MOCK_METHOD( method, 1 ) // only possible when referring unambiguously to a base class method }; //] -} // namespace member_function_example_1 +} -namespace member_function_example_2 { +namespace member_function_example_2 +{ //[ member_function_example_2 struct base_class { - virtual ~base_class() = default; - virtual void method(int, const std::string&) = 0; - virtual void method(float) = 0; + virtual ~base_class() + {} + virtual void method( int, const std::string& ) = 0; + virtual void method( float ) = 0; }; -MOCK_BASE_CLASS(mock_class, base_class) +MOCK_BASE_CLASS( mock_class, base_class ) { - // both the signature and identifier must be specified because of ambiguity due to overloading - MOCK_METHOD(method, 2, void(int, const std::string&), identifier_1) - // the identifier must differ from the previous one in order to fully disambiguate methods - MOCK_METHOD(method, 1, void(float), identifier_2) + MOCK_METHOD( method, 2, void( int, const std::string& ), identifier_1 ) // both the signature and identifier must be specified because of ambiguity due to overloading + MOCK_METHOD( method, 1, void( float ), identifier_2 ) // the identifier must differ from the previous one in order to fully disambiguate methods }; //] -} // namespace member_function_example_2 +} -namespace member_function_example_3 { +namespace member_function_example_3 +{ //[ member_function_example_3 struct base_class { - virtual ~base_class() = default; - virtual void method(float) = 0; - virtual void method(float) const = 0; + virtual ~base_class() + {} + virtual void method( float ) = 0; + virtual void method( float ) const = 0; }; -MOCK_BASE_CLASS(mock_class, base_class) +MOCK_BASE_CLASS( mock_class, base_class ) { - MOCK_METHOD(method, 1, void(float)) // this generates both const and non-const versions + MOCK_METHOD( method, 1, void( float ) ) // this generates both const and non-const versions }; //] -} // namespace member_function_example_3 +} -namespace member_function_example_4 { +namespace member_function_example_4 +{ //[ member_function_example_4 struct base_class { - virtual ~base_class() = default; - virtual void method(float) = 0; - virtual void method(float) const = 0; + virtual ~base_class() + {} + virtual void method( float ) = 0; + virtual void method( float ) const = 0; }; -MOCK_BASE_CLASS(mock_class, base_class) +MOCK_BASE_CLASS( mock_class, base_class ) { - // this generates only the const version - MOCK_CONST_METHOD(method, 1, void(float), identifier_1) - // this generates only the non-const version, with a different identifier - MOCK_NON_CONST_METHOD(method, 1, void(float), identifier_2) + MOCK_CONST_METHOD( method, 1, void( float ), identifier_1 ) // this generates only the const version + MOCK_NON_CONST_METHOD( method, 1, void( float ), identifier_2 ) // this generates only the non-const version, with a different identifier }; //] -} // namespace member_function_example_4 +} -namespace member_function_example_5 { +namespace member_function_example_5 +{ //[ member_function_example_5 struct base_class { - virtual ~base_class() = default; - virtual void method(float) = 0; + virtual ~base_class() + {} + virtual void method( float ) = 0; }; struct mock_class : base_class { - using base_type = base_class; // this is required for MOCK_METHOD to work when not using MOCK_BASE_CLASS + typedef base_class base_type; // this is required for MOCK_METHOD to work when not using MOCK_BASE_CLASS - MOCK_METHOD(method, 1) + MOCK_METHOD( method, 1 ) }; //] -} // namespace member_function_example_5 +} -namespace member_function_example_6 { +namespace member_function_example_6 +{ //[ member_function_example_6 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - MOCK_NON_CONST_METHOD(operator=, - 1, - mock_class &(const mock_class&), - assignment) // operators require a custom identifier + MOCK_NON_CONST_METHOD( operator=, 1, mock_class&( const mock_class& ), assignment ) // operators require a custom identifier }; //] -} // namespace member_function_example_6 +} -namespace member_function_example_7 { +namespace member_function_example_7 +{ //[ member_function_example_7 -template -MOCK_CLASS(mock_class) +template< typename T > +MOCK_CLASS( mock_class ) { - // includes a template parameter of the class - MOCK_METHOD(method, 1, void(const T&)) + MOCK_METHOD_TPL( method, 1, void( const T& ) ) // the _TPL variants must be used if the signature includes a template parameter of the class }; //] -} // namespace member_function_example_7 +} -namespace member_function_example_8 { +namespace member_function_example_8 +{ //[ member_function_example_8 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - // the signature must be wrapped in MOCK_PROTECT_SIGNATURE if the return type contains a comma - MOCK_METHOD(method, 0, MOCK_PROTECT_SIGNATURE(std::map())) + MOCK_METHOD( method, 0, BOOST_IDENTITY_TYPE((std::map< int, int >())) ) // the signature must be wrapped in BOOST_IDENTITY_TYPE if the return type contains a comma }; //] - -static_assert(std::is_same().method()), std::map>::value, - "Wrong return value"); - -} // namespace member_function_example_8 +} #ifdef BOOST_MSVC -namespace member_function_example_9 { +namespace member_function_example_9 +{ //[ member_function_example_9 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - // all parameters must be provided when specifying a different calling convention - MOCK_METHOD(__stdcall method, 0, void(), method) + MOCK_METHOD( __stdcall method, 0, void(), method ) // all parameters must be provided when specifying a different calling convention }; //] -} // namespace member_function_example_9 +} #endif -namespace static_member_function_example_1 { +namespace static_member_function_example_1 +{ //[ static_member_function_example_1 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - MOCK_STATIC_METHOD(method, 1, float(int)) + MOCK_STATIC_METHOD( method, 1, float( int ) ) }; //] -} // namespace static_member_function_example_1 +} -namespace static_member_function_example_2 { +namespace static_member_function_example_2 +{ //[ static_member_function_example_2 -template -MOCK_CLASS(mock_class) +template< typename T > +MOCK_CLASS( mock_class ) { - MOCK_STATIC_METHOD(method, 1, void(T)) // includes a template parameter of the class + MOCK_STATIC_METHOD_TPL( method, 1, void( T ) ) }; //] -} // namespace static_member_function_example_2 +} #ifdef BOOST_MSVC -namespace static_member_function_example_3 { +namespace static_member_function_example_3 +{ //[ static_member_function_example_3 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - // all parameters must be provided when specifying a different calling convention - MOCK_STATIC_METHOD(__stdcall method, 0, void(), method) + MOCK_STATIC_METHOD( __stdcall method, 0, void(), method ) // all parameters must be provided when specifying a different calling convention }; //] -} // namespace static_member_function_example_3 +} #endif -namespace constructor_example_1 { +namespace constructor_example_1 +{ //[ constructor_example_1 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - MOCK_CONSTRUCTOR(mock_class, 2, (int, const std::string&), identifier) + MOCK_CONSTRUCTOR( mock_class, 2, ( int, const std::string& ), identifier ) }; //] -} // namespace constructor_example_1 +} -namespace constructor_example_2 { +namespace constructor_example_2 +{ //[ constructor_example_2 -template -MOCK_CLASS(mock_class) +template< typename T > +MOCK_CLASS( mock_class ) { - MOCK_CONSTRUCTOR(mock_class, 2, (int, const std::string&), identifier) - MOCK_CONSTRUCTOR(mock_class, 2, (T, const std::string&), identifier_2) // includes a template parameter of the class + MOCK_CONSTRUCTOR( mock_class, 2, ( int, const std::string& ), identifier ) + MOCK_CONSTRUCTOR_TPL( mock_class, 2, ( T, const std::string& ), identifier_2 ) }; //] -} // namespace constructor_example_2 +} #ifdef BOOST_MSVC -namespace constructor_example_3 { +namespace constructor_example_3 +{ //[ constructor_example_3 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - MOCK_CONSTRUCTOR(__stdcall mock_class, 0, (), constructor) + MOCK_CONSTRUCTOR( __stdcall mock_class, 0, (), constructor ) }; //] -} // namespace constructor_example_3 +} #endif -namespace destructor_example_1 { +namespace destructor_example_1 +{ //[ destructor_example_1 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - MOCK_DESTRUCTOR(~mock_class, destructor) + MOCK_DESTRUCTOR( ~mock_class, destructor ) }; //] -} // namespace destructor_example_1 +} #ifdef BOOST_MSVC -namespace destructor_example_2 { +namespace destructor_example_2 +{ //[ destructor_example_2 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - MOCK_DESTRUCTOR(__stdcall ~mock_class, destructor) + MOCK_DESTRUCTOR( __stdcall ~mock_class, destructor ) }; //] -} // namespace destructor_example_2 +} #endif -namespace conversion_operator_example_1 { +namespace conversion_operator_example_1 +{ //[ conversion_operator_example_1 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - MOCK_CONVERSION_OPERATOR(operator, int, conversion_to_int) - MOCK_CONST_CONVERSION_OPERATOR(operator, const std::string&, conversion_to_string) + MOCK_CONVERSION_OPERATOR( operator, int, conversion_to_int ) + MOCK_CONST_CONVERSION_OPERATOR( operator, const std::string&, conversion_to_string ) }; //] -} // namespace conversion_operator_example_1 +} -namespace conversion_operator_example_2 { +namespace conversion_operator_example_2 +{ //[ conversion_operator_example_2 -template -MOCK_CLASS(mock_class) +template< typename T > +MOCK_CLASS( mock_class ) { - MOCK_CONVERSION_OPERATOR(operator, T, conversion_to_T) // includes a template parameter of the class - MOCK_CONST_CONVERSION_OPERATOR(operator, const std::string&, const_conversion_to_string) - MOCK_NON_CONST_CONVERSION_OPERATOR(operator, const std::string&, non_const_conversion_to_string) + MOCK_CONVERSION_OPERATOR_TPL( operator, T, conversion_to_T ) // the _TPL variants must be used if the signature includes a template parameter of the class + MOCK_CONST_CONVERSION_OPERATOR( operator, const std::string&, const_conversion_to_string ) + MOCK_NON_CONST_CONVERSION_OPERATOR( operator, const std::string&, non_const_conversion_to_string ) }; //] -} // namespace conversion_operator_example_2 +} #ifdef BOOST_MSVC -namespace conversion_operator_example_3 { +namespace conversion_operator_example_3 +{ //[ conversion_operator_example_3 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - MOCK_CONVERSION_OPERATOR(__stdcall operator, int, conversion_to_int) + MOCK_CONVERSION_OPERATOR( __stdcall operator, int, conversion_to_int ) }; //] -} // namespace conversion_operator_example_3 +} #endif -namespace function_example_1 { -//[ function_example_1 -MOCK_FUNCTION(f, 1, void(int)) - -BOOST_AUTO_TEST_CASE(demonstrates_instantiating_a_mock_function) +namespace function_example_1 { - MOCK_EXPECT(f).once().with(3); - f(3); +//[ function_example_1 +MOCK_FUNCTION( f, 1, float( int ) ) + +BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_mock_function ) +{ + f( 3 ); } //] -} // namespace function_example_1 +} #ifdef BOOST_MSVC -namespace function_example_2 { +namespace function_example_2 +{ //[ function_example_2 -// all parameters must be provided when specifying a different calling convention -MOCK_FUNCTION(__stdcall f, 0, void(), f) +MOCK_FUNCTION( __stdcall f, 0, void(), f ) // all parameters must be provided when specifying a different calling convention //] -} // namespace function_example_2 +} #endif -namespace functor_example_1 { -//[ functor_example_1 -BOOST_AUTO_TEST_CASE(demonstrates_instantiating_a_mock_functor) +namespace functor_example_1 { - MOCK_FUNCTOR(f, void(int)); - MOCK_EXPECT(f).once().with(3); - f(3); +//[ functor_example_1 +BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_mock_functor ) +{ + MOCK_FUNCTOR( f, void( int ) ); + f( 3 ); } //] -} // namespace functor_example_1 +} -namespace functor_example_2 { +namespace functor_example_2 +{ //[ functor_example_2 -template +template< typename T > struct mock_class { - MOCK_FUNCTOR(f, void(T)); + MOCK_FUNCTOR_TPL( f, void( T ) ); }; -BOOST_AUTO_TEST_CASE(demonstrates_instantiating_a_mock_functor_inside_a_class) +BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_mock_functor ) { - mock_class c; - MOCK_EXPECT(c.f).once().with(3); - c.f(3); + mock_class< int > c; + c.f( 3 ); } //] -} // namespace functor_example_2 +} -namespace expectation_example_1 { -//[ expectation_example_1 -MOCK_CLASS(mock_class) +namespace expectation_example_1 { - MOCK_METHOD(method, 1, int(int), method) - MOCK_METHOD(method, 2, void(const std::string&, float), method2) +//[ expectation_example_1 +MOCK_CLASS( mock_class ) +{ + MOCK_METHOD( method, 1, int( int ), method ) + MOCK_METHOD( method, 2, void( const std::string&, float ), method2 ) }; -BOOST_AUTO_TEST_CASE(demonstrates_configuring_mock_objects) +BOOST_AUTO_TEST_CASE( demonstrates_configuring_mock_objects ) { mock_class c; mock::sequence s; - MOCK_EXPECT(c.method).once().with(0).in(s).returns(42); - MOCK_EXPECT(c.method2).never().with("ok", mock::any); - MOCK_EXPECT(c.method2).at_least(2).in(s).throws(std::runtime_error("error !")); - BOOST_TEST(c.method(0) == 42); - BOOST_CHECK_THROW(c.method("not ok", 1.f), std::runtime_error); - BOOST_CHECK_THROW(c.method("not ok", 2.f), std::runtime_error); + MOCK_EXPECT( c.method ).once().with( 0 ).in( s ).returns( 42 ); + MOCK_EXPECT( c.method2 ).never().with( "ok", mock::any ); + MOCK_EXPECT( c.method2 ).at_least( 2 ).in( s ).throws( std::runtime_error( "error !" ) ); } //] -} // namespace expectation_example_1 +} -namespace invocation_example_1 { +namespace invocation_example_1 +{ //[ invocation_example_1 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - MOCK_METHOD(method, 2, void(int, const std::string&)) - MOCK_METHOD(method2, 1, void(int)) + MOCK_METHOD( method, 2, void( int, const std::string& ) ) }; -BOOST_AUTO_TEST_CASE(demonstrates_setting_up_invocations_on_a_mock_method) +BOOST_AUTO_TEST_CASE( demonstrates_setting_up_invocations_on_a_mock_method ) { mock_class c; - MOCK_EXPECT(c.method).once(); // can only be called once - MOCK_EXPECT(c.method2); // can be called an unlimited number of times - c.method(42, "Hello world!"); - c.method2(42); - c.method2(42); - c.method2(42); + MOCK_EXPECT( c.method ).once(); // can only be called once + MOCK_EXPECT( c.method ); // can be called an unlimited number of times } //] -} // namespace invocation_example_1 +} -namespace invocation_example_2 { +namespace invocation_example_2 +{ //[ invocation_example_2 -BOOST_AUTO_TEST_CASE(demonstrates_setting_up_an_invocation_on_a_mock_functor) +BOOST_AUTO_TEST_CASE( demonstrates_setting_up_an_invocation_on_a_mock_functor ) { - MOCK_FUNCTOR(f, void(int, const std::string&)); - MOCK_EXPECT(f).once(); - f(42, "Hello world!"); + MOCK_FUNCTOR( f, void( int, const std::string& ) ); + MOCK_EXPECT( f ).once(); } //] -} // namespace invocation_example_2 +} -namespace invocation_example_3 { +namespace invocation_example_3 +{ //[ invocation_example_3 -MOCK_FUNCTION(f, 1, void(int)) +MOCK_FUNCTION( f, 1, void( int ) ) -BOOST_AUTO_TEST_CASE(demonstrates_setting_up_an_invocation_on_a_mock_function) +BOOST_AUTO_TEST_CASE( demonstrates_setting_up_an_invocation_on_a_mock_function ) { - MOCK_EXPECT(f).once(); - f(42); + MOCK_EXPECT( f ).once(); } //] -} // namespace invocation_example_3 +} -namespace invocation_example_4 { +namespace invocation_example_4 +{ //[ invocation_example_4 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - MOCK_STATIC_METHOD(method1, 1, void(int)) - MOCK_STATIC_METHOD(method2, 1, void(int)) + MOCK_STATIC_METHOD( method, 1, void( int ) ) }; -BOOST_AUTO_TEST_CASE(demonstrates_setting_up_an_invocation_on_a_mock_static_method) +BOOST_AUTO_TEST_CASE( demonstrates_setting_up_an_invocation_on_a_mock_static_method ) { mock_class c; - MOCK_EXPECT(c.method1).once(); - MOCK_EXPECT(mock_class::method2).once(); // does the same (but for the other method) - c.method1(42); - c.method2(42); + MOCK_EXPECT( c.method ).once(); + MOCK_EXPECT( mock_class::method ).once(); // does the same } //] -} // namespace invocation_example_4 +} -namespace constraints_example_1 { +namespace constraints_example_1 +{ //[ constraints_example_1 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - MOCK_METHOD(method1, 2, void(int, const std::string&)) - MOCK_METHOD(method2, 2, void(int, const std::string&)) + MOCK_METHOD( method, 2, void( int, const std::string& ) ) }; -BOOST_AUTO_TEST_CASE(demonstrates_adding_builtin_constraints) +BOOST_AUTO_TEST_CASE( demonstrates_adding_builtin_constraints ) { - mock_class c; - MOCK_EXPECT(c.method1).with(mock::equal(3), mock::equal("some string")); - MOCK_EXPECT(c.method2).with(3, "some string"); // similar to the previous one using short-cuts - c.method1(3, "some string"); - c.method2(3, "some string"); + mock_class c; + MOCK_EXPECT( c.method ).with( mock::equal( 3 ), mock::equal( "some string" ) ); + MOCK_EXPECT( c.method ).with( 3, "some string" ); // equivalent to the previous one using short-cuts } //] -} // namespace constraints_example_1 +} -namespace constraints_example_2 { +namespace constraints_example_2 +{ //[ constraints_example_2 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - MOCK_METHOD(method, 1, void(int)) + MOCK_METHOD( method, 1, void( int ) ) }; -bool custom_constraint(int actual) +bool custom_constraint( int actual ) { - return actual == 42; + return actual == 42; } -BOOST_AUTO_TEST_CASE(demonstrates_adding_a_custom_constraint_with_a_free_function) +BOOST_AUTO_TEST_CASE( demonstrates_adding_a_custom_constraint_with_a_free_function ) { - mock_class c; - MOCK_EXPECT(c.method).with(&custom_constraint); - c.method(42); + mock_class c; + MOCK_EXPECT( c.method ).with( &custom_constraint ); } //] -} // namespace constraints_example_2 +} -namespace constraints_example_3 { +namespace constraints_example_3 +{ //[ constraints_example_3 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - MOCK_METHOD(method, 1, void(int)) + MOCK_METHOD( method, 1, void( int ) ) }; -bool custom_constraint(int expected, int actual) +bool custom_constraint( int expected, int actual ) { - return expected == actual; + return expected == actual; } -#if MOCK_CXX_VERSION < 201703L -BOOST_AUTO_TEST_CASE(demonstrates_adding_a_custom_constraint_with_a_standard_library_functor) +BOOST_AUTO_TEST_CASE( demonstrates_adding_a_custom_constraint_with_a_standard_library_functor ) { - mock_class c; - MOCK_EXPECT(c.method).with( - std::bind1st(std::ptr_fun(&custom_constraint), 42)); // std::ptr_fun creates an std::unary_function - c.method(42); + mock_class c; + MOCK_EXPECT( c.method ).with( std::bind1st( std::ptr_fun( &custom_constraint ), 42 ) ); // std::ptr_fun creates an std::unary_function } -#endif //] -} // namespace constraints_example_3 +} -namespace constraints_example_4 { +namespace constraints_example_4 +{ //[ constraints_example_4 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - MOCK_METHOD(method, 1, void(int)) + MOCK_METHOD( method, 1, void( int ) ) }; -bool custom_constraint(int expected, int actual) +bool custom_constraint( int expected, int actual ) { - return expected == actual; + return expected == actual; } -BOOST_AUTO_TEST_CASE(demonstrates_adding_a_custom_constraint_with_std_bind) +BOOST_AUTO_TEST_CASE( demonstrates_adding_a_custom_constraint_with_boost_bind ) { - mock_class c; - using namespace std::placeholders; - MOCK_EXPECT(c.method).with(std::bind(&custom_constraint, 42, _1)); - c.method(42); + mock_class c; + MOCK_EXPECT( c.method ).with( boost::bind( &custom_constraint, 42, _1 ) ); } //] -} // namespace constraints_example_4 +} #ifndef BOOST_MSVC // this produces an ICE with all versions of MSVC -# include +#include -namespace constraints_example_5 { -//[ constraints_example_5 -MOCK_CLASS(mock_class) +namespace constraints_example_5 { - MOCK_METHOD(method, 1, void(int)) +//[ constraints_example_5 +MOCK_CLASS( mock_class ) +{ + MOCK_METHOD( method, 1, void( int ) ) }; -BOOST_AUTO_TEST_CASE(demonstrates_adding_a_custom_constraint_with_boost_lambda) +BOOST_AUTO_TEST_CASE( demonstrates_adding_a_custom_constraint_with_boost_lambda ) { - mock_class c; - MOCK_EXPECT(c.method).with(boost::lambda::_1 == 42); - c.method(42); + mock_class c; + MOCK_EXPECT( c.method ).with( boost::lambda::_1 == 42 ); } //] -} // namespace constraints_example_5 +} #endif // BOOST_MSVC #include -namespace constraints_example_6 { +namespace constraints_example_6 +{ //[ constraints_example_6 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - MOCK_METHOD(method1, 1, void(int)) - MOCK_METHOD(method2, 1, void(int)) + MOCK_METHOD( method, 1, void( int ) ) }; -BOOST_AUTO_TEST_CASE(demonstrates_adding_a_custom_constraint_with_boost_phoenix) +BOOST_AUTO_TEST_CASE( demonstrates_adding_a_custom_constraint_with_boost_phoenix ) { - mock_class c; - MOCK_EXPECT(c.method1).with(boost::phoenix::arg_names::arg1 == 42); - MOCK_EXPECT(c.method2).with(boost::phoenix::arg_names::_1 == 42); - c.method1(42); - c.method2(42); + mock_class c; + MOCK_EXPECT( c.method ).with( boost::phoenix::arg_names::arg1 == 42 ); + MOCK_EXPECT( c.method ).with( boost::phoenix::arg_names::_1 == 42 ); } //] -} // namespace constraints_example_6 +} -namespace constraints_example_7 { +#ifdef MOCK_LAMBDAS + +namespace constraints_example_7 +{ //[ constraints_example_7 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - MOCK_METHOD(method, 1, void(int)) + MOCK_METHOD( method, 1, void( int ) ) }; -BOOST_AUTO_TEST_CASE(demonstrates_adding_a_constraint_with_cxx11_lambda) +BOOST_AUTO_TEST_CASE( demonstrates_adding_a_constraint_with_cxx11_lambda ) { mock_class c; - MOCK_EXPECT(c.method).with([](int actual) { return 42 == actual; }); - c.method(42); + MOCK_EXPECT( c.method ).with( []( int actual ) { return 42 == actual; } ); } //] -} // namespace constraints_example_7 +} -namespace constraints_example_8 { +#endif + +namespace constraints_example_8 +{ //[ constraints_example_8 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - MOCK_METHOD(method, 2, void(int, const std::string&)) + MOCK_METHOD( method, 2, void( int, const std::string& ) ) }; -BOOST_AUTO_TEST_CASE(demonstrates_combining_constraints) +BOOST_AUTO_TEST_CASE( demonstrates_combining_constraints ) { - mock_class c; - MOCK_EXPECT(c.method).with(mock::less(4) && mock::greater(2), !mock::equal("")); - c.method(3, "Hello World!"); + mock_class c; + MOCK_EXPECT( c.method ).with( mock::less( 4 ) && mock::greater( 2 ), ! mock::equal( "" ) ); } //] -} // namespace constraints_example_8 +} -namespace constraints_example_9 { -//[ constraints_example_9 -MOCK_CLASS(mock_class) +namespace constraints_example_9 { - MOCK_METHOD(method, 2, void(const std::string&, std::size_t)) +//[ constraints_example_9 +MOCK_CLASS( mock_class ) +{ + MOCK_METHOD( method, 2, void( const std::string&, std::size_t ) ) }; -bool custom_constraint(const std::string& actual_1, std::size_t actual_2) +bool custom_constraint( const std::string& actual_1, std::size_t actual_2 ) { return actual_1.size() <= actual_2; } -BOOST_AUTO_TEST_CASE(demonstrates_one_constraint_for_all_arguments) +BOOST_AUTO_TEST_CASE( demonstrates_one_constraint_for_all_arguments ) { - mock_class c; - MOCK_EXPECT(c.method).with(&custom_constraint); - c.method("1234", 4); + mock_class c; + MOCK_EXPECT( c.method ).with( &custom_constraint ); } //] -} // namespace constraints_example_9 +} -namespace sequence_example_1 { +namespace sequence_example_1 +{ //[ sequence_example_1 -MOCK_CLASS(mock_class_1) +MOCK_CLASS( mock_class_1 ) { - MOCK_METHOD(method_1, 0, void()) + MOCK_METHOD( method_1, 0, void() ) }; -MOCK_CLASS(mock_class_2) +MOCK_CLASS( mock_class_2 ) { - MOCK_METHOD(method_2, 0, void()) + MOCK_METHOD( method_2, 0, void() ) }; -MOCK_CLASS(mock_class_3) +MOCK_CLASS( mock_class_3 ) { - MOCK_METHOD(method_3, 0, void()) + MOCK_METHOD( method_3, 0, void() ) }; -BOOST_AUTO_TEST_CASE(demonstrates_enforcing_several_expectation_orders) +BOOST_AUTO_TEST_CASE( demonstrates_enforcing_several_expectation_orders ) { - mock_class_1 c_1; - mock_class_2 c_2; - mock_class_3 c_3; - mock::sequence s_1, s_2; - MOCK_EXPECT(c_1.method_1).in(s_1); - MOCK_EXPECT(c_2.method_2) - .in(s_2); // c_1.method_1 and c_2.method_2 are in different sequences and can be called in any order - MOCK_EXPECT(c_3.method_3).in(s_1, s_2); // c_3.method_3 must be called after both c_1.method_1 and c_2.method_2 - c_2.method_2(); - c_1.method_1(); - c_3.method_3(); + mock_class_1 c_1; + mock_class_2 c_2; + mock_class_3 c_3; + mock::sequence s_1, s_2; + MOCK_EXPECT( c_1.method_1 ).in( s_1 ); + MOCK_EXPECT( c_2.method_2 ).in( s_2 ); // c_1.method_1 and c_2.method_2 are in different sequences and can be called in any order + MOCK_EXPECT( c_3.method_3 ).in( s_1, s_2 ); // c_3.method_3 must be called after both c_1.method_1 and c_2.method_2 } //] -} // namespace sequence_example_1 +} -namespace action_example_1 { -//[ action_example_1 -MOCK_CLASS(mock_class) +#ifdef MOCK_LAMBDAS + +namespace action_example_1 { - MOCK_METHOD(method, 1, int(int)) +//[ action_example_1 +MOCK_CLASS( mock_class ) +{ + MOCK_METHOD( method, 1, int( int ) ) }; -int function(int i) +int function( int i ) { return i; } -BOOST_AUTO_TEST_CASE(demonstrates_configuring_actions) +BOOST_AUTO_TEST_CASE( demonstrates_configuring_actions ) { - mock_class c; - MOCK_EXPECT(c.method).once().returns(42); - MOCK_EXPECT(c.method).once().moves(42); // returns by moving the value - MOCK_EXPECT(c.method).once().throws(std::runtime_error("error !")); - MOCK_EXPECT(c.method).once().calls(&function); // forwards 'method' parameter to 'function' - MOCK_EXPECT(c.method).once().calls( - std::bind(&function, 42)); // drops 'method' parameter and binds 42 as parameter to 'function' - MOCK_EXPECT(c.method).once().calls([](int i) { return i; }); // uses a C++11 lambda - BOOST_TEST(c.method(0) == 42); - BOOST_TEST(c.method(1) == 42); - BOOST_CHECK_THROW(c.method(0), std::runtime_error); - BOOST_TEST(c.method(2) == 2); - BOOST_TEST(c.method(3) == 42); - BOOST_TEST(c.method(4) == 4); + mock_class c; + MOCK_EXPECT( c.method ).returns( 42 ); + MOCK_EXPECT( c.method ).moves( 42 ); // returns by moving the value + MOCK_EXPECT( c.method ).throws( std::runtime_error( "error !" ) ); + MOCK_EXPECT( c.method ).calls( &function ); // forwards 'method' parameter to 'function' + MOCK_EXPECT( c.method ).calls( boost::bind( &function, 42 ) ); // drops 'method' parameter and binds 42 as parameter to 'function' + MOCK_EXPECT( c.method ).calls( []( int i ) { return i; } ); // uses a C++11 lambda } //] -} // namespace action_example_1 +} -namespace action_example_2 { +#endif + +namespace action_example_2 +{ //[ action_example_2 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - MOCK_METHOD(method, 0, int&()) + MOCK_METHOD( method, 0, int&() ) }; -BOOST_AUTO_TEST_CASE(demonstrates_configuring_actions_with_references) +BOOST_AUTO_TEST_CASE( demonstrates_configuring_actions_with_references ) { - mock_class c; - int i = 0; - MOCK_EXPECT(c.method).returns(std::ref(i)); // wrap i to store a reference - c.method() = 42; // really change i and not just the stored copy - BOOST_CHECK_EQUAL(42, i); // indeed + mock_class c; + int i = 0; + MOCK_EXPECT( c.method ).returns( boost::ref( i ) ); // wrap i to store a reference + c.method() = 42; // really change i and not just the stored copy + BOOST_CHECK_EQUAL( 42, i ); // indeed } //] -} // namespace action_example_2 +} -namespace verification_example_1 { +namespace verification_example_1 +{ //[ verification_example_1 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - MOCK_METHOD(method, 0, void()) + MOCK_METHOD( method, 0, void() ) }; -BOOST_AUTO_TEST_CASE(demonstrates_verifying_a_mock_method) +BOOST_AUTO_TEST_CASE( demonstrates_verifying_a_mock_method ) { - mock_class c; - MOCK_VERIFY(c.method); // logs an error and returns false if not all expectations are met - mock::verify(c); // verifies all expectations set for all methods of 'c' - mock::verify(); // verifies all existing mock objects, functions and functors + mock_class c; + MOCK_VERIFY( c.method ); // logs an error and returns false if not all expectations are met + mock::verify( c ); // verifies all expectations set for all methods of 'c' + mock::verify(); // verifies all existing mock objects, functions and functors } //] -} // namespace verification_example_1 +} -namespace verification_example_2 { +namespace verification_example_2 +{ //[ verification_example_2 -BOOST_AUTO_TEST_CASE(demonstrates_verifying_a_mock_functor) +BOOST_AUTO_TEST_CASE( demonstrates_verifying_a_mock_functor ) { - MOCK_FUNCTOR(f, void(int)); - MOCK_VERIFY(f); // logs an error and returns false if not all expectations are met - mock::verify(f); // behaves the same as MOCK_VERIFY - mock::verify(); // verifies all existing mock objects, functions and functors + MOCK_FUNCTOR( f, void( int ) ); + MOCK_VERIFY( f ); // logs an error and returns false if not all expectations are met + mock::verify( f ); // behaves the same as MOCK_VERIFY + mock::verify(); // verifies all existing mock objects, functions and functors } //] -} // namespace verification_example_2 +} -namespace verification_example_3 { +namespace verification_example_3 +{ //[ verification_example_3 -MOCK_FUNCTION(f, 1, void(int)) +MOCK_FUNCTION( f, 1, void( int ) ) -BOOST_AUTO_TEST_CASE(demonstrates_verifying_a_mock_function) +BOOST_AUTO_TEST_CASE( demonstrates_verifying_a_mock_function ) { - MOCK_VERIFY(f); // logs an error and returns false if not all expectations are met - mock::verify(); // verifies all existing mock objects, functions and functors + MOCK_VERIFY( f ); // logs an error and returns false if not all expectations are met + mock::verify(); // verifies all existing mock objects, functions and functors } //] -} // namespace verification_example_3 +} -namespace verification_example_4 { +namespace verification_example_4 +{ //[ verification_example_4 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - MOCK_STATIC_METHOD(method, 0, void()) + MOCK_STATIC_METHOD( method, 0, void() ) }; -BOOST_AUTO_TEST_CASE(demonstrates_verifying_a_static_mock_method) +BOOST_AUTO_TEST_CASE( demonstrates_verifying_a_static_mock_method ) { - mock_class c; - MOCK_VERIFY(c.method); // logs an error and returns false if not all expectations are met - MOCK_VERIFY(mock_class::method); // does the same - mock::verify(); // verifies all existing mock objects, functions and functors + mock_class c; + MOCK_VERIFY( c.method ); // logs an error and returns false if not all expectations are met + MOCK_VERIFY( mock_class::method ); // does the same + mock::verify(); // verifies all existing mock objects, functions and functors } //] -} // namespace verification_example_4 +} -namespace reset_example_1 { +namespace reset_example_1 +{ //[ reset_example_1 -MOCK_CLASS(mock_class) +MOCK_CLASS( mock_class ) { - MOCK_METHOD(method, 0, void()) + MOCK_METHOD( method, 0, void() ) }; -BOOST_AUTO_TEST_CASE(demonstrates_resetting_a_mock_method) +BOOST_AUTO_TEST_CASE( demonstrates_resetting_a_mock_method ) { - mock_class c; - MOCK_RESET(c.method); // resets all expectations set for 'c.method' - mock::reset(c); // resets all expectations set on 'c' - mock::reset(); // resets all existing mock objects, functions and functors + mock_class c; + MOCK_RESET( c.method ); // resets all expectations set for 'c.method' + mock::reset( c ); // resets all expectations set on 'c' + mock::reset(); // resets all existing mock objects, functions and functors } //] -} // namespace reset_example_1 +} -namespace reset_example_2 { +namespace reset_example_2 +{ //[ reset_example_2 -BOOST_AUTO_TEST_CASE(demonstrates_resetting_a_mock_functor) +BOOST_AUTO_TEST_CASE( demonstrates_resetting_a_mock_functor ) { - MOCK_FUNCTOR(f, void(int)); - MOCK_RESET(f); // resets all expectations set for 'f' - mock::reset(f); // behaves the same as MOCK_RESET - mock::reset(); // resets all existing mock objects, functions and functors + MOCK_FUNCTOR( f, void( int ) ); + MOCK_RESET( f ); // resets all expectations set for 'f' + mock::reset( f ); // behaves the same as MOCK_RESET + mock::reset(); // resets all existing mock objects, functions and functors } //] -} // namespace reset_example_2 +} -namespace reset_example_3 { +namespace reset_example_3 +{ //[ reset_example_3 -MOCK_FUNCTION(f, 1, void(int)) +MOCK_FUNCTION( f, 1, void( int ) ) -BOOST_AUTO_TEST_CASE(demonstrates_resetting_a_mock_function) +BOOST_AUTO_TEST_CASE( demonstrates_resetting_a_mock_function ) { - MOCK_RESET(f); // resets all expectations set for 'f' - mock::reset(); // resets all existing mock objects, functions and functors + MOCK_RESET( f ); // resets all expectations set for 'f' + mock::reset(); // resets all existing mock objects, functions and functors } //] -} // namespace reset_example_3 +} -namespace reset_example_4 { -//[ reset_example_4 -MOCK_CLASS(mock_class) +namespace reset_example_4 { - MOCK_STATIC_METHOD(method, 0, void()) +//[ reset_example_4 +MOCK_CLASS( mock_class ) +{ + MOCK_STATIC_METHOD( method, 0, void() ) }; -BOOST_AUTO_TEST_CASE(demonstrates_resetting_a_static_mock_method) +BOOST_AUTO_TEST_CASE( demonstrates_resetting_a_static_mock_method ) { - mock_class c; - MOCK_RESET(c.method); // resets all expectations set for 'c::method' - MOCK_RESET(mock_class::method); // resets all expectations set for 'c::method' - mock::reset(); // resets all existing mock objects, functions and functors + mock_class c; + MOCK_RESET( c.method ); // resets all expectations set for 'c::method' + MOCK_RESET( mock_class::method ); // resets all expectations set for 'c::method' + mock::reset(); // resets all existing mock objects, functions and functors } //] -} // namespace reset_example_4 +} -namespace helpers_example_1 { +namespace helpers_example_1 +{ //[ helpers_example_1 -MOCK_CONSTRAINT(any, true) // this is how mock::any could be defined -MOCK_CONSTRAINT(forty_two, actual == 42) // this defines a 'forty_two' constraint +MOCK_CONSTRAINT( any, true ) // this is how mock::any could be defined +MOCK_CONSTRAINT( forty_two, actual == 42 ) // this defines a 'forty_two' constraint -BOOST_AUTO_TEST_CASE(mock_constraint_0_arity) +BOOST_AUTO_TEST_CASE( mock_constraint_0_arity ) { - MOCK_FUNCTOR(f, void(int)); - MOCK_EXPECT(f).with(forty_two); - MOCK_EXPECT(f).with(any); + MOCK_FUNCTOR( f, void( int ) ); + MOCK_EXPECT( f ).with( forty_two ); + MOCK_EXPECT( f ).with( any ); } //] -} // namespace helpers_example_1 +} -namespace helpers_example_2 { +namespace helpers_example_2 +{ //[ helpers_example_2 -// this is how mock::equal could be defined -MOCK_CONSTRAINT(equal, expected, actual == expected) -// this defines a 'near' constraint which can be used as 'near( 42 )' -MOCK_CONSTRAINT(near, expected, std::abs(actual - expected) < 0.01) +MOCK_CONSTRAINT( equal, expected, actual == expected ) // this is how mock::equal could be defined +MOCK_CONSTRAINT( near, expected, std::abs( actual - expected ) < 0.01 ) // this defines a 'near' constraint which can be used as 'near( 42 )' -BOOST_AUTO_TEST_CASE(mock_constraint_1_arity) +BOOST_AUTO_TEST_CASE( mock_constraint_1_arity ) { - MOCK_FUNCTOR(f, void(int)); - MOCK_EXPECT(f).with(near(42)); - MOCK_EXPECT(f).with(equal(42)); + MOCK_FUNCTOR( f, void( int ) ); + MOCK_EXPECT( f ).with( near( 42 ) ); + MOCK_EXPECT( f ).with( equal( 42 ) ); } //] -} // namespace helpers_example_2 +} -namespace helpers_example_3 { +namespace helpers_example_3 +{ //[ helpers_example_3 -// this is how mock::near could be defined -MOCK_CONSTRAINT(near, expected, tolerance, std::abs(actual - expected) <= tolerance) +MOCK_CONSTRAINT( near, expected, tolerance, std::abs( actual - expected ) < tolerance ) // this is how mock::near could be defined -BOOST_AUTO_TEST_CASE(mock_constraint_2_arity) +BOOST_AUTO_TEST_CASE( mock_constraint_2_arity ) { - MOCK_FUNCTOR(f, void(int)); - MOCK_EXPECT(f).with(near(42, 0.001)); + MOCK_FUNCTOR( f, void( int ) ); + MOCK_EXPECT( f ).with( near( 42, 0.001 ) ); } //] -} // namespace helpers_example_3 +} + +namespace helpers_example_4 +{ +//[ helpers_example_4 +MOCK_CONSTRAINT_EXT( any, 0,, true ) // this is (almost) how mock::any is defined +MOCK_CONSTRAINT_EXT( forty_two, 0,, actual == 42 ) // this defines a 'forty_two' constraint + +BOOST_AUTO_TEST_CASE( mock_constraint_0_arity ) +{ + MOCK_FUNCTOR( f, void( int ) ); + MOCK_EXPECT( f ).with( forty_two ); + MOCK_EXPECT( f ).with( any ); +} +//] +} + +namespace helpers_example_5 +{ +//[ helpers_example_5 +MOCK_CONSTRAINT_EXT( equal, 1, ( expected ), actual == expected ) // this is how mock::equal is defined +MOCK_CONSTRAINT_EXT( near, 1, ( expected ), std::abs( actual - expected ) < 0.01 ) // this defines a 'near' constraint which can be used as 'near( 42 )' + +BOOST_AUTO_TEST_CASE( mock_constraint_1_arity ) +{ + MOCK_FUNCTOR( f, void( int ) ); + MOCK_EXPECT( f ).with( near( 42 ) ); + MOCK_EXPECT( f ).with( equal( 42 ) ); +} +//] +} + +namespace helpers_example_6 +{ +//[ helpers_example_6 +MOCK_CONSTRAINT_EXT( near, 2, ( expected, tolerance ), std::abs( actual - expected ) < tolerance ) // this is how mock::near is defined + +BOOST_AUTO_TEST_CASE( mock_constraint_2_arity ) +{ + MOCK_FUNCTOR( f, void( int ) ); + MOCK_EXPECT( f ).with( near( 42, 0.001 ) ); +} +//] +} diff --git a/doc/example/view.hpp b/doc/example/view.hpp index 82dfbd2..797523a 100644 --- a/doc/example/view.hpp +++ b/doc/example/view.hpp @@ -13,7 +13,7 @@ class view { public: - virtual void display(int result) = 0; + virtual void display( int result ) = 0; }; //] diff --git a/doc/limitations.qbk b/doc/limitations.qbk index 19c6294..ece78fd 100644 --- a/doc/limitations.qbk +++ b/doc/limitations.qbk @@ -12,6 +12,7 @@ [import example/limitations_template_base_class_method.cpp] [import example/limitations_template_method.cpp] [import example/limitations_protected_private_method.cpp] +[import example/limitations_comma_in_macro.cpp] [import example/limitations_const_parameter_warning.cpp] This section lists the library known limitations. @@ -75,7 +76,7 @@ Given : [limitations_template_method_problem] -writing a mock object modeling the 'concept class' requires to list all the possible versions of 'method' : +writing a mock object modeling 'concept' requires to list all the possible versions of 'method' : [limitations_template_method_solution] @@ -111,7 +112,7 @@ A workaround would be to add the signature to MOCK_METHOD : [endsect] -[section Protected and private virtual methods cannot be mocked without specifying the signature] +[section Private virtual methods cannot be mocked without specifying the signature] Given : @@ -150,6 +151,43 @@ A workaround would be to write a proxy member function : [endsect] +[section Compilers without support for variadic macros fail on commas in MOCK_BASE_CLASS] + +For compilers without support for variadic macros given : + +[limitations_comma_in_macro_problem] + +the following code does not compile : + + MOCK_BASE_CLASS( my_mock, my_base_class< int, int > ) // this fails because the pre-processor believes the macro to be called with 3 arguments + {}; + +One workaround is : + +[limitations_comma_in_macro_solution_1] + +Of course this is not always possible, as in : + + template< typename T1, typename T2 > + MOCK_BASE_CLASS( my_mock, my_base_type< T1, T2 > ) + {}; + +Another workaround would make use of [@http://www.boost.org/libs/preprocessor Boost.Preprocessor] : + +[limitations_comma_in_macro_solution_2] + +Actually BOOST_PP_COMMA implementation is quite trivial, being only : + + #define BOOST_PP_COMMA() , + +Finally another workaround would be to not use the macro at all : + +[limitations_comma_in_macro_solution_3] + +Note that [@http://www.boost.org/libs/utility/identity_type/doc/html/index.html Boost.IdentityType] is of little help here because the type is by essence very often abstract, which doesn't work well for some compilers (e.g. gcc). + +[endsect] + [section Warning C4505: '...' : unreferenced local function has been removed] Example : diff --git a/doc/mock.qbk b/doc/mock.qbk index 4915d9b..7cdd860 100644 --- a/doc/mock.qbk +++ b/doc/mock.qbk @@ -7,7 +7,8 @@ [article Turtle [quickbook 1.5] - [authors [Champlon, Mathieu]] +[/ [authors [Champlon, Mathieu]] ] + [authors [,A C++ mock object library for Boost]] [copyright 2008-2014 Mathieu Champlon] [license Distributed under the [@http://www.boost.org/LICENSE_1_0.txt Boost Software License, Version 1.0]. @@ -15,6 +16,8 @@ [/ [purpose A C++ mock object library for Boost] ] ] +[note Turtle is not an official Boost library.] + [/ [section:introduction Introduction] diff --git a/doc/reference.qbk b/doc/reference.qbk index 8d1239e..434a630 100644 --- a/doc/reference.qbk +++ b/doc/reference.qbk @@ -90,22 +90,32 @@ Synopsis : MOCK_METHOD( [calling convention] name, arity[, signature[, identifier]] ) // generates both const and non-const methods MOCK_CONST_METHOD( [calling convention] name, arity[, signature[, identifier]] ) // generates only the const version of the method MOCK_NON_CONST_METHOD( [calling convention] name, arity[, signature[, identifier]] ) // generates only the non-const version of the method + + MOCK_METHOD_TPL( [calling convention] name, arity, signature[, identifier] ) // must be used if the signature uses a template parameter of the class, generates both const and non-const methods + MOCK_CONST_METHOD_TPL( [calling convention] name, arity, signature[, identifier] ) // must be used if the signature uses a template parameter of the class, generates only the const version of the method + MOCK_NON_CONST_METHOD_TPL( [calling convention] name, arity, signature[, identifier] ) // must be used if the signature uses a template parameter of the class, generates only the non-const version of the method [note If the identifier is omitted it will default to the method name.] [note If the method name is not ambiguous both the signature and the identifier can be omitted in the context of a derived MOCK_BASE_CLASS or base_type typedef.] -[note The signature cannot be omitted if it uses a template parameter of the class, see the related [link turtle.limitations.template_base_class_methods_cannot_be_mocked_without_specifying_the_signature limitation section].] +[note The signature cannot be omitted for the _TPL familly of macros, see the related [link turtle.limitations.template_base_class_methods_cannot_be_mocked_without_specifying_the_signature limitation section].] [note [link turtle.reference.creation.constructor Constructors], [link turtle.reference.creation.destructor destructors] and [link turtle.reference.creation.conversion_operator conversion operators] require special care.] [note In case of a calling convention specified, all four parameters must be provided.] +[warning For compilers without support for variadic macros the MOCK_METHOD_EXT familly set of macros must be used.] + Synopsis : - MOCK_METHOD( [calling convention] name, arity, signature, identifier ) // generates both const and non-const methods - MOCK_CONST_METHOD( [calling convention] name, arity, signature, identifier ) // generates only the const version of the method - MOCK_NON_CONST_METHOD( [calling convention] name, arity, signature, identifier ) // generates only the non-const version of the method + MOCK_METHOD_EXT( [calling convention] name, arity, signature, identifier ) // generates both const and non-const methods + MOCK_CONST_METHOD_EXT( [calling convention] name, arity, signature, identifier ) // generates only the const version of the method + MOCK_NON_CONST_METHOD_EXT( [calling convention] name, arity, signature, identifier ) // generates only the non-const version of the method + + MOCK_METHOD_EXT_TPL( [calling convention] name, arity, signature, identifier ) // must be used if the signature uses a template parameter of the class, generates both const and non-const methods + MOCK_CONST_METHOD_EXT_TPL( [calling convention] name, arity, signature, identifier ) // must be used if the signature uses a template parameter of the class, generates only the const version of the method + MOCK_NON_CONST_METHOD_EXT_TPL( [calling convention] name, arity, signature, identifier ) // must be used if the signature uses a template parameter of the class, generates only the non-const version of the method Example : @@ -150,11 +160,15 @@ Example for gcc : Synopsis : MOCK_STATIC_METHOD( [calling convention] name, arity, signature[, identifier] ) // if 'identifier' is omitted it will default to 'name' + + MOCK_STATIC_METHOD_TPL( [calling convention] name, arity, signature[, identifier] ) // must be used if the signature uses a template parameter of the class, if 'identifier' is omitted it will default to 'name' [note A static object is used behind the scene in order to keep track of the expectations of a mock static method, therefore to ensure all tests run in isolation it is strongly suggested to manually [link turtle.reference.verification verify] and [link turtle.reference.reset reset] the static method at the end of each test, see the related [link turtle.patterns.managing_static_mock_objects pattern section].] [note In case of a calling convention specified, all four parameters must be provided.] +[warning For compilers without support for variadic macros the identifier cannot be omitted and must be given explicitly.] + Example : [static_member_function_example_1] @@ -179,6 +193,8 @@ Synopsis : MOCK_CONSTRUCTOR( [calling convention] name, arity, parameters, identifier ) + MOCK_CONSTRUCTOR_TPL( [calling convention] name, arity, parameters, identifier ) // must be used if the signature uses a template parameter of the class + [note As constructors do not have a return type, the usual signature gets restricted here to just the parameters.] Example : @@ -229,6 +245,10 @@ Synopsis : MOCK_CONST_CONVERSION_OPERATOR( [calling convention] name, type, identifier ) // generates only a const operator MOCK_NON_CONST_CONVERSION_OPERATOR( [calling convention] name, type, identifier ) // generates only a non-const operator + MOCK_CONVERSION_OPERATOR_TPL( [calling convention] name, type, identifier ) // must be used if the signature uses a template parameter of the class + MOCK_CONST_CONVERSION_OPERATOR_TPL( [calling convention] name, type, identifier ) // must be used if the signature uses a template parameter of the class + MOCK_NON_CONST_CONVERSION_OPERATOR_TPL( [calling convention] name, type, identifier ) // must be used if the signature uses a template parameter of the class + Example : [conversion_operator_example_1] @@ -257,6 +277,8 @@ Synopsis : [note In case of a calling convention specified, all four parameters must be provided.] +[warning For compilers without support for variadic macros the identifier cannot be omitted and must be given explicitly.] + Example : [function_example_1] @@ -277,6 +299,8 @@ Synopsis : MOCK_FUNCTOR( [calling convention] name, signature ); + MOCK_FUNCTOR_TPL( [calling convention] name, signature ); // must be used if the signature uses a template parameter + Example : [functor_example_1] @@ -391,13 +415,13 @@ Constraints : [[mock::evaluate] [['actual]()] [evaluates ['actual] as a functor returning a ['bool] and taking no argument]] ] -[important When passing ['expected] directly as a shortcut mock::call is implied for a callable (function, function pointer, functor, ...); mock::equal is implied for anything else.] +[important When passing ['expected] directly as a shortcut mock::call is implied for a function, a function pointer, an instance of a type with a result_type member typedef (support for standard library, [@http://www.boost.org/libs/bind/bind.html Boost.Bind], [@http://www.boost.org/libs/function Boost.Function] functors), an instance of a type with a sig member (support for [@http://www.boost.org/libs/lambda Boost.Lambda] functors), an instance of a type with a result member (support for [@http://www.boost.org/libs/phoenix Boost.Phoenix] functors); mock::equal is implied for anything else.] [warning Because mock::assign and mock::retrieve have side effects they may modify ['expected] in unexpected ways. For instance they may be called again after their expectations have already been exhausted because of the way the [link turtle.getting_started.expectation_selection_algorithm expectation selection algorithm] works. Therefore it is probably a good idea to use an [link turtle.reference.expectation.actions action] instead.] [note For mock::assign and mock::retrieve the switch to one form or another is made depending on whichever is the most relevant based on types involved.] -[note All constraints accepting a parameter support the use of std::ref and std::cref in order to delay initialization.] +[note All constraints accepting a parameter support the use of boost::ref and boost::cref in order to delay initialization.] [note All constraints can be combined using the && and || operators, as well as negated with the ! operator.] @@ -413,7 +437,7 @@ Example using a standard library functor : [constraints_example_3] -Example using std::bind : +Example using [@http://www.boost.org/libs/bind Boost.Bind] : [constraints_example_4] @@ -449,7 +473,10 @@ Synopsis : Each sequence is an instance of mock::sequence. -The maximum number of sequences that can be set is basically unlimited. +The maximum number of sequences that can be set is MOCK_MAX_SEQUENCES which defaults to 10. If needed the value can be increased before including the library : + + #define MOCK_MAX_SEQUENCES 12 + #include Example : @@ -464,13 +491,13 @@ An action performs additional treatments after an expectation has been deemed va Synopsis : MOCK_EXPECT( identifier ).returns( value ); // stored internally by copy - MOCK_EXPECT( identifier ).moves( value ); // stored internally by copy/move + MOCK_EXPECT( identifier ).moves( value ); // stored internally by copy MOCK_EXPECT( identifier ).throws( exception ); // stored internally by copy MOCK_EXPECT( identifier ).calls( functor ); // stored internally by copy, throws std::invalid_argument if empty [note The returns and moves actions are not available for mock methods returning void, including constructors and destructors.] -[note Actions are captured by copy, std::ref and std::cref can however be used to turn the copies into references.] +[note Actions are captured by copy, boost::ref and boost::cref can however be used to turn the copies into references.] Example : @@ -554,18 +581,38 @@ Synopsis : The expression manipulates a received parameter ['actual] in order to implement the constraint, as well as extra optional arguments named ['expected_1], ['expected_2], ... +For compilers without support for variadic macros the alternate following macro must be used. + +Synopsis : + + MOCK_CONSTRAINT_EXT( name, arity, ( expected_1, expected_2, ... ), expression ) // defines a constraint 'name' based on the given 'expression' + +Of course this macro is also available for compilers which support variadic macros. + Example without any extra argument : [helpers_example_1] +or with the alternate more portable macro : + +[helpers_example_4] + Example with one extra argument : [helpers_example_2] +or with the alternate more portable macro : + +[helpers_example_5] + Example with two extra arguments : [helpers_example_3] +or with the alternate more portable macro : + +[helpers_example_6] + [endsect] [endsect] diff --git a/include/turtle/catch.hpp b/include/turtle/catch.hpp index 77c753b..dd9c8ad 100644 --- a/include/turtle/catch.hpp +++ b/include/turtle/catch.hpp @@ -11,33 +11,34 @@ #include -template +template< typename Result > struct catch_mock_error_policy { static Result abort() { - FAIL("Aborted"); - throw std::runtime_error("unreachable"); + FAIL( "Aborted" ); + throw std::runtime_error( "unreachable" ); } - - template - static void fail(const char* message, - const Context& context, - const char* file = "file://unknown-location", - int line = 0) + + template< typename Context > + static void fail( const char* message, const Context& context, + const char* file = "file://unknown-location", int line = 0 ) { - CAPTURE(context); - FAIL_CHECK(message << " in: " << file << ":" << line); + CAPTURE( context ); + FAIL_CHECK( message << " in: " << file << ":" << line ); } - - template - static void call(const Context& context, const char* file, int line) + + template< typename Context > + static void call( const Context& context, const char* file, int line ) { - CAPTURE(context); - INFO(file << ":" << line); + CAPTURE( context ); + INFO( file << ":" << line ); + } + + static void pass( const char* file, int line ) + { + INFO( file << ":" << line ); } - - static void pass(const char* file, int line) { INFO(file << ":" << line); } }; #define MOCK_ERROR_POLICY catch_mock_error_policy diff --git a/include/turtle/cleanup.hpp b/include/turtle/cleanup.hpp index e2bde3d..de49559 100644 --- a/include/turtle/cleanup.hpp +++ b/include/turtle/cleanup.hpp @@ -10,25 +10,30 @@ #define MOCK_CLEANUP_HPP_INCLUDED #include "config.hpp" -#include "reset.hpp" #include "verify.hpp" +#include "reset.hpp" #ifdef MOCK_USE_BOOST_TEST -# include +#include #endif -namespace mock { -struct cleanup +namespace mock { - ~cleanup() { mock::reset(); } -}; + struct cleanup + { + ~cleanup() + { + mock::reset(); + } + }; #ifdef MOCK_USE_BOOST_TEST -BOOST_GLOBAL_FIXTURE(cleanup) -# if BOOST_VERSION >= 105900 - ; -# endif + BOOST_GLOBAL_FIXTURE( cleanup ) +#if BOOST_VERSION >= 105900 + ; +#endif #endif -} // namespace mock +} // mock + #endif // MOCK_CLEANUP_HPP_INCLUDED diff --git a/include/turtle/config.hpp b/include/turtle/config.hpp index 9395005..16b0ed5 100644 --- a/include/turtle/config.hpp +++ b/include/turtle/config.hpp @@ -1,7 +1,6 @@ // http://turtle.sourceforge.net // // Copyright Mathieu Champlon 2009 -// Copyright 2020-2025 Alexander Grund // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at @@ -13,36 +12,93 @@ #define MOCK_CONFIG_HPP_INCLUDED #include +#include +#include #ifndef MOCK_ERROR_POLICY -# define MOCK_ERROR_POLICY mock::error -# define MOCK_USE_BOOST_TEST +# define MOCK_ERROR_POLICY mock::error +# define MOCK_USE_BOOST_TEST +#endif + +#ifndef MOCK_MAX_ARGS +# define MOCK_MAX_ARGS 9 +#endif + +#ifndef MOCK_MAX_SEQUENCES +# define MOCK_MAX_SEQUENCES 10 +#endif + +#ifndef BOOST_FUNCTION_MAX_ARGS +# define BOOST_FUNCTION_MAX_ARGS MOCK_MAX_ARGS +#elif BOOST_PP_LESS(BOOST_FUNCTION_MAX_ARGS, MOCK_MAX_ARGS) +# error BOOST_FUNCTION_MAX_ARGS must be set to MOCK_MAX_ARGS or higher +#endif + +#ifndef BOOST_FT_MAX_ARITY +# define BOOST_FT_MAX_ARITY BOOST_PP_INC(MOCK_MAX_ARGS) +#elif BOOST_PP_LESS_EQUAL(BOOST_FT_MAX_ARITY, MOCK_MAX_ARGS) +# error BOOST_FT_MAX_ARITY must be set to MOCK_MAX_ARGS + 1 or higher +#endif + +#if !defined(BOOST_NO_CXX11_NULLPTR) && !defined(BOOST_NO_NULLPTR) +# ifndef MOCK_NO_NULLPTR +# define MOCK_NULLPTR +# endif +#endif + +#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_DECLTYPE) +# ifndef MOCK_NO_DECLTYPE +# define MOCK_DECLTYPE +# endif +#endif + +#if !defined(BOOST_NO_CXX11_VARIADIC_MACROS) && !defined(BOOST_NO_VARIADIC_MACROS) +# ifndef MOCK_NO_VARIADIC_MACROS +# define MOCK_VARIADIC_MACROS +# endif +#endif + +#if !defined(BOOST_NO_CXX11_SMART_PTR) && !defined(BOOST_NO_SMART_PTR) +# ifndef MOCK_NO_SMART_PTR +# define MOCK_SMART_PTR +# endif +#endif + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_RVALUE_REFERENCES) +# ifndef MOCK_NO_RVALUE_REFERENCES +# define MOCK_RVALUE_REFERENCES +# endif +#endif + +#if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL) +# ifndef MOCK_NO_HDR_FUNCTIONAL +# define MOCK_HDR_FUNCTIONAL +# endif #endif #if !defined(BOOST_NO_CXX11_HDR_MUTEX) && !defined(BOOST_NO_0X_HDR_MUTEX) -# ifndef MOCK_NO_HDR_MUTEX -# define MOCK_HDR_MUTEX -# endif +# ifndef MOCK_NO_HDR_MUTEX +# define MOCK_HDR_MUTEX +# endif #endif -#ifndef MOCK_NO_UNCAUGHT_EXCEPTIONS -# if(defined(__cpp_lib_uncaught_exceptions) && __cpp_lib_uncaught_exceptions >= 201411) || \ - (defined(_MSC_VER) && _MSC_VER >= 1900) -# define MOCK_UNCAUGHT_EXCEPTIONS -# endif +#if !defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_LAMBDAS) +# ifndef MOCK_NO_LAMBDAS +# define MOCK_LAMBDAS +# endif #endif -#if BOOST_VERSION >= 107700 -# define MOCK_CXX_VERSION BOOST_CXX_VERSION -#elif defined(_MSC_VER) -# ifdef _MSVC_LANG -# define MOCK_CXX_VERSION _MSVC_LANG -# elif defined(_HAS_CXX17) -# define MOCK_CXX_VERSION 201703L -# endif +#if !defined(BOOST_NO_AUTO_PTR) +# ifndef MOCK_NO_AUTO_PTR +# define MOCK_AUTO_PTR +# endif #endif -#ifndef MOCK_CXX_VERSION -# define MOCK_CXX_VERSION __cplusplus + +#if defined(__cpp_lib_uncaught_exceptions) || \ + defined(_MSC_VER) && (_MSC_VER >= 1900) +# ifndef MOCK_NO_UNCAUGHT_EXCEPTIONS +# define MOCK_UNCAUGHT_EXCEPTIONS +# endif #endif #endif // MOCK_CONFIG_HPP_INCLUDED diff --git a/include/turtle/constraint.hpp b/include/turtle/constraint.hpp index 2eb7cf5..25aa160 100644 --- a/include/turtle/constraint.hpp +++ b/include/turtle/constraint.hpp @@ -1,7 +1,6 @@ // http://turtle.sourceforge.net // // Copyright Mathieu Champlon 2008 -// Copyright 2020-2025 Alexander Grund // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at @@ -12,179 +11,249 @@ #include "config.hpp" #include "log.hpp" -#include "unwrap_reference.hpp" -#include +#include +#include #include -#include +#include #include #include -#include -#include -#include -#include -#include +#include +#include +#include +#include -namespace mock { -template -struct constraint +namespace mock { - constraint() {} - constraint(const Constraint& c) : c_(c) {} - Constraint c_; -}; + template< typename Constraint > + struct constraint + { + constraint() + {} + constraint( const Constraint& c ) + : c_( c ) + {} + Constraint c_; + }; -namespace detail { - template +namespace detail +{ + template< typename Lhs, typename Rhs > class and_ { public: - and_(const Lhs& lhs, const Rhs& rhs) : lhs_(lhs), rhs_(rhs) {} - template - bool operator()(const Actual& actual) const + and_( const Lhs& lhs, const Rhs& rhs ) + : lhs_( lhs ) + , rhs_( rhs ) + {} + template< typename Actual > + bool operator()( const Actual& actual ) const { - return lhs_(actual) && rhs_(actual); + return lhs_( actual ) && rhs_( actual ); } - friend std::ostream& operator<<(std::ostream& s, const and_& a) + friend std::ostream& operator<<( std::ostream& s, const and_& a ) { - return s << "( " << mock::format(a.lhs_) << " && " << mock::format(a.rhs_) << " )"; + return s << "( " << mock::format( a.lhs_ ) + << " && " << mock::format( a.rhs_ ) << " )"; } - private: Lhs lhs_; Rhs rhs_; }; - template + template< typename Lhs, typename Rhs > class or_ { public: - or_(const Lhs& lhs, const Rhs& rhs) : lhs_(lhs), rhs_(rhs) {} - template - bool operator()(const Actual& actual) const + or_( const Lhs& lhs, const Rhs& rhs ) + : lhs_( lhs ) + , rhs_( rhs ) + {} + template< typename Actual > + bool operator()( const Actual& actual ) const { - return lhs_(actual) || rhs_(actual); + return lhs_( actual ) || rhs_( actual ); } - friend std::ostream& operator<<(std::ostream& s, const or_& o) + friend std::ostream& operator<<( std::ostream& s, const or_& o ) { - return s << "( " << mock::format(o.lhs_) << " || " << mock::format(o.rhs_) << " )"; + return s << "( " << mock::format( o.lhs_ ) + << " || " << mock::format( o.rhs_ )<< " )"; } - private: Lhs lhs_; Rhs rhs_; }; - template + template< typename Constraint > class not_ { public: - explicit not_(const Constraint& c) : c_(c) {} - template - bool operator()(const Actual& actual) const + explicit not_( const Constraint& c ) + : c_( c ) + {} + template< typename Actual > + bool operator()( const Actual& actual ) const { - return !c_(actual); + return ! c_( actual ); + } + friend std::ostream& operator<<( std::ostream& s, const not_& n ) + { + return s << "! " << mock::format( n.c_ ); } - friend std::ostream& operator<<(std::ostream& s, const not_& n) { return s << "! " << mock::format(n.c_); } - private: Constraint c_; }; -} // namespace detail - -template -const constraint> operator||(const constraint& lhs, const constraint& rhs) -{ - return detail::or_(lhs.c_, rhs.c_); } -template -const constraint> operator&&(const constraint& lhs, const constraint& rhs) -{ - return detail::and_(lhs.c_, rhs.c_); -} + template< typename Lhs, typename Rhs > + const constraint< detail::or_< Lhs, Rhs > > + operator||( const constraint< Lhs >& lhs, + const constraint< Rhs >& rhs ) + { + return detail::or_< Lhs, Rhs >( lhs.c_, rhs.c_ ); + } -template -const constraint> operator!(const constraint& c) -{ - return detail::not_(c.c_); -} -} // namespace mock + template< typename Lhs, typename Rhs > + const constraint< detail::and_< Lhs, Rhs > > + operator&&( const constraint< Lhs >& lhs, + const constraint< Rhs >& rhs ) + { + return detail::and_< Lhs, Rhs >( lhs.c_, rhs.c_ ); + } -#define MOCK_UNARY_CONSTRAINT(Name, n, Args, Expr) \ - namespace detail { \ - struct Name \ - { \ - template \ - bool operator()(const Actual& actual) const \ - { \ - (void)actual; \ - return Expr; \ - } \ - friend std::ostream& operator<<(std::ostream& s, const Name&) { return s << BOOST_STRINGIZE(Name); } \ - }; \ - } \ - const mock::constraint Name; + template< typename Constraint > + const constraint< detail::not_< Constraint > > + operator!( const constraint< Constraint >& c ) + { + return detail::not_< Constraint >( c.c_ ); + } +} // mock -#define MOCK_CONSTRAINT_ASSIGN(z, n, d) expected##n(std::forward(e##n)) +#define MOCK_UNARY_CONSTRAINT(Name, n, Args, Expr) \ + namespace detail \ + { \ + struct Name \ + { \ + template< typename Actual > \ + bool operator()( const Actual& actual ) const \ + { \ + return Expr; \ + } \ + friend std::ostream& operator<<( std::ostream& s, const Name& ) \ + { \ + return s << BOOST_STRINGIZE(Name); \ + } \ + }; \ + } \ + const mock::constraint< detail::Name > Name; -#define MOCK_CONSTRAINT_UNWRAP_REF(z, n, d) mock::unwrap_ref(expected##n) +#define MOCK_CONSTRAINT_ASSIGN(z, n, d) \ + expected##n( boost::forward< T##n >(e##n) ) -#define MOCK_CONSTRAINT_FORMAT(z, n, d) BOOST_PP_IF(n, << ", " <<, ) mock::format(c.expected##n) +#define MOCK_CONSTRAINT_UNWRAP_REF(z, n, d) \ + boost::unwrap_ref( expected##n ) -#define MOCK_CONSTRAINT_MEMBER(z, n, d) Expected_##n expected##n; +#define MOCK_CONSTRAINT_FORMAT(z, n, d) \ + BOOST_PP_IF(n, << ", " <<,) mock::format( c.expected##n ) -#define MOCK_CONSTRAINT_TPL_TYPE(z, n, d) std::decay_t +#define MOCK_CONSTRAINT_MEMBER(z, n, d) \ + Expected_##n expected##n; + +#define MOCK_CONSTRAINT_TPL_TYPE(z, n, d) \ + typename boost::decay< const T##n >::type #define MOCK_CONSTRAINT_CREF_PARAM(z, n, Args) \ - const mock::unwrap_reference_t& BOOST_PP_ARRAY_ELEM(n, Args) + const typename boost::unwrap_reference< Expected_##n >::type& \ + BOOST_PP_ARRAY_ELEM(n, Args) -#define MOCK_CONSTRAINT_ARG(z, n, Args) T##n&& BOOST_PP_ARRAY_ELEM(n, Args) +#define MOCK_CONSTRAINT_ARG(z, n, Args) \ + BOOST_FWD_REF(T##n) BOOST_PP_ARRAY_ELEM(n, Args) -#define MOCK_CONSTRAINT_ARGS(z, n, Args) T##n&& e##n +#define MOCK_CONSTRAINT_ARGS(z, n, Args) \ + BOOST_FWD_REF(T##n) e##n -#define MOCK_CONSTRAINT_PARAM(z, n, Args) std::forward(BOOST_PP_ARRAY_ELEM(n, Args)) +#define MOCK_CONSTRAINT_PARAM(z, n, Args) \ + boost::forward< T##n >( BOOST_PP_ARRAY_ELEM(n, Args) ) -#define MOCK_NARY_CONSTRAINT(Name, n, Args, Expr) \ - namespace detail { \ - template \ - struct Name \ - { \ - template \ - explicit Name(BOOST_PP_ENUM(n, MOCK_CONSTRAINT_ARGS, _)) : BOOST_PP_ENUM(n, MOCK_CONSTRAINT_ASSIGN, _) \ - {} \ - template \ - bool operator()(const Actual& actual) const \ - { \ - return test(actual, BOOST_PP_ENUM(n, MOCK_CONSTRAINT_UNWRAP_REF, _)); \ - } \ - template \ - bool test(const Actual& actual, BOOST_PP_ENUM(n, MOCK_CONSTRAINT_CREF_PARAM, (n, Args))) const \ - { \ - return Expr; \ - } \ - friend std::ostream& operator<<(std::ostream& s, const Name& c) \ - { \ - return s << BOOST_STRINGIZE(Name) << "( " << BOOST_PP_REPEAT(n, MOCK_CONSTRAINT_FORMAT, _) << " )"; \ - } \ - BOOST_PP_REPEAT(n, MOCK_CONSTRAINT_MEMBER, _) \ - }; \ - } \ - template \ - mock::constraint> Name( \ - BOOST_PP_ENUM(n, MOCK_CONSTRAINT_ARG, (n, Args))) \ - { \ - return detail::Name( \ - BOOST_PP_ENUM(n, MOCK_CONSTRAINT_PARAM, (n, Args))); \ +#define MOCK_NARY_CONSTRAINT(Name, n, Args, Expr) \ + namespace detail \ + { \ + template< BOOST_PP_ENUM_PARAMS(n, typename Expected_) > \ + struct Name \ + { \ + template< BOOST_PP_ENUM_PARAMS(n, typename T) > \ + explicit Name( \ + BOOST_PP_ENUM(n, MOCK_CONSTRAINT_ARGS, _) ) \ + : BOOST_PP_ENUM(n, MOCK_CONSTRAINT_ASSIGN, _) \ + {} \ + template< typename Actual > \ + bool operator()( const Actual& actual ) const \ + { \ + return test( actual, \ + BOOST_PP_ENUM(n, MOCK_CONSTRAINT_UNWRAP_REF, _) ); \ + } \ + template< typename Actual > \ + bool test( const Actual& actual, \ + BOOST_PP_ENUM(n, \ + MOCK_CONSTRAINT_CREF_PARAM, (n, Args)) ) const \ + { \ + return Expr; \ + } \ + friend std::ostream& operator<<( std::ostream& s, const Name& c ) \ + { \ + return s << BOOST_STRINGIZE(Name) << "( " \ + << BOOST_PP_REPEAT(n, MOCK_CONSTRAINT_FORMAT, _) \ + << " )"; \ + } \ + BOOST_PP_REPEAT(n, MOCK_CONSTRAINT_MEMBER, _) \ + }; \ + } \ + template< BOOST_PP_ENUM_PARAMS(n, typename T) > \ + mock::constraint< \ + detail::Name< BOOST_PP_ENUM(n, MOCK_CONSTRAINT_TPL_TYPE, _) > \ + > Name( BOOST_PP_ENUM(n, MOCK_CONSTRAINT_ARG, (n, Args)) ) \ + { \ + return detail::Name< BOOST_PP_ENUM(n, MOCK_CONSTRAINT_TPL_TYPE, _) >( \ + BOOST_PP_ENUM(n, MOCK_CONSTRAINT_PARAM, (n, Args)) ); \ } #define MOCK_CONSTRAINT_EXT(Name, n, Args, Expr) \ - BOOST_PP_IF(n, MOCK_NARY_CONSTRAINT, MOCK_UNARY_CONSTRAINT)(Name, n, Args, Expr) + BOOST_PP_IF(n, \ + MOCK_NARY_CONSTRAINT, \ + MOCK_UNARY_CONSTRAINT)(Name, n, Args, Expr) + +#ifdef MOCK_VARIADIC_MACROS + +#if BOOST_MSVC +# define MOCK_VARIADIC_SIZE(...) \ + BOOST_PP_CAT(MOCK_VARIADIC_SIZE_I(__VA_ARGS__, \ + 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, \ + 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, \ + 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,),) +#else // BOOST_MSVC +# define MOCK_VARIADIC_SIZE(...) \ + MOCK_VARIADIC_SIZE_I(__VA_ARGS__, \ + 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, \ + 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, \ + 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,) +#endif // BOOST_MSVC +#define MOCK_VARIADIC_SIZE_I( \ + e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, \ + e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, \ + e25, e26, e27, e28, e29, e30, e31, size, ...) size #define MOCK_CONSTRAINT_AUX_AUX(Name, n, Array) \ - MOCK_CONSTRAINT_EXT(Name, n, BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_POP_BACK(Array)), BOOST_PP_ARRAY_ELEM(n, Array)) + MOCK_CONSTRAINT_EXT( \ + Name, n, \ + BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_POP_BACK(Array)), \ + BOOST_PP_ARRAY_ELEM(n, Array)) -#define MOCK_CONSTRAINT_AUX(Name, Size, Tuple) MOCK_CONSTRAINT_AUX_AUX(Name, BOOST_PP_DEC(Size), (Size, Tuple)) +#define MOCK_CONSTRAINT_AUX(Name, Size, Tuple) \ + MOCK_CONSTRAINT_AUX_AUX(Name, BOOST_PP_DEC(Size), (Size,Tuple)) -#define MOCK_CONSTRAINT(Name, ...) MOCK_CONSTRAINT_AUX(Name, BOOST_PP_VARIADIC_SIZE(__VA_ARGS__), (__VA_ARGS__)) +#define MOCK_CONSTRAINT(Name, ...) \ + MOCK_CONSTRAINT_AUX( \ + Name, MOCK_VARIADIC_SIZE(__VA_ARGS__), (__VA_ARGS__)) + +#endif // MOCK_VARIADIC_MACROS #endif // MOCK_CONSTRAINT_HPP_INCLUDED diff --git a/include/turtle/constraints.hpp b/include/turtle/constraints.hpp index 572b7d9..a24ee04 100644 --- a/include/turtle/constraints.hpp +++ b/include/turtle/constraints.hpp @@ -11,243 +11,298 @@ #include "config.hpp" #include "constraint.hpp" -#include "detail/void_t.hpp" -#include "unwrap_reference.hpp" +#include "detail/addressof.hpp" +#include "detail/move_helper.hpp" +#include #include -#if BOOST_VERSION >= 107000 -# include -#else -# include -#endif -#include -#include -#include +#include +#include +#include +#include +#include -namespace mock { -MOCK_UNARY_CONSTRAINT(any, 0, , ((void)actual, true)) -MOCK_UNARY_CONSTRAINT(affirm, 0, , !!actual) -MOCK_UNARY_CONSTRAINT(negate, 0, , !actual) -MOCK_UNARY_CONSTRAINT(evaluate, 0, , actual()) +namespace mock +{ + MOCK_UNARY_CONSTRAINT( any, 0,, ((void)actual, true) ) + MOCK_UNARY_CONSTRAINT( affirm, 0,, !! actual ) + MOCK_UNARY_CONSTRAINT( negate, 0,, ! actual ) + MOCK_UNARY_CONSTRAINT( evaluate, 0,, actual() ) -MOCK_NARY_CONSTRAINT(less, 1, (expected), actual < expected) -MOCK_NARY_CONSTRAINT(greater, 1, (expected), actual > expected) -MOCK_NARY_CONSTRAINT(less_equal, 1, (expected), actual <= expected) -MOCK_NARY_CONSTRAINT(greater_equal, 1, (expected), actual >= expected) + MOCK_NARY_CONSTRAINT( less, 1, ( expected ), actual < expected ) + MOCK_NARY_CONSTRAINT( greater, 1, ( expected ), actual > expected ) + MOCK_NARY_CONSTRAINT( less_equal, 1, ( expected ), actual <= expected ) + MOCK_NARY_CONSTRAINT( greater_equal, 1, ( expected ), actual >= expected ) #if BOOST_VERSION < 105900 -# define MOCK_SMALL() boost::test_tools::check_is_small(actual, tolerance) -# define MOCK_PERCENT_TOLERANCE() \ - boost::test_tools::check_is_close(actual, expected, boost::test_tools::percent_tolerance(tolerance)) -# define MOCK_FRACTION_TOLERANCE() \ - boost::test_tools::check_is_close(actual, expected, boost::test_tools::fraction_tolerance(tolerance)) +# define MOCK_SMALL() \ + boost::test_tools::check_is_small( actual, tolerance ) +# define MOCK_PERCENT_TOLERANCE() \ + boost::test_tools::check_is_close( \ + actual, \ + expected, \ + boost::test_tools::percent_tolerance( tolerance ) ) +# define MOCK_FRACTION_TOLERANCE() \ + boost::test_tools::check_is_close( \ + actual, \ + expected, \ + boost::test_tools::fraction_tolerance( tolerance ) ) #else // BOOST_VERSION < 105900 -namespace detail { - template - bool is_small(const T& t, const Tolerance& tolerance) +namespace detail +{ + template< typename T, typename Tolerance > + bool is_small( const T& t, const Tolerance& tolerance ) { - return boost::math::fpc::small_with_tolerance(tolerance)(t); + return boost::math::fpc::small_with_tolerance< T >( tolerance )( t ); } - template - bool is_close(const T1& t1, const T2& t2, const Tolerance& tolerance) + template< typename T1, typename T2, typename Tolerance > + bool is_close( const T1& t1, const T2& t2, const Tolerance& tolerance ) { - typedef std::common_type_t common_type; - return boost::math::fpc::close_at_tolerance(tolerance, boost::math::fpc::FPC_STRONG)(t1, t2); + typedef typename boost::common_type< T1, T2 >::type common_type; + return boost::math::fpc::close_at_tolerance< common_type >( + tolerance, boost::math::fpc::FPC_STRONG )( t1, t2 ); } -} // namespace detail +} -# define MOCK_SMALL() detail::is_small(actual, tolerance) -# define MOCK_PERCENT_TOLERANCE() detail::is_close(actual, expected, boost::math::fpc::percent_tolerance(tolerance)) -# define MOCK_FRACTION_TOLERANCE() detail::is_close(actual, expected, tolerance) +# define MOCK_SMALL() \ + detail::is_small( actual, tolerance ) +# define MOCK_PERCENT_TOLERANCE() \ + detail::is_close( actual, expected, \ + boost::math::fpc::percent_tolerance( tolerance ) ) +# define MOCK_FRACTION_TOLERANCE() \ + detail::is_close( actual, expected, tolerance ) #endif // BOOST_VERSION < 105900 #ifdef small -# pragma push_macro("small") -# undef small -# define MOCK_SMALL_DEFINED +# pragma push_macro( "small" ) +# undef small +# define MOCK_SMALL_DEFINED #endif -MOCK_NARY_CONSTRAINT(small, 1, (tolerance), (MOCK_SMALL())) + MOCK_NARY_CONSTRAINT( small, 1, ( tolerance ), + ( MOCK_SMALL() ) ) #ifdef MOCK_SMALL_DEFINED -# pragma pop_macro("small") +# pragma pop_macro( "small" ) #endif -MOCK_NARY_CONSTRAINT(close, 2, (expected, tolerance), (MOCK_PERCENT_TOLERANCE())) + MOCK_NARY_CONSTRAINT( close, 2, ( expected, tolerance ), + ( MOCK_PERCENT_TOLERANCE() ) ) -MOCK_NARY_CONSTRAINT(close_fraction, 2, (expected, tolerance), (MOCK_FRACTION_TOLERANCE())) + MOCK_NARY_CONSTRAINT( close_fraction, 2, ( expected, tolerance ), + ( MOCK_FRACTION_TOLERANCE() ) ) #undef MOCK_PERCENT_TOLERANCE #undef MOCK_FRACTION_TOLERANCE #ifdef near -# pragma push_macro("near") -# undef near -# define MOCK_NEAR_DEFINED +# pragma push_macro( "near" ) +# undef near +# define MOCK_NEAR_DEFINED #endif -MOCK_NARY_CONSTRAINT(near, 2, (expected, tolerance), std::abs(actual - expected) <= tolerance) + MOCK_NARY_CONSTRAINT( near, 2, ( expected, tolerance ), + std::abs( actual - expected ) < tolerance ) #ifdef MOCK_NEAR_DEFINED -# pragma pop_macro("near") +# pragma pop_macro( "near" ) #endif -namespace detail { - template - struct has_equal_to : std::false_type - {}; - - template - struct has_equal_to() == std::declval())>> : std::true_type - {}; - - template +namespace detail +{ + template< typename Expected > struct equal { - explicit equal(Expected expected) : expected_(expected) {} - template - bool operator()(const Actual& actual, - std::enable_if_t>::value>* = 0) const + explicit equal( Expected expected ) + : expected_( expected ) + {} + template< typename Actual > + bool operator()( const Actual& actual, + typename boost::enable_if< + boost::has_equal_to< + Actual, + typename + boost::unwrap_reference< Expected >::type + > + >::type* = 0 ) const { - return actual == unwrap_ref(expected_); + return actual == boost::unwrap_ref( expected_ ); } - template - bool operator()(const Actual& actual, - std::enable_if_t>::value>* = 0) const + template< typename Actual > + bool operator()( const Actual& actual, + typename boost::disable_if< + boost::has_equal_to< + Actual, + typename + boost::unwrap_reference< Expected >::type + > + >::type* = 0 ) const { - return actual && *actual == unwrap_ref(expected_); + return actual && *actual == boost::unwrap_ref( expected_ ); } - friend std::ostream& operator<<(std::ostream& s, const equal& e) + friend std::ostream& operator<<( std::ostream& s, const equal& e ) { - return s << "equal( " << mock::format(e.expected_) << " )"; + return s << "equal( " << mock::format( e.expected_ ) << " )"; } Expected expected_; }; - template + template< typename Expected > struct same { - explicit same(const Expected& expected) : expected_(std::addressof(unwrap_ref(expected))) {} - template - bool operator()(const Actual& actual) const + explicit same( const Expected& expected ) + : expected_( detail::addressof( boost::unwrap_ref( expected ) ) ) + {} + template< typename Actual > + bool operator()( const Actual& actual ) const { - return std::addressof(actual) == expected_; + return detail::addressof( actual ) == expected_; } - friend std::ostream& operator<<(std::ostream& os, const same& s) + friend std::ostream& operator<<( std::ostream& os, const same& s ) { - return os << "same( " << mock::format(*s.expected_) << " )"; + return os << "same( " << mock::format( *s.expected_ ) << " )"; } - const unwrap_reference_t* expected_; + const typename + boost::unwrap_reference< Expected >::type* expected_; }; - template + template< typename Expected > struct retrieve { - explicit retrieve(Expected& expected) : expected_(std::addressof(unwrap_ref(expected))) {} - template - bool operator()( - const Actual& actual, - std::enable_if_t>::value>* = 0) const + explicit retrieve( Expected& expected ) + : expected_( detail::addressof( boost::unwrap_ref( expected ) ) ) + {} + template< typename Actual > + bool operator()( const Actual& actual, + typename boost::disable_if< + boost::is_convertible< + const Actual*, + typename + boost::unwrap_reference< Expected >::type + > + >::type* = 0 ) const { *expected_ = actual; return true; } - template - bool operator()( - Actual&& actual, - std::enable_if_t>::value>* = 0) const + template< typename Actual > + bool operator()( BOOST_RV_REF(Actual) actual, + typename boost::disable_if< + boost::is_convertible< + const Actual*, + typename + boost::unwrap_reference< Expected >::type + > + >::type* = 0 ) const { - *expected_ = std::move(actual); + *expected_ = boost::move( actual ); return true; } - template - bool operator()(Actual& actual, - std::enable_if_t>::value>* = 0) const + template< typename Actual > + bool operator()( Actual& actual, + typename boost::enable_if< + boost::is_convertible< Actual*, + typename + boost::unwrap_reference< Expected >::type + > + >::type* = 0 ) const { - *expected_ = std::addressof(actual); + *expected_ = detail::addressof( actual ); return true; } - friend std::ostream& operator<<(std::ostream& s, const retrieve& r) + friend std::ostream& operator<<( std::ostream& s, const retrieve& r ) { - return s << "retrieve( " << mock::format(*r.expected_) << " )"; + return s << "retrieve( " << mock::format( *r.expected_ ) << " )"; } - unwrap_reference_t* expected_; + typename + boost::unwrap_reference< Expected >::type* expected_; }; - template + template< typename Expected > struct assign { - explicit assign(const Expected& expected) : expected_(expected) {} - template - bool operator()(Actual& actual) const + explicit assign( const Expected& expected ) + : expected_( expected ) + {} + template< typename Actual > + bool operator()( Actual& actual ) const { - actual = unwrap_ref(expected_); + actual = boost::unwrap_ref( expected_ ); return true; } - template - bool operator()(Actual* actual, - std::enable_if_t, Actual>::value>* = 0) const + template< typename Actual > + bool operator()( Actual* actual, + typename boost::enable_if< + boost::is_convertible< + typename + boost::unwrap_reference< Expected >::type, + Actual + > + >::type* = 0 ) const { - if(!actual) + if( ! actual ) return false; - *actual = unwrap_ref(expected_); + *actual = boost::unwrap_ref( expected_ ); return true; } - friend std::ostream& operator<<(std::ostream& s, const assign& a) + friend std::ostream& operator<<( std::ostream& s, const assign& a ) { - return s << "assign( " << mock::format(a.expected_) << " )"; + return s << "assign( " << mock::format( a.expected_ ) << " )"; } Expected expected_; }; - template + template< typename Expected > struct contain { - explicit contain(const Expected& expected) : expected_(expected) {} - bool operator()(const std::string& actual) const + explicit contain( const Expected& expected ) + : expected_( expected ) + {} + bool operator()( const std::string& actual ) const { - return actual.find(unwrap_ref(expected_)) != std::string::npos; + return actual.find( boost::unwrap_ref( expected_ ) ) + != std::string::npos; } - friend std::ostream& operator<<(std::ostream& s, const contain& n) + friend std::ostream& operator<<( std::ostream& s, const contain& n ) { - return s << "contain( " << mock::format(n.expected_) << " )"; + return s << "contain( " << mock::format( n.expected_ ) << " )"; } Expected expected_; }; -} // namespace detail - -template -constraint> equal(T&& t) -{ - return detail::equal(std::forward(t)); } -template -constraint> same(T& t) -{ - return detail::same(t); -} -template -constraint> retrieve(T& t) -{ - return detail::retrieve(t); -} -template -constraint> assign(T t) -{ - return detail::assign(t); -} -template -constraint> contain(T t) -{ - return detail::contain(t); -} + template< typename T > + constraint< detail::equal< typename detail::forward_type< T >::type > > equal( BOOST_FWD_REF(T) t ) + { + return detail::equal< typename detail::forward_type< T >::type >( boost::forward< T >( t ) ); + } -template -constraint call(T t) -{ - return constraint(t); -} -} // namespace mock + template< typename T > + constraint< detail::same< T > > same( T& t ) + { + return detail::same< T >( t ); + } + template< typename T > + constraint< detail::retrieve< T > > retrieve( T& t ) + { + return detail::retrieve< T >( t ); + } + template< typename T > + constraint< detail::assign< T > > assign( T t ) + { + return detail::assign< T >( t ); + } + template< typename T > + constraint< detail::contain< T > > contain( T t ) + { + return detail::contain< T >( t ); + } + + template< typename T > + constraint< T > call( T t ) + { + return constraint< T >( t ); + } +} // mock #endif // MOCK_CONSTRAINTS_HPP_INCLUDED diff --git a/include/turtle/detail/action.hpp b/include/turtle/detail/action.hpp index 8b267e5..a146130 100644 --- a/include/turtle/detail/action.hpp +++ b/include/turtle/detail/action.hpp @@ -10,128 +10,217 @@ #define MOCK_ACTION_HPP_INCLUDED #include "../config.hpp" -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include +#include -namespace mock { namespace detail { - template +namespace mock +{ +namespace detail +{ + template< typename Result, typename Signature > class action_base { private: - typedef std::function functor_type; - typedef std::function action_type; - - protected: - // Meant to be subclassed and not be directly used - // Non-relocatable (contained functions may wrap references/pointers which could be invalidated) - action_base() = default; - action_base(const action_base&) = delete; - action_base(action_base&&) = delete; - action_base& operator=(const action_base&) = delete; - action_base& operator=(action_base&&) = delete; +#ifdef MOCK_HDR_FUNCTIONAL + typedef std::function< Signature > functor_type; + typedef std::function< Result() > action_type; +#else + typedef boost::function< Signature > functor_type; + typedef boost::function< Result() > action_type; +#endif public: - const functor_type& functor() const { return f_; } - bool valid() const { return f_ || a_; } - Result trigger() const { return a_(); } - - void calls(const functor_type& f) + const functor_type& functor() const { - if(!f) - throw std::invalid_argument("null functor"); + return f_; + } + bool valid() const + { + return f_ || a_; + } + Result trigger() const + { + return a_(); + } + + void calls( const functor_type& f ) + { + if( ! f ) + throw std::invalid_argument( "null functor" ); f_ = f; } - template - void throws(Exception e) + template< typename Exception > + void throws( Exception e ) { - a_ = [e]() -> Result { throw e; }; + a_ = boost::bind( &do_throw< Exception >, e ); } protected: - void set(const action_type& a) { a_ = a; } - template - void set(const std::reference_wrapper& r) + void set( const action_type& a ) { - a_ = [r]() -> Result { return r.get(); }; + a_ = a; + } + template< typename Y > + void set( const boost::reference_wrapper< Y >& r ) + { + a_ = boost::bind( &do_ref< Y >, r.get_pointer() ); } private: + template< typename T > + static T& do_ref( T* t ) + { + return *t; + } + template< typename T > + static Result do_throw( T t ) + { + throw t; + } + functor_type f_; action_type a_; }; - /// Type erased value storage - struct value - { - value() = default; - value(const value&) = delete; - value& operator=(const value&) = delete; - virtual ~value() = default; - }; - /// Actual value storage, - /// holds an instance of T (stripped of reference qualifiers) - template - struct value_imp : value - { - using type = std::remove_const_t>; - - template - value_imp(U&& t) : t_(std::forward(t)) - {} - type t_; - }; - - template - class action : public action_base + template< typename Result, typename Signature > + class action : public action_base< Result, Signature > { public: - template - void returns(const Value& v) + template< typename Value > + void returns( const Value& v ) { - this->set(std::ref(store(v))); + this->set( boost::ref( store( v ) ) ); } - template - void returns(const std::reference_wrapper& r) + template< typename Y > + void returns( const boost::reference_wrapper< Y >& r ) { - this->set(r); + this->set( r ); } - template - void moves(Value&& v) + template< typename Value > + void moves( BOOST_RV_REF(Value) v ) { - auto vRef = std::ref(store(std::move(v))); - this->set([vRef]() { return std::move(vRef.get()); }); + this->set( + boost::bind( + &move< typename boost::remove_reference< Value >::type >, + boost::ref( store( boost::move( v ) ) ) ) ); } private: - template - typename value_imp::type& store(T&& t) + template< typename Value > + static BOOST_RV_REF(Value) move( Value& t ) { - v_ = std::make_unique>(std::forward(t)); - return static_cast&>(*v_).t_; + return boost::move( t ); } - template - std::remove_reference_t& store(T* t) + struct value : boost::noncopyable { - v_ = std::make_unique>(t); - return static_cast&>(*v_).t_; + virtual ~value() + {} + }; + template< typename T > + struct value_imp : value + { + typedef + typename boost::remove_const< + typename boost::remove_reference< + T + >::type + >::type value_type; + + value_imp( BOOST_RV_REF(value_type) t ) + : t_( boost::move( t ) ) + {} + value_imp( const value_type& t ) + : t_( t ) + {} + template< typename Y > + value_imp( Y* y ) + : t_( y ) + {} + value_type t_; + }; + + template< typename T > + T& store( BOOST_RV_REF(T) t ) + { + v_.reset( new value_imp< T >( boost::move( t ) ) ); + return static_cast< value_imp< T >& >( *v_ ).t_; + } + template< typename T > + T& store( const T& t ) + { + v_.reset( new value_imp< T >( t ) ); + return static_cast< value_imp< T >& >( *v_ ).t_; + } + template< typename T > + typename boost::remove_reference< Result >::type& store( T* t ) + { + v_.reset( new value_imp< Result >( t ) ); + return static_cast< value_imp< Result >& >( *v_ ).t_; } - std::unique_ptr v_; + boost::shared_ptr< value > v_; }; - template - class action : public action_base + template< typename Signature > + class action< void, Signature > : public action_base< void, Signature > { public: action() { - this->set([]() {}); + this->set( boost::bind( &do_nothing ) ); } + + private: + static void do_nothing() + {} }; -}} // namespace mock::detail +#ifdef MOCK_AUTO_PTR + template< typename Result, typename Signature > + class action< std::auto_ptr< Result >, Signature > + : public action_base< std::auto_ptr< Result >, Signature > + { + public: + action() + {} + action( const action& rhs ) + : v_( rhs.v_.release() ) + { + if( v_.get() ) + returns( boost::ref( v_ ) ); + } + + template< typename Y > + void returns( Y* r ) + { + v_.reset( r ); + this->set( boost::ref( v_ ) ); + } + template< typename Y > + void returns( std::auto_ptr< Y > r ) + { + v_ = r; + this->set( boost::ref( v_ ) ); + } + template< typename Y > + void returns( const boost::reference_wrapper< Y >& r ) + { + this->set( r ); + } + + private: + mutable std::auto_ptr< Result > v_; + }; +#endif // MOCK_AUTO_PTR +} +} // mock #endif // MOCK_ACTION_HPP_INCLUDED diff --git a/include/turtle/detail/addressof.hpp b/include/turtle/detail/addressof.hpp new file mode 100644 index 0000000..4e48a8d --- /dev/null +++ b/include/turtle/detail/addressof.hpp @@ -0,0 +1,36 @@ +// http://turtle.sourceforge.net +// +// Copyright Mathieu Champlon 2013 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef MOCK_ADDRESSOF_HPP_INCLUDED +#define MOCK_ADDRESSOF_HPP_INCLUDED + +#include "../config.hpp" +#include + +namespace mock +{ +namespace detail +{ + using boost::addressof; + +#ifdef MOCK_NULLPTR + + inline const std::nullptr_t* addressof( const std::nullptr_t& p ) + { + return &p; + } + inline std::nullptr_t* addressof( std::nullptr_t& p ) + { + return &p; + } + +#endif +} +} // mock + +#endif // MOCK_ADDRESSOF_HPP_INCLUDED diff --git a/include/turtle/detail/child.hpp b/include/turtle/detail/child.hpp index a5621fb..992d397 100644 --- a/include/turtle/detail/child.hpp +++ b/include/turtle/detail/child.hpp @@ -10,38 +10,43 @@ #define MOCK_CHILD_HPP_INCLUDED #include "../config.hpp" -#include "parent.hpp" #include "type_name.hpp" -#include +#include "parent.hpp" #include +#include #include -namespace mock { namespace detail { +namespace mock +{ +namespace detail +{ class child { public: - child() : parent_(0) {} - void update(parent& p, - boost::unit_test::const_string instance, - boost::optional type, - boost::unit_test::const_string name) + child() + : parent_( 0 ) + {} + void update( parent& p, + boost::unit_test::const_string instance, + boost::optional< type_name > type, + boost::unit_test::const_string name ) { - if(instance != "?." || name_.empty()) - p = parent(instance, type); + if( instance != "?." || name_.empty() ) + p = parent( instance, type ); parent_ = &p; name_ = name; } - friend std::ostream& operator<<(std::ostream& s, const child& c) + friend std::ostream& operator<<( std::ostream& s, const child& c ) { - if(c.parent_) + if( c.parent_ ) s << *c.parent_; return s << c.name_; } - private: const parent* parent_; boost::unit_test::const_string name_; }; -}} // namespace mock::detail +} +} // mock #endif // MOCK_CHILD_HPP_INCLUDED diff --git a/include/turtle/detail/context.hpp b/include/turtle/detail/context.hpp index 28fc98c..9b275a3 100644 --- a/include/turtle/detail/context.hpp +++ b/include/turtle/detail/context.hpp @@ -11,32 +11,34 @@ #include "../config.hpp" #include "type_name.hpp" +#include #include #include #include -namespace mock { namespace detail { +namespace mock +{ +namespace detail +{ class verifiable; - class context + class context : boost::noncopyable { public: - context() = default; - context(const context&) = delete; - context& operator=(const context&) = delete; + context() {} + virtual ~context() {} - virtual ~context() = default; + virtual void add( const void* p, verifiable& v, + boost::unit_test::const_string instance, + boost::optional< type_name > type, + boost::unit_test::const_string name ) = 0; + virtual void add( verifiable& v ) = 0; + virtual void remove( verifiable& v ) = 0; - virtual void add(const void* p, - verifiable& v, - boost::unit_test::const_string instance, - boost::optional type, - boost::unit_test::const_string name) = 0; - virtual void add(verifiable& v) = 0; - virtual void remove(verifiable& v) = 0; - - virtual void serialize(std::ostream& s, const verifiable& v) const = 0; + virtual void serialize( std::ostream& s, + const verifiable& v ) const = 0; }; -}} // namespace mock::detail +} +} // mock #endif // MOCK_CONTEXT_HPP_INCLUDED diff --git a/include/turtle/detail/expectation.hpp b/include/turtle/detail/expectation.hpp deleted file mode 100644 index d4e477a..0000000 --- a/include/turtle/detail/expectation.hpp +++ /dev/null @@ -1,183 +0,0 @@ -// http://turtle.sourceforge.net -// -// Copyright Mathieu Champlon 2012 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#ifndef MOCK_EXPECTATION_HPP_INCLUDED -#define MOCK_EXPECTATION_HPP_INCLUDED - -#include "../matcher.hpp" -#include "../sequence.hpp" -#include "action.hpp" -#include "invocation.hpp" -#include "matcher_base.hpp" -#include -#include -#include -#include - -namespace mock { namespace detail { - template - class default_matcher : public matcher_base - { - private: - bool operator()(ref_arg_t...) override { return true; } - void serialize(std::ostream& s) const override - { - constexpr auto arity = sizeof...(Args); - for(unsigned i = 0; i < arity; ++i) - { - if(i) - s << ", "; - s << "any"; - } - } - }; - - template - class single_matcher; - - template - class single_matcher : public matcher_base - { - static_assert(sizeof...(Args) > 0, "This class is only useful for functions with arguments"); - static_assert(sizeof...(Constraints) == sizeof...(Args), "Need exactly 1 constraint per argument"); - - public: - single_matcher(Constraints... constraints) : matchers_(matcher(constraints)...) {} - - private: - template - bool is_valid_impl(std::index_sequence, ref_arg_t... t) - { - using expander = bool[]; - bool result = true; - (void)expander{ result &= std::get(matchers_)(static_cast>(t))... }; - return result; - } - bool operator()(ref_arg_t... t) override - { - return is_valid_impl(std::make_index_sequence{}, static_cast>(t)...); - } - template - void serialize_impl(std::index_sequence, std::ostream& s) const - { - using expander = int[]; - s << std::get<0>(matchers_); - (void)expander{ 0, (s << ", " << std::get(matchers_), 0)... }; - } - void serialize(std::ostream& s) const override - { - serialize_impl(std::make_index_sequence{}, s); - } - - private: - std::tuple...> matchers_; - }; - - template - class multi_matcher : public matcher_base - { - static_assert(sizeof...(Args) > 0, "This class is only useful for functions with arguments"); - - public: - multi_matcher(const F& f) : f_(f) {} - - private: - bool operator()(ref_arg_t... t) override { return f_(static_cast>(t)...); } - void serialize(std::ostream& s) const override { s << mock::format(f_); } - - private: - F f_; - }; - - template - class expectation; - - template - class expectation : public action - { - static constexpr std::size_t arity = sizeof...(Args); - - public: - expectation() : expectation("unknown location", 0) {} - expectation(const char* file, int line) - : invocation_(std::make_unique()), matcher_(std::make_unique>()), - file_(file), line_(line) - {} - - expectation(expectation&&) = default; - expectation(expectation const&) = default; - expectation& operator=(expectation&&) = default; - expectation& operator=(expectation const&) = default; - - ~expectation() - { - for(auto& sequence : sequences_) - sequence->remove(this); - } - - void invoke(std::unique_ptr i) { invocation_ = std::move(i); } - - template - std::enable_if_t<(arity > 0u) && sizeof...(Constraints) == arity> with(Constraints... c) - { - matcher_ = std::make_unique>(c...); - } - template - std::enable_if_t<(Arity > 1u)> with(const Constraint& c) - { - matcher_ = std::make_unique>(c); - } - - void add(sequence& s) - { - s.impl_->add(this); - sequences_.push_back(s.impl_); - } - - bool verify() const { return invocation_->verify(); } - - bool is_valid(ref_arg_t... t) const - { - return !invocation_->exhausted() && (*matcher_)(static_cast>(t)...); - } - - bool invoke() const - { - for(auto& sequence : sequences_) - { - if(!sequence->is_valid(this)) - return false; - } - bool result = invocation_->invoke(); - for(auto& sequence : sequences_) - sequence->invalidate(this); - return result; - } - - const char* file() const { return file_; } - int line() const { return line_; } - - friend std::ostream& operator<<(std::ostream& s, const expectation& e) - { - s << (e.invocation_->exhausted() ? 'v' : '.') << ' ' << *e.invocation_; - constexpr bool hasArguments = arity > 0u; - if(hasArguments) - s << ".with( " << *e.matcher_ << " )"; - return s; - } - - private: - std::unique_ptr invocation_; - std::unique_ptr> matcher_; - std::vector> sequences_; - const char* file_; - int line_; - }; -}} // namespace mock::detail - -#endif // MOCK_EXPECTATION_HPP_INCLUDED diff --git a/include/turtle/detail/expectation_template.hpp b/include/turtle/detail/expectation_template.hpp new file mode 100644 index 0000000..030a062 --- /dev/null +++ b/include/turtle/detail/expectation_template.hpp @@ -0,0 +1,272 @@ +// http://turtle.sourceforge.net +// +// Copyright Mathieu Champlon 2012 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "matcher_base_template.hpp" + +#define MOCK_EXPECTATION_INITIALIZE(z, n, d) \ + BOOST_PP_COMMA_IF(n) c##n##_( c##n ) + +#define MOCK_EXPECTATION_MEMBER(z, n, d) \ + matcher< T##n, Constraint_##n > c##n##_; + +#define MOCK_EXPECTATION_IS_VALID(z, n, d) \ + BOOST_PP_IF(n, &&,) c##n##_( mock::detail::move_if_not_lvalue_reference< T##n >( a##n ) ) + +#define MOCK_EXPECTATION_SERIALIZE(z, n, d) \ + BOOST_PP_IF(n, << ", " <<,) c##n##_ + +#define MOCK_EXPECTATION_SERIALIZE_ANY(z, n, d) \ + BOOST_PP_IF(n, << ", " <<,) "any" + +#define MOCK_EXPECTATION_PARAM(z, n, Args) \ + mock::detail::move_if_not_lvalue_reference< T##n >( a##n ) + +#define MOCK_REF_ARG(z, n, d) \ + typename ref_arg< T##n >::type a##n + +namespace mock +{ +namespace detail +{ + template< typename Signature > class default_matcher; + + template< + BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename T) > + class default_matcher< void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) > + : public matcher_base< void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) > + { + private: + virtual bool operator()( + BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG, _) ) + { + return true; + } + virtual void serialize( std::ostream& s ) const + { + s << "" BOOST_PP_REPEAT(MOCK_NUM_ARGS, + MOCK_EXPECTATION_SERIALIZE_ANY, _); + } + }; + +#ifndef MOCK_NUM_ARGS_0 + + template< typename Constraint, typename Signature > class single_matcher; + + template< + BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename Constraint_), + BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename T) + > + class single_matcher< + void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, Constraint_) ), + void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) + > + : public matcher_base< void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) > + { + public: + single_matcher( + BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, Constraint_, c) ) + : BOOST_PP_REPEAT(MOCK_NUM_ARGS, + MOCK_EXPECTATION_INITIALIZE, _) + {} + + private: + virtual bool operator()( + BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG, _) ) + { + return BOOST_PP_REPEAT(MOCK_NUM_ARGS, + MOCK_EXPECTATION_IS_VALID, _); + } + virtual void serialize( std::ostream& s ) const + { + s << BOOST_PP_REPEAT(MOCK_NUM_ARGS, + MOCK_EXPECTATION_SERIALIZE, _); + } + + private: + BOOST_PP_REPEAT( + MOCK_NUM_ARGS, MOCK_EXPECTATION_MEMBER, _) +}; + + template< typename F, typename Signature > class multi_matcher; + + template< typename F, + BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename T) > + class multi_matcher< F, void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) > + : public matcher_base< void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) > + { + public: + multi_matcher( const F& f ) + : f_( f ) + {} + + private: + virtual bool operator()( + BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG, _) ) + { + return f_( BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_EXPECTATION_PARAM, _) ); + } + virtual void serialize( std::ostream& s ) const + { + s << mock::format( f_ ); + } + + private: + F f_; + }; + +#endif + + template< typename Signature > class expectation; + + template< typename R + BOOST_PP_ENUM_TRAILING_PARAMS(MOCK_NUM_ARGS, typename T) > + class expectation< R (BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS,T)) > + : public action< R, R (BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS,T)) > + { + public: + expectation() + : invocation_( boost::make_shared< unlimited >() ) + , matcher_( + boost::make_shared< + default_matcher< + void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) + > + > () ) + , file_( "unknown location" ) + , line_( 0 ) + {} + expectation( const char* file, int line ) + : invocation_( boost::make_shared< unlimited >() ) + , matcher_( + boost::make_shared< + default_matcher< + void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) + > + > () ) + , file_( file ) + , line_( line ) + {} + + ~expectation() + { + for( sequences_cit it = sequences_.begin(); + it != sequences_.end(); ++it ) + (*it)->remove( this ); + } + + void invoke( const boost::shared_ptr< invocation >& i ) + { + invocation_ = i; + } + +#ifndef MOCK_NUM_ARGS_0 + template< + BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename Constraint_) + > + expectation& with( + BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, Constraint_, c) ) + { + matcher_.reset( + new single_matcher< + void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, Constraint_) ), + void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) + >( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, c) ) ); + return *this; + } +#if MOCK_NUM_ARGS > 1 + template< typename Constraint > + expectation& with( const Constraint& c ) + { + matcher_.reset( + new multi_matcher< + Constraint, + void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) + >( c ) ); + return *this; + } +#endif +#endif + + void add( sequence& s ) + { + s.impl_->add( this ); + sequences_.push_back( s.impl_ ); + } + + bool verify() const + { + return invocation_->verify(); + } + + bool is_valid( + BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG, _) ) const + { + return !invocation_->exhausted() + && (*matcher_)( BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_EXPECTATION_PARAM, _) ); + } + + bool invoke() const + { + for( sequences_cit it = sequences_.begin(); + it != sequences_.end(); ++it ) + if( ! (*it)->is_valid( this ) ) + return false; + bool result = invocation_->invoke(); + for( sequences_cit it = sequences_.begin(); + it != sequences_.end(); ++it ) + (*it)->invalidate( this ); + return result; + } + + const char* file() const + { + return file_; + } + int line() const + { + return line_; + } + + friend std::ostream& operator<<( + std::ostream& s, const expectation& e ) + { + return s << ( e.invocation_->exhausted() ? 'v' : '.' ) + << ' ' << *e.invocation_ +#ifndef MOCK_NUM_ARGS_0 + << ".with( " << *e.matcher_ << " )" +#endif + ; + } + + private: + typedef std::vector< + boost::shared_ptr< sequence_impl > + > sequences_type; + typedef sequences_type::const_iterator sequences_cit; + + boost::shared_ptr< invocation > invocation_; + boost::shared_ptr< + matcher_base< + void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) + > + > matcher_; + sequences_type sequences_; + const char* file_; + int line_; + }; +} +} // mock + +#undef MOCK_EXPECTATION_INITIALIZE +#undef MOCK_EXPECTATION_MEMBER +#undef MOCK_EXPECTATION_IS_VALID +#undef MOCK_EXPECTATION_SERIALIZE +#undef MOCK_EXPECTATION_SERIALIZE_ANY +#undef MOCK_EXPECTATION_PARAM +#undef MOCK_REF_ARG +#undef MOCK_RV_REF diff --git a/include/turtle/detail/formatter.hpp b/include/turtle/detail/formatter.hpp index a27923a..18ccd73 100644 --- a/include/turtle/detail/formatter.hpp +++ b/include/turtle/detail/formatter.hpp @@ -11,31 +11,40 @@ #include "../config.hpp" #include "../stream.hpp" -#include +#include "addressof.hpp" -namespace mock { namespace detail { - template +namespace mock +{ +namespace detail +{ + template< typename T > struct formatter { - explicit formatter(const T& t) : t_(std::addressof(t)) {} - void serialize(stream& s) const { detail::serialize(s, *t_); } + explicit formatter( const T& t ) + : t_( detail::addressof( t ) ) + {} + void serialize( stream& s ) const + { + detail::serialize( s, *t_ ); + } const T* t_; }; - template - stream& operator<<(stream& s, const formatter& f) + template< typename T > + stream& operator<<( stream& s, const formatter< T >& f ) { - f.serialize(s); + f.serialize( s ); return s; } - template - std::ostream& operator<<(std::ostream& s, const formatter& f) + template< typename T > + std::ostream& operator<<( std::ostream& s, const formatter< T >& f ) { - stream ss(s); - f.serialize(ss); + stream ss( s ); + f.serialize( ss ); return s; } -}} // namespace mock::detail +} +} // mock #endif // MOCK_FORMATTER_HPP_INCLUDED diff --git a/include/turtle/detail/function.hpp b/include/turtle/detail/function.hpp index e4e8c64..a17dfec 100644 --- a/include/turtle/detail/function.hpp +++ b/include/turtle/detail/function.hpp @@ -10,72 +10,106 @@ #define MOCK_FUNCTION_HPP_INCLUDED #include "../config.hpp" +#include "../error.hpp" #include "../log.hpp" +#include "../constraints.hpp" #include "../sequence.hpp" -#include "context.hpp" -#include "function_impl.hpp" +#include "../matcher.hpp" +#include "action.hpp" +#include "verifiable.hpp" +#include "invocation.hpp" #include "type_name.hpp" -#include +#include "context.hpp" +#include "mutex.hpp" +#include "move_helper.hpp" +#include +#include +#include +#include +#include +#include #include +#include +#include +#include +#include +#include +#include +#include #include +#include +#include -namespace mock { namespace detail { - template - class function; - - template - class function +namespace mock +{ +namespace detail +{ + template< typename R, typename E > + struct wrapper_base { - private: - typedef function_impl impl_type; - typedef typename impl_type::wrapper_type expectation_type; - typedef typename impl_type::error_type error_type; + wrapper_base( E& e ) + : e_( &e ) + {} - public: - function() : impl_(std::make_shared()) {} - - bool verify() const { return impl_->verify(); } - bool verify(const char* file, int line) const + template< typename T > + void returns( T t ) { - error_type::pass(file, line); - return impl_->verify(); - } - void reset() { impl_->reset(); } - void reset(const char* file, int line) - { - error_type::pass(file, line); - impl_->reset(); + e_->returns( t ); } - expectation_type expect(const char* file, int line) - { - error_type::pass(file, line); - return impl_->expect(file, line); - } - expectation_type expect() { return impl_->expect(); } - - R operator()(Ts... args) const { return (*impl_)(static_cast>(args)...); } - - friend std::ostream& operator<<(std::ostream& s, const function& f) { return s << *f.impl_; } - - function& operator()(context& c, boost::unit_test::const_string instance) - { - impl_->add(c, impl_.get(), instance, boost::none, ""); - return *this; - } - - void configure(context& c, - const void* p, - boost::unit_test::const_string instance, - boost::optional type, - boost::unit_test::const_string name) const - { - impl_->add(c, p, instance, type, name); - } - - private: - std::shared_ptr impl_; + E* e_; }; -}} // namespace mock::detail + template< typename E > + struct wrapper_base< void, E > + { + wrapper_base( E& e ) + : e_( &e ) + {} + + E* e_; + }; + template< typename R, typename E > + struct wrapper_base< R*, E > + { + wrapper_base( E& e ) + : e_( &e ) + {} + + void returns( R* r ) + { + e_->returns( r ); + } + template< typename Y > + void returns( const boost::reference_wrapper< Y >& r ) + { + e_->returns( r ); + } + + E* e_; + }; + + inline int exceptions() + { +#ifdef MOCK_UNCAUGHT_EXCEPTIONS + using namespace std; + return uncaught_exceptions(); +#else + return std::uncaught_exception() ? 1 : 0; +#endif + } +} +} // mock + +#define MOCK_NUM_ARGS 0 +#define MOCK_NUM_ARGS_0 +#include "function_template.hpp" +#undef MOCK_NUM_ARGS_0 +#undef MOCK_NUM_ARGS + +#define BOOST_PP_FILENAME_1 +#define BOOST_PP_ITERATION_LIMITS (1, MOCK_MAX_ARGS) +#include BOOST_PP_ITERATE() +#undef BOOST_PP_FILENAME_1 +#undef BOOST_PP_ITERATION_LIMITS #endif // MOCK_FUNCTION_HPP_INCLUDED diff --git a/include/turtle/detail/function_impl.hpp b/include/turtle/detail/function_impl.hpp deleted file mode 100644 index c11f386..0000000 --- a/include/turtle/detail/function_impl.hpp +++ /dev/null @@ -1,362 +0,0 @@ -// http://turtle.sourceforge.net -// -// Copyright 2012 Mathieu Champlon -// Copyright 2025 Alexander Grund -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#ifndef MOCK_FUNCTION_IMPL_HPP_INCLUDED -#define MOCK_FUNCTION_IMPL_HPP_INCLUDED - -#include "../error.hpp" -#include "expectation.hpp" -#include "mutex.hpp" -#include "verifiable.hpp" -#include -#include -#include - -#ifndef MOCK_ERROR_POLICY -# error no error policy has been set -#endif - -namespace mock { namespace detail { - template - struct wrapper_base - { - wrapper_base(E& e) : e_(&e) {} - - template - void returns(T t) - { - e_->returns(t); - } - - E* e_; - }; - template - struct wrapper_base - { - wrapper_base(E& e) : e_(&e) {} - - E* e_; - }; - template - struct wrapper_base - { - wrapper_base(E& e) : e_(&e) {} - - void returns(R* r) { e_->returns(r); } - template - void returns(const std::reference_wrapper& r) - { - e_->returns(r); - } - - E* e_; - }; - - inline int exceptions() - { -#ifdef MOCK_UNCAUGHT_EXCEPTIONS - using namespace std; - return uncaught_exceptions(); -#else - return std::uncaught_exception() ? 1 : 0; -#endif - } - - template - class lazy_args; - - template - class function_impl; - - template - class function_impl : public verifiable, public std::enable_shared_from_this> - { - public: - typedef safe_error> error_type; - - public: - function_impl() : exceptions_(exceptions()), mutex_(std::make_shared()) {} - virtual ~function_impl() - { - if(valid_ && exceptions_ >= exceptions()) - { - for(const auto& expectation : expectations_) - { - if(!expectation.verify()) - { - error_type::fail("untriggered expectation", - boost::unit_test::lazy_ostream::instance() - << lazy_context(this) << lazy_expectations(this), - expectation.file(), - expectation.line()); - } - } - } - if(context_) - context_->remove(*this); - } - - virtual bool verify() const - { - lock _(mutex_); - for(const auto& expectation : expectations_) - { - if(!expectation.verify()) - { - valid_ = false; - error_type::fail("verification failed", - boost::unit_test::lazy_ostream::instance() - << lazy_context(this) << lazy_expectations(this), - expectation.file(), - expectation.line()); - } - } - return valid_; - } - - virtual void reset() - { - lock _(mutex_); - valid_ = true; - std::shared_ptr guard = this->shared_from_this(); - expectations_.clear(); - } - - private: - typedef expectation expectation_type; - - class wrapper : public wrapper_base - { - private: - typedef wrapper_base base_type; - static constexpr std::size_t arity = sizeof...(Args); - - public: - wrapper(const std::shared_ptr& m, expectation_type& e) : base_type(e), lock_(m) {} - wrapper(const wrapper&) = delete; - wrapper(wrapper&& x) = default; - wrapper& operator=(const wrapper&) = delete; - wrapper& operator=(wrapper&& x) = default; - wrapper& once() - { - this->e_->invoke(std::make_unique()); - return *this; - } - wrapper& never() - { - this->e_->invoke(std::make_unique()); - return *this; - } - wrapper& exactly(std::size_t count) - { - this->e_->invoke(std::make_unique(count)); - return *this; - } - wrapper& at_least(std::size_t min) - { - this->e_->invoke(std::make_unique(min)); - return *this; - } - wrapper& at_most(std::size_t max) - { - this->e_->invoke(std::make_unique(max)); - return *this; - } - wrapper& between(std::size_t min, std::size_t max) - { - this->e_->invoke(std::make_unique(min, max)); - return *this; - } - - /// Callable only for functions taking arguments - /// Number of constraints must match the number of arguments - /// or a single constraint checking all arguments must be passed - template - std::enable_if_t<(arity > 0u && (sizeof...(Constraints) == arity || sizeof...(Constraints) == 1u)), - wrapper&> - with(Constraints... c) - { - this->e_->with(c...); - return *this; - } - - /// Ensure the expectation is met in the given sequence(s) - template - wrapper& in(sequence& s0, MockSequences&... s) - { - using expander = int[]; - (void)expander{ (this->e_->add(s0), 0), (this->e_->add(s), 0)... }; - return *this; - } - - template - void calls(TT t) - { - this->e_->calls(t); - } - template - void throws(TT t) - { - this->e_->throws(t); - } - template - void moves(TT&& t) - { - this->e_->moves(std::move(t)); - } - - lock lock_; - }; - - public: - typedef wrapper wrapper_type; - - wrapper expect(const char* file, int line) - { - lock _(mutex_); - expectations_.emplace_back(file, line); - valid_ = true; - return wrapper(mutex_, expectations_.back()); - } - wrapper expect() - { - lock _(mutex_); - expectations_.emplace_back(); - valid_ = true; - return wrapper(mutex_, expectations_.back()); - } - - R operator()(Args... args) const - { -// Due to lifetime rules of references this must be created and consumed in one line -#define MOCK_FUNCTION_CONTEXT \ - boost::unit_test::lazy_ostream::instance() \ - << lazy_context(this) << lazy_args(args...) << lazy_expectations(this) - - lock _(mutex_); - valid_ = false; - for(const auto& expectation : expectations_) - { - if(expectation.is_valid(static_cast>(args)...)) - { - if(!expectation.invoke()) - { - error_type::fail( - "sequence failed", MOCK_FUNCTION_CONTEXT, expectation.file(), expectation.line()); - return error_type::abort(); - } - if(!expectation.valid()) - { - error_type::fail( - "missing action", MOCK_FUNCTION_CONTEXT, expectation.file(), expectation.line()); - return error_type::abort(); - } - valid_ = true; - error_type::call(MOCK_FUNCTION_CONTEXT, expectation.file(), expectation.line()); - if(expectation.functor()) - return expectation.functor()(static_cast>(args)...); - return expectation.trigger(); - } - } - error_type::fail("unexpected call", MOCK_FUNCTION_CONTEXT); - return error_type::abort(); -#undef MOCK_FUNCTION_CONTEXT - } - - void add(context& c, - const void* p, - boost::unit_test::const_string instance, - boost::optional type, - boost::unit_test::const_string name) - { - lock _(mutex_); - if(!context_) - c.add(*this); - c.add(p, *this, instance, type, name); - context_ = &c; - } - - friend std::ostream& operator<<(std::ostream& s, const function_impl& impl) - { - lock _(impl.mutex_); - return s << lazy_context(&impl) << lazy_expectations(&impl); - } - - struct lazy_context - { - lazy_context(const function_impl* impl) : impl_(impl) {} - friend std::ostream& operator<<(std::ostream& s, const lazy_context& c) - { - if(c.impl_->context_) - c.impl_->context_->serialize(s, *c.impl_); - else - s << '?'; - return s; - } - const function_impl* impl_; - }; - - struct lazy_expectations - { - lazy_expectations(const function_impl* impl) : impl_(impl) {} - friend std::ostream& operator<<(std::ostream& s, const lazy_expectations& e) - { - for(const auto& expectation : e.impl_->expectations_) - s << std::endl << expectation; - return s; - } - const function_impl* impl_; - }; - - std::list expectations_; - context* context_ = nullptr; - mutable bool valid_ = true; - const int exceptions_; - const std::shared_ptr mutex_; - }; - - template - class lazy_args : lazy_args - { - ArgFirst& arg_; - - public: - lazy_args(ArgFirst& arg, std::add_lvalue_reference_t... args) - : lazy_args(args...), arg_(arg) - {} - std::ostream& print(std::ostream& s) const - { - s << ' ' << mock::format(arg_) << ','; - return lazy_args::print(s); - } - }; - template - class lazy_args - { - ArgFirst& arg_; - - public: - lazy_args(ArgFirst& arg) : arg_(arg) {} - std::ostream& print(std::ostream& s) const { return s << ' ' << mock::format(arg_) << ' '; } - }; - template<> - class lazy_args<> - { - public: - std::ostream& print(std::ostream& s) const { return s; } - }; - template - std::ostream& operator<<(std::ostream& s, const lazy_args& a) - { - s << '('; - return a.print(s) << ')'; - } -}} // namespace mock::detail - -#endif // MOCK_FUNCTION_IMPL_HPP_INCLUDED diff --git a/include/turtle/detail/function_impl_template.hpp b/include/turtle/detail/function_impl_template.hpp new file mode 100644 index 0000000..3a68971 --- /dev/null +++ b/include/turtle/detail/function_impl_template.hpp @@ -0,0 +1,329 @@ +// http://turtle.sourceforge.net +// +// Copyright Mathieu Champlon 2012 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "expectation_template.hpp" + +#ifndef MOCK_ERROR_POLICY +# error no error policy has been set +#endif + +#define MOCK_FUNCTION_FORMAT(z, n, N) \ + << ' ' << mock::format( t##n ) \ + << BOOST_PP_IF(BOOST_PP_EQUAL(N,n), ' ', ',') + +#define MOCK_FUNCTION_CONTEXT \ + boost::unit_test::lazy_ostream::instance() \ + << lazy_context( this ) \ + << '(' BOOST_PP_REPEAT(MOCK_NUM_ARGS, MOCK_FUNCTION_FORMAT, \ + BOOST_PP_DEC(MOCK_NUM_ARGS)) \ + << ')' \ + << lazy_expectations( this ) + +#define MOCK_MOVE(z, n, d) \ + mock::detail::move_if_not_lvalue_reference< T##n >( t##n ) + +namespace mock +{ +namespace detail +{ + template< typename Signature > class function_impl; + + template< typename R + BOOST_PP_ENUM_TRAILING_PARAMS(MOCK_NUM_ARGS, typename T) > + class function_impl< R ( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) > + : public verifiable, public boost::enable_shared_from_this< + function_impl< R ( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) )> > + { + public: + typedef safe_error< R, MOCK_ERROR_POLICY< R > > error_type; + + public: + function_impl() + : context_( 0 ) + , valid_( true ) + , exceptions_( exceptions() ) + , mutex_( boost::make_shared< mutex >() ) + {} + virtual ~function_impl() + { + if( valid_ && exceptions_ >= exceptions() ) + for( expectations_cit it = expectations_.begin(); + it != expectations_.end(); ++it ) + if( ! it->verify() ) + error_type::fail( "untriggered expectation", + boost::unit_test::lazy_ostream::instance() + << lazy_context( this ) + << lazy_expectations( this ), + it->file(), it->line() ); + if( context_ ) + context_->remove( *this ); + } + + virtual bool verify() const + { + lock _( mutex_ ); + for( expectations_cit it = expectations_.begin(); + it != expectations_.end(); ++it ) + if( ! it->verify() ) + { + valid_ = false; + error_type::fail( "verification failed", + boost::unit_test::lazy_ostream::instance() + << lazy_context( this ) + << lazy_expectations( this ), + it->file(), it->line() ); + } + return valid_; + } + + virtual void reset() + { + lock _( mutex_ ); + valid_ = true; + boost::shared_ptr< function_impl > guard = + this->shared_from_this(); + expectations_.clear(); + } + + private: + typedef expectation< + R( BOOST_PP_ENUM_PARAMS( MOCK_NUM_ARGS, T ) ) + > expectation_type; + + class wrapper : public wrapper_base< R, expectation_type > + { + private: + typedef wrapper_base< R, expectation_type > base_type; + BOOST_MOVABLE_BUT_NOT_COPYABLE(wrapper) + + public: + wrapper( const boost::shared_ptr< mutex >& m, expectation_type& e ) + : base_type( e ) + , lock_( m ) + {} + wrapper( BOOST_RV_REF( wrapper ) x ) + : base_type( x ) + , lock_( boost::move( x.lock_) ) + {} + wrapper& operator=( BOOST_RV_REF( wrapper ) x ) + { + static_cast< base_type& >( *this ) = x; + lock_ = boost::move( x.lock_ ); + return *this; + } + wrapper& once() + { + this->e_->invoke( boost::make_shared< detail::once >() ); + return *this; + } + wrapper& never() + { + this->e_->invoke( boost::make_shared< detail::never >() ); + return *this; + } + wrapper& exactly( std::size_t count ) + { + this->e_->invoke( + boost::make_shared< detail::exactly >( count ) ); + return *this; + } + wrapper& at_least( std::size_t min ) + { + this->e_->invoke( + boost::make_shared< detail::at_least >( min ) ); + return *this; + } + wrapper& at_most( std::size_t max ) + { + this->e_->invoke( + boost::make_shared< detail::at_most >( max ) ); + return *this; + } + wrapper& between( std::size_t min, std::size_t max ) + { + this->e_->invoke( + boost::make_shared< detail::between >( min, max ) ); + return *this; + } + +#ifndef MOCK_NUM_ARGS_0 + template< + BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename Constraint_) + > + wrapper& with( + BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, Constraint_, c) ) + { + this->e_->with( + BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, c) ); + return *this; + } + +#if MOCK_NUM_ARGS > 1 + template< typename Constraint > + wrapper& with( const Constraint& c ) + { + this->e_->with( c ); + return *this; + } +#endif +#endif + +#define MOCK_FUNCTION_IN_ADD(z, n, d) \ + this->e_->add( s##n ); + +#define MOCK_FUNCTION_IN(z, n, d) \ + wrapper& in( BOOST_PP_ENUM_PARAMS(n, sequence& s) ) \ + { \ + BOOST_PP_REPEAT(n, MOCK_FUNCTION_IN_ADD, _) \ + return *this; \ + } + + BOOST_PP_REPEAT(MOCK_MAX_SEQUENCES, + MOCK_FUNCTION_IN, _) + +#undef MOCK_FUNCTION_IN +#undef MOCK_FUNCTION_IN_ADD + + template< typename TT > + void calls( TT t ) + { + this->e_->calls( t ); + } + template< typename TT > + void throws( TT t ) + { + this->e_->throws( t ); + } + template< typename TT > + void moves( BOOST_RV_REF(TT) t ) + { + this->e_->moves( boost::move( t ) ); + } + + lock lock_; + }; + + public: + typedef wrapper wrapper_type; + + wrapper expect( const char* file, int line ) + { + lock _( mutex_ ); + expectations_.push_back( expectation_type( file, line ) ); + valid_ = true; + return wrapper( mutex_, expectations_.back() ); + } + wrapper expect() + { + lock _( mutex_ ); + expectations_.push_back( expectation_type() ); + valid_ = true; + return wrapper( mutex_, expectations_.back() ); + } + + R operator()( + BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, T, t) ) const + { + lock _( mutex_ ); + valid_ = false; + for( expectations_cit it = expectations_.begin(); + it != expectations_.end(); ++it ) + if( it->is_valid( + BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_MOVE, _) ) ) + { + if( ! it->invoke() ) + { + error_type::fail( "sequence failed", + MOCK_FUNCTION_CONTEXT, it->file(), it->line() ); + return error_type::abort(); + } + if( ! it->valid() ) + { + error_type::fail( "missing action", + MOCK_FUNCTION_CONTEXT, it->file(), it->line() ); + return error_type::abort(); + } + valid_ = true; + error_type::call( + MOCK_FUNCTION_CONTEXT, it->file(), it->line() ); + if( it->functor() ) + return it->functor()( + BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_MOVE, _) ); + return it->trigger(); + } + error_type::fail( "unexpected call", MOCK_FUNCTION_CONTEXT ); + return error_type::abort(); + } + + void add( context& c, const void* p, + boost::unit_test::const_string instance, + boost::optional< type_name > type, + boost::unit_test::const_string name ) + { + lock _( mutex_ ); + if( ! context_ ) + c.add( *this ); + c.add( p, *this, instance, type, name ); + context_ = &c; + } + + friend std::ostream& operator<<( + std::ostream& s, const function_impl& impl ) + { + lock _( impl.mutex_ ); + return s << lazy_context( &impl ) << lazy_expectations( &impl ); + } + + struct lazy_context + { + lazy_context( const function_impl* impl ) + : impl_( impl ) + {} + friend std::ostream& operator<<( + std::ostream& s, const lazy_context& c ) + { + if( c.impl_->context_ ) + c.impl_->context_->serialize( s, *c.impl_ ); + else + s << '?'; + return s; + } + const function_impl* impl_; + }; + + struct lazy_expectations + { + lazy_expectations( const function_impl* impl ) + : impl_( impl ) + {} + friend std::ostream& operator<<( + std::ostream& s, const lazy_expectations& e ) + { + for( expectations_cit it = e.impl_->expectations_.begin(); + it != e.impl_->expectations_.end(); ++it ) + s << std::endl << *it; + return s; + } + const function_impl* impl_; + }; + + typedef std::list< expectation_type > expectations_type; + typedef typename expectations_type::const_iterator expectations_cit; + + expectations_type expectations_; + context* context_; + mutable bool valid_; + const int exceptions_; + const boost::shared_ptr< mutex > mutex_; + }; +} +} // mock + +#undef MOCK_FUNCTION_FORMAT +#undef MOCK_FUNCTION_CONTEXT +#undef MOCK_MOVE diff --git a/include/turtle/detail/function_iterate.hpp b/include/turtle/detail/function_iterate.hpp new file mode 100644 index 0000000..f86538e --- /dev/null +++ b/include/turtle/detail/function_iterate.hpp @@ -0,0 +1,11 @@ +// http://turtle.sourceforge.net +// +// Copyright Mathieu Champlon 2012 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#define MOCK_NUM_ARGS BOOST_PP_ITERATION() +#include "function_template.hpp" +#undef MOCK_NUM_ARGS diff --git a/include/turtle/detail/function_template.hpp b/include/turtle/detail/function_template.hpp new file mode 100644 index 0000000..0ebfe14 --- /dev/null +++ b/include/turtle/detail/function_template.hpp @@ -0,0 +1,106 @@ +// http://turtle.sourceforge.net +// +// Copyright Mathieu Champlon 2008 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "function_impl_template.hpp" + +#define MOCK_MOVE(z, n, d) \ + mock::detail::move_if_not_lvalue_reference< T##n >( t##n ) + +namespace mock +{ +namespace detail +{ + template< typename Signature > class function; + + template< typename R + BOOST_PP_ENUM_TRAILING_PARAMS(MOCK_NUM_ARGS, typename T) > + class function< R ( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) > + { + public: + typedef R result_type; + + template< typename Args > + struct sig + { + typedef R type; + }; + + private: + typedef function_impl< + R ( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) + > impl_type; + typedef typename impl_type::wrapper_type expectation_type; + typedef typename impl_type::error_type error_type; + + public: + function() + : impl_( boost::make_shared< impl_type >() ) + {} + + bool verify() const + { + return impl_->verify(); + } + bool verify( const char* file, int line ) const + { + error_type::pass( file, line ); + return impl_->verify(); + } + void reset() + { + impl_->reset(); + } + void reset( const char* file, int line ) + { + error_type::pass( file, line ); + impl_->reset(); + } + + expectation_type expect( const char* file, int line ) + { + error_type::pass( file, line ); + return impl_->expect( file, line ); + } + expectation_type expect() + { + return impl_->expect(); + } + + R operator()( + BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, T, t) ) const + { + return (*impl_)( BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_MOVE, _) ); + } + + friend std::ostream& operator<<( std::ostream& s, const function& f ) + { + return s << *f.impl_; + } + + function& operator()( context& c, + boost::unit_test::const_string instance ) + { + impl_->add( c, impl_.get(), instance, boost::none, "" ); + return *this; + } + + void configure( context& c, const void* p, + boost::unit_test::const_string instance, + boost::optional< type_name > type, + boost::unit_test::const_string name ) const + { + impl_->add( c, p, instance, type, name ); + } + + private: + boost::shared_ptr< impl_type > impl_; + }; +} +} // mock + +#undef MOCK_MOVE diff --git a/include/turtle/detail/functor.hpp b/include/turtle/detail/functor.hpp index dfb793d..53e776f 100644 --- a/include/turtle/detail/functor.hpp +++ b/include/turtle/detail/functor.hpp @@ -14,41 +14,39 @@ #include "mutex.hpp" #include "singleton.hpp" -namespace mock { namespace detail { - class functor_mutex_t : public singleton, public mutex +namespace mock +{ +namespace detail +{ + class functor_mutex_t : + public singleton< functor_mutex_t >, + public mutex { - MOCK_SINGLETON_CONS(functor_mutex_t); + MOCK_SINGLETON_CONS( functor_mutex_t ); }; - MOCK_SINGLETON_INST(functor_mutex) + MOCK_SINGLETON_INST( functor_mutex ) - template - struct functor : function + template< typename Signature > + struct functor : function< Signature > { functor() { - scoped_lock _(functor_mutex); - // MOCK_FUNCTOR creates 2 functor objects: - // The user-usable one with the passed name and a 2nd used by MOCK_EXPECT with a suffixed name - // We need the 2nd to be a copy of the first and use a static variable for storing a pointer to the first - static functor* f = nullptr; - if(f) + scoped_lock _( functor_mutex ); + static functor* f = 0; + if( f ) { - // Release the lock from the first call (see below) so other threads can create functors again - // after the function exits (the scoped_lock still holds the mutex) - functor_mutex.unlock(); - // Copy the first functor to the current (2nd) one *this = *f; - f = nullptr; - } else + f = 0; + functor_mutex.unlock(); + } + else { - // This is the first object, store its pointer - f = this; - // Lock the mutex again so only this thread can create new instances of a functor - // making sure that we copy the right instance above and not one from a concurrent thread functor_mutex.lock(); + f = this; } } }; -}} // namespace mock::detail +} +} // mock #endif // MOCK_FUNCTOR_HPP_INCLUDED diff --git a/include/turtle/detail/group.hpp b/include/turtle/detail/group.hpp index d8a8e41..d0668cc 100644 --- a/include/turtle/detail/group.hpp +++ b/include/turtle/detail/group.hpp @@ -11,39 +11,54 @@ #include "../config.hpp" #include "verifiable.hpp" -#include #include +#include #include -namespace mock { namespace detail { +namespace mock +{ +namespace detail +{ class group { public: - void add(verifiable& v) { verifiables_.push_back(&v); } - void remove(verifiable& v) + void add( verifiable& v ) { - verifiables_.erase(std::remove(verifiables_.begin(), verifiables_.end(), &v), verifiables_.end()); + verifiables_.push_back( &v ); + } + void remove( verifiable& v ) + { + verifiables_.erase( + std::remove( verifiables_.begin(), verifiables_.end(), &v ), + verifiables_.end() ); } bool verify() const { bool valid = true; - for(const auto* verifiable : verifiables_) - if(!verifiable->verify()) + for( verifiables_cit it = verifiables_.begin(); + it != verifiables_.end(); ++it ) + if( ! (*it)->verify() ) valid = false; return valid; } void reset() { - const auto verifiables = verifiables_; - for(auto* verifiable : verifiables) - if(std::find(verifiables_.begin(), verifiables_.end(), verifiable) != verifiables_.end()) - verifiable->reset(); + const verifiables_t verifiables = verifiables_; + for( verifiables_cit it = verifiables.begin(); + it != verifiables.end(); ++it ) + if( std::find( verifiables_.begin(), verifiables_.end(), *it ) + != verifiables_.end() ) + (*it)->reset(); } private: - std::vector verifiables_; + typedef std::vector< verifiable* > verifiables_t; + typedef verifiables_t::const_iterator verifiables_cit; + + verifiables_t verifiables_; }; -}} // namespace mock::detail +} +} // mock #endif // MOCK_GROUP_HPP_INCLUDED diff --git a/include/turtle/detail/invocation.hpp b/include/turtle/detail/invocation.hpp index 5b711e2..fd1c0f6 100644 --- a/include/turtle/detail/invocation.hpp +++ b/include/turtle/detail/invocation.hpp @@ -10,70 +10,86 @@ #define MOCK_INVOCATION_HPP_INCLUDED #include "../config.hpp" -#include -#include +#include #include +#include +#include -namespace mock { namespace detail { - class invocation +namespace mock +{ +namespace detail +{ + class invocation : private boost::noncopyable { public: - invocation() = default; - invocation(const invocation&) = delete; - invocation& operator=(const invocation&) = delete; - - virtual ~invocation() = default; + invocation() {} + virtual ~invocation() {} virtual bool invoke() = 0; virtual bool verify() const = 0; virtual bool exhausted() const = 0; - friend std::ostream& operator<<(std::ostream& s, const invocation& i) { return i.serialize(s); } + friend std::ostream& operator<<( std::ostream& s, const invocation& i ) + { + return i.serialize( s ); + } private: - virtual std::ostream& serialize(std::ostream& s) const = 0; + virtual std::ostream& serialize( std::ostream& s ) const = 0; }; class between : public invocation { public: - between(std::size_t min, std::size_t max) : min_(min), max_(max), count_(0) + between( std::size_t min, std::size_t max ) + : min_( min ) + , max_( max ) + , count_( 0 ) { - if(min > max) - throw std::invalid_argument("'min' > 'max'"); + if( min > max ) + throw std::invalid_argument( "'min' > 'max'" ); } virtual bool invoke() { - if(count_ == max_) + if( count_ == max_ ) return false; ++count_; return true; } - virtual bool exhausted() const { return count_ >= max_; } + virtual bool exhausted() const + { + return count_ >= max_; + } - virtual bool verify() const { return min_ <= count_ && count_ <= max_; } + virtual bool verify() const + { + return min_ <= count_ && count_ <= max_; + } protected: const std::size_t min_, max_; std::size_t count_; private: - virtual std::ostream& serialize(std::ostream& s) const + virtual std::ostream& serialize( std::ostream& s ) const { - return s << "between( " << count_ << "/[" << min_ << ',' << max_ << "] )"; + return s << "between( " << count_ + << "/[" << min_ << ',' << max_ << "] )"; } }; class exactly : public between { public: - explicit exactly(std::size_t count) : between(count, count) {} + explicit exactly( std::size_t count ) + : between( count, count ) + {} private: - virtual std::ostream& serialize(std::ostream& s) const + virtual std::ostream& serialize( std::ostream& s ) const { return s << "exactly( " << count_ << '/' << max_ << " )"; } @@ -82,28 +98,40 @@ namespace mock { namespace detail { class never : public exactly { public: - never() : exactly(0) {} + never() + : exactly( 0 ) + {} private: - virtual std::ostream& serialize(std::ostream& s) const { return s << "never()"; } + virtual std::ostream& serialize( std::ostream& s ) const + { + return s << "never()"; + } }; class once : public exactly { public: - once() : exactly(1) {} + once() + : exactly( 1 ) + {} private: - virtual std::ostream& serialize(std::ostream& s) const { return s << "once()"; } + virtual std::ostream& serialize( std::ostream& s ) const + { + return s << "once()"; + } }; class at_least : public between { public: - explicit at_least(std::size_t min) : between(min, (std::numeric_limits::max)()) {} + explicit at_least( std::size_t min ) + : between( min, (std::numeric_limits< std::size_t >::max)() ) + {} private: - virtual std::ostream& serialize(std::ostream& s) const + virtual std::ostream& serialize( std::ostream& s ) const { return s << "at_least( " << count_ << '/' << min_ << " )"; } @@ -112,10 +140,12 @@ namespace mock { namespace detail { class at_most : public between { public: - explicit at_most(std::size_t max) : between(0, max) {} + explicit at_most( std::size_t max ) + : between( 0, max ) + {} private: - virtual std::ostream& serialize(std::ostream& s) const + virtual std::ostream& serialize( std::ostream& s ) const { return s << "at_most( " << count_ << '/' << max_ << " )"; } @@ -124,11 +154,17 @@ namespace mock { namespace detail { class unlimited : public at_least { public: - unlimited() : at_least(0) {} + unlimited() + : at_least( 0 ) + {} private: - virtual std::ostream& serialize(std::ostream& s) const { return s << "unlimited()"; } + virtual std::ostream& serialize( std::ostream& s ) const + { + return s << "unlimited()"; + } }; -}} // namespace mock::detail +} +} // mock #endif // MOCK_INVOCATION_HPP_INCLUDED diff --git a/include/turtle/detail/is_functor.hpp b/include/turtle/detail/is_functor.hpp index bcc0699..5d4de95 100644 --- a/include/turtle/detail/is_functor.hpp +++ b/include/turtle/detail/is_functor.hpp @@ -10,17 +10,53 @@ #define MOCK_IS_FUNCTOR_HPP_INCLUDED #include "../config.hpp" -#include "void_t.hpp" -#include +#include +#include +#include +#include +#include -namespace mock { namespace detail { - /// Trait to return true if F is a functor that can be called with a single argument Arg - template - struct is_functor : std::false_type +namespace mock +{ +namespace detail +{ + BOOST_MPL_HAS_XXX_TRAIT_DEF( result_type ) + BOOST_MPL_HAS_XXX_TEMPLATE_DEF( sig ) + BOOST_MPL_HAS_XXX_TEMPLATE_DEF( result ) + +#ifdef MOCK_DECLTYPE + + template< typename F, typename P > + struct is_callable + { + typedef boost::type_traits::yes_type yes_type; + typedef boost::type_traits::no_type no_type; + + template< typename T > + static yes_type check( + decltype( boost::declval< T >()( boost::declval< P >() ) )* ); + template< typename T > + static no_type check( ... ); + + typedef boost::mpl::bool_< + sizeof( check< F >( 0 ) ) == sizeof( yes_type ) > type; + }; + +#endif // MOCK_DECLTYPE + + template< typename T, typename P > + struct is_functor + : boost::mpl::or_< + boost::function_types::is_callable_builtin< T >, +#ifdef MOCK_DECLTYPE + is_callable< T, P >, +#endif + has_result_type< T >, + has_result< T >, + has_sig< T > + > {}; - template - struct is_functor()(std::declval()))>> : std::true_type - {}; -}} // namespace mock::detail +} +} // mock #endif // MOCK_IS_FUNCTOR_HPP_INCLUDED diff --git a/include/turtle/detail/matcher_base.hpp b/include/turtle/detail/matcher_base.hpp deleted file mode 100644 index abb1fb9..0000000 --- a/include/turtle/detail/matcher_base.hpp +++ /dev/null @@ -1,38 +0,0 @@ -// http://turtle.sourceforge.net -// -// Copyright Mathieu Champlon 2012 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#ifndef MOCK_MATCHER_BASE_HPP_INCLUDED -#define MOCK_MATCHER_BASE_HPP_INCLUDED - -#include "ref_arg.hpp" -#include - -namespace mock { namespace detail { - template - class matcher_base - { - public: - matcher_base() = default; - matcher_base(const matcher_base&) = delete; - matcher_base& operator=(const matcher_base&) = delete; - virtual ~matcher_base() = default; - - virtual bool operator()(ref_arg_t...) = 0; - - friend std::ostream& operator<<(std::ostream& s, const matcher_base& m) - { - m.serialize(s); - return s; - } - - private: - virtual void serialize(std::ostream&) const = 0; - }; -}} // namespace mock::detail - -#endif // MOCK_MATCHER_BASE_HPP_INCLUDED diff --git a/include/turtle/detail/matcher_base_template.hpp b/include/turtle/detail/matcher_base_template.hpp new file mode 100644 index 0000000..07fa326 --- /dev/null +++ b/include/turtle/detail/matcher_base_template.hpp @@ -0,0 +1,42 @@ +// http://turtle.sourceforge.net +// +// Copyright Mathieu Champlon 2012 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#define MOCK_REF_ARG(z, n, d) \ + typename ref_arg< T##n >::type + +namespace mock +{ +namespace detail +{ + template< typename Signature > class matcher_base; + + template< + BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename T) > + class matcher_base< void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) > + : boost::noncopyable + { + public: + virtual ~matcher_base() {} + + virtual bool operator()( + BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG, _) ) = 0; + + friend std::ostream& operator<<( + std::ostream& s, const matcher_base& m ) + { + m.serialize( s ); + return s; + } + + private: + virtual void serialize( std::ostream& ) const = 0; + }; +} +} // mock + +#undef MOCK_REF_ARG diff --git a/include/turtle/detail/mock_impl.hpp b/include/turtle/detail/mock_impl.hpp deleted file mode 100644 index 59fe4e0..0000000 --- a/include/turtle/detail/mock_impl.hpp +++ /dev/null @@ -1,114 +0,0 @@ -// http://turtle.sourceforge.net -// -// Copyright Mathieu Champlon 2008 -// Copyright 2022-2025 Alexander Grund -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#ifndef MOCK_MOCK_IMPL_HPP_INCLUDED -#define MOCK_MOCK_IMPL_HPP_INCLUDED - -#include "function.hpp" -#include "functor.hpp" -#include "signature.hpp" -#include "signature_traits.hpp" -#include "type_name.hpp" -#include -#include -#include - -namespace mock { namespace detail { - /// Simplified trait to extract the argument type of a function signature with 1 argument - template - struct arg_type; - template - struct arg_type - { - using type = U; - }; - /// Used in MOCK_PROTECT_SIGNATURE to unwrap the passed function signature - /// T is something like `void(std::map)` - template - using unwrap_signature_t = std::remove_pointer_t::type>; -}} // namespace mock::detail - -#define MOCK_HELPER(t) t##_mock(mock::detail::root, BOOST_PP_STRINGIZE(t)) -#define MOCK_ANONYMOUS_HELPER(t) t##_mock(mock::detail::root, "?.") - -#define MOCK_METHOD_HELPER(S, t) \ - mutable mock::detail::function t##_mock_; \ - mock::detail::function& t##_mock(const mock::detail::context&, const boost::unit_test::const_string& instance) \ - const \ - { \ - mock::detail::configure(*this, \ - t##_mock_, \ - instance.substr(0, instance.rfind(BOOST_PP_STRINGIZE(t))), \ - mock::detail::make_type_name(*this), \ - BOOST_PP_STRINGIZE(t)); \ - return t##_mock_; \ - } - -#define MOCK_PARAM(S, n) mock::detail::parameter_t - -#define MOCK_DECL_PARAM(z, n, S) MOCK_PARAM(S, n) p##n -#define MOCK_DECL_PARAMS(n, S) BOOST_PP_ENUM(n, MOCK_DECL_PARAM, S) -#define MOCK_DECL(name, arity, signature, qualifier) \ - mock::detail::result_type_t name(MOCK_DECL_PARAMS(arity, signature)) qualifier - -#define MOCK_FORWARD_PARAM(z, n, S) std::forward(p##n) -#define MOCK_FORWARD_PARAMS(n, S) BOOST_PP_ENUM(n, MOCK_FORWARD_PARAM, S) -#define MOCK_METHOD_AUX(name, arity, signature, identifier, qualifier) \ - MOCK_DECL(name, arity, signature, qualifier) \ - { \ - return MOCK_ANONYMOUS_HELPER(identifier)(MOCK_FORWARD_PARAMS(arity, signature)); \ - } - -#define MOCK_METHOD_EXT(name, arity, signature, identifier) \ - MOCK_METHOD_AUX(name, arity, signature, identifier, ) \ - MOCK_METHOD_AUX(name, arity, signature, identifier, const) \ - MOCK_METHOD_HELPER(signature, identifier) -#define MOCK_CONST_METHOD_EXT(name, arity, signature, identifier) \ - MOCK_METHOD_AUX(name, arity, signature, identifier, const) \ - MOCK_METHOD_HELPER(signature, identifier) -#define MOCK_NON_CONST_METHOD_EXT(name, arity, signature, identifier) \ - MOCK_METHOD_AUX(name, arity, signature, identifier, ) \ - MOCK_METHOD_HELPER(signature, identifier) - -#define MOCK_FUNCTION_HELPER(signature, identifier, prefix) \ - prefix mock::detail::function& identifier##_mock(mock::detail::context& context, \ - boost::unit_test::const_string instance) \ - { \ - static mock::detail::function f; \ - return f(context, instance); \ - } - -#define MOCK_FUNCTION_AUX(name, arity, signature, identifier, prefix) \ - MOCK_FUNCTION_HELPER(signature, identifier, prefix) \ - static_assert(arity == mock::detail::function_arity_t::value, "Arity mismatch"); \ - prefix MOCK_DECL(name, arity, signature, ) \ - { \ - return MOCK_HELPER(identifier)(MOCK_FORWARD_PARAMS(arity, signature)); \ - } - -#define MOCK_REPLACED_MACRO_ERROR(oldName, newName) static_assert(false, #oldName " has been replaced by " #newName) -// Replaced macros -#define MOCK_CONST_CONVERSION_OPERATOR_TPL(...) \ - MOCK_REPLACED_MACRO_ERROR(MOCK_CONST_CONVERSION_OPERATOR_TPL, MOCK_CONST_CONVERSION_OPERATOR) -#define MOCK_CONST_METHOD_EXT_TPL(...) MOCK_REPLACED_MACRO_ERROR(MOCK_CONST_METHOD_EXT_TPL, MOCK_CONST_METHOD) -#define MOCK_CONST_METHOD_TPL(...) MOCK_REPLACED_MACRO_ERROR(MOCK_CONST_METHOD_TPL, MOCK_CONST_METHOD) -#define MOCK_CONVERSION_OPERATOR_TPL(...) \ - MOCK_REPLACED_MACRO_ERROR(MOCK_CONVERSION_OPERATOR_TPL, MOCK_CONVERSION_OPERATOR) -#define MOCK_FUNCTOR_TPL(...) MOCK_REPLACED_MACRO_ERROR(MOCK_FUNCTOR_TPL, MOCK_FUNCTOR) -#define MOCK_METHOD_EXT_TPL(...) MOCK_REPLACED_MACRO_ERROR(MOCK_METHOD_EXT_TPL, MOCK_METHOD) -#define MOCK_METHOD_TPL(...) MOCK_REPLACED_MACRO_ERROR(MOCK_METHOD_TPL, MOCK_METHOD) -#define MOCK_NON_CONST_CONVERSION_OPERATOR_TPL(...) \ - MOCK_REPLACED_MACRO_ERROR(MOCK_NON_CONST_CONVERSION_OPERATOR_TPL, MOCK_NON_CONST_CONVERSION_OPERATOR) -#define MOCK_NON_CONST_METHOD_EXT_TPL(...) \ - MOCK_REPLACED_MACRO_ERROR(MOCK_NON_CONST_METHOD_EXT_TPL, MOCK_NON_CONST_METHOD) -#define MOCK_NON_CONST_METHOD_TPL(...) MOCK_REPLACED_MACRO_ERROR(MOCK_NON_CONST_METHOD_TPL, MOCK_NON_CONST_METHOD) -#define MOCK_STATIC_METHOD_TPL(...) MOCK_REPLACED_MACRO_ERROR(MOCK_STATIC_METHOD_TPL, MOCK_STATIC_METHOD) -#define MOCK_CONSTRUCTOR_TPL(...) MOCK_REPLACED_MACRO_ERROR(MOCK_CONSTRUCTOR_TPL, MOCK_CONSTRUCTOR) - -#endif // MOCK_MOCK_IMPL_HPP_INCLUDED diff --git a/include/turtle/detail/move_helper.hpp b/include/turtle/detail/move_helper.hpp new file mode 100644 index 0000000..87f1f2d --- /dev/null +++ b/include/turtle/detail/move_helper.hpp @@ -0,0 +1,78 @@ +// http://turtle.sourceforge.net +// +// Copyright Mathieu Champlon 2018 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef MOCK_MOVE_HELPER_HPP_INCLUDED +#define MOCK_MOVE_HELPER_HPP_INCLUDED + +#include "../config.hpp" +#include +#include +#include +#include +#include +#include + +namespace mock +{ +namespace detail +{ +#ifdef MOCK_RVALUE_REFERENCES + template< typename T > + struct forward_type + { + typedef T type; + }; + template< typename T > + struct ref_arg + { + typedef typename boost::conditional< + boost::is_reference< T >::value, + T, + typename boost::add_rvalue_reference< T >::type >::type type; + }; + + template< typename T > + inline T&& move_if_not_lvalue_reference(typename boost::remove_reference< T >::type& t) + { + return static_cast< T&& >(t); + } + + template< typename T > + inline T&& move_if_not_lvalue_reference(typename boost::remove_reference< T >::type&& t) + { + return static_cast< T&& >(t); + } +#else + template< typename T > + struct forward_type + { + typedef typename boost::decay< const T >::type type; + }; + template< class T> + struct forward_type< boost::rv< T > > + { + typedef T type; + }; + template< typename T > + struct ref_arg + { + typedef typename boost::conditional< + boost::is_reference< T >::value, + T, + const typename boost::add_reference< T >::type >::type type; + }; + template< typename T > + inline typename boost::remove_reference< T >::type& move_if_not_lvalue_reference(typename boost::remove_reference< T >::type& t) + { + return t; + } +#endif +} +} + +#endif // MOCK_MOVE_HELPER_HPP_INCLUDED diff --git a/include/turtle/detail/mutex.hpp b/include/turtle/detail/mutex.hpp index d74d20d..18ae0a5 100644 --- a/include/turtle/detail/mutex.hpp +++ b/include/turtle/detail/mutex.hpp @@ -11,124 +11,156 @@ #include "../config.hpp" #include "singleton.hpp" -#include +#include +#include +#include #ifdef MOCK_THREAD_SAFE -# ifdef MOCK_HDR_MUTEX -# include -# else -# include -# include -# endif +#ifdef MOCK_HDR_MUTEX +#include +#else +#include +#include +#endif -namespace mock { namespace detail { -# ifdef MOCK_HDR_MUTEX +namespace mock +{ +namespace detail +{ +#ifdef MOCK_HDR_MUTEX typedef std::recursive_mutex mutex; - typedef std::lock_guard scoped_lock; -# else + typedef std::lock_guard< mutex > scoped_lock; +#else typedef boost::recursive_mutex mutex; - typedef boost::lock_guard scoped_lock; -# endif + typedef boost::lock_guard< mutex > scoped_lock; +#endif struct lock { + private: + BOOST_MOVABLE_BUT_NOT_COPYABLE(lock) + public: - lock(const std::shared_ptr& m) : m_(m) { m_->lock(); } + lock( const boost::shared_ptr< mutex >& m ) + : m_( m ) + { + m_->lock(); + } ~lock() { - if(m_) + if( m_ ) m_->unlock(); } - lock(const lock&) = delete; - lock(lock&& x) = default; - lock& operator=(const lock&) = delete; - lock& operator=(lock&& x) = default; + lock( BOOST_RV_REF( lock ) x ) + : m_( x.m_ ) + { + // Explicit reset to avoid unlock in destructor + x.m_.reset(); + } + lock& operator=( BOOST_RV_REF( lock ) x ) + { + m_ = x.m_; + x.m_.reset(); + return *this; + } private: - std::shared_ptr m_; + boost::shared_ptr< mutex > m_; }; -}} // namespace mock::detail +} +} // mock #else // MOCK_THREAD_SAFE -namespace mock { namespace detail { - struct mutex +namespace mock +{ +namespace detail +{ + struct mutex : boost::noncopyable { - mutex() = default; - mutex(const mutex&) = delete; - mutex& operator=(const mutex&) = delete; - - void lock() {} - void unlock() {} + void lock() + {} + void unlock() + {} }; // Dummy lock classes. // Constructor + Destructor make it RAII classes for compilers and avoid unused variable warnings - struct scoped_lock + struct scoped_lock : boost::noncopyable { - scoped_lock(const scoped_lock&) = delete; - scoped_lock& operator=(const scoped_lock&) = delete; + scoped_lock( mutex& ) + {} + ~scoped_lock() + {} + }; + class lock : boost::noncopyable + { + private: + BOOST_MOVABLE_BUT_NOT_COPYABLE(lock) - scoped_lock(mutex&) {} - ~scoped_lock() {} - }; - class lock - { public: - lock(const std::shared_ptr&) {} - ~lock() {} - lock(const lock&) = delete; - lock(lock&&) = default; - lock& operator=(const lock&) = delete; - lock& operator=(lock&&) = default; + lock( const boost::shared_ptr< mutex >& ) + {} + ~lock() + {} + lock( BOOST_RV_REF( lock ) x ) + {} + lock& operator=( BOOST_RV_REF( lock ) x ) + { + return *this; + } }; -}} // namespace mock::detail +} +} // mock #endif // MOCK_THREAD_SAFE -namespace mock { namespace detail { - class error_mutex_t : public singleton, public mutex +namespace mock +{ +namespace detail +{ + class error_mutex_t : public singleton< error_mutex_t >, + public mutex { - MOCK_SINGLETON_CONS(error_mutex_t); + MOCK_SINGLETON_CONS( error_mutex_t ); }; - MOCK_SINGLETON_INST(error_mutex) + MOCK_SINGLETON_INST( error_mutex ) #ifdef BOOST_MSVC -# pragma warning(push) -# pragma warning(disable : 4702) +# pragma warning( push ) +# pragma warning( disable: 4702 ) #endif - template + template< typename Result, typename Error > struct safe_error { static Result abort() { - scoped_lock _(error_mutex); + scoped_lock _( error_mutex ); return Error::abort(); } - template - static void fail(const char* message, - const Context& context, - const char* file = "unknown location", - int line = 0) + template< typename Context > + static void fail( const char* message, const Context& context, + const char* file = "unknown location", int line = 0 ) { - scoped_lock _(error_mutex); - Error::fail(message, context, file, line); + scoped_lock _( error_mutex ); + Error::fail( message, context, file, line ); } - template - static void call(const Context& context, const char* file, int line) + template< typename Context > + static void call( const Context& context, const char* file, int line ) { - scoped_lock _(error_mutex); - Error::call(context, file, line); + scoped_lock _( error_mutex ); + Error::call( context, file, line ); } - static void pass(const char* file, int line) + static void pass( const char* file, int line ) { - scoped_lock _(error_mutex); - Error::pass(file, line); + scoped_lock _( error_mutex ); + Error::pass( file, line ); } }; #ifdef BOOST_MSVC -# pragma warning(pop) +# pragma warning( pop ) #endif -}} // namespace mock::detail +} +} // mock #endif // MOCK_MUTEX_HPP_INCLUDED diff --git a/include/turtle/detail/object_impl.hpp b/include/turtle/detail/object_impl.hpp index 081aeb2..6aa215f 100644 --- a/include/turtle/detail/object_impl.hpp +++ b/include/turtle/detail/object_impl.hpp @@ -10,51 +10,58 @@ #define MOCK_OBJECT_IMPL_HPP_INCLUDED #include "../config.hpp" -#include "child.hpp" -#include "context.hpp" -#include "mutex.hpp" -#include "parent.hpp" #include "root.hpp" +#include "parent.hpp" #include "type_name.hpp" -#include +#include "context.hpp" +#include "child.hpp" +#include "mutex.hpp" #include +#include +#include +#include -namespace mock { namespace detail { - class object_impl : public context, public verifiable, public std::enable_shared_from_this +namespace mock +{ +namespace detail +{ + class object_impl : public context, public verifiable, + public boost::enable_shared_from_this< object_impl > { public: - object_impl() : mutex_(std::make_shared()) {} + object_impl() + : mutex_( boost::make_shared< mutex >() ) + {} - virtual void add(const void* /*p*/, - verifiable& v, - boost::unit_test::const_string instance, - boost::optional type, - boost::unit_test::const_string name) + virtual void add( const void* /*p*/, verifiable& v, + boost::unit_test::const_string instance, + boost::optional< type_name > type, + boost::unit_test::const_string name ) { - lock _(mutex_); - if(children_.empty()) - detail::root.add(*this); - children_[&v].update(parent_, instance, type, name); + lock _( mutex_ ); + if( children_.empty() ) + detail::root.add( *this ); + children_[ &v ].update( parent_, instance, type, name ); } - virtual void add(verifiable& v) + virtual void add( verifiable& v ) { - lock _(mutex_); - group_.add(v); + lock _( mutex_ ); + group_.add( v ); } - virtual void remove(verifiable& v) + virtual void remove( verifiable& v ) { - lock _(mutex_); - group_.remove(v); - children_.erase(&v); - if(children_.empty()) - detail::root.remove(*this); + lock _( mutex_ ); + group_.remove( v ); + children_.erase( &v ); + if( children_.empty() ) + detail::root.remove( *this ); } - virtual void serialize(std::ostream& s, const verifiable& v) const + virtual void serialize( std::ostream& s, const verifiable& v ) const { - lock _(mutex_); - const auto it = children_.find(&v); - if(it != children_.end()) + lock _( mutex_ ); + children_cit it = children_.find( &v ); + if( it != children_.end() ) s << it->second; else s << "?"; @@ -62,22 +69,26 @@ namespace mock { namespace detail { virtual bool verify() const { - lock _(mutex_); + lock _( mutex_ ); return group_.verify(); } virtual void reset() { - lock _(mutex_); - std::shared_ptr guard = shared_from_this(); + lock _( mutex_ ); + boost::shared_ptr< object_impl > guard = shared_from_this(); group_.reset(); } private: + typedef std::map< const verifiable*, child > children_t; + typedef children_t::const_iterator children_cit; + group group_; parent parent_; - std::map children_; - const std::shared_ptr mutex_; + children_t children_; + const boost::shared_ptr< mutex > mutex_; }; -}} // namespace mock::detail +} +} // mock #endif // MOCK_OBJECT_IMPL_HPP_INCLUDED diff --git a/include/turtle/detail/parameter.hpp b/include/turtle/detail/parameter.hpp new file mode 100644 index 0000000..38925a2 --- /dev/null +++ b/include/turtle/detail/parameter.hpp @@ -0,0 +1,34 @@ +// http://turtle.sourceforge.net +// +// Copyright Mathieu Champlon 2012 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef MOCK_PARAMETER_HPP_INCLUDED +#define MOCK_PARAMETER_HPP_INCLUDED + +#include "../config.hpp" +#include +#include +#include + +namespace mock +{ +namespace detail +{ + template< typename Signature, int n > + struct parameter + { + typedef typename + boost::mpl::at_c< + typename + boost::function_types::parameter_types< Signature >, + n + >::type type; + }; +} +} // mock + +#endif // MOCK_PARAMETER_HPP_INCLUDED diff --git a/include/turtle/detail/parent.hpp b/include/turtle/detail/parent.hpp index 8c3352e..0d14e77 100644 --- a/include/turtle/detail/parent.hpp +++ b/include/turtle/detail/parent.hpp @@ -11,30 +11,36 @@ #include "../config.hpp" #include "type_name.hpp" -#include #include +#include #include -namespace mock { namespace detail { +namespace mock +{ +namespace detail +{ class parent { public: - parent() = default; - parent(boost::unit_test::const_string instance, boost::optional type) - : instance_(instance), type_(type) + parent() {} - friend std::ostream& operator<<(std::ostream& s, const parent& p) + parent( boost::unit_test::const_string instance, + boost::optional< type_name > type ) + : instance_( instance ) + , type_( type ) + {} + friend std::ostream& operator<<( std::ostream& s, const parent& p ) { s << p.instance_; - if(p.type_) + if( p.type_ ) s << *p.type_ << "::"; return s; } - private: boost::unit_test::const_string instance_; - boost::optional type_; + boost::optional< type_name > type_; }; -}} // namespace mock::detail +} +} // mock #endif // MOCK_PARENT_HPP_INCLUDED diff --git a/include/turtle/detail/ref_arg.hpp b/include/turtle/detail/ref_arg.hpp deleted file mode 100644 index abd755f..0000000 --- a/include/turtle/detail/ref_arg.hpp +++ /dev/null @@ -1,22 +0,0 @@ -// http://turtle.sourceforge.net -// -// Copyright Mathieu Champlon 2018 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#ifndef MOCK_REF_ARG_HPP_INCLUDED -#define MOCK_REF_ARG_HPP_INCLUDED - -#include - -namespace mock { namespace detail { - /// Make T a reference type: - /// If T is already a reference type, return T, else return an rvalue reference to T - /// Useful to pass along arguments keeping the ability to modify them (e.g. move from them) - template - using ref_arg_t = typename std::conditional::value, T, std::add_rvalue_reference_t>::type; -}} // namespace mock::detail - -#endif // MOCK_REF_ARG_HPP_INCLUDED diff --git a/include/turtle/detail/root.hpp b/include/turtle/detail/root.hpp index 664ce0a..dae3790 100644 --- a/include/turtle/detail/root.hpp +++ b/include/turtle/detail/root.hpp @@ -10,110 +10,128 @@ #define MOCK_ROOT_HPP_INCLUDED #include "../config.hpp" -#include "child.hpp" -#include "context.hpp" -#include "group.hpp" -#include "mutex.hpp" #include "parent.hpp" +#include "group.hpp" +#include "context.hpp" +#include "child.hpp" +#include "mutex.hpp" #include "singleton.hpp" #include -#include #include +#include -namespace mock { namespace detail { - class root_t : public singleton, public context +namespace mock +{ +namespace detail +{ + class root_t : public singleton< root_t >, public context { public: - virtual void add(const void* p, - verifiable& v, - boost::unit_test::const_string instance, - boost::optional type, - boost::unit_test::const_string name) + virtual void add( const void* p, verifiable& v, + boost::unit_test::const_string instance, + boost::optional< type_name > type, + boost::unit_test::const_string name ) { - scoped_lock _(mutex_); - auto it = children_.lower_bound(&v); - if(it == children_.end() || children_.key_comp()(&v, it->first)) - it = children_.insert(it, std::make_pair(&v, counter_child(parents_, p))); - it->second.update(instance, type, name); + scoped_lock _( mutex_ ); + children_t::iterator it = children_.lower_bound( &v ); + if( it == children_.end() || + children_.key_comp()( &v, it->first ) ) + it = children_.insert( it, + std::make_pair( &v, counter_child( parents_, p ) ) ); + it->second.update( instance, type, name ); } - virtual void add(verifiable& v) + virtual void add( verifiable& v ) { - scoped_lock _(mutex_); - group_.add(v); + scoped_lock _( mutex_ ); + group_.add( v ); } - virtual void remove(verifiable& v) + virtual void remove( verifiable& v ) { - scoped_lock _(mutex_); - group_.remove(v); - children_.erase(&v); + scoped_lock _( mutex_ ); + group_.remove( v ); + children_.erase( &v ); } bool verify() const { - scoped_lock _(mutex_); + scoped_lock _( mutex_ ); return group_.verify(); } void reset() { - scoped_lock _(mutex_); + scoped_lock _( mutex_ ); group_.reset(); } - virtual void serialize(std::ostream& s, const verifiable& v) const + virtual void serialize( std::ostream& s, const verifiable& v ) const { - scoped_lock _(mutex_); - const auto it = children_.find(&v); - if(it != children_.end()) + scoped_lock _( mutex_ ); + children_cit it = children_.find( &v ); + if( it != children_.end() ) s << it->second; else s << "?"; } private: - typedef std::map> parents_t; + typedef std::map< const void*, + std::pair< parent, std::size_t > > parents_t; class counter_child { public: - counter_child(parents_t& parents, const void* p) - : parents_(&parents), it_(parents.insert(std::make_pair(p, parents_t::mapped_type())).first) + counter_child( parents_t& parents, const void* p ) + : parents_( &parents ) + , it_( parents.insert( + std::make_pair( p, parents_t::mapped_type() ) ).first ) { ++it_->second.second; } - counter_child(const counter_child& rhs) : parents_(rhs.parents_), it_(rhs.it_), child_(rhs.child_) + counter_child( const counter_child& rhs ) + : parents_( rhs.parents_ ) + , it_( rhs.it_ ) + , child_( rhs.child_ ) { ++it_->second.second; } ~counter_child() { - if(--it_->second.second == 0) - parents_->erase(it_); + if( --it_->second.second == 0 ) + parents_->erase( it_ ); } - void update(boost::unit_test::const_string instance, - boost::optional type, - boost::unit_test::const_string name) + void update( boost::unit_test::const_string instance, + boost::optional< type_name > type, + boost::unit_test::const_string name ) { - child_.update(it_->second.first, instance, type, name); + child_.update( it_->second.first, instance, type, name ); + } + friend std::ostream& operator<<( std::ostream& s, + const counter_child& c ) + { + return s << c.child_; } - friend std::ostream& operator<<(std::ostream& s, const counter_child& c) { return s << c.child_; } private: - counter_child& operator=(const counter_child&); + counter_child& operator=( const counter_child& ); parents_t* parents_; parents_t::iterator it_; child child_; }; + typedef std::map< const verifiable*, counter_child > children_t; + typedef children_t::const_iterator children_cit; + parents_t parents_; - std::map children_; + children_t children_; group group_; mutable mutex mutex_; - MOCK_SINGLETON_CONS(root_t); + MOCK_SINGLETON_CONS( root_t ); }; - MOCK_SINGLETON_INST(root) -}} // namespace mock::detail + MOCK_SINGLETON_INST( root ) +} +} // mock #endif // MOCK_ROOT_HPP_INCLUDED diff --git a/include/turtle/detail/sequence_impl.hpp b/include/turtle/detail/sequence_impl.hpp index 79d6fa0..c7d3ce6 100644 --- a/include/turtle/detail/sequence_impl.hpp +++ b/include/turtle/detail/sequence_impl.hpp @@ -11,45 +11,57 @@ #include "../config.hpp" #include "mutex.hpp" +#include +#include #include -#include #include -namespace mock { namespace detail { - class sequence_impl +namespace mock +{ +namespace detail +{ + class sequence_impl : private boost::noncopyable { public: - sequence_impl() : mutex_(std::make_shared()) {} + sequence_impl() + : mutex_( boost::make_shared< mutex >() ) + {} - void add(void* e) + void add( void* e ) { - lock _(mutex_); - elements_.push_back(e); + lock _( mutex_ ); + elements_.push_back( e ); } - void remove(void* e) + void remove( void* e ) { - lock _(mutex_); - elements_.erase(std::remove(elements_.begin(), elements_.end(), e), elements_.end()); + lock _( mutex_ ); + elements_.erase( std::remove( elements_.begin(), + elements_.end(), e ), elements_.end() ); } - bool is_valid(const void* e) const + bool is_valid( const void* e ) const { - lock _(mutex_); - return std::find(elements_.begin(), elements_.end(), e) != elements_.end(); + lock _( mutex_ ); + return std::find( elements_.begin(), elements_.end(), e ) + != elements_.end(); } - void invalidate(const void* e) + void invalidate( const void* e ) { - lock _(mutex_); - const auto it = std::find(elements_.begin(), elements_.end(), e); - if(it != elements_.end()) - elements_.erase(elements_.begin(), it); + lock _( mutex_ ); + elements_type::iterator it = + std::find( elements_.begin(), elements_.end(), e ); + if( it != elements_.end() ) + elements_.erase( elements_.begin(), it ); } private: - std::vector elements_; - const std::shared_ptr mutex_; + typedef std::vector< void* > elements_type; + + elements_type elements_; + const boost::shared_ptr< mutex > mutex_; }; -}} // namespace mock::detail +} +} // mock #endif // MOCK_SEQUENCE_IMPL_HPP_INCLUDED diff --git a/include/turtle/detail/signature.hpp b/include/turtle/detail/signature.hpp index cb4b3eb..03c016c 100644 --- a/include/turtle/detail/signature.hpp +++ b/include/turtle/detail/signature.hpp @@ -10,68 +10,54 @@ #define MOCK_SIGNATURE_HPP_INCLUDED #include "../config.hpp" -#include +#include +#include +#include +#include +#include +#include +#define BOOST_TYPEOF_SILENT +#include -namespace mock { namespace detail { -#define MOCK_NOARG -#define MOCK_STRIP_FUNCTION_QUALIFIERS(cv, ref) \ - template \ - struct strip_function_qualifiers \ - { \ - using type = R(Args...); \ - }; \ - template \ - struct strip_function_qualifiers \ - { \ - using type = R(Args..., ...); \ - }; - -#define MOCK_STRIP_FUNCTION_QUALIFIERS_REF(cv) \ - MOCK_STRIP_FUNCTION_QUALIFIERS(cv, ) \ - MOCK_STRIP_FUNCTION_QUALIFIERS(cv, &) \ - MOCK_STRIP_FUNCTION_QUALIFIERS(cv, &&) - - template - struct strip_function_qualifiers; - MOCK_STRIP_FUNCTION_QUALIFIERS_REF(MOCK_NOARG) - MOCK_STRIP_FUNCTION_QUALIFIERS_REF(const) - MOCK_STRIP_FUNCTION_QUALIFIERS_REF(volatile) - MOCK_STRIP_FUNCTION_QUALIFIERS_REF(const volatile) -#undef MOCK_NOARG -#undef MOCK_STRIP_FUNCTION_QUALIFIERS -#undef MOCK_STRIP_FUNCTION_QUALIFIERS_REF - - template - struct signature; - - template - struct signature - { - using type = R(Args...); - }; - - template - struct signature : signature::type> +namespace mock +{ +namespace detail +{ + template< typename M > + struct signature : + boost::function_types::function_type< + boost::mpl::joint_view< + boost::mpl::single_view< + typename + boost::function_types::result_type< M >::type + >, + typename boost::mpl::pop_front< + typename + boost::function_types::parameter_types< M > + >::type + > + > {}; - /// Return the (non-member) function signature out of (any) signature - template - using signature_t = typename signature::type; - - /// CRTP class to define the base_type typedef - template + template< typename T > struct base { - using base_type = T; + typedef T base_type; }; - // If an error is generated by the line below it means the method is ambiguous. - // Specify its signature to disambiguate - template - T ambiguous_method_requires_to_specify_signature(const T&); -}} // namespace mock::detail + // if an error is generated by the line below it means + // the method is ambiguous : specify its signature to + // disambiguate + template< typename T > + T& ambiguous_method_requires_to_specify_signature( const T& ); +} +} // mock #define MOCK_SIGNATURE(M) \ - mock::detail::signature_t + mock::detail::signature< \ + BOOST_TYPEOF( \ + mock::detail::ambiguous_method_requires_to_specify_signature( \ + &base_type::M ) ) \ + >::type #endif // MOCK_SIGNATURE_HPP_INCLUDED diff --git a/include/turtle/detail/signature_traits.hpp b/include/turtle/detail/signature_traits.hpp deleted file mode 100644 index 02c108f..0000000 --- a/include/turtle/detail/signature_traits.hpp +++ /dev/null @@ -1,62 +0,0 @@ -// http://turtle.sourceforge.net -// -// Copyright Mathieu Champlon 2012 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#ifndef MOCK_SIGNATURE_TRAITS_HPP_INCLUDED -#define MOCK_SIGNATURE_TRAITS_HPP_INCLUDED - -#include "../config.hpp" -#include - -namespace mock { namespace detail { - /// Helper class to store a tuple/list of types - template - struct tuple; - - /// Get the type at the given index in the tuple - template - struct tuple_element; - - template - struct tuple_element> : tuple_element> - {}; - - template - struct tuple_element<0, tuple> - { - using type = H; - }; - - /// Provides information about a given function signature - /// Member types: return_type, args - /// Member constant: arity - template - struct signature_traits; - - template - struct signature_traits - { - using return_type = R; - static constexpr std::size_t arity = sizeof...(Args); - using args = tuple; - }; - - /// Return the result type of the function signature - template - using result_type_t = typename signature_traits::return_type; - - /// Return the arity of the function signature - template - using function_arity_t = std::integral_constant::arity>; - - /// Return the type at the given index of the function signature - template - using parameter_t = typename tuple_element::args>::type; - -}} // namespace mock::detail - -#endif // MOCK_SIGNATURE_TRAITS_HPP_INCLUDED diff --git a/include/turtle/detail/singleton.hpp b/include/turtle/detail/singleton.hpp index e1f4ae6..2080750 100644 --- a/include/turtle/detail/singleton.hpp +++ b/include/turtle/detail/singleton.hpp @@ -11,34 +11,36 @@ #include -namespace mock { namespace detail { +namespace mock { +namespace detail { - template - class singleton +template< typename Derived > +class singleton { +public: + static Derived& instance() { - public: - static Derived& instance() - { - static Derived the_inst; - return the_inst; - } + static Derived the_inst; + return the_inst; + } - singleton(singleton const&) = delete; - singleton& operator=(singleton const&) = delete; + BOOST_DELETED_FUNCTION(singleton(singleton const&)) + BOOST_DELETED_FUNCTION(singleton& operator=(singleton const&)) - protected: - singleton() = default; - ~singleton() = default; - }; +protected: + BOOST_DEFAULTED_FUNCTION(singleton(), {}) + BOOST_DEFAULTED_FUNCTION(~singleton(), {}) +}; -}} // namespace mock::detail +} // detail +} // mock // Add a private ctor to the type to prevent misuse -#define MOCK_SINGLETON_CONS(type) \ -private: \ - friend class mock::detail::singleton; \ - type() = default +#define MOCK_SINGLETON_CONS( type ) \ +private: \ +friend class mock::detail::singleton< type >; \ +type() {} -#define MOCK_SINGLETON_INST(inst) static BOOST_JOIN(inst, _t)& inst = BOOST_JOIN(inst, _t)::instance(); +#define MOCK_SINGLETON_INST( inst ) \ +static BOOST_JOIN( inst, _t )& inst = BOOST_JOIN( inst, _t )::instance(); #endif // MOCK_SINGLETON_HPP diff --git a/include/turtle/detail/type_name.hpp b/include/turtle/detail/type_name.hpp index 1aaa79d..8867d81 100644 --- a/include/turtle/detail/type_name.hpp +++ b/include/turtle/detail/type_name.hpp @@ -10,110 +10,107 @@ #define MOCK_TYPE_NAME_HPP_INCLUDED #include "../config.hpp" -#include -#include -#include #include -#include -#include -#include +#include +#include +#include +#include +#include #include #include +#include #ifdef __GNUC__ -# include -# include +#include +#include #endif -namespace mock { namespace detail { +#define MOCK_TYPE_NAME( t ) mock::detail::type_name( BOOST_SP_TYPEID(t) ) + +namespace mock +{ +namespace detail +{ class type_name { public: - explicit type_name(const std::type_info& info) : info_(&info) {} - friend std::ostream& operator<<(std::ostream& s, const type_name& t) + explicit type_name( const boost::detail::sp_typeinfo& info ) + : info_( &info ) + {} + friend std::ostream& operator<<( std::ostream& s, const type_name& t ) { - t.serialize(s, *t.info_); + t.serialize( s, *t.info_ ); return s; } - private: - static void serialize(std::ostream& s, const std::type_info& info) + void serialize( std::ostream& s, + const boost::detail::sp_typeinfo& info ) const { const char* name = info.name(); #ifdef __GNUC__ int status = 0; - struct Deleter - { - void operator()(const void* p) { std::free(const_cast(p)); } - }; - std::unique_ptr demangled(abi::__cxa_demangle(name, 0, 0, &status)); - if(!status && demangled) - name = demangled.get(); + boost::shared_ptr< char > demangled( + abi::__cxa_demangle( name, 0, 0, &status ), + &std::free ); + if( ! status && demangled ) + serialize( s, demangled.get() ); + else #endif - serialize(s, name); + serialize( s, name ); } typedef std::string::size_type size_type; - static void serialize(std::ostream& s, std::string name) + void serialize( std::ostream& s, std::string name ) const { - const size_type nm = rfind(name, ':') + 1; - const size_type tpl = name.find('<', nm); - s << clean(name.substr(nm, tpl - nm)); - if(tpl == std::string::npos) + const size_type nm = rfind( name, ':' ) + 1; + const size_type tpl = name.find( '<', nm ); + s << clean( name.substr( nm, tpl - nm ) ); + if( tpl == std::string::npos ) return; s << '<'; - list(s, name.substr(tpl + 1, name.rfind('>') - tpl - 1)); + list( s, name.substr( tpl + 1, name.rfind( '>' ) - tpl - 1 ) ); s << '>'; } - static void list(std::ostream& s, const std::string& name) + void list( std::ostream& s, const std::string& name ) const { - const size_type comma = rfind(name, ','); - if(comma != std::string::npos) + const size_type comma = rfind( name, ',' ); + if( comma != std::string::npos ) { - list(s, name.substr(0, comma)); + list( s, name.substr( 0, comma ) ); s << ", "; } - serialize(s, name.substr(comma + 1)); + serialize( s, name.substr( comma + 1 ) ); } - static std::string clean(std::string name) + std::string clean( std::string name ) const { - boost::algorithm::trim(name); - boost::algorithm::erase_all(name, "class "); - boost::algorithm::erase_all(name, "struct "); - boost::algorithm::erase_all(name, "__ptr64"); - boost::algorithm::replace_all(name, " &", "&"); - boost::algorithm::replace_all(name, "& ", "&"); - boost::algorithm::replace_all(name, " *", "*"); - boost::algorithm::replace_all(name, "* ", "*"); + boost::algorithm::trim( name ); + boost::algorithm::erase_all( name, "class " ); + boost::algorithm::erase_all( name, "struct " ); + boost::algorithm::erase_all( name, "__ptr64" ); + boost::algorithm::replace_all( name, " &", "&" ); + boost::algorithm::replace_all( name, "& ", "&" ); + boost::algorithm::replace_all( name, " *", "*" ); + boost::algorithm::replace_all( name, "* ", "*" ); return name; } - static size_type rfind(const std::string& name, char c) + size_type rfind( const std::string& name, char c ) const { size_type count = 0; - for(size_type i = name.size() - 1; i > 0; --i) + for( size_type i = name.size() - 1; i > 0; --i ) { - if(name[i] == '>') + if( name[ i ] == '>' ) ++count; - else if(name[i] == '<') + else if( name[ i ] == '<' ) --count; - if(name[i] == c && count == 0) + if( name[ i ] == c && count == 0 ) return i; } return std::string::npos; } - const std::type_info* info_; + const boost::detail::sp_typeinfo* info_; }; - template - type_name make_type_name() - { - return type_name(typeid(T)); - } - template - type_name make_type_name(const T&) - { - return type_name(typeid(T)); - } -}} // namespace mock::detail +} +} // mock #endif // MOCK_TYPE_NAME_HPP_INCLUDED diff --git a/include/turtle/detail/verifiable.hpp b/include/turtle/detail/verifiable.hpp index f6f2150..5d85c93 100644 --- a/include/turtle/detail/verifiable.hpp +++ b/include/turtle/detail/verifiable.hpp @@ -10,20 +10,23 @@ #define MOCK_VERIFIABLE_HPP_INCLUDED #include "../config.hpp" +#include -namespace mock { namespace detail { - class verifiable +namespace mock +{ +namespace detail +{ + class verifiable : private boost::noncopyable { public: - verifiable() = default; - verifiable(const verifiable&) = delete; - verifiable& operator=(const verifiable&) = delete; - virtual ~verifiable() = default; + verifiable() {} + virtual ~verifiable() {} virtual bool verify() const = 0; virtual void reset() = 0; }; -}} // namespace mock::detail +} +} // mock #endif // MOCK_VERIFIABLE_HPP_INCLUDED diff --git a/include/turtle/detail/void_t.hpp b/include/turtle/detail/void_t.hpp deleted file mode 100644 index acc2b6b..0000000 --- a/include/turtle/detail/void_t.hpp +++ /dev/null @@ -1,23 +0,0 @@ -// http://turtle.sourceforge.net -// -// Copyright Alexander Grund 2020 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#ifndef MOCK_VOID_T_HPP_INCLUDED -#define MOCK_VOID_T_HPP_INCLUDED - -namespace mock { namespace detail { - template - struct make_void - { - using type = void; - }; - /// Standard helper to implement the detection idiom. Returns always void - template - using void_t = typename make_void::type; -}} // namespace mock::detail - -#endif // MOCK_VOID_T_HPP_INCLUDED diff --git a/include/turtle/error.hpp b/include/turtle/error.hpp index fd48a3e..95be42c 100644 --- a/include/turtle/error.hpp +++ b/include/turtle/error.hpp @@ -11,59 +11,69 @@ #include "config.hpp" #ifdef MOCK_USE_BOOST_TEST -# include "exception.hpp" -# include -# include -# include -# include -# include +#include "exception.hpp" +#include +#include +#include +#include +#include -namespace mock { -template -struct error +namespace mock { - static Result abort() + template< typename Result > + struct error { - boost::unit_test::framework::test_unit_aborted(boost::unit_test::framework::current_test_case()); - throw boost::enable_current_exception(exception()); - } + static Result abort() + { + boost::unit_test::framework::test_unit_aborted( + boost::unit_test::framework::current_test_case() ); + throw boost::enable_current_exception( exception() ); + } - static void pass(const char* file, int line) - { - boost::unit_test::unit_test_log.set_checkpoint(file, static_cast(line)); - } + static void pass( const char* file, int line ) + { + boost::unit_test::unit_test_log.set_checkpoint( file, + static_cast< std::size_t >( line ) ); + } - template - static void fail(const char* message, const Context& context, const char* file = "unknown location", int line = 0) - { - boost::unit_test::framework::assertion_result( -# if BOOST_VERSION < 105900 - false -# else - boost::unit_test::AR_FAILED -# endif - ); - boost::unit_test::unit_test_log << boost::unit_test::log::begin(file, static_cast(line)) - << boost::unit_test::log_all_errors << message << ": " << context - << boost::unit_test::log::end(); - } + template< typename Context > + static void fail( const char* message, const Context& context, + const char* file = "unknown location", int line = 0 ) + { + boost::unit_test::framework::assertion_result( +#if BOOST_VERSION < 105900 + false +#else + boost::unit_test::AR_FAILED +#endif + ); + boost::unit_test::unit_test_log + << boost::unit_test::log::begin( file, + static_cast< std::size_t >( line ) ) + << boost::unit_test::log_all_errors + << message << ": " << context + << boost::unit_test::log::end(); + } - template - static void call(const Context& context, const char* file, int line) - { - boost::unit_test::framework::assertion_result( -# if BOOST_VERSION < 105900 - true -# else - boost::unit_test::AR_PASSED -# endif - ); - boost::unit_test::unit_test_log << boost::unit_test::log::begin(file, static_cast(line)) - << boost::unit_test::log_successful_tests - << "mock expectation fulfilled: " << context << boost::unit_test::log::end(); - } -}; -} // namespace mock + template< typename Context > + static void call( const Context& context, const char* file, int line ) + { + boost::unit_test::framework::assertion_result( +#if BOOST_VERSION < 105900 + true +#else + boost::unit_test::AR_PASSED +#endif + ); + boost::unit_test::unit_test_log + << boost::unit_test::log::begin( file, + static_cast< std::size_t >( line ) ) + << boost::unit_test::log_successful_tests + << "mock expectation fulfilled: " << context + << boost::unit_test::log::end(); + } + }; +} // mock #endif // MOCK_USE_BOOST_TEST diff --git a/include/turtle/exception.hpp b/include/turtle/exception.hpp index ced9893..4e7796c 100644 --- a/include/turtle/exception.hpp +++ b/include/turtle/exception.hpp @@ -11,12 +11,13 @@ #include "config.hpp" #ifdef MOCK_USE_BOOST_TEST -# include +#include -namespace mock { -struct exception : virtual boost::execution_aborted -{}; -} // namespace mock +namespace mock +{ + struct exception : virtual boost::execution_aborted + {}; +} // mock #endif // MOCK_USE_BOOST_TEST diff --git a/include/turtle/format.hpp b/include/turtle/format.hpp index 56aa1e1..6b4095c 100644 --- a/include/turtle/format.hpp +++ b/include/turtle/format.hpp @@ -12,13 +12,14 @@ #include "config.hpp" #include "detail/formatter.hpp" -namespace mock { -template -detail::formatter format(const T& t) +namespace mock { - return detail::formatter(t); -} + template< typename T > + detail::formatter< T > format( const T& t ) + { + return detail::formatter< T >( t ); + } -} // namespace mock +} // mock #endif // MOCK_FORMAT_HPP_INCLUDED diff --git a/include/turtle/log.hpp b/include/turtle/log.hpp index c87b259..104c9fe 100644 --- a/include/turtle/log.hpp +++ b/include/turtle/log.hpp @@ -10,187 +10,195 @@ #define MOCK_LOG_HPP_INCLUDED #include "config.hpp" -#include "format.hpp" #include "stream.hpp" +#include "format.hpp" +#include #include +#include #include #include -#include -namespace boost { -template -class shared_ptr; -template -class weak_ptr; -template -class reference_wrapper; -template -class optional; +namespace boost +{ + template< typename T > class shared_ptr; + template< typename T > class weak_ptr; + template< typename T > class reference_wrapper; + template< typename T > class optional; -namespace phoenix { - template - struct actor; +namespace phoenix +{ + template< typename T > struct actor; } -namespace lambda { - template - class lambda_functor; +namespace lambda +{ + template< typename T > class lambda_functor; +} +namespace assign_detail +{ + template< typename T > class generic_list; } -namespace assign_detail { - template - class generic_list; } -} // namespace boost -namespace mock { -namespace detail { - template - void serialize(stream& s, const T& begin, const T& end) +namespace mock +{ +namespace detail +{ + template< typename T > + void serialize( stream& s, const T& begin, const T& end ) { s << '('; - for(T it = begin; it != end; ++it) - s << (it == begin ? "" : ",") << mock::format(*it); + for( T it = begin; it != end; ++it ) + s << (it == begin ? "" : ",") << mock::format( *it ); s << ')'; } - template - struct is_callable_impl : std::false_type - {}; - template - struct is_callable_impl : std::true_type - {}; - template - struct is_callable : is_callable_impl> - {}; -} // namespace detail - -template -stream& operator<<(stream& s, const std::pair& p) -{ - return s << '(' << mock::format(p.first) << ',' << mock::format(p.second) << ')'; } -template -stream& operator<<(stream& s, const std::deque& t) -{ - detail::serialize(s, t.begin(), t.end()); - return s; -} -template -stream& operator<<(stream& s, const std::list& t) -{ - detail::serialize(s, t.begin(), t.end()); - return s; -} -template -stream& operator<<(stream& s, const std::vector& t) -{ - detail::serialize(s, t.begin(), t.end()); - return s; -} -template -stream& operator<<(stream& s, const std::map& t) -{ - detail::serialize(s, t.begin(), t.end()); - return s; -} -template -stream& operator<<(stream& s, const std::multimap& t) -{ - detail::serialize(s, t.begin(), t.end()); - return s; -} -template -stream& operator<<(stream& s, const std::set& t) -{ - detail::serialize(s, t.begin(), t.end()); - return s; -} -template -stream& operator<<(stream& s, const std::multiset& t) -{ - detail::serialize(s, t.begin(), t.end()); - return s; -} -template -stream& operator<<(stream& s, const boost::assign_detail::generic_list& t) -{ - detail::serialize(s, t.begin(), t.end()); - return s; -} -template -stream& operator<<(stream& s, const boost::reference_wrapper& t) -{ - return s << mock::format(t.get()); -} -template -stream& operator<<(stream& s, const std::reference_wrapper& t) -{ - return s << mock::format(t.get()); -} -template -stream& operator<<(stream& s, const boost::shared_ptr& t) -{ - return s << mock::format(t.get()); -} -template -stream& operator<<(stream& s, const boost::weak_ptr& t) -{ - return s << mock::format(t.lock()); -} -inline stream& operator<<(stream& s, const boost::none_t&) -{ - return s << "none"; -} -template -stream& operator<<(stream& s, const boost::optional& t) -{ - if(t) - return s << mock::format(t.get()); - return s << boost::none; -} +#ifdef MOCK_AUTO_PTR + template< typename T > + stream& operator<<( stream& s, const std::auto_ptr< T >& t ) + { + return s << mock::format( t.get() ); + } +#endif // MOCK_AUTO_PTR -template -stream& operator<<(stream& s, const std::shared_ptr& t) -{ - return s << mock::format(t.get()); -} -template -stream& operator<<(stream& s, const std::weak_ptr& t) -{ - return s << mock::format(t.lock()); -} -template -stream& operator<<(stream& s, const std::unique_ptr& p) -{ - return s << mock::format(p.get()); -} + template< typename T1, typename T2 > + stream& operator<<( stream& s, const std::pair< T1, T2 >& p ) + { + return s << '(' << mock::format( p.first ) + << ',' << mock::format( p.second ) << ')'; + } -template -stream& operator<<(stream& s, const boost::lambda::lambda_functor&) -{ - return s << '?'; -} -template -stream& operator<<(stream& s, const boost::phoenix::actor&) -{ - return s << '?'; -} + template< typename T, typename A > + stream& operator<<( stream& s, const std::deque< T, A >& t ) + { + detail::serialize( s, t.begin(), t.end() ); + return s; + } + template< typename T, typename A > + stream& operator<<( stream& s, const std::list< T, A >& t ) + { + detail::serialize( s, t.begin(), t.end() ); + return s; + } + template< typename T, typename A > + stream& operator<<( stream& s, const std::vector< T, A >& t ) + { + detail::serialize( s, t.begin(), t.end() ); + return s; + } + template< typename K, typename T, typename C, typename A > + stream& operator<<( stream& s, const std::map< K, T, C, A >& t ) + { + detail::serialize( s, t.begin(), t.end() ); + return s; + } + template< typename K, typename T, typename C, typename A > + stream& operator<<( stream& s, const std::multimap< K, T, C, A >& t ) + { + detail::serialize( s, t.begin(), t.end() ); + return s; + } + template< typename T, typename C, typename A > + stream& operator<<( stream& s, const std::set< T, C, A >& t ) + { + detail::serialize( s, t.begin(), t.end() ); + return s; + } + template< typename T, typename C, typename A > + stream& operator<<( stream& s, const std::multiset< T, C, A >& t ) + { + detail::serialize( s, t.begin(), t.end() ); + return s; + } + template< typename T > + stream& operator<<( stream& s, + const boost::assign_detail::generic_list< T >& t ) + { + detail::serialize( s, t.begin(), t.end() ); + return s; + } + template< typename T > + stream& operator<<( stream& s, const boost::reference_wrapper< T >& t ) + { + return s << mock::format( t.get() ); + } + template< typename T > + stream& operator<<( stream& s, const boost::shared_ptr< T >& t ) + { + return s << mock::format( t.get() ); + } + template< typename T > + stream& operator<<( stream& s, const boost::weak_ptr< T >& t ) + { + return s << mock::format( t.lock() ); + } + inline stream& operator<<( stream& s, const boost::none_t& ) + { + return s << "none"; + } + template< typename T > + stream& operator<<( stream& s, const boost::optional< T >& t ) + { + if( t ) + return s << mock::format( t.get() ); + return s << boost::none; + } -inline stream& operator<<(stream& s, std::nullptr_t) -{ - return s << "nullptr"; -} +#ifdef MOCK_SMART_PTR + template< typename T > + stream& operator<<( stream& s, const std::shared_ptr< T >& t ) + { + return s << mock::format( t.get() ); + } + template< typename T > + stream& operator<<( stream& s, const std::weak_ptr< T >& t ) + { + return s << mock::format( t.lock() ); + } + template< typename T, typename D > + stream& operator<<( stream& s, const std::unique_ptr< T, D >& p ) + { + return s << mock::format( p.get() ); + } +#endif -template -std::enable_if_t::value, stream&> operator<<(stream& s, T*) -{ - return s << '?'; -} -template -std::enable_if_t::value, stream&> operator<<(stream& s, T* t) -{ - *s.s_ << t; - return s; -} -} // namespace mock + template< typename T > + stream& operator<<( stream& s, const boost::lambda::lambda_functor< T >& ) + { + return s << '?'; + } + template< typename T > + stream& operator<<( stream& s, const boost::phoenix::actor< T >& ) + { + return s << '?'; + } + +#ifdef MOCK_NULLPTR + inline stream& operator<<( stream& s, std::nullptr_t ) + { + return s << "nullptr"; + } +#endif + + template< typename T > + typename boost::enable_if< + boost::function_types::is_callable_builtin< T >, + stream& + >::type + operator<<( stream& s, T* ) + { + return s << '?'; + } + template< typename T > + typename boost::disable_if< + boost::function_types::is_callable_builtin< T >, + stream& + >::type + operator<<( stream& s, T* t ) + { + *s.s_ << t; + return s; + } +} // mock #endif // MOCK_LOG_HPP_INCLUDED diff --git a/include/turtle/matcher.hpp b/include/turtle/matcher.hpp index 3bd9923..c6082a7 100644 --- a/include/turtle/matcher.hpp +++ b/include/turtle/matcher.hpp @@ -10,70 +10,101 @@ #define MOCK_MATCHER_HPP_INCLUDED #include "config.hpp" +#include "log.hpp" #include "constraints.hpp" #include "detail/is_functor.hpp" -#include "detail/ref_arg.hpp" -#include "log.hpp" +#include "detail/move_helper.hpp" +#include +#include +#include #include -#include -#include -namespace mock { -template -class matcher +namespace mock { -public: - explicit matcher(Expected expected) : expected_(expected) {} - bool operator()(std::add_lvalue_reference_t actual) + template< typename Actual, typename Expected, typename Enable = void > + class matcher { - return mock::equal(mock::unwrap_ref(expected_)).c_(actual); - } - friend std::ostream& operator<<(std::ostream& s, const matcher& m) { return s << mock::format(m.expected_); } + public: + explicit matcher( Expected expected ) + : expected_( expected ) + {} + bool operator()( typename boost::add_reference< const Actual >::type actual ) + { + return mock::equal( + boost::unwrap_ref( expected_ ) ).c_( actual ); + } + friend std::ostream& operator<<( + std::ostream& s, const matcher& m ) + { + return s << mock::format( m.expected_ ); + } + private: + Expected expected_; + }; -private: - Expected expected_; -}; - -template<> -class matcher -{ -public: - explicit matcher(const char* expected) : expected_(expected) {} - bool operator()(const char* actual) + template<> + class matcher< const char*, const char* > { - if(!actual || !expected_) - return actual == expected_; - return std::strcmp(actual, expected_) == 0; - } - friend std::ostream& operator<<(std::ostream& s, const matcher& m) { return s << mock::format(m.expected_); } + public: + explicit matcher( const char* expected ) + : expected_( expected ) + {} + bool operator()( const char* actual ) + { + return std::strcmp( actual, expected_ ) == 0; + } + friend std::ostream& operator<<( + std::ostream& s, const matcher& m ) + { + return s << mock::format( m.expected_ ); + } + private: + const char* expected_; + }; -private: - const char* expected_; -}; + template< typename Actual, typename Constraint > + class matcher< Actual, mock::constraint< Constraint > > + { + public: + explicit matcher( const constraint< Constraint >& c ) + : c_( c.c_ ) + {} + bool operator()( typename detail::ref_arg< Actual >::type actual ) + { + return c_( mock::detail::move_if_not_lvalue_reference< typename detail::ref_arg< Actual >::type >( actual ) ); + } + friend std::ostream& operator<<( + std::ostream& s, const matcher& m ) + { + return s << mock::format( m.c_ ); + } + private: + Constraint c_; + }; -template -class matcher> -{ -public: - explicit matcher(const constraint& c) : c_(c.c_) {} - bool operator()(detail::ref_arg_t actual) { return c_(static_cast>(actual)); } - friend std::ostream& operator<<(std::ostream& s, const matcher& m) { return s << mock::format(m.c_); } - -private: - Constraint c_; -}; - -template -class matcher::value>> -{ -public: - explicit matcher(const Functor& f) : c_(f) {} - bool operator()(detail::ref_arg_t actual) { return c_(static_cast>(actual)); } - friend std::ostream& operator<<(std::ostream& s, const matcher& m) { return s << mock::format(m.c_); } - -private: - Functor c_; -}; -} // namespace mock + template< typename Actual, typename Functor > + class matcher< Actual, Functor, + typename boost::enable_if< + detail::is_functor< Functor, Actual > + >::type + > + { + public: + explicit matcher( const Functor& f ) + : c_( f ) + {} + bool operator()( typename detail::ref_arg< Actual >::type actual ) + { + return c_( mock::detail::move_if_not_lvalue_reference< typename detail::ref_arg< Actual >::type >( actual ) ); + } + friend std::ostream& operator<<( + std::ostream& s, const matcher& m ) + { + return s << mock::format( m.c_ ); + } + private: + Functor c_; + }; +} // mock #endif // MOCK_MATCHER_HPP_INCLUDED diff --git a/include/turtle/mock.hpp b/include/turtle/mock.hpp index 31d5dc8..0b44e02 100644 --- a/include/turtle/mock.hpp +++ b/include/turtle/mock.hpp @@ -1,7 +1,6 @@ // http://turtle.sourceforge.net // // Copyright Mathieu Champlon 2008 -// Copyright 2022-2025 Alexander Grund // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at @@ -10,116 +9,243 @@ #ifndef MOCK_MOCK_HPP_INCLUDED #define MOCK_MOCK_HPP_INCLUDED -#include "cleanup.hpp" #include "config.hpp" -#include "detail/mock_impl.hpp" #include "object.hpp" #include "reset.hpp" #include "verify.hpp" -#include +#include "cleanup.hpp" +#include "detail/functor.hpp" +#include "detail/function.hpp" +#include "detail/type_name.hpp" +#include "detail/signature.hpp" +#include "detail/parameter.hpp" +#include +#include +#include +#include -/// MOCK_CLASS( name ) -/// Define a class -#define MOCK_CLASS(name) struct name : mock::object +#define MOCK_CLASS(T) \ + struct T : mock::object -/// MOCK_BASE_CLASS( name, base ) -/// Define a class deriving from a base class -#define MOCK_BASE_CLASS(name, ...) struct name : __VA_ARGS__, mock::object, mock::detail::base<__VA_ARGS__> +#define MOCK_FUNCTION_TYPE(S, tpn) \ + tpn boost::remove_pointer< tpn BOOST_IDENTITY_TYPE(S) >::type -/// MOCK_PROTECT_SIGNATURE( signature ) -/// Use this with MOCK_FUNCTION/MOCK_*_METHOD if the return type contains commas -#define MOCK_PROTECT_SIGNATURE(...) mock::detail::unwrap_signature_t +#ifdef MOCK_VARIADIC_MACROS -/// MOCK_FUNCTOR( name, signature ) -/// Define a callable variable/member -#define MOCK_FUNCTOR(name, ...) mock::detail::functor<__VA_ARGS__> name, name##_mock +#define MOCK_BASE_CLASS(T, ...) \ + struct T : __VA_ARGS__, mock::object, mock::detail::base< __VA_ARGS__ > -/// MOCK_CONVERSION_OPERATOR( [calling convention] name, type, identifier ) -/// generates both const and non-const conversion operators -#define MOCK_CONVERSION_OPERATOR(M, T, identifier) \ - M T() const { return MOCK_ANONYMOUS_HELPER(identifier)(); } \ - M T() { return MOCK_ANONYMOUS_HELPER(identifier)(); } \ - MOCK_METHOD_HELPER(T(), identifier) -/// MOCK_CONST_CONVERSION_OPERATOR( [calling convention] name, type, identifier ) -/// generates only a const conversion operator -#define MOCK_CONST_CONVERSION_OPERATOR(M, T, identifier) \ - M T() const { return MOCK_ANONYMOUS_HELPER(identifier)(); } \ - MOCK_METHOD_HELPER(T(), identifier) -/// MOCK_NON_CONST_CONVERSION_OPERATOR( [calling convention] name, type, identifier ) -/// generates only a non-const conversion operator -#define MOCK_NON_CONST_CONVERSION_OPERATOR(M, T, identifier) \ - M T() { return MOCK_ANONYMOUS_HELPER(identifier)(); } \ - MOCK_METHOD_HELPER(T(), identifier) +#define MOCK_FUNCTOR(f, ...) \ + mock::detail::functor< MOCK_FUNCTION_TYPE((__VA_ARGS__),) > f, f##_mock +#define MOCK_FUNCTOR_TPL(f, ...) \ + mock::detail::functor< \ + MOCK_FUNCTION_TYPE((__VA_ARGS__), typename) > f, f##_mock -/// MOCK_CONSTRUCTOR( [calling convention] name, arity, parameters, identifier ) -/// As constructors do not have a return type, the usual signature gets restricted here to just the parameters. -#define MOCK_CONSTRUCTOR(T, arity, parameters, identifier) \ - T(MOCK_DECL_PARAMS(arity, void parameters)) \ - { \ - MOCK_HELPER(identifier)(MOCK_FORWARD_PARAMS(arity, void parameters)); \ - } \ - MOCK_FUNCTION_HELPER(void parameters, identifier, static) +#else // MOCK_VARIADIC_MACROS -/// MOCK_DESTRUCTOR( [calling convention] ~name, identifier ) -#define MOCK_DESTRUCTOR(T, identifier) \ - T() \ - { \ - try \ - { \ - MOCK_ANONYMOUS_HELPER(identifier)(); \ - } catch(...) \ - {} \ - } \ - MOCK_METHOD_HELPER(void(), identifier) +#define MOCK_BASE_CLASS(T, I) \ + struct T : I, mock::object, mock::detail::base< I > -/// MOCK_METHOD( [calling convention] name, arity[, signature[, identifier]] ) -/// generates both const and non-const methods -/// The 'signature' can be omitted if it can be uniquely identified from the base class -/// if 'identifier' is omitted it will default to 'name' -#define MOCK_METHOD(M, ...) \ - MOCK_METHOD_EXT(M, \ - BOOST_PP_VARIADIC_ELEM(0, __VA_ARGS__, ), \ - BOOST_PP_VARIADIC_ELEM(1, __VA_ARGS__, MOCK_SIGNATURE(M), ), \ - BOOST_PP_VARIADIC_ELEM(2, __VA_ARGS__, M, M, )) -/// MOCK_CONST_METHOD( [calling convention] name, arity[, signature[, identifier]] ) -/// generates only the const version of the method -/// The 'signature' can be omitted if it can be uniquely identified from the base class -/// if 'identifier' is omitted it will default to 'name' -#define MOCK_CONST_METHOD(M, ...) \ - MOCK_CONST_METHOD_EXT(M, \ - BOOST_PP_VARIADIC_ELEM(0, __VA_ARGS__, ), \ - BOOST_PP_VARIADIC_ELEM(1, __VA_ARGS__, MOCK_SIGNATURE(M), ), \ - BOOST_PP_VARIADIC_ELEM(2, __VA_ARGS__, M, M, )) -/// MOCK_NON_CONST_METHOD( [calling convention] name, arity[, signature[, identifier]] ) -/// generates only the non-const version of the method -/// The 'signature' can be omitted if it can be uniquely identified from the base class -/// if 'identifier' is omitted it will default to 'name' -#define MOCK_NON_CONST_METHOD(M, ...) \ - MOCK_NON_CONST_METHOD_EXT(M, \ - BOOST_PP_VARIADIC_ELEM(0, __VA_ARGS__, ), \ - BOOST_PP_VARIADIC_ELEM(1, __VA_ARGS__, MOCK_SIGNATURE(M), ), \ - BOOST_PP_VARIADIC_ELEM(2, __VA_ARGS__, M, M, )) +#define MOCK_FUNCTOR(f, S) \ + mock::detail::functor< MOCK_FUNCTION_TYPE((S),) > f, f##_mock +#define MOCK_FUNCTOR_TPL(f, S) \ + mock::detail::functor< \ + MOCK_FUNCTION_TYPE((S), typename) > f, f##_mock -/// MOCK_FUNCTION( [calling convention] name, arity, signature[, identifier] ) -/// if 'identifier' is omitted it will default to 'name' -#define MOCK_FUNCTION(F, arity, ...) \ - MOCK_FUNCTION_AUX( \ - F, arity, BOOST_PP_VARIADIC_ELEM(0, __VA_ARGS__, ), BOOST_PP_VARIADIC_ELEM(1, __VA_ARGS__, F, ), inline) +#endif // MOCK_VARIADIC_MACROS -/// MOCK_STATIC_METHOD( [calling convention] name, arity, signature[, identifier] ) -/// if 'identifier' is omitted it will default to 'name' -#define MOCK_STATIC_METHOD(F, arity, ...) \ - MOCK_FUNCTION_AUX( \ - F, arity, BOOST_PP_VARIADIC_ELEM(0, __VA_ARGS__, ), BOOST_PP_VARIADIC_ELEM(1, __VA_ARGS__, F, ), static) +#define MOCK_HELPER(t) \ + t##_mock( mock::detail::root, BOOST_PP_STRINGIZE(t) ) +#define MOCK_ANONYMOUS_HELPER(t) \ + t##_mock( mock::detail::root, "?." ) -/// MOCK_EXPECT( identifier ) -/// Begin setting up expectation for the identifier -#define MOCK_EXPECT(identifier) MOCK_HELPER(identifier).expect(__FILE__, __LINE__) -/// MOCK_RESET( identifier ) -/// Reset all pending expectations for the identifier -#define MOCK_RESET(identifier) MOCK_HELPER(identifier).reset(__FILE__, __LINE__) -/// MOCK_VERIFY( identifier ) -/// Verify all expectations for the identifier have been met -#define MOCK_VERIFY(identifier) MOCK_HELPER(identifier).verify(__FILE__, __LINE__) +#define MOCK_METHOD_HELPER(S, t, tpn) \ + mutable mock::detail::function< MOCK_FUNCTION_TYPE((S), tpn) > t##_mock_; \ + mock::detail::function< MOCK_FUNCTION_TYPE((S), tpn) >& t##_mock( \ + const mock::detail::context&, \ + boost::unit_test::const_string instance ) const \ + { \ + mock::detail::configure( *this, t##_mock_, \ + instance.substr( 0, instance.rfind( BOOST_PP_STRINGIZE(t) ) ), \ + MOCK_TYPE_NAME(*this), \ + BOOST_PP_STRINGIZE(t) ); \ + return t##_mock_; \ + } + +#define MOCK_PARAM(S, tpn) \ + tpn mock::detail::parameter< MOCK_FUNCTION_TYPE((S), tpn) +#define MOCK_DECL_PARAM(z, n, d) \ + BOOST_PP_COMMA_IF(n) d, n >::type p##n +#define MOCK_DECL_PARAMS(n, S, tpn) \ + BOOST_PP_REPEAT(n, MOCK_DECL_PARAM, MOCK_PARAM(S, tpn)) +#define MOCK_DECL(M, n, S, c, tpn) \ + tpn boost::function_types::result_type< \ + MOCK_FUNCTION_TYPE((S), tpn) >::type M( \ + MOCK_DECL_PARAMS(n, S, tpn) ) c + +#define MOCK_FORWARD_PARAM(z, n, d) \ + BOOST_PP_COMMA_IF(n) d, n >::type >( p##n ) +#define MOCK_FORWARD_PARAMS(n, S, tpn) \ + BOOST_PP_REPEAT(n, MOCK_FORWARD_PARAM, \ + mock::detail::move_if_not_lvalue_reference< MOCK_PARAM(S, tpn)) +#define MOCK_METHOD_AUX(M, n, S, t, c, tpn) \ + MOCK_DECL(M, n, S, c, tpn) \ + { \ + BOOST_MPL_ASSERT_RELATION( n, ==, \ + boost::function_types::function_arity< \ + MOCK_FUNCTION_TYPE((S), tpn) >::value ); \ + return MOCK_ANONYMOUS_HELPER(t)( \ + MOCK_FORWARD_PARAMS(n, S, tpn) ); \ + } + +#define MOCK_METHOD_EXT(M, n, S, t) \ + MOCK_METHOD_AUX(M, n, S, t,,) \ + MOCK_METHOD_AUX(M, n, S, t, const,) \ + MOCK_METHOD_HELPER(S, t,) +#define MOCK_CONST_METHOD_EXT(M, n, S, t) \ + MOCK_METHOD_AUX(M, n, S, t, const,) \ + MOCK_METHOD_HELPER(S, t,) +#define MOCK_NON_CONST_METHOD_EXT(M, n, S, t) \ + MOCK_METHOD_AUX(M, n, S, t,,) \ + MOCK_METHOD_HELPER(S, t,) + +#define MOCK_METHOD_EXT_TPL(M, n, S, t) \ + MOCK_METHOD_AUX(M, n, S, t,, typename) \ + MOCK_METHOD_AUX(M, n, S, t, const, typename) \ + MOCK_METHOD_HELPER(S, t, typename) +#define MOCK_CONST_METHOD_EXT_TPL(M, n, S, t) \ + MOCK_METHOD_AUX(M, n, S, t, const, typename) \ + MOCK_METHOD_HELPER(S, t, typename) +#define MOCK_NON_CONST_METHOD_EXT_TPL(M, n, S, t) \ + MOCK_METHOD_AUX(M, n, S, t,, typename) \ + MOCK_METHOD_HELPER(S, t, typename) + +#define MOCK_CONVERSION_OPERATOR(M, T, t) \ + M T() const { return MOCK_ANONYMOUS_HELPER(t)(); } \ + M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \ + MOCK_METHOD_HELPER(T(), t,) +#define MOCK_CONST_CONVERSION_OPERATOR(M, T, t) \ + M T() const { return MOCK_ANONYMOUS_HELPER(t)(); } \ + MOCK_METHOD_HELPER(T(), t,) +#define MOCK_NON_CONST_CONVERSION_OPERATOR(M, T, t) \ + M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \ + MOCK_METHOD_HELPER(T(), t,) + +#define MOCK_CONVERSION_OPERATOR_TPL(M, T, t) \ + M T() const { return MOCK_ANONYMOUS_HELPER(t)(); } \ + M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \ + MOCK_METHOD_HELPER(T(), t, typename) +#define MOCK_CONST_CONVERSION_OPERATOR_TPL(M, T, t) \ + M T() const { return MOCK_ANONYMOUS_HELPER(t)(); } \ + MOCK_METHOD_HELPER(T(), t, typename) +#define MOCK_NON_CONST_CONVERSION_OPERATOR_TPL(M, T, t) \ + M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \ + MOCK_METHOD_HELPER(T(), t, typename) + +#define MOCK_FUNCTION_HELPER(S, t, s, tpn) \ + s mock::detail::function< MOCK_FUNCTION_TYPE((S), tpn) >& t##_mock( \ + mock::detail::context& context, \ + boost::unit_test::const_string instance ) \ + { \ + static mock::detail::function< MOCK_FUNCTION_TYPE((S), tpn) > f; \ + return f( context, instance ); \ + } + +#define MOCK_CONSTRUCTOR_AUX(T, n, A, t, tpn) \ + T( MOCK_DECL_PARAMS(n, void A, tpn) ) \ + { \ + MOCK_HELPER(t)( MOCK_FORWARD_PARAMS(n, void A, tpn) ); \ + } \ + MOCK_FUNCTION_HELPER(void A, t, static, tpn) + +#define MOCK_CONSTRUCTOR(T, n, A, t) \ + MOCK_CONSTRUCTOR_AUX(T, n, A, t,) +#define MOCK_CONSTRUCTOR_TPL(T, n, A, t) \ + MOCK_CONSTRUCTOR_AUX(T, n, A, t, typename) + +#define MOCK_DESTRUCTOR(T, t) \ + T() { try { MOCK_ANONYMOUS_HELPER(t)(); } catch( ... ) {} } \ + MOCK_METHOD_HELPER(void(), t,) + +#define MOCK_FUNCTION_AUX(F, n, S, t, s, tpn) \ + MOCK_FUNCTION_HELPER(S, t, s, tpn) \ + s MOCK_DECL(F, n, S,,tpn) \ + { \ + BOOST_MPL_ASSERT_RELATION( n, ==, \ + boost::function_types::function_arity< \ + MOCK_FUNCTION_TYPE((S), tpn) >::value ); \ + return MOCK_HELPER(t)( MOCK_FORWARD_PARAMS(n, S, tpn) ); \ + } + +#ifdef MOCK_VARIADIC_MACROS + +#define MOCK_VARIADIC_ELEM_0(e0, ...) e0 +#define MOCK_VARIADIC_ELEM_1(e0, e1, ...) e1 +#define MOCK_VARIADIC_ELEM_2(e0, e1, e2, ...) e2 + +#define MOCK_METHOD(M, ...) \ + MOCK_METHOD_EXT(M, \ + MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \ + MOCK_VARIADIC_ELEM_1(__VA_ARGS__, MOCK_SIGNATURE(M), ), \ + MOCK_VARIADIC_ELEM_2(__VA_ARGS__, M, M, )) +#define MOCK_CONST_METHOD(M, n, ...) \ + MOCK_CONST_METHOD_EXT(M, n, \ + MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \ + MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, )) +#define MOCK_NON_CONST_METHOD(M, n, ...) \ + MOCK_NON_CONST_METHOD_EXT(M, n, \ + MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \ + MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, )) + +#define MOCK_METHOD_TPL(M, n, ...) \ + MOCK_METHOD_EXT_TPL(M, n, \ + MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \ + MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, )) +#define MOCK_CONST_METHOD_TPL(M, n, ...) \ + MOCK_CONST_METHOD_EXT_TPL(M, n, \ + MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \ + MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, )) +#define MOCK_NON_CONST_METHOD_TPL(M, n, ...) \ + MOCK_NON_CONST_METHOD_EXT_TPL(M, n, \ + MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \ + MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, )) + +#define MOCK_FUNCTION(F, n, ...) \ + MOCK_FUNCTION_AUX(F, n, \ + MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \ + MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), \ + inline,) + +#define MOCK_STATIC_METHOD(F, n, ...) \ + MOCK_FUNCTION_AUX(F, n, \ + MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \ + MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), \ + static,) + +#define MOCK_STATIC_METHOD_TPL(F, n, ...) \ + MOCK_FUNCTION_AUX(F, n, \ + MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \ + MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), \ + static, typename) + +#else // MOCK_VARIADIC_MACROS + +#define MOCK_METHOD(M, n) \ + MOCK_METHOD_EXT(M, n, MOCK_SIGNATURE(M), M) + +#define MOCK_FUNCTION(F, n, S, t) \ + MOCK_FUNCTION_AUX(F, n, S, t, inline,) + +#define MOCK_STATIC_METHOD(F, n, S, t) \ + MOCK_FUNCTION_AUX(F, n, S, t, static,) + +#define MOCK_STATIC_METHOD_TPL(F, n, S, t) \ + MOCK_FUNCTION_AUX(F, n, S, t, static, typename) + +#endif // MOCK_VARIADIC_MACROS + +#define MOCK_EXPECT(t) MOCK_HELPER(t).expect( __FILE__, __LINE__ ) +#define MOCK_RESET(t) MOCK_HELPER(t).reset( __FILE__, __LINE__ ) +#define MOCK_VERIFY(t) MOCK_HELPER(t).verify( __FILE__, __LINE__ ) #endif // MOCK_MOCK_HPP_INCLUDED diff --git a/include/turtle/object.hpp b/include/turtle/object.hpp index 74da12f..d201757 100644 --- a/include/turtle/object.hpp +++ b/include/turtle/object.hpp @@ -10,61 +10,65 @@ #define MOCK_OBJECT_HPP_INCLUDED #include "config.hpp" -#include "detail/object_impl.hpp" #include "detail/root.hpp" #include "detail/type_name.hpp" -#include +#include "detail/object_impl.hpp" #include -#include -#include +#include +#include +#include +#include -namespace mock { -class object; - -namespace detail { - template - E& configure(const object& o, - E& e, - boost::unit_test::const_string instance, - boost::optional type, - boost::unit_test::const_string name); - - template - E& configure(const T& t, - E& e, - boost::unit_test::const_string instance, - boost::optional type, - boost::unit_test::const_string name, - std::enable_if_t::value>* = 0) - { - e.configure(detail::root, &t, instance, type, name); - return e; - } -} // namespace detail -class object +namespace mock { -public: - object() : impl_(std::make_shared()) {} + class object; -protected: - ~object() = default; +namespace detail +{ + template< typename E > + E& configure( const object& o, E& e, + boost::unit_test::const_string instance, + boost::optional< type_name > type, + boost::unit_test::const_string name ); -public: - std::shared_ptr impl_; -}; - -namespace detail { - template - E& configure(const object& o, - E& e, - boost::unit_test::const_string instance, - boost::optional type, - boost::unit_test::const_string name) + template< typename T, typename E > + E& configure( const T& t, E& e, + boost::unit_test::const_string instance, + boost::optional< type_name > type, + boost::unit_test::const_string name, + typename boost::disable_if< + typename boost::is_base_of< object, T > + >::type* = 0 ) { - e.configure(*o.impl_, o.impl_.get(), instance, type, name); + e.configure( detail::root, &t, instance, type, name ); return e; } -} // namespace detail -} // namespace mock +} + class object + { + public: + object() + : impl_( boost::make_shared< detail::object_impl >() ) + {} + protected: + ~object() + {} + public: + boost::shared_ptr< detail::object_impl > impl_; + }; + +namespace detail +{ + template< typename E > + E& configure( const object& o, E& e, + boost::unit_test::const_string instance, + boost::optional< type_name > type, + boost::unit_test::const_string name ) + { + e.configure( *o.impl_, o.impl_.get(), instance, type, name ); + return e; + } +} +} // mock #endif // MOCK_OBJECT_HPP_INCLUDED diff --git a/include/turtle/reset.hpp b/include/turtle/reset.hpp index 4315d4c..20237b9 100644 --- a/include/turtle/reset.hpp +++ b/include/turtle/reset.hpp @@ -10,24 +10,25 @@ #define MOCK_RESET_HPP_INCLUDED #include "config.hpp" -#include "detail/functor.hpp" -#include "detail/root.hpp" #include "object.hpp" +#include "detail/root.hpp" +#include "detail/functor.hpp" -namespace mock { -inline void reset() +namespace mock { - detail::root.reset(); -} -inline void reset(const object& o) -{ - o.impl_->reset(); -} -template -void reset(detail::functor& f) -{ - f.reset(); -} -} // namespace mock + inline void reset() + { + detail::root.reset(); + } + inline void reset( const object& o ) + { + o.impl_->reset(); + } + template< typename Signature > + void reset( detail::functor< Signature >& f ) + { + f.reset(); + } +} // mock #endif // MOCK_RESET_HPP_INCLUDED diff --git a/include/turtle/sequence.hpp b/include/turtle/sequence.hpp index a4a6281..28a2ee9 100644 --- a/include/turtle/sequence.hpp +++ b/include/turtle/sequence.hpp @@ -11,16 +11,18 @@ #include "config.hpp" #include "detail/sequence_impl.hpp" -#include -namespace mock { -class sequence +namespace mock { -public: - sequence() : impl_(std::make_shared()) {} + class sequence + { + public: + sequence() + : impl_( boost::make_shared< detail::sequence_impl >() ) + {} - std::shared_ptr impl_; -}; -} // namespace mock + boost::shared_ptr< detail::sequence_impl > impl_; + }; +} // mock #endif // MOCK_SEQUENCE_HPP_INCLUDED diff --git a/include/turtle/stream.hpp b/include/turtle/stream.hpp index 979e6a7..d8f3707 100644 --- a/include/turtle/stream.hpp +++ b/include/turtle/stream.hpp @@ -10,43 +10,51 @@ #define MOCK_STREAM_HPP_INCLUDED #include "config.hpp" -#include +#include #include -namespace mock { -struct stream +namespace mock { - explicit stream(std::ostream& s) : s_(&s) {} - std::ostream* s_; -}; + struct stream + { + explicit stream( std::ostream& s ) + : s_( &s ) + {} + std::ostream* s_; + }; #ifdef MOCK_USE_CONVERSIONS -namespace detail { namespace conversion { +namespace detail +{ +namespace conversion +{ struct sink { - template - sink(const T&) + template< typename T > + sink( const T& ) {} }; - inline std::ostream& operator<<(std::ostream& s, const sink&) { return s << '?'; } - - struct holder + inline std::ostream& operator<<( std::ostream& s, const sink& ) { - holder() = default; - holder(const holder&) = delete; - holder& operator=(const holder&) = delete; + return s << '?'; + } - virtual ~holder() = default; - virtual void serialize(std::ostream& s) const = 0; + struct holder : boost::noncopyable + { + virtual ~holder() + {} + virtual void serialize( std::ostream& s ) const = 0; }; - template + template< typename T > struct holder_imp : holder { - explicit holder_imp(const T& t) : t_(t) {} - virtual void serialize(std::ostream& s) const + explicit holder_imp( const T& t ) + : t_( t ) + {} + virtual void serialize( std::ostream& s ) const { // if an error about an ambiguous conversion is generated by the // line below the solution is to add a serialization operator to a @@ -56,65 +64,79 @@ namespace detail { namespace conversion { const T& t_; }; - struct any + struct any : boost::noncopyable { - template - any(const T& t) : h_(std::make_unique>(t)) + template< typename T > + any( const T& t ) + : h_( new holder_imp< T >( t ) ) {} - std::unique_ptr h_; + ~any() + { + delete h_; + } + holder* h_; }; -}} // namespace detail::conversion - -inline stream& operator<<(stream& s, const detail::conversion::any& d) -{ - d.h_->serialize(*s.s_); - return s; } +} + + inline stream& operator<<( stream& s, const detail::conversion::any& d ) + { + d.h_->serialize( *s.s_ ); + return s; + } #else // MOCK_USE_CONVERSIONS -namespace detail { namespace conversion { - template - S& operator<<(S& s, const T&) +namespace detail +{ +namespace conversion +{ + template< typename S, typename T > + S& operator<<( S &s, const T& ) { return s << '?'; } -}} // namespace detail::conversion - -template -stream& operator<<(stream& s, const T& t) -{ - using namespace detail::conversion; - *s.s_ << t; - return s; } +} + + template< typename T > + stream& operator<<( stream& s, const T& t ) + { + using namespace detail::conversion; + *s.s_ << t; + return s; + } #endif // MOCK_USE_CONVERSIONS -namespace detail { - template - void serialize(stream& s, const T& t) +namespace detail +{ + template< typename T > + void serialize( stream& s, const T& t ) { // if an error about an ambiguous conversion is generated by the // line below the solution is to add a serialization operator to a // mock::stream for T s << t; } - inline void serialize(stream& s, bool b) { s << (b ? "true" : "false"); } - template - void serialize(stream& s, const std::basic_string& str) + inline void serialize( stream& s, bool b ) + { + s << (b ? "true" : "false"); + } + template< typename C, typename T, typename A > + void serialize( stream& s, const std::basic_string< C, T, A >& str ) { s << '"' << str << '"'; } - inline void serialize(stream& s, const char* const str) + inline void serialize( stream& s, const char* const str ) { - if(str) - s << '"' << str << '"'; - else - s << "nullptr"; + s << '"' << str << '"'; } - inline void serialize(stream& s, unsigned char c) { s << static_cast(c); } -} // namespace detail -} // namespace mock + inline void serialize( stream& s, unsigned char c ) + { + s << static_cast< int >( c ); + } +} +} // mock #endif // MOCK_STREAM_HPP_INCLUDED diff --git a/include/turtle/unwrap_reference.hpp b/include/turtle/unwrap_reference.hpp deleted file mode 100644 index 93f6f5e..0000000 --- a/include/turtle/unwrap_reference.hpp +++ /dev/null @@ -1,41 +0,0 @@ -// http://turtle.sourceforge.net -// -// Copyright Alexander Grund 2020 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#ifndef MOCK_UNWRAP_REFERENCE_HPP_INCLUDED -#define MOCK_UNWRAP_REFERENCE_HPP_INCLUDED - -#include -#include - -namespace mock { -template -struct unwrap_reference -{ - using type = T; -}; -template -struct unwrap_reference> -{ - using type = T; -}; -template -struct unwrap_reference> -{ - using type = T; -}; -template -using unwrap_reference_t = typename unwrap_reference::type; - -template -BOOST_FORCEINLINE unwrap_reference_t& unwrap_ref(T& t) noexcept -{ - return t; -} -} // namespace mock - -#endif // MOCK_UNWRAP_REFERENCE_HPP_INCLUDED diff --git a/include/turtle/verify.hpp b/include/turtle/verify.hpp index 1995374..61df6df 100644 --- a/include/turtle/verify.hpp +++ b/include/turtle/verify.hpp @@ -10,24 +10,25 @@ #define MOCK_VERIFY_HPP_INCLUDED #include "config.hpp" -#include "detail/functor.hpp" -#include "detail/root.hpp" #include "object.hpp" +#include "detail/root.hpp" +#include "detail/functor.hpp" -namespace mock { -inline bool verify() +namespace mock { - return detail::root.verify(); -} -inline bool verify(const object& o) -{ - return o.impl_->verify(); -} -template -bool verify(const detail::functor& f) -{ - return f.verify(); -} -} // namespace mock + inline bool verify() + { + return detail::root.verify(); + } + inline bool verify( const object& o ) + { + return o.impl_->verify(); + } + template< typename Signature > + bool verify( const detail::functor< Signature >& f ) + { + return f.verify(); + } +} // mock #endif // MOCK_VERIFY_HPP_INCLUDED diff --git a/index.html b/index.html index fa5974d..cfecfa2 100644 --- a/index.html +++ b/index.html @@ -8,7 +8,7 @@ Automatic redirection failed, please go to doc/html/index.html
-Turtle
+Boost.Mock

Copyright Mathieu Champlon 2012

diff --git a/scripts/build.bat b/scripts/build.bat deleted file mode 100644 index 98dda03..0000000 --- a/scripts/build.bat +++ /dev/null @@ -1,30 +0,0 @@ -@echo off - -rem Copyright (C) 2015 Mathieu Champlon -rem -rem Distributed under the Boost Software License, Version 1.0. -rem (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) - -setlocal - -rem Need to set BOOST_ROOT and run from the source root directory - -set PROJECT_DIR=%cd% - -cd %BOOST_ROOT% -b2.exe %PROJECT_DIR%\test -q %BUILD_ARGS% %* -if errorlevel 1 exit /b %ERRORLEVEL% - -cd %PROJECT_DIR% -set BOOSTBOOK_DIR=%PROJECT_DIR%\bin\turtle\boostbook -xcopy /Y /S /Q /I %BOOST_ROOT%\tools\boostbook\xsl %BOOSTBOOK_DIR%\xsl -xcopy /Y /S /Q /I %BOOST_ROOT%\tools\boostbook\dtd %BOOSTBOOK_DIR%\dtd -xcopy /Y /S /Q /I doc\boostbook %BOOSTBOOK_DIR% -xcopy /Y /S /Q /I %BOOST_ROOT%\doc\src\boostbook.css doc\html -xcopy /Y /S /Q /I %BOOST_ROOT%\doc\src\images\*.png doc\html\images -xcopy /Y /S /Q /I %BOOST_ROOT%\doc\src\images\callouts\*.png doc\html\images\callouts -if errorlevel 1 exit /b %ERRORLEVEL% - -cd %BOOST_ROOT% -b2.exe %PROJECT_DIR%\doc -q %* -if errorlevel 1 exit /b %ERRORLEVEL% diff --git a/scripts/build.sh b/scripts/build.sh deleted file mode 100755 index 2b69951..0000000 --- a/scripts/build.sh +++ /dev/null @@ -1,24 +0,0 @@ -#!/bin/sh - -# Copyright (C) 2015 Mathieu Champlon -# Copyright (C) 2025 Alexander Grund -# -# Distributed under the Boost Software License, Version 1.0. -# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) - -set -eux - -# Need to set BOOST_ROOT and run from the source root directory -PROJECT_DIR="$(pwd)" - -cd "$BOOST_ROOT" -./b2 "$PROJECT_DIR/test" -q "$@" - -cd "$PROJECT_DIR" -scripts/build_doc.sh "$@" - -cd "$BOOST_ROOT" -./b2 "$PROJECT_DIR/doc//mock_examples" -q "$@" - -cd "$BOOST_ROOT" -./b2 "$PROJECT_DIR/test//inspect" -q "$@" diff --git a/scripts/build_doc.sh b/scripts/build_doc.sh deleted file mode 100755 index 42af832..0000000 --- a/scripts/build_doc.sh +++ /dev/null @@ -1,31 +0,0 @@ -#!/bin/bash - -# Copyright (C) 2015 Mathieu Champlon -# -# Distributed under the Boost Software License, Version 1.0. -# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) - -# Execute from repo root folder or set PROJECT_DIR -# Requires BOOST_ROOT to be set - -set -eu - -copy() -{ - for dir; do true; done - mkdir -p "$dir" - cp "$@" -} - -PROJECT_DIR="${PROJECT_DIR:-$(pwd)}" - -export BOOSTBOOK_DIR="${PROJECT_DIR}/bin/turtle/boostbook" -copy -r "$BOOST_ROOT"/tools/boostbook/xsl "$BOOSTBOOK_DIR" -copy -r "$BOOST_ROOT"/tools/boostbook/dtd "$BOOSTBOOK_DIR" -copy -r doc/boostbook/* "$BOOSTBOOK_DIR" -copy "$BOOST_ROOT"/doc/src/boostbook.css doc/html -copy "$BOOST_ROOT"/doc/src/images/*.png doc/html/images -copy "$BOOST_ROOT"/doc/src/images/callouts/*.png doc/html/images/callouts - -cd "$BOOST_ROOT" -./b2 "$PROJECT_DIR/doc" -q "$@" diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt deleted file mode 100644 index 486fdb7..0000000 --- a/test/CMakeLists.txt +++ /dev/null @@ -1,104 +0,0 @@ -# Copyright 2019 Alexander Grund -# Distributed under the Boost Software License, Version 1.0. -# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt - -find_package(Boost 1.58 REQUIRED COMPONENTS unit_test_framework thread) - -add_library(TurtleTestMain INTERFACE) -target_link_libraries(TurtleTestMain INTERFACE Boost::unit_test_framework Boost::disable_autolinking) -target_compile_definitions(TurtleTestMain INTERFACE BOOST_AUTO_TEST_MAIN) -# Heuristically guess if we are compiling against dynamic boost -if(NOT Boost_USE_STATIC_LIBS AND Boost_UNIT_TEST_FRAMEWORK_LIBRARY AND NOT Boost_UNIT_TEST_FRAMEWORK_LIBRARY MATCHES "\\${CMAKE_STATIC_LIBRARY_SUFFIX}\$") - target_compile_definitions(TurtleTestMain INTERFACE BOOST_TEST_DYN_LINK) -endif() -# Enable warnings -option(TURTLE_WERROR "Treat warnings as errors" ON) -if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang") - target_compile_options(TurtleTestMain INTERFACE -Wall -Wextra -pedantic) - include(CheckCXXCompilerFlag) - check_cxx_compiler_flag(-Wunused-function TURTLE_CXX_UNUSED_FUNCTION) - if(TURTLE_CXX_UNUSED_FUNCTION) - target_compile_options(TurtleTestMain INTERFACE -Wno-unused-function) - endif() - if(TURTLE_WERROR) - check_cxx_compiler_flag(-Wdeprecated-declarations TURTLE_CXX_DEPRECATED_DECLARATIONS) - if(TURTLE_CXX_DEPRECATED_DECLARATIONS) - target_compile_options(TurtleTestMain INTERFACE -Wno-error=deprecated-declarations) - endif() - target_compile_options(TurtleTestMain INTERFACE -Werror) - endif() -elseif(MSVC) - target_compile_options(TurtleTestMain INTERFACE /W4) - if(TURTLE_WERROR) - target_compile_options(TurtleTestMain INTERFACE /WX) - endif() -endif() - -# Regular unit tests in variations -file(GLOB_RECURSE testFiles test_*.cpp) -set(testsUsingUndefinedCPP test_function test_integration) -foreach(testFile IN LISTS testFiles) - get_filename_component(name ${testFile} NAME_WE) - - foreach(testVariant IN ITEMS "" _use_conversions _thread_safe) - set(curName ${name}${testVariant}) - add_executable(${curName} ${testFile}) - if(name IN_LIST testsUsingUndefinedCPP) - target_sources(${curName} PRIVATE undefined.cpp) - endif() - target_link_libraries(${curName} PRIVATE turtle::turtle TurtleTestMain) - add_test(NAME ${curName} COMMAND ${curName}) - endforeach() - - target_compile_definitions(${name}_use_conversions PRIVATE MOCK_USE_CONVERSIONS) - - target_link_libraries(${name}_thread_safe PRIVATE Boost::thread) - target_compile_definitions(${name}_thread_safe PRIVATE MOCK_THREAD_SAFE) -endforeach() - -# Link test only to check for a regression -add_executable(link-test_defined EXCLUDE_FROM_ALL test_exception.cpp defined_1.cpp defined_2.cpp) -target_link_libraries(link-test_defined PRIVATE turtle::turtle TurtleTestMain) -add_test(NAME link-test_defined COMMAND "${CMAKE_COMMAND}" --build ${CMAKE_BINARY_DIR} --target link-test_defined --config $) - -# Should fail to compile -file(GLOB_RECURSE compileFailureTestFiles fail_*.cpp) -foreach(testFile IN LISTS compileFailureTestFiles) - get_filename_component(name ${testFile} NAME_WE) - - add_library(${name} STATIC EXCLUDE_FROM_ALL ${testFile}) - target_link_libraries(${name} turtle::turtle) - add_test(NAME compile-${name} COMMAND "${CMAKE_COMMAND}" --build ${CMAKE_BINARY_DIR} --target ${name} --config $) - set_tests_properties(compile-${name} PROPERTIES WILL_FAIL TRUE) -endforeach() - -# Examples are runnable tests -file(GLOB_RECURSE exampleFiles ${PROJECT_SOURCE_DIR}/doc/example/*.cpp) -foreach(testFile IN LISTS exampleFiles) - get_filename_component(name ${testFile} NAME_WE) - set(name "example_${name}") - add_executable(${name} ${testFile}) - target_link_libraries(${name} PRIVATE turtle::turtle TurtleTestMain) - add_test(NAME ${name} COMMAND ${name}) -endforeach() - -file(GLOB_RECURSE exampleTargetFiles ${PROJECT_SOURCE_DIR}/doc/example/*.hpp) -foreach(name IN ITEMS customization getting_started motivation rationale) - target_sources(example_${name} PUBLIC ${exampleTargetFiles}) -endforeach() - -# Expected to trigger a mock failure -set_tests_properties(example_rationale PROPERTIES WILL_FAIL TRUE PASS_REGULAR_EXPRESSION "Exception thrown but should not") -foreach(name IN ITEMS example_patterns_async_call) - target_link_libraries(${name} PRIVATE Boost::thread) - target_compile_definitions(${name} PRIVATE MOCK_THREAD_SAFE BOOST_THREAD_USES_MOVE) -endforeach() - -# Compile benchmarks -file(GLOB_RECURSE benchFiles bench_*.cpp) -foreach(testFile IN LISTS benchFiles) - get_filename_component(name ${testFile} NAME_WE) - add_executable(${name} EXCLUDE_FROM_ALL ${testFile}) - target_link_libraries(${name} PRIVATE turtle::turtle TurtleTestMain) - add_test(NAME ${name} COMMAND "${CMAKE_COMMAND}" --build ${CMAKE_BINARY_DIR} --target ${name} --config $) -endforeach() diff --git a/test/Jamfile.jam b/test/Jamfile.jam index 31a4292..3eccba2 100644 --- a/test/Jamfile.jam +++ b/test/Jamfile.jam @@ -1,5 +1,6 @@ -# Copyright 2012 Mathieu Champlon -# Copyright 2025 Alexander Grund +# Boost.Mock +# +# Copyright Mathieu Champlon 2012 # # Distributed under the Boost Software License version 1.0. (See # accompanying file LICENSE_1_0.txt or copy at @@ -16,27 +17,25 @@ project path-constant parent : .. ; -run /boost/tools/inspect//inspect/release : $(parent) -text -brief : : always_show_run_output : inspect ; -explicit inspect ; +alias mock_inspect : + [ run /boost/tools/inspect//inspect/release + : $(parent) -text -brief : : : inspect + ] +; -rule run-test ( name : options * ) +rule run-test ( name ) { - run $(name) defined_1.cpp defined_2.cpp undefined.cpp /boost//unit_test_framework : : : $(options) : $(name)_ ; - run $(name) undefined.cpp /boost//unit_test_framework : : : $(options) MOCK_USE_CONVERSIONS : $(name)_use_conversions ; - run $(name) undefined.cpp /boost//unit_test_framework /boost//thread : : : $(options) MOCK_THREAD_SAFE BOOST_THREAD_USES_MOVE multi : $(name)_thread_safe ; + run $(name) defined_1.cpp defined_2.cpp undefined.cpp /boost//unit_test_framework : : : : $(name)_ ; + run $(name) defined_1.cpp defined_2.cpp undefined.cpp /boost//unit_test_framework : : : MOCK_MAX_ARGS=21 : $(name)_max_args ; + run $(name) defined_1.cpp defined_2.cpp undefined.cpp /boost//unit_test_framework : : : MOCK_USE_CONVERSIONS : $(name)_use_conversions ; + run $(name) defined_1.cpp defined_2.cpp undefined.cpp /boost//unit_test_framework : : : MOCK_NO_DECLTYPE : $(name)_no_decltype ; + run $(name) defined_1.cpp defined_2.cpp undefined.cpp /boost//unit_test_framework : : : MOCK_NO_VARIADIC_MACROS : $(name)_no_variadic_macros ; + run $(name) defined_1.cpp defined_2.cpp undefined.cpp /boost//unit_test_framework /boost//thread : : : MOCK_THREAD_SAFE BOOST_THREAD_USES_MOVE multi : $(name)_thread_safe ; } rule run-tests { - for name in [ glob test_*.cpp ] { run-test $(name) ; } - # Avoid object file getting to big on MinGW - run-test detail/test_function.cpp : - gcc,windows:on - gcc,windows:space ; - run-test detail/test_invocation.cpp ; - run-test detail/test_is_functor.cpp ; - run-test detail/test_signature.cpp ; - run-test detail/test_type_name.cpp ; + for name in [ glob test_*.cpp detail/test_*.cpp ] { run-test $(name) ; } } alias mock_tests : [ run-tests ] ; diff --git a/test/bench_0_class_10_max_args.cpp b/test/bench_0_class_10_max_args.cpp new file mode 100644 index 0000000..0772e7d --- /dev/null +++ b/test/bench_0_class_10_max_args.cpp @@ -0,0 +1,10 @@ +// http://turtle.sourceforge.net +// +// Copyright Mathieu Champlon 2011 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#define MOCK_MAX_ARGS 10 +#include diff --git a/test/bench_0_class_20_max_args.cpp b/test/bench_0_class_20_max_args.cpp new file mode 100644 index 0000000..b236e09 --- /dev/null +++ b/test/bench_0_class_20_max_args.cpp @@ -0,0 +1,10 @@ +// http://turtle.sourceforge.net +// +// Copyright Mathieu Champlon 2011 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#define MOCK_MAX_ARGS 20 +#include diff --git a/test/bench_0_class_30_max_args.cpp b/test/bench_0_class_30_max_args.cpp new file mode 100644 index 0000000..d87d02f --- /dev/null +++ b/test/bench_0_class_30_max_args.cpp @@ -0,0 +1,10 @@ +// http://turtle.sourceforge.net +// +// Copyright Mathieu Champlon 2011 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#define MOCK_MAX_ARGS 30 +#include diff --git a/test/bench_30_classes_30_methods_30_args.cpp b/test/bench_30_classes_30_methods_30_args.cpp deleted file mode 100644 index 7f14ebd..0000000 --- a/test/bench_30_classes_30_methods_30_args.cpp +++ /dev/null @@ -1,1947 +0,0 @@ -// http://turtle.sourceforge.net -// -// Copyright Mathieu Champlon 2011 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#include -#ifdef _MSC_VER -# pragma warning(disable : 4505) -#endif - -namespace { -class base_class -{ -public: - virtual ~base_class() = default; - virtual void f1(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f2(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f3(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f4(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f5(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f6(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f7(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f8(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f9(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f10(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f11(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f12(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f13(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f14(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f15(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f16(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f17(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f18(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f19(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f20(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f21(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f22(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f23(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f24(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f25(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f26(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f27(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f28(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f29(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; - virtual void f30(int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int, - int) = 0; -}; - -MOCK_BASE_CLASS(mock_class_1, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_2, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_3, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_4, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_5, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_6, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_7, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_8, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_9, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_10, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_11, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_12, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_13, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_14, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_15, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_16, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_17, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_18, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_19, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_20, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_21, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_22, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_23, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_24, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_25, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_26, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_27, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_28, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_29, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; -MOCK_BASE_CLASS(mock_class_30, base_class) -{ - MOCK_METHOD(f1, 30) - MOCK_METHOD(f2, 30) - MOCK_METHOD(f3, 30) - MOCK_METHOD(f4, 30) - MOCK_METHOD(f5, 30) - MOCK_METHOD(f6, 30) - MOCK_METHOD(f7, 30) - MOCK_METHOD(f8, 30) - MOCK_METHOD(f9, 30) - MOCK_METHOD(f10, 30) - MOCK_METHOD(f11, 30) - MOCK_METHOD(f12, 30) - MOCK_METHOD(f13, 30) - MOCK_METHOD(f14, 30) - MOCK_METHOD(f15, 30) - MOCK_METHOD(f16, 30) - MOCK_METHOD(f17, 30) - MOCK_METHOD(f18, 30) - MOCK_METHOD(f19, 30) - MOCK_METHOD(f20, 30) - MOCK_METHOD(f21, 30) - MOCK_METHOD(f22, 30) - MOCK_METHOD(f23, 30) - MOCK_METHOD(f24, 30) - MOCK_METHOD(f25, 30) - MOCK_METHOD(f26, 30) - MOCK_METHOD(f27, 30) - MOCK_METHOD(f28, 30) - MOCK_METHOD(f29, 30) - MOCK_METHOD(f30, 30) -}; - -mock_class_1 c_1; -mock_class_2 c_2; -mock_class_3 c_3; -mock_class_4 c_4; -mock_class_5 c_5; -mock_class_6 c_6; -mock_class_7 c_7; -mock_class_8 c_8; -mock_class_9 c_9; -mock_class_10 c_10; -mock_class_11 c_11; -mock_class_12 c_12; -mock_class_13 c_13; -mock_class_14 c_14; -mock_class_15 c_15; -mock_class_16 c_16; -mock_class_17 c_17; -mock_class_18 c_18; -mock_class_19 c_19; -mock_class_20 c_20; -mock_class_21 c_21; -mock_class_22 c_22; -mock_class_23 c_23; -mock_class_24 c_24; -mock_class_25 c_25; -mock_class_26 c_26; -mock_class_27 c_27; -mock_class_28 c_28; -mock_class_29 c_29; -mock_class_30 c_30; -} // namespace - -int main() -{ - return 0; -} diff --git a/test/bench_30_classes_30_methods_30_args_30_max_args.cpp b/test/bench_30_classes_30_methods_30_args_30_max_args.cpp new file mode 100644 index 0000000..7872dc2 --- /dev/null +++ b/test/bench_30_classes_30_methods_30_args_30_max_args.cpp @@ -0,0 +1,1134 @@ +// http://turtle.sourceforge.net +// +// Copyright Mathieu Champlon 2011 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#define MOCK_MAX_ARGS 30 +#include +#ifdef _MSC_VER +#pragma warning( disable: 4505 ) +#endif + +namespace +{ + class base_class + { + public: + virtual ~base_class() {} + virtual void f1( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f2( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f3( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f4( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f5( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f6( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f7( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f8( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f9( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f10( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f11( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f12( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f13( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f14( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f15( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f16( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f17( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f18( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f19( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f20( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f21( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f22( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f23( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f24( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f25( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f26( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f27( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f28( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f29( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + virtual void f30( int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int ) = 0; + }; + + MOCK_BASE_CLASS( mock_class_1, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_2, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_3, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_4, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_5, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_6, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_7, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_8, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_9, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_10, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_11, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_12, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_13, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_14, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_15, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_16, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_17, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_18, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_19, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_20, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_21, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_22, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_23, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_24, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_25, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_26, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_27, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_28, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_29, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + MOCK_BASE_CLASS( mock_class_30, base_class ) + { + MOCK_METHOD( f1, 30 ) + MOCK_METHOD( f2, 30 ) + MOCK_METHOD( f3, 30 ) + MOCK_METHOD( f4, 30 ) + MOCK_METHOD( f5, 30 ) + MOCK_METHOD( f6, 30 ) + MOCK_METHOD( f7, 30 ) + MOCK_METHOD( f8, 30 ) + MOCK_METHOD( f9, 30 ) + MOCK_METHOD( f10, 30 ) + MOCK_METHOD( f11, 30 ) + MOCK_METHOD( f12, 30 ) + MOCK_METHOD( f13, 30 ) + MOCK_METHOD( f14, 30 ) + MOCK_METHOD( f15, 30 ) + MOCK_METHOD( f16, 30 ) + MOCK_METHOD( f17, 30 ) + MOCK_METHOD( f18, 30 ) + MOCK_METHOD( f19, 30 ) + MOCK_METHOD( f20, 30 ) + MOCK_METHOD( f21, 30 ) + MOCK_METHOD( f22, 30 ) + MOCK_METHOD( f23, 30 ) + MOCK_METHOD( f24, 30 ) + MOCK_METHOD( f25, 30 ) + MOCK_METHOD( f26, 30 ) + MOCK_METHOD( f27, 30 ) + MOCK_METHOD( f28, 30 ) + MOCK_METHOD( f29, 30 ) + MOCK_METHOD( f30, 30 ) + }; + + mock_class_1 c_1; + mock_class_2 c_2; + mock_class_3 c_3; + mock_class_4 c_4; + mock_class_5 c_5; + mock_class_6 c_6; + mock_class_7 c_7; + mock_class_8 c_8; + mock_class_9 c_9; + mock_class_10 c_10; + mock_class_11 c_11; + mock_class_12 c_12; + mock_class_13 c_13; + mock_class_14 c_14; + mock_class_15 c_15; + mock_class_16 c_16; + mock_class_17 c_17; + mock_class_18 c_18; + mock_class_19 c_19; + mock_class_20 c_20; + mock_class_21 c_21; + mock_class_22 c_22; + mock_class_23 c_23; + mock_class_24 c_24; + mock_class_25 c_25; + mock_class_26 c_26; + mock_class_27 c_27; + mock_class_28 c_28; + mock_class_29 c_29; + mock_class_30 c_30; +} diff --git a/test/bench_30_classes_30_methods_9_args.cpp b/test/bench_30_classes_30_methods_9_args.cpp index 72def03..67d1b65 100644 --- a/test/bench_30_classes_30_methods_9_args.cpp +++ b/test/bench_30_classes_30_methods_9_args.cpp @@ -8,1070 +8,1066 @@ #include #ifdef _MSC_VER -# pragma warning(disable : 4505) +#pragma warning( disable: 4505 ) #endif -namespace { -class base_class +namespace { -public: - virtual ~base_class() = default; - virtual void f1(int, int, int, int, int, int, int, int, int) = 0; - virtual void f2(int, int, int, int, int, int, int, int, int) = 0; - virtual void f3(int, int, int, int, int, int, int, int, int) = 0; - virtual void f4(int, int, int, int, int, int, int, int, int) = 0; - virtual void f5(int, int, int, int, int, int, int, int, int) = 0; - virtual void f6(int, int, int, int, int, int, int, int, int) = 0; - virtual void f7(int, int, int, int, int, int, int, int, int) = 0; - virtual void f8(int, int, int, int, int, int, int, int, int) = 0; - virtual void f9(int, int, int, int, int, int, int, int, int) = 0; - virtual void f10(int, int, int, int, int, int, int, int, int) = 0; - virtual void f11(int, int, int, int, int, int, int, int, int) = 0; - virtual void f12(int, int, int, int, int, int, int, int, int) = 0; - virtual void f13(int, int, int, int, int, int, int, int, int) = 0; - virtual void f14(int, int, int, int, int, int, int, int, int) = 0; - virtual void f15(int, int, int, int, int, int, int, int, int) = 0; - virtual void f16(int, int, int, int, int, int, int, int, int) = 0; - virtual void f17(int, int, int, int, int, int, int, int, int) = 0; - virtual void f18(int, int, int, int, int, int, int, int, int) = 0; - virtual void f19(int, int, int, int, int, int, int, int, int) = 0; - virtual void f20(int, int, int, int, int, int, int, int, int) = 0; - virtual void f21(int, int, int, int, int, int, int, int, int) = 0; - virtual void f22(int, int, int, int, int, int, int, int, int) = 0; - virtual void f23(int, int, int, int, int, int, int, int, int) = 0; - virtual void f24(int, int, int, int, int, int, int, int, int) = 0; - virtual void f25(int, int, int, int, int, int, int, int, int) = 0; - virtual void f26(int, int, int, int, int, int, int, int, int) = 0; - virtual void f27(int, int, int, int, int, int, int, int, int) = 0; - virtual void f28(int, int, int, int, int, int, int, int, int) = 0; - virtual void f29(int, int, int, int, int, int, int, int, int) = 0; - virtual void f30(int, int, int, int, int, int, int, int, int) = 0; -}; + class base_class + { + public: + virtual ~base_class() {} + virtual void f1( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f2( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f3( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f4( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f5( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f6( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f7( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f8( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f9( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f10( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f11( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f12( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f13( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f14( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f15( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f16( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f17( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f18( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f19( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f20( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f21( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f22( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f23( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f24( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f25( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f26( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f27( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f28( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f29( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f30( int, int, int, int, int, int, int, int, int ) = 0; + }; -MOCK_BASE_CLASS(mock_class_1, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_2, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_3, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_4, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_5, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_6, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_7, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_8, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_9, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_10, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_11, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_12, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_13, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_14, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_15, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_16, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_17, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_18, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_19, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_20, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_21, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_22, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_23, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_24, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_25, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_26, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_27, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_28, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_29, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; -MOCK_BASE_CLASS(mock_class_30, base_class) -{ - MOCK_METHOD(f1, 9) - MOCK_METHOD(f2, 9) - MOCK_METHOD(f3, 9) - MOCK_METHOD(f4, 9) - MOCK_METHOD(f5, 9) - MOCK_METHOD(f6, 9) - MOCK_METHOD(f7, 9) - MOCK_METHOD(f8, 9) - MOCK_METHOD(f9, 9) - MOCK_METHOD(f10, 9) - MOCK_METHOD(f11, 9) - MOCK_METHOD(f12, 9) - MOCK_METHOD(f13, 9) - MOCK_METHOD(f14, 9) - MOCK_METHOD(f15, 9) - MOCK_METHOD(f16, 9) - MOCK_METHOD(f17, 9) - MOCK_METHOD(f18, 9) - MOCK_METHOD(f19, 9) - MOCK_METHOD(f20, 9) - MOCK_METHOD(f21, 9) - MOCK_METHOD(f22, 9) - MOCK_METHOD(f23, 9) - MOCK_METHOD(f24, 9) - MOCK_METHOD(f25, 9) - MOCK_METHOD(f26, 9) - MOCK_METHOD(f27, 9) - MOCK_METHOD(f28, 9) - MOCK_METHOD(f29, 9) - MOCK_METHOD(f30, 9) -}; + MOCK_BASE_CLASS( mock_class_1, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_2, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_3, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_4, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_5, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_6, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_7, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_8, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_9, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_10, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_11, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_12, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_13, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_14, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_15, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_16, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_17, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_18, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_19, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_20, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_21, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_22, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_23, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_24, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_25, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_26, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_27, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_28, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_29, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_30, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; -mock_class_1 c_1; -mock_class_2 c_2; -mock_class_3 c_3; -mock_class_4 c_4; -mock_class_5 c_5; -mock_class_6 c_6; -mock_class_7 c_7; -mock_class_8 c_8; -mock_class_9 c_9; -mock_class_10 c_10; -mock_class_11 c_11; -mock_class_12 c_12; -mock_class_13 c_13; -mock_class_14 c_14; -mock_class_15 c_15; -mock_class_16 c_16; -mock_class_17 c_17; -mock_class_18 c_18; -mock_class_19 c_19; -mock_class_20 c_20; -mock_class_21 c_21; -mock_class_22 c_22; -mock_class_23 c_23; -mock_class_24 c_24; -mock_class_25 c_25; -mock_class_26 c_26; -mock_class_27 c_27; -mock_class_28 c_28; -mock_class_29 c_29; -mock_class_30 c_30; -} // namespace - -int main() -{ - return 0; + mock_class_1 c_1; + mock_class_2 c_2; + mock_class_3 c_3; + mock_class_4 c_4; + mock_class_5 c_5; + mock_class_6 c_6; + mock_class_7 c_7; + mock_class_8 c_8; + mock_class_9 c_9; + mock_class_10 c_10; + mock_class_11 c_11; + mock_class_12 c_12; + mock_class_13 c_13; + mock_class_14 c_14; + mock_class_15 c_15; + mock_class_16 c_16; + mock_class_17 c_17; + mock_class_18 c_18; + mock_class_19 c_19; + mock_class_20 c_20; + mock_class_21 c_21; + mock_class_22 c_22; + mock_class_23 c_23; + mock_class_24 c_24; + mock_class_25 c_25; + mock_class_26 c_26; + mock_class_27 c_27; + mock_class_28 c_28; + mock_class_29 c_29; + mock_class_30 c_30; } diff --git a/test/bench_30_classes_30_methods_9_args_10_max_args.cpp b/test/bench_30_classes_30_methods_9_args_10_max_args.cpp new file mode 100644 index 0000000..61a553c --- /dev/null +++ b/test/bench_30_classes_30_methods_9_args_10_max_args.cpp @@ -0,0 +1,1074 @@ +// http://turtle.sourceforge.net +// +// Copyright Mathieu Champlon 2011 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#define MOCK_MAX_ARGS 10 +#include +#ifdef _MSC_VER +#pragma warning( disable: 4505 ) +#endif + +namespace +{ + class base_class + { + public: + virtual ~base_class() {} + virtual void f1( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f2( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f3( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f4( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f5( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f6( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f7( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f8( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f9( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f10( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f11( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f12( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f13( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f14( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f15( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f16( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f17( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f18( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f19( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f20( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f21( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f22( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f23( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f24( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f25( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f26( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f27( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f28( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f29( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f30( int, int, int, int, int, int, int, int, int ) = 0; + }; + + MOCK_BASE_CLASS( mock_class_1, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_2, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_3, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_4, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_5, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_6, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_7, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_8, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_9, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_10, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_11, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_12, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_13, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_14, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_15, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_16, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_17, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_18, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_19, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_20, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_21, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_22, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_23, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_24, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_25, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_26, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_27, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_28, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_29, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_30, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + + mock_class_1 c_1; + mock_class_2 c_2; + mock_class_3 c_3; + mock_class_4 c_4; + mock_class_5 c_5; + mock_class_6 c_6; + mock_class_7 c_7; + mock_class_8 c_8; + mock_class_9 c_9; + mock_class_10 c_10; + mock_class_11 c_11; + mock_class_12 c_12; + mock_class_13 c_13; + mock_class_14 c_14; + mock_class_15 c_15; + mock_class_16 c_16; + mock_class_17 c_17; + mock_class_18 c_18; + mock_class_19 c_19; + mock_class_20 c_20; + mock_class_21 c_21; + mock_class_22 c_22; + mock_class_23 c_23; + mock_class_24 c_24; + mock_class_25 c_25; + mock_class_26 c_26; + mock_class_27 c_27; + mock_class_28 c_28; + mock_class_29 c_29; + mock_class_30 c_30; +} diff --git a/test/bench_30_classes_30_methods_9_args_20_max_args.cpp b/test/bench_30_classes_30_methods_9_args_20_max_args.cpp new file mode 100644 index 0000000..fe442fa --- /dev/null +++ b/test/bench_30_classes_30_methods_9_args_20_max_args.cpp @@ -0,0 +1,1074 @@ +// http://turtle.sourceforge.net +// +// Copyright Mathieu Champlon 2011 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#define MOCK_MAX_ARGS 20 +#include +#ifdef _MSC_VER +#pragma warning( disable: 4505 ) +#endif + +namespace +{ + class base_class + { + public: + virtual ~base_class() {} + virtual void f1( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f2( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f3( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f4( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f5( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f6( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f7( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f8( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f9( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f10( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f11( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f12( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f13( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f14( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f15( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f16( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f17( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f18( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f19( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f20( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f21( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f22( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f23( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f24( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f25( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f26( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f27( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f28( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f29( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f30( int, int, int, int, int, int, int, int, int ) = 0; + }; + + MOCK_BASE_CLASS( mock_class_1, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_2, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_3, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_4, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_5, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_6, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_7, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_8, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_9, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_10, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_11, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_12, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_13, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_14, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_15, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_16, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_17, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_18, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_19, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_20, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_21, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_22, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_23, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_24, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_25, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_26, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_27, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_28, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_29, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_30, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + + mock_class_1 c_1; + mock_class_2 c_2; + mock_class_3 c_3; + mock_class_4 c_4; + mock_class_5 c_5; + mock_class_6 c_6; + mock_class_7 c_7; + mock_class_8 c_8; + mock_class_9 c_9; + mock_class_10 c_10; + mock_class_11 c_11; + mock_class_12 c_12; + mock_class_13 c_13; + mock_class_14 c_14; + mock_class_15 c_15; + mock_class_16 c_16; + mock_class_17 c_17; + mock_class_18 c_18; + mock_class_19 c_19; + mock_class_20 c_20; + mock_class_21 c_21; + mock_class_22 c_22; + mock_class_23 c_23; + mock_class_24 c_24; + mock_class_25 c_25; + mock_class_26 c_26; + mock_class_27 c_27; + mock_class_28 c_28; + mock_class_29 c_29; + mock_class_30 c_30; +} diff --git a/test/bench_30_classes_30_methods_9_args_30_max_args.cpp b/test/bench_30_classes_30_methods_9_args_30_max_args.cpp new file mode 100644 index 0000000..3f6e0af --- /dev/null +++ b/test/bench_30_classes_30_methods_9_args_30_max_args.cpp @@ -0,0 +1,1074 @@ +// http://turtle.sourceforge.net +// +// Copyright Mathieu Champlon 2011 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#define MOCK_MAX_ARGS 30 +#include +#ifdef _MSC_VER +#pragma warning( disable: 4505 ) +#endif + +namespace +{ + class base_class + { + public: + virtual ~base_class() {} + virtual void f1( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f2( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f3( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f4( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f5( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f6( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f7( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f8( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f9( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f10( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f11( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f12( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f13( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f14( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f15( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f16( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f17( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f18( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f19( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f20( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f21( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f22( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f23( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f24( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f25( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f26( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f27( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f28( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f29( int, int, int, int, int, int, int, int, int ) = 0; + virtual void f30( int, int, int, int, int, int, int, int, int ) = 0; + }; + + MOCK_BASE_CLASS( mock_class_1, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_2, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_3, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_4, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_5, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_6, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_7, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_8, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_9, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_10, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_11, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_12, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_13, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_14, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_15, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_16, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_17, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_18, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_19, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_20, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_21, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_22, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_23, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_24, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_25, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_26, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_27, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_28, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_29, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + MOCK_BASE_CLASS( mock_class_30, base_class ) + { + MOCK_METHOD( f1, 9 ) + MOCK_METHOD( f2, 9 ) + MOCK_METHOD( f3, 9 ) + MOCK_METHOD( f4, 9 ) + MOCK_METHOD( f5, 9 ) + MOCK_METHOD( f6, 9 ) + MOCK_METHOD( f7, 9 ) + MOCK_METHOD( f8, 9 ) + MOCK_METHOD( f9, 9 ) + MOCK_METHOD( f10, 9 ) + MOCK_METHOD( f11, 9 ) + MOCK_METHOD( f12, 9 ) + MOCK_METHOD( f13, 9 ) + MOCK_METHOD( f14, 9 ) + MOCK_METHOD( f15, 9 ) + MOCK_METHOD( f16, 9 ) + MOCK_METHOD( f17, 9 ) + MOCK_METHOD( f18, 9 ) + MOCK_METHOD( f19, 9 ) + MOCK_METHOD( f20, 9 ) + MOCK_METHOD( f21, 9 ) + MOCK_METHOD( f22, 9 ) + MOCK_METHOD( f23, 9 ) + MOCK_METHOD( f24, 9 ) + MOCK_METHOD( f25, 9 ) + MOCK_METHOD( f26, 9 ) + MOCK_METHOD( f27, 9 ) + MOCK_METHOD( f28, 9 ) + MOCK_METHOD( f29, 9 ) + MOCK_METHOD( f30, 9 ) + }; + + mock_class_1 c_1; + mock_class_2 c_2; + mock_class_3 c_3; + mock_class_4 c_4; + mock_class_5 c_5; + mock_class_6 c_6; + mock_class_7 c_7; + mock_class_8 c_8; + mock_class_9 c_9; + mock_class_10 c_10; + mock_class_11 c_11; + mock_class_12 c_12; + mock_class_13 c_13; + mock_class_14 c_14; + mock_class_15 c_15; + mock_class_16 c_16; + mock_class_17 c_17; + mock_class_18 c_18; + mock_class_19 c_19; + mock_class_20 c_20; + mock_class_21 c_21; + mock_class_22 c_22; + mock_class_23 c_23; + mock_class_24 c_24; + mock_class_25 c_25; + mock_class_26 c_26; + mock_class_27 c_27; + mock_class_28 c_28; + mock_class_29 c_29; + mock_class_30 c_30; +} diff --git a/test/defined.hpp b/test/defined.hpp index 8ea5946..e0587f6 100644 --- a/test/defined.hpp +++ b/test/defined.hpp @@ -10,11 +10,11 @@ #define MOCK_TEST_DEFINED_HPP_INCLUDED #ifdef BOOST_AUTO_TEST_MAIN -# undef BOOST_AUTO_TEST_MAIN +#undef BOOST_AUTO_TEST_MAIN #endif #include -MOCK_FUNCTION(f, 0, void(), f) +MOCK_FUNCTION( f, 0, void(), f ) #endif // MOCK_TEST_DEFINED_HPP_INCLUDED diff --git a/test/detail/test_function.cpp b/test/detail/test_function.cpp index 59ed333..682840a 100644 --- a/test/detail/test_function.cpp +++ b/test/detail/test_function.cpp @@ -8,435 +8,345 @@ #include "../mock_error.hpp" #include "../undefined.hpp" -#include #include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include // static -namespace { -std::function static_f; +namespace +{ + boost::function< void() > static_f; -static_assert(std::is_same{}())>::value, "!"); -static_assert(std::is_same{}())>::value, "!"); -static_assert(std::is_same{}(std::declval()))>::value, "!"); -static_assert(std::is_same{}(std::declval()))>::value, "!"); - -template -using with_call_t = decltype(std::declval().expect().with(std::declval()...)); -template -struct with_is_callable : std::false_type -{}; -template -struct with_is_callable>, TFunction, TParams...> : - std::true_type -{}; -// Detect if we can call function.expect().with(params) -template -using with_is_callable_t = with_is_callable; - -// For function with no parameters `with` can never be called -using function_0_args = mock::detail::function; -static_assert(!with_is_callable_t::value, "Can't call with()"); -static_assert(!with_is_callable_t::value, "Can't call with(int)"); -static_assert(!with_is_callable_t::value, "Can't call with custom constraint"); - -// For functions with parameters `with` can be called with a custom constraint (taking all params) -// or exactly as many parameters as the function has (here 1 and 4 respectively) -using function_1_args = mock::detail::function; -static_assert(!with_is_callable_t::value, "Can't call with()"); -static_assert(with_is_callable_t::value, "Can call with(int)"); -static_assert(with_is_callable_t::value, "Can call with custom constraint"); -static_assert(!with_is_callable_t::value, "Can't call with(int, int)"); - -using function_4_args = mock::detail::function; -static_assert(!with_is_callable_t::value, "Can't call with()"); -static_assert(with_is_callable_t::value, "Can call with custom constraint"); -static_assert(!with_is_callable_t::value, "Can't call with(int, int)"); -static_assert(!with_is_callable_t::value, "Can't call with(int, int, int)"); -static_assert(with_is_callable_t::value, "Can call with(int, int, int, int)"); -static_assert(!with_is_callable_t::value, - "Can't call with(int, int, int, int, int)"); -} // namespace + BOOST_MPL_ASSERT(( + boost::is_same< void, boost::result_of< mock::detail::function< void() >() >::type > )); + BOOST_MPL_ASSERT(( + boost::is_same< int, boost::result_of< mock::detail::function< int() >() >::type > )); + BOOST_MPL_ASSERT(( + boost::is_same< void, boost::result_of< mock::detail::function< void( float ) >( float ) >::type > )); + BOOST_MPL_ASSERT(( + boost::is_same< int, boost::result_of< mock::detail::function< int( float ) >( float ) >::type > )); +} // functor -BOOST_FIXTURE_TEST_CASE(a_function_can_be_passed_as_functor, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( a_function_can_be_passed_as_functor, mock_error_fixture ) { - mock::detail::function f; - std::function functor = f; + mock::detail::function< void() > f; + boost::function< void() > functor = f; } -BOOST_FIXTURE_TEST_CASE(a_function_can_be_passed_as_functor_using_std_bind_and_std_ref, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( a_function_can_be_passed_as_functor_using_boost_bind_and_boost_ref, mock_error_fixture ) { - mock::detail::function f; - std::function functor = std::bind(std::ref(f)); + mock::detail::function< void() > f; + boost::function< void() > functor = boost::bind( boost::ref( f ) ); } // invocations -BOOST_FIXTURE_TEST_CASE(triggering_an_unconfigured_function_calls_unexpected_call_error, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( triggering_an_unconfigured_function_calls_unexpected_call_error, mock_error_fixture ) { { - mock::detail::function f; - CHECK_ERROR(f(), "unexpected call", 0, "?()"); + mock::detail::function< void() > f; + CHECK_ERROR( f(), "unexpected call", 0, "?()" ); } { - mock::detail::function f; - CHECK_ERROR(f(1, "s"), "unexpected call", 0, "?( 1, \"s\" )"); + mock::detail::function< int( int, const std::string& ) > f; + CHECK_ERROR( f( 1, "s" ), "unexpected call", 0, "?( 1, \"s\" )" ); } } -BOOST_FIXTURE_TEST_CASE(triggering_a_never_expectation_calls_unexpected_call_error, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( triggering_a_never_expectation_calls_unexpected_call_error, mock_error_fixture ) { { - mock::detail::function f; + mock::detail::function< void() > f; f.expect().never(); - CHECK_ERROR(f(), "unexpected call", 0, "?()\nv never()"); + CHECK_ERROR( f(), "unexpected call", 0, "?()\nv never()" ); } { - mock::detail::function f; + mock::detail::function< int( int, const std::string& ) > f; f.expect().never(); - CHECK_ERROR(f(1, "s"), "unexpected call", 0, "?( 1, \"s\" )\nv never().with( any, any )"); + CHECK_ERROR( f( 1, "s" ), "unexpected call", 0, "?( 1, \"s\" )\nv never().with( any, any )" ); } } -BOOST_FIXTURE_TEST_CASE(triggering_an_unlimited_expectation_is_valid, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( triggering_an_unlimited_expectation_is_valid, mock_error_fixture ) { { - mock::detail::function f; + mock::detail::function< void() > f; f.expect(); f(); f(); - CHECK_CALLS(2); + CHECK_CALLS( 2 ); } { - mock::detail::function f; + mock::detail::function< void( int, std::string ) > f; f.expect(); - f(1, "s1"); - f(2, "s2"); - CHECK_CALLS(2); + f( 1, "s1" ); + f( 2, "s2" ); + CHECK_CALLS( 2 ); } { - mock::detail::function f; + mock::detail::function< void( int, const std::string& ) > f; f.expect(); - f(1, "s1"); - f(2, "s2"); - CHECK_CALLS(2); + f( 1, "s1" ); + f( 2, "s2" ); + CHECK_CALLS( 2 ); } } -BOOST_FIXTURE_TEST_CASE(triggering_several_once_expectations_is_valid, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( triggering_several_once_expectations_is_valid, mock_error_fixture ) { { - mock::detail::function f; + mock::detail::function< void() > f; f.expect().once(); f.expect().once(); f(); f(); - CHECK_CALLS(2); + CHECK_CALLS( 2 ); } { - mock::detail::function f; - f.expect().once().with(1, "s1"); - f.expect().once().with(2, "s2"); - f(1, "s1"); - f(2, "s2"); - CHECK_CALLS(2); + mock::detail::function< void( int, std::string ) > f; + f.expect().once().with( 1, "s1" ); + f.expect().once().with( 2, "s2" ); + f( 1, "s1" ); + f( 2, "s2" ); + CHECK_CALLS( 2 ); } { - mock::detail::function f; - f.expect().once().with(1, "s1"); - f.expect().once().with(2, "s2"); - f(1, "s1"); - f(2, "s2"); - CHECK_CALLS(2); + mock::detail::function< void( int, const std::string& ) > f; + f.expect().once().with( 1, "s1" ); + f.expect().once().with( 2, "s2" ); + f( 1, "s1" ); + f( 2, "s2" ); + CHECK_CALLS( 2 ); } } -BOOST_FIXTURE_TEST_CASE(string_likes_are_matched, mock_error_fixture) -{ - const char* c_string = "value"; - const char c_string2[] = "value"; - BOOST_REQUIRE(c_string != c_string2); // Different pointers - const std::string string = c_string; - { - mock::detail::function f; - - f.expect().once().with(string); - f(string); - BOOST_TEST(f.verify()); - - f.reset(); - f.expect().once().with(c_string); - f(string); - BOOST_TEST(f.verify()); - - f.reset(); - f.expect().once().with(c_string2); - f(string); - BOOST_TEST(f.verify()); - - CHECK_CALLS(3); - } - { - mock::detail::function f; - - f.expect().once().with(c_string); - f(c_string); - BOOST_TEST(f.verify()); - - f.reset(); - f.expect().once().with(c_string); - f(c_string2); - BOOST_TEST(f.verify()); - - f.reset(); - f.expect().once().with(c_string2); - f(c_string); - BOOST_TEST(f.verify()); - - f.reset(); - f.expect().once().with(string); - f(c_string); - BOOST_TEST(f.verify()); - CHECK_CALLS(4); - } -} - -BOOST_FIXTURE_TEST_CASE(triggering_a_once_expectation_calls_unexpected_call_error_after_one_call, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( triggering_a_once_expectation_calls_unexpected_call_error_after_one_call, mock_error_fixture ) { { - mock::detail::function f; + mock::detail::function< void() > f; f.expect().once(); f(); - CHECK_ERROR(f(), "unexpected call", 1, "?()\nv once()"); + CHECK_ERROR( f(), "unexpected call", 1, "?()\nv once()" ); } { - mock::detail::function f; + mock::detail::function< void( int, const std::string& ) > f; f.expect().once(); - f(1, "s"); - CHECK_ERROR(f(1, "s"), "unexpected call", 1, "?( 1, \"s\" )\nv once().with( any, any )"); + f( 1, "s" ); + CHECK_ERROR( f( 1, "s" ), "unexpected call", 1, "?( 1, \"s\" )\nv once().with( any, any )" ); } } -BOOST_FIXTURE_TEST_CASE(literal_zero_can_be_used_in_function_call_as_pointers, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( literal_zero_can_be_used_in_function_call_as_pointers, mock_error_fixture ) { - mock::detail::function f; + mock::detail::function< void( int* ) > f; f.expect().once(); - f(0); - CHECK_CALLS(1); + f( 0 ); + CHECK_CALLS( 1 ); } // verify -BOOST_FIXTURE_TEST_CASE(verifying_an_unconfigured_function_succeeds, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( verifying_an_unconfigured_function_succeeds, mock_error_fixture ) { { - mock::detail::function f; - BOOST_CHECK(f.verify()); + mock::detail::function< void() > f; + BOOST_CHECK( f.verify() ); } { - mock::detail::function f; - BOOST_CHECK(f.verify()); + mock::detail::function< int( int, const std::string& ) > f; + BOOST_CHECK( f.verify() ); } } -BOOST_FIXTURE_TEST_CASE(verifying_an_unlimited_expectation_succeeds, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( verifying_an_unlimited_expectation_succeeds, mock_error_fixture ) { { - mock::detail::function f; + mock::detail::function< void() > f; f.expect(); - BOOST_CHECK(f.verify()); - CHECK_CALLS(0); + BOOST_CHECK( f.verify() ); + CHECK_CALLS( 0 ); } { - mock::detail::function f; + mock::detail::function< int( int, const std::string& ) > f; f.expect(); - BOOST_CHECK(f.verify()); - CHECK_CALLS(0); + BOOST_CHECK( f.verify() ); + CHECK_CALLS( 0 ); } } -BOOST_FIXTURE_TEST_CASE(verifying_a_once_expectation_after_one_call_succeeds, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( verifying_a_once_expectation_after_one_call_succeeds, mock_error_fixture ) { { - mock::detail::function f; + mock::detail::function< void() > f; f.expect().once(); f(); - BOOST_CHECK(f.verify()); - CHECK_CALLS(1); + BOOST_CHECK( f.verify() ); + CHECK_CALLS( 1 ); } { - mock::detail::function f; + mock::detail::function< void( int, const std::string& ) > f; f.expect().once(); - f(1, "s"); - BOOST_CHECK(f.verify()); - CHECK_CALLS(1); + f( 1, "s" ); + BOOST_CHECK( f.verify() ); + CHECK_CALLS( 1 ); } } -BOOST_FIXTURE_TEST_CASE(verifying_a_once_expectation_before_the_call_fails, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( verifying_a_once_expectation_before_the_call_fails, mock_error_fixture ) { { - mock::detail::function f; + mock::detail::function< void() > f; f.expect().once(); - CHECK_ERROR(BOOST_CHECK(!f.verify()), "verification failed", 0, "?\n. once()"); + CHECK_ERROR( BOOST_CHECK( ! f.verify() ), "verification failed", 0, "?\n. once()" ); } { - mock::detail::function f; + mock::detail::function< int( int, const std::string& ) > f; f.expect().once(); - CHECK_ERROR(BOOST_CHECK(!f.verify()), "verification failed", 0, "?\n. once().with( any, any )"); + CHECK_ERROR( BOOST_CHECK( ! f.verify() ), "verification failed", 0, "?\n. once().with( any, any )" ); } } -BOOST_FIXTURE_TEST_CASE(verifying_a_once_expectation_after_a_verify_and_one_call_succeeds, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( verifying_a_once_expectation_after_a_verify_and_one_call_succeeds, mock_error_fixture ) { - mock::detail::function f; + mock::detail::function< void() > f; f.expect().once(); - CHECK_ERROR(BOOST_CHECK(!f.verify()), "verification failed", 0, "?\n. once()"); + CHECK_ERROR( BOOST_CHECK( ! f.verify() ), "verification failed", 0, "?\n. once()" ); f(); - BOOST_CHECK(f.verify()); - CHECK_CALLS(1); + BOOST_CHECK( f.verify() ); + CHECK_CALLS( 1 ); } // reset -BOOST_FIXTURE_TEST_CASE(triggering_a_reset_function_calls_unexpected_call_error, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( triggering_a_reset_function_calls_unexpected_call_error, mock_error_fixture ) { { - mock::detail::function f; + mock::detail::function< void() > f; f.expect(); f.reset(); - CHECK_ERROR(f(), "unexpected call", 0, "?()"); + CHECK_ERROR( f(), "unexpected call", 0, "?()" ); } { - mock::detail::function f; + mock::detail::function< int( int, const std::string& ) > f; f.expect(); f.reset(); - CHECK_ERROR(f(1, "s"), "unexpected call", 0, "?( 1, \"s\" )"); + CHECK_ERROR( f( 1, "s" ), "unexpected call", 0, "?( 1, \"s\" )" ); } } -BOOST_FIXTURE_TEST_CASE(verifying_a_reset_function_succeeds, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( verifying_a_reset_function_succeeds, mock_error_fixture ) { { - mock::detail::function f; + mock::detail::function< void() > f; f.expect(); f.reset(); - BOOST_CHECK(f.verify()); + BOOST_CHECK( f.verify() ); } { - mock::detail::function f; + mock::detail::function< int( int, const std::string& ) > f; f.expect(); f.reset(); - BOOST_CHECK(f.verify()); + BOOST_CHECK( f.verify() ); } } // constraints -BOOST_FIXTURE_TEST_CASE( - triggering_an_expectation_with_wrong_parameter_value_in_equal_constraint_calls_unexpected_call_error, - mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_with_wrong_parameter_value_in_equal_constraint_calls_unexpected_call_error, mock_error_fixture ) { { - mock::detail::function f; - f.expect().with(42); - CHECK_ERROR(f(43), "unexpected call", 0, "?( 43 )\n. unlimited().with( 42 )"); + mock::detail::function< void( int ) > f; + f.expect().with( 42 ); + CHECK_ERROR( f( 43 ), "unexpected call", 0, "?( 43 )\n. unlimited().with( 42 )" ); } { - mock::detail::function f; - f.expect().with(42, "expected"); - CHECK_ERROR( - f(42, "actual"), "unexpected call", 0, "?( 42, \"actual\" )\n. unlimited().with( 42, \"expected\" )"); + mock::detail::function< int( int, const std::string& ) > f; + f.expect().with( 42, "expected" ); + CHECK_ERROR( f( 42, "actual" ), "unexpected call", 0, "?( 42, \"actual\" )\n. unlimited().with( 42, \"expected\" )" ); } } -BOOST_FIXTURE_TEST_CASE( - triggering_an_expectation_with_wrong_parameter_value_in_equal_or_less_constraint_calls_unexpected_call_error, - mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_with_wrong_parameter_value_in_equal_or_less_constraint_calls_unexpected_call_error, mock_error_fixture ) { - mock::detail::function f; - f.expect().with(mock::equal(42) || mock::less(42)); - f(41); - f(42); - CHECK_ERROR(f(43), "unexpected call", 2, "?( 43 )\n. unlimited().with( ( equal( 42 ) || less( 42 ) ) )"); + mock::detail::function< void( int ) > f; + f.expect().with( mock::equal( 42 ) || mock::less( 42 ) ); + f( 41 ); + f( 42 ); + CHECK_ERROR( f( 43 ), "unexpected call", 2, "?( 43 )\n. unlimited().with( ( equal( 42 ) || less( 42 ) ) )" ); } -BOOST_FIXTURE_TEST_CASE( - triggering_an_expectation_with_wrong_parameter_value_in_equal_and_not_less_constraint_calls_unexpected_call_error, - mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_with_wrong_parameter_value_in_equal_and_not_less_constraint_calls_unexpected_call_error, mock_error_fixture ) { - mock::detail::function f; - f.expect().with(mock::equal(42) && !mock::less(41)); - f(42); - CHECK_ERROR(f(43), "unexpected call", 1, "?( 43 )\n. unlimited().with( ( equal( 42 ) && ! less( 41 ) ) )"); + mock::detail::function< void( int ) > f; + f.expect().with( mock::equal( 42 ) && ! mock::less( 41 ) ); + f( 42 ); + CHECK_ERROR( f( 43 ), "unexpected call", 1, "?( 43 )\n. unlimited().with( ( equal( 42 ) && ! less( 41 ) ) )" ); } -namespace { -class my_interface +namespace { -public: - my_interface() = default; - my_interface(const my_interface&) = delete; - my_interface& operator=(const my_interface&) = delete; - virtual ~my_interface() = default; + class my_interface : boost::noncopyable + { + public: + virtual ~my_interface() {} + private: + virtual void my_method() = 0; + }; + class my_implementation : public my_interface + { + virtual void my_method() {} + }; +} -private: - virtual void my_method() = 0; -}; -class my_implementation : public my_interface -{ - virtual void my_method() {} -}; -} // namespace - -BOOST_FIXTURE_TEST_CASE(passing_call_values_by_reference_is_transparent, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( passing_call_values_by_reference_is_transparent, mock_error_fixture ) { { - mock::detail::function f; + mock::detail::function< void( my_interface& ) > f; my_implementation imp; - f.expect().with(mock::same(imp)); - f(imp); - CHECK_CALLS(1); + f.expect().with( mock::same( imp ) ); + f( imp ); + CHECK_CALLS( 1 ); } { - mock::detail::function f; + mock::detail::function< void( const my_interface& ) > f; my_implementation imp; - f.expect().with(mock::same(imp)); - f(imp); - CHECK_CALLS(1); + f.expect().with( mock::same( imp ) ); + f( imp ); + CHECK_CALLS( 1 ); } } -namespace { -bool custom_constraint(int) +namespace { - return false; + bool custom_constraint( int ) + { + return false; + } } -} // namespace -BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_with_failing_custom_constraint_calls_unexpected_call_error, - mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_with_failing_custom_constraint_calls_unexpected_call_error, mock_error_fixture ) { { - mock::detail::function f; - f.expect().with(&custom_constraint); - CHECK_ERROR(f(42), "unexpected call", 0, "?( 42 )\n. unlimited().with( ? )"); + mock::detail::function< void( int ) > f; + f.expect().with( &custom_constraint ); + CHECK_ERROR( f( 42 ), "unexpected call", 0, "?( 42 )\n. unlimited().with( ? )" ); } { - mock::detail::function f; - f.expect().with(&custom_constraint, "actual"); - CHECK_ERROR(f(42, "actual"), "unexpected call", 0, "?( 42, \"actual\" )\n. unlimited().with( ?, \"actual\" )"); + mock::detail::function< int( int, const std::string& ) > f; + f.expect().with( &custom_constraint, "actual" ); + CHECK_ERROR( f( 42, "actual" ), "unexpected call", 0, "?( 42, \"actual\" )\n. unlimited().with( ?, \"actual\" )" ); } } -// BOOST_FIXTURE_TEST_CASE( literal_zero_can_be_used_in_place_of_null_pointers_in_constraints, mock_error_fixture ) +//BOOST_FIXTURE_TEST_CASE( literal_zero_can_be_used_in_place_of_null_pointers_in_constraints, mock_error_fixture ) //{ // mock::detail::function< void( int* ) > f; // f.expect().with( 0 ); @@ -444,518 +354,589 @@ BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_with_failing_custom_constraint // CHECK_CALLS( 1 ); //} -BOOST_FIXTURE_TEST_CASE(nullptr_can_be_used_in_place_of_null_pointers_in_constraints, mock_error_fixture) +#ifdef MOCK_NULLPTR + +BOOST_FIXTURE_TEST_CASE( nullptr_can_be_used_in_place_of_null_pointers_in_constraints, mock_error_fixture ) { - mock::detail::function f; - f.expect().with(nullptr); - f(0); - CHECK_CALLS(1); + mock::detail::function< void( int* ) > f; + f.expect().with( nullptr ); + f( 0 ); + CHECK_CALLS( 1 ); } -BOOST_FIXTURE_TEST_CASE(unique_ptr_is_supported_as_parameter, mock_error_fixture) +#endif + +#ifdef MOCK_SMART_PTR + +BOOST_FIXTURE_TEST_CASE( unique_ptr_is_supported_as_parameter, mock_error_fixture ) { - mock::detail::function)> f; + mock::detail::function< void( std::unique_ptr< int > ) > f; f.expect(); - std::unique_ptr p(new int); - f(std::move(p)); - CHECK_CALLS(1); + std::unique_ptr< int > p( new int ); + f( std::move( p ) ); + CHECK_CALLS( 1 ); } +#endif // MOCK_SMART_PTR + // result handling -BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_with_no_return_set_calls_missing_action, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_with_no_return_set_calls_missing_action, mock_error_fixture ) { { - mock::detail::function f; + mock::detail::function< int() > f; f.expect(); - CHECK_ERROR(f(), "missing action", 0, "?()\n. unlimited()"); + CHECK_ERROR( f(), "missing action", 0, "?()\n. unlimited()" ); } { - mock::detail::function f; + mock::detail::function< int&() > f; f.expect(); - CHECK_ERROR(f(), "missing action", 0, "?()\n. unlimited()"); + CHECK_ERROR( f(), "missing action", 0, "?()\n. unlimited()" ); } { - mock::detail::function f; + mock::detail::function< const std::string&() > f; f.expect(); - CHECK_ERROR(f(), "missing action", 0, "?()\n. unlimited()"); + CHECK_ERROR( f(), "missing action", 0, "?()\n. unlimited()" ); } } -BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_returns_the_set_value, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_returns_the_set_value, mock_error_fixture ) { { - mock::detail::function f; - f.expect().returns(42); - BOOST_CHECK_EQUAL(42, f()); - CHECK_CALLS(1); + mock::detail::function< int() > f; + f.expect().returns( 42 ); + BOOST_CHECK_EQUAL( 42, f() ); + CHECK_CALLS( 1 ); } { - mock::detail::function f; + mock::detail::function< int() > f; const int i = 42; - f.expect().returns(i); - BOOST_CHECK_EQUAL(i, f()); - CHECK_CALLS(1); + f.expect().returns( i ); + BOOST_CHECK_EQUAL( i, f() ); + CHECK_CALLS( 1 ); } { - mock::detail::function f; + mock::detail::function< int() > f; int i = 42; - f.expect().returns(std::ref(i)); + f.expect().returns( boost::ref( i ) ); i = 43; - BOOST_CHECK_EQUAL(43, f()); - CHECK_CALLS(1); + BOOST_CHECK_EQUAL( 43, f() ); + CHECK_CALLS( 1 ); } { - mock::detail::function f; - f.expect().returns(42); - BOOST_CHECK_EQUAL(42, f()); - CHECK_CALLS(1); + mock::detail::function< int&() > f; + f.expect().returns( 42 ); + BOOST_CHECK_EQUAL( 42, f() ); + CHECK_CALLS( 1 ); } { - mock::detail::function f; + mock::detail::function< int&() > f; const int result = 42; - f.expect().returns(result); - BOOST_CHECK_EQUAL(result, f()); - CHECK_CALLS(1); + f.expect().returns( result ); + BOOST_CHECK_EQUAL( result, f() ); + CHECK_CALLS( 1 ); } { - mock::detail::function f; + mock::detail::function< int&() > f; int i = 42; - f.expect().returns(i); + f.expect().returns( i ); i = 43; - BOOST_CHECK_EQUAL(42, f()); - CHECK_CALLS(1); + BOOST_CHECK_EQUAL( 42, f() ); + CHECK_CALLS( 1 ); } { - mock::detail::function f; + mock::detail::function< int&() > f; int i = 42; - f.expect().returns(std::ref(i)); + f.expect().returns( boost::ref( i ) ); i = 43; - BOOST_CHECK_EQUAL(43, f()); - BOOST_CHECK_EQUAL(12, f() = 12); - BOOST_CHECK_EQUAL(12, i); - CHECK_CALLS(2); + BOOST_CHECK_EQUAL( 43, f() ); + BOOST_CHECK_EQUAL( 12, f() = 12 ); + BOOST_CHECK_EQUAL( 12, i ); + CHECK_CALLS( 2 ); } { - mock::detail::function f; - f.expect().returns("result"); - BOOST_CHECK_EQUAL("result", f()); - CHECK_CALLS(1); + mock::detail::function< std::string() > f; + f.expect().returns( "result" ); + BOOST_CHECK_EQUAL( "result", f() ); + CHECK_CALLS( 1 ); } { - mock::detail::function f; - f.expect().returns("result"); - BOOST_CHECK_EQUAL("result", f()); - CHECK_CALLS(1); + mock::detail::function< const std::string&() > f; + f.expect().returns( "result" ); + BOOST_CHECK_EQUAL( "result", f() ); + CHECK_CALLS( 1 ); } { - mock::detail::function f; - f.expect().returns(0); - BOOST_CHECK(!f()); - CHECK_CALLS(1); + mock::detail::function< int*() > f; + f.expect().returns( 0 ); + BOOST_CHECK( ! f() ); + CHECK_CALLS( 1 ); } #ifdef BOOST_MSVC // this produces a warning with gcc { - mock::detail::function f; + mock::detail::function< int* const() > f; int i = 0; - f.expect().returns(&i); - BOOST_CHECK_EQUAL(&i, f()); - CHECK_CALLS(1); + f.expect().returns( &i ); + BOOST_CHECK_EQUAL( &i, f() ); + CHECK_CALLS( 1 ); } #endif { - mock::detail::function f; - f.expect().returns(0); - BOOST_CHECK_EQUAL(0, f()); - CHECK_CALLS(1); + mock::detail::function< int() > f; + f.expect().returns( 0 ); + BOOST_CHECK_EQUAL( 0, f() ); + CHECK_CALLS( 1 ); } { - mock::detail::function f; - f.expect().returns(0); - BOOST_CHECK_EQUAL(0, f()); - CHECK_CALLS(1); + mock::detail::function< int&() > f; + f.expect().returns( 0 ); + BOOST_CHECK_EQUAL( 0, f() ); + CHECK_CALLS( 1 ); } { - mock::detail::function f; - f.expect().returns(0); - BOOST_CHECK_EQUAL(0u, f()); - CHECK_CALLS(1); + mock::detail::function< unsigned int() > f; + f.expect().returns( 0 ); + BOOST_CHECK_EQUAL( 0u, f() ); + CHECK_CALLS( 1 ); } } -namespace { -struct base +namespace { - virtual ~base() = default; - virtual void f() = 0; -}; -struct derived : base -{ - virtual void f() {} -}; -} // namespace + struct base + { + virtual ~base() + {} + virtual void f() = 0; + }; + struct derived : base + { + virtual void f() + {} + }; +} -BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_moves_the_set_lvalue, mock_error_fixture) +#ifdef MOCK_AUTO_PTR + +BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_returns_the_set_auto_ptr_value, mock_error_fixture ) { - mock::detail::function f; + { + mock::detail::function< std::auto_ptr< int >() > f; + std::auto_ptr< int > ptr( new int( 3 ) ); + f.expect().returns( boost::ref( ptr ) ); + BOOST_CHECK_EQUAL( 3, *ptr ); + BOOST_CHECK_EQUAL( 3, *f() ); + BOOST_CHECK( ! ptr.get() ); + BOOST_CHECK( ! f().get() ); + CHECK_CALLS( 2 ); + } + { + mock::detail::function< std::auto_ptr< int >() > f; + std::auto_ptr< int > ptr( new int( 3 ) ); + f.expect().returns( ptr ); + BOOST_CHECK( ! ptr.get() ); + BOOST_CHECK_EQUAL( 3, *f() ); + BOOST_CHECK( ! f().get() ); + CHECK_CALLS( 2 ); + } + { + mock::detail::function< std::auto_ptr< int >() > f; + f.expect().returns( new int( 3 ) ); + BOOST_CHECK_EQUAL( 3, *f() ); + BOOST_CHECK( ! f().get() ); + CHECK_CALLS( 2 ); + } + { + mock::detail::function< std::auto_ptr< int >() > f; + f.expect().returns( std::auto_ptr< int >( new int( 3 ) ) ); + BOOST_CHECK_EQUAL( 3, *f() ); + BOOST_CHECK( ! f().get() ); + CHECK_CALLS( 2 ); + } + { + mock::detail::function< std::auto_ptr< base >() > f; + f.expect().returns( new derived ); + BOOST_CHECK_NO_THROW( f() ); + CHECK_CALLS( 1 ); + } + { + mock::detail::function< std::auto_ptr< base >() > f; + f.expect().returns( std::auto_ptr< base >( new derived ) ); + BOOST_CHECK_NO_THROW( f() ); + CHECK_CALLS( 1 ); + } + { + mock::detail::function< std::auto_ptr< base >() > f; + f.expect().returns( std::auto_ptr< derived >( new derived ) ); + BOOST_CHECK_NO_THROW( f() ); + CHECK_CALLS( 1 ); + } +} + +#endif // MOCK_AUTO_PTR + +#ifdef MOCK_RVALUE_REFERENCES + +BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_moves_the_set_lvalue, mock_error_fixture ) +{ + mock::detail::function< int() > f; int i = 3; - f.expect().moves(i); - BOOST_CHECK_NO_THROW(f()); - CHECK_CALLS(1); + f.expect().moves( i ); + BOOST_CHECK_NO_THROW( f() ); + CHECK_CALLS( 1 ); } -BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_moves_the_set_const_lvalue, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_moves_the_set_const_lvalue, mock_error_fixture ) { - mock::detail::function f; + mock::detail::function< int() > f; const int i = 3; - f.expect().moves(i); - BOOST_CHECK_NO_THROW(f()); - CHECK_CALLS(1); + f.expect().moves( i ); + BOOST_CHECK_NO_THROW( f() ); + CHECK_CALLS( 1 ); } -BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_moves_the_set_rvalue, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_moves_the_set_rvalue, mock_error_fixture ) { - mock::detail::function f; - f.expect().moves(3); - BOOST_CHECK_NO_THROW(f()); - CHECK_CALLS(1); + mock::detail::function< int() > f; + f.expect().moves( 3 ); + BOOST_CHECK_NO_THROW( f() ); + CHECK_CALLS( 1 ); } -BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_moves_the_set_unique_ptr_lvalue, mock_error_fixture) +#endif + +#ifdef MOCK_SMART_PTR + +BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_moves_the_set_unique_ptr_lvalue, mock_error_fixture ) { - mock::detail::function()> f; - std::unique_ptr p(new int); - f.expect().moves(std::move(p)); - BOOST_CHECK_NO_THROW(f()); - CHECK_CALLS(1); + mock::detail::function< std::unique_ptr< int >() > f; + std::unique_ptr< int > p( new int ); + f.expect().moves( std::move( p ) ); + BOOST_CHECK_NO_THROW( f() ); + CHECK_CALLS( 1 ); } -BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_moves_the_set_unique_ptr_rvalue, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_moves_the_set_unique_ptr_rvalue, mock_error_fixture ) { { - mock::detail::function()> f; - f.expect().moves(std::unique_ptr(new int)); - BOOST_CHECK_NO_THROW(f()); - CHECK_CALLS(1); + mock::detail::function< std::unique_ptr< int >() > f; + f.expect().moves( std::unique_ptr< int >( new int ) ); + BOOST_CHECK_NO_THROW( f() ); + CHECK_CALLS( 1 ); } } -BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_returns_the_set_shared_ptr_value, mock_error_fixture) +#endif // MOCK_SMART_PTR + +BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_returns_the_set_shared_ptr_value, mock_error_fixture ) { { - mock::detail::function()> f; - f.expect().returns(new derived); - BOOST_CHECK_NO_THROW(f()); - CHECK_CALLS(1); + mock::detail::function< boost::shared_ptr< base >() > f; + f.expect().returns( new derived ); + BOOST_CHECK_NO_THROW( f() ); + CHECK_CALLS( 1 ); } { - mock::detail::function&()> f; - f.expect().returns(new derived); - BOOST_CHECK_NO_THROW(f()); - CHECK_CALLS(1); + mock::detail::function< const boost::shared_ptr< base >&() > f; + f.expect().returns( new derived ); + BOOST_CHECK_NO_THROW( f() ); + CHECK_CALLS( 1 ); } { - mock::detail::function&()> f; - f.expect().returns(new derived); - BOOST_CHECK_NO_THROW(f()); - CHECK_CALLS(1); + mock::detail::function< boost::shared_ptr< base >&() > f; + f.expect().returns( new derived ); + BOOST_CHECK_NO_THROW( f() ); + CHECK_CALLS( 1 ); } } -BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_returns_by_reference, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_returns_by_reference, mock_error_fixture ) { { - mock::detail::function f; + mock::detail::function< base&() > f; derived b; - f.expect().returns(std::ref(b)); - BOOST_CHECK_NO_THROW(f()); - CHECK_CALLS(1); + f.expect().returns( boost::ref( b ) ); + BOOST_CHECK_NO_THROW( f() ); + CHECK_CALLS( 1 ); } { - mock::detail::function f; + mock::detail::function< base&() > f; derived b; - f.expect().returns(b); - BOOST_CHECK_NO_THROW(f()); - CHECK_CALLS(1); + f.expect().returns( b ); + BOOST_CHECK_NO_THROW( f() ); + CHECK_CALLS( 1 ); } { - mock::detail::function f; - f.expect().returns(std::ref(get_undefined())); + mock::detail::function< undefined&() > f; + f.expect().returns( boost::ref( get_undefined() ) ); f.reset(); } } -namespace { -int custom_result() +namespace { - return 42; -} -} // namespace - -BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_calls_the_custom_functor, mock_error_fixture) -{ - mock::detail::function f; - f.expect().calls(&custom_result); - BOOST_CHECK_EQUAL(42, f()); - CHECK_CALLS(1); + int custom_result() + { + return 42; + } } -namespace { -int custom_result_with_parameter(int i) +BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_calls_the_custom_functor, mock_error_fixture ) { - return i; -} -} // namespace - -BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_calls_the_custom_functor_with_parameters, mock_error_fixture) -{ - mock::detail::function f; - f.expect().calls(&custom_result_with_parameter); - BOOST_CHECK_EQUAL(42, f(42)); - CHECK_CALLS(1); + mock::detail::function< int() > f; + f.expect().calls( &custom_result ); + BOOST_CHECK_EQUAL( 42, f() ); + CHECK_CALLS( 1 ); } -BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_calls_the_custom_functor_without_parameters_thanks_to_std_bind, - mock_error_fixture) +namespace { - mock::detail::function f; - f.expect().calls(std::bind(&custom_result)); - BOOST_CHECK_EQUAL(42, f(17)); - CHECK_CALLS(1); + int custom_result_with_parameter( int i ) + { + return i; + } } -BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_throws_the_set_exception, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_calls_the_custom_functor_with_parameters, mock_error_fixture ) { - mock::detail::function f; - f.expect().throws(std::runtime_error("some exception")); + mock::detail::function< int( int ) > f; + f.expect().calls( &custom_result_with_parameter ); + BOOST_CHECK_EQUAL( 42, f( 42 ) ); + CHECK_CALLS( 1 ); +} + +BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_calls_the_custom_functor_without_parameters_thanks_to_boost_bind, mock_error_fixture ) +{ + mock::detail::function< int( int ) > f; + f.expect().calls( boost::bind( &custom_result ) ); + BOOST_CHECK_EQUAL( 42, f( 17 ) ); + CHECK_CALLS( 1 ); +} + +BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_throws_the_set_exception, mock_error_fixture ) +{ + mock::detail::function< int() > f; + f.expect().throws( std::runtime_error( "some exception" ) ); try { f(); - } catch(std::runtime_error& f) + } + catch( std::runtime_error& f ) { - BOOST_CHECK_EQUAL("some exception", f.what()); - CHECK_CALLS(1); + BOOST_CHECK_EQUAL( "some exception", f.what() ); + CHECK_CALLS( 1 ); return; } - BOOST_FAIL("should have thrown"); + BOOST_FAIL( "should have thrown" ); } // multiple expectations -BOOST_FIXTURE_TEST_CASE(expecting_twice_a_single_expectation_makes_it_callable_twice, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( expecting_twice_a_single_expectation_makes_it_callable_twice, mock_error_fixture ) { { - mock::detail::function f; + mock::detail::function< void() > f; f.expect().once(); f.expect().once(); f(); f(); - CHECK_ERROR(f(), "unexpected call", 2, "?()\nv once()\nv once()"); + CHECK_ERROR( f(), "unexpected call", 2, "?()\nv once()\nv once()" ); } { - mock::detail::function f; - f.expect().once().with("first"); - f.expect().once().with("second"); - f("first"); - f("second"); - CHECK_ERROR( - f("third"), "unexpected call", 2, "?( \"third\" )\nv once().with( \"first\" )\nv once().with( \"second\" )"); + mock::detail::function< void( const std::string& ) > f; + f.expect().once().with( "first" ); + f.expect().once().with( "second" ); + f( "first" ); + f( "second" ); + CHECK_ERROR( f( "third"), "unexpected call", 2, "?( \"third\" )\nv once().with( \"first\" )\nv once().with( \"second\" )" ); } } -BOOST_FIXTURE_TEST_CASE(best_expectation_is_selected_first, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( best_expectation_is_selected_first, mock_error_fixture ) { { - mock::detail::function f; - f.expect().once().with(1); - f.expect().once().with(2); - f(2); - f(1); - CHECK_ERROR(f(3), "unexpected call", 2, "?( 3 )\nv once().with( 1 )\nv once().with( 2 )"); + mock::detail::function< void( int ) > f; + f.expect().once().with( 1 ); + f.expect().once().with( 2 ); + f( 2 ); + f( 1 ); + CHECK_ERROR( f( 3 ), "unexpected call", 2, "?( 3 )\nv once().with( 1 )\nv once().with( 2 )" ); } { - mock::detail::function f; - f.expect().once().with("first"); - f.expect().once().with("second"); - f("second"); - f("first"); - CHECK_ERROR( - f("third"), "unexpected call", 2, "?( \"third\" )\nv once().with( \"first\" )\nv once().with( \"second\" )"); + mock::detail::function< void( const std::string& ) > f; + f.expect().once().with( "first" ); + f.expect().once().with( "second" ); + f( "second" ); + f( "first" ); + CHECK_ERROR( f( "third"), "unexpected call", 2, "?( \"third\" )\nv once().with( \"first\" )\nv once().with( \"second\" )" ); } } // error report -namespace { -template -std::string to_string(const T& t) +namespace { - std::stringstream s; - s << t; - return s.str(); + template< typename T > + std::string to_string( const T& t ) + { + std::stringstream s; + s << t; + return s.str(); + } } -} // namespace -BOOST_FIXTURE_TEST_CASE(expectation_can_be_serialized_to_be_human_readable, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( expectation_can_be_serialized_to_be_human_readable, mock_error_fixture ) { { - mock::detail::function f; - f.expect().once().with(1); - f.expect().once().with(mock::close(3, 1)); - int target = 0; - f.expect().once().with(mock::retrieve(target)); - f.expect().once().with(mock::same(target)); - BOOST_CHECK_NO_THROW(f(2)); - std::string expected = "?\n"; // Not in a current call context - expected += ". once().with( 1 )\n"; // Unmet/Unverified expectation with value - expected += "v once().with( close( 3, 1 ) )\n"; // Verified expectation with constraint - target = 42; - // (Unverified) expectation with retrieve/same constraint print current value - expected += ". once().with( retrieve( 42 ) )\n"; - expected += ". once().with( same( 42 ) )"; - BOOST_CHECK_EQUAL(expected, to_string(f)); - CHECK_CALLS(1); + mock::detail::function< void( int ) > f; + f.expect().once().with( 1 ); + f.expect().once().with( 2 ); + BOOST_CHECK_NO_THROW( f( 2 ) ); + const std::string expected = "?\n" + ". once().with( 1 )\n" + "v once().with( 2 )"; + BOOST_CHECK_EQUAL( expected, to_string( f ) ); + CHECK_CALLS( 1 ); f.reset(); } { - mock::detail::function f; - f.expect().never().with(1); + mock::detail::function< void( int ) > f; + f.expect().never().with( 1 ); const std::string expected = "?\n" "v never().with( 1 )"; - BOOST_CHECK_EQUAL(expected, to_string(f)); + BOOST_CHECK_EQUAL( expected, to_string( f ) ); f.reset(); } { - mock::detail::function f; - f.expect().never().with(mock::less("first")); - f.expect().exactly(2).with("second"); - BOOST_CHECK_NO_THROW(f("second")); + mock::detail::function< void( const std::string& ) > f; + f.expect().never().with( mock::less( "first" ) ); + f.expect().exactly( 2 ).with( "second" ); + BOOST_CHECK_NO_THROW( f( "second" ) ); { const std::string expected = "?\n" "v never().with( less( \"first\" ) )\n" ". exactly( 1/2 ).with( \"second\" )"; - BOOST_CHECK_EQUAL(expected, to_string(f)); + BOOST_CHECK_EQUAL( expected, to_string( f ) ); } - BOOST_CHECK_NO_THROW(f("second")); + BOOST_CHECK_NO_THROW( f( "second" ) ); { const std::string expected = "?\n" "v never().with( less( \"first\" ) )\n" "v exactly( 2/2 ).with( \"second\" )"; - BOOST_CHECK_EQUAL(expected, to_string(f)); - CHECK_CALLS(2); + BOOST_CHECK_EQUAL( expected, to_string( f ) ); + CHECK_CALLS( 2 ); } f.reset(); } { - mock::detail::function f; + mock::detail::function< void( int ) > f; f.expect().once(); const std::string expected = "?\n" ". once().with( any )"; - BOOST_CHECK_EQUAL(expected, to_string(f)); + BOOST_CHECK_EQUAL( expected, to_string( f ) ); f.reset(); } { - mock::detail::function f; - f.expect().once().with(mock::any); + mock::detail::function< void( int ) > f; + f.expect().once().with( mock::any ); const std::string expected = "?\n" ". once().with( any )"; - BOOST_CHECK_EQUAL(expected, to_string(f)); + BOOST_CHECK_EQUAL( expected, to_string( f ) ); f.reset(); } { - mock::detail::function f; + mock::detail::function< void( int ) > f; f.expect().once(); const std::string expected = "?\n" ". once().with( any )"; - BOOST_CHECK_EQUAL(expected, to_string(f)); + BOOST_CHECK_EQUAL( expected, to_string( f ) ); f.reset(); } { - mock::detail::function f; - f.expect().once().with(&custom_constraint); + mock::detail::function< void( int ) > f; + f.expect().once().with( &custom_constraint ); const std::string expected = "?\n" ". once().with( ? )"; - BOOST_CHECK_EQUAL(expected, to_string(f)); + BOOST_CHECK_EQUAL( expected, to_string( f ) ); f.reset(); } } -BOOST_FIXTURE_TEST_CASE(expectation_with_remaining_untriggered_matches_upon_destruction_calls_untriggered_expectation, - mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( expectation_with_remaining_untriggered_matches_upon_destruction_calls_untriggered_expectation, mock_error_fixture ) { - auto f = std::make_unique>(); + boost::scoped_ptr< mock::detail::function< void() > > f( new mock::detail::function< void() > ); f->expect().once(); - CHECK_ERROR(f.reset(), "untriggered expectation", 0, "?\n. once()"); + CHECK_ERROR( f.reset(), "untriggered expectation", 0, "?\n. once()" ); } -BOOST_FIXTURE_TEST_CASE( - verifying_expectation_with_remaining_matches_disables_the_automatic_verification_upon_destruction, - mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( verifying_expectation_with_remaining_matches_disables_the_automatic_verification_upon_destruction, mock_error_fixture ) { - mock::detail::function f; + mock::detail::function< void() > f; f.expect().once(); - CHECK_ERROR(f.verify(), "verification failed", 0, "?\n. once()"); + CHECK_ERROR( f.verify(), "verification failed", 0, "?\n. once()" ); } -BOOST_FIXTURE_TEST_CASE(triggering_unexpected_call_call_disables_the_automatic_verification_upon_destruction, - mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( triggering_unexpected_call_call_disables_the_automatic_verification_upon_destruction, mock_error_fixture ) { - mock::detail::function f; - CHECK_ERROR(f(), "unexpected call", 0, "?()"); + mock::detail::function< void() > f; + CHECK_ERROR( f(), "unexpected call", 0, "?()" ); } -BOOST_FIXTURE_TEST_CASE(adding_an_expectation_reactivates_the_verification_upon_destruction, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( adding_an_expectation_reactivates_the_verification_upon_destruction, mock_error_fixture ) { - auto f = std::make_unique>(); - CHECK_ERROR((*f)(), "unexpected call", 0, "?()"); + boost::scoped_ptr< mock::detail::function< void() > > f( new mock::detail::function< void() > ); + CHECK_ERROR( (*f)(), "unexpected call", 0, "?()" ); f->expect().once(); - CHECK_ERROR(f.reset(), "untriggered expectation", 0, "?\n. once()"); + CHECK_ERROR( f.reset(), "untriggered expectation", 0, "?\n. once()" ); } -BOOST_FIXTURE_TEST_CASE(throwing_an_exception_disables_the_automatic_verification_upon_destruction, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( throwing_an_exception_disables_the_automatic_verification_upon_destruction, mock_error_fixture ) { try { - mock::detail::function f; + mock::detail::function< void() > f; f.expect().once(); throw std::exception(); - } catch(std::exception&) + } + catch( std::exception& ) {} } -BOOST_FIXTURE_TEST_CASE(adding_file_and_line_number_information, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( adding_file_and_line_number_information, mock_error_fixture ) { - mock::detail::function f; - f.expect("file name", 42).once(); - CHECK_ERROR(f.verify(), "verification failed", 0, "?\n. once()"); - BOOST_CHECK_EQUAL("file name", mock_error_data.last_file); - BOOST_CHECK_EQUAL(42, mock_error_data.last_line); + mock::detail::function< void() > f; + f.expect( "file name", 42 ).once(); + CHECK_ERROR( f.verify(), "verification failed", 0, "?\n. once()" ); + BOOST_CHECK_EQUAL( "file name", mock_error_data.last_file ); + BOOST_CHECK_EQUAL( 42, mock_error_data.last_line ); } #ifdef MOCK_THREAD_SAFE -# include +#include -namespace { -void iterate(mock::detail::function& f) +namespace { - f.expect().once().returns(0); - try + void iterate( mock::detail::function< int() >& f ) { - f(); - } catch(...) - {} + f.expect().once().returns( 0 ); + try + { + f(); + } + catch( ... ) + {} + } } -} // namespace -BOOST_FIXTURE_TEST_CASE(function_is_thread_safe, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( function_is_thread_safe, mock_error_fixture ) { - mock::detail::function f; + mock::detail::function< int() > f; boost::thread_group group; - for(int i = 0; i < 100; ++i) - group.create_thread([&f]() { iterate(f); }); + for( int i = 0; i < 100; ++i ) + group.create_thread( boost::bind( &iterate, boost::ref( f ) ) ); group.join_all(); - CHECK_CALLS(100); + CHECK_CALLS( 100 ); } #endif // MOCK_THREAD_SAFE diff --git a/test/detail/test_invocation.cpp b/test/detail/test_invocation.cpp index ad7421e..7bec6f8 100644 --- a/test/detail/test_invocation.cpp +++ b/test/detail/test_invocation.cpp @@ -7,114 +7,70 @@ // http://www.boost.org/LICENSE_1_0.txt) #include -#include -#include +#include -/// Serialize using the base class as done by e.g. the expectation class -std::string to_string(const mock::detail::invocation& invocation) -{ - std::ostringstream s; - s << invocation; - return s.str(); -} - -BOOST_AUTO_TEST_CASE(unlimited) +BOOST_AUTO_TEST_CASE( unlimited ) { mock::detail::unlimited invocation; - BOOST_TEST(invocation.verify()); - BOOST_TEST(!invocation.exhausted()); - BOOST_TEST(invocation.invoke()); - BOOST_TEST(invocation.verify()); - BOOST_TEST(!invocation.exhausted()); - BOOST_TEST(invocation.invoke()); - BOOST_TEST(to_string(invocation) == "unlimited()"); + BOOST_CHECK( invocation.verify() ); + BOOST_CHECK( ! invocation.exhausted() ); + BOOST_CHECK( invocation.invoke() ); + BOOST_CHECK( invocation.verify() ); + BOOST_CHECK( ! invocation.exhausted() ); + BOOST_CHECK( invocation.invoke() ); } -BOOST_AUTO_TEST_CASE(once) +BOOST_AUTO_TEST_CASE( once ) { mock::detail::once invocation; - BOOST_TEST(!invocation.verify()); - BOOST_TEST(!invocation.exhausted()); - BOOST_TEST(invocation.invoke()); - BOOST_TEST(invocation.verify()); - BOOST_TEST(invocation.exhausted()); - BOOST_TEST(!invocation.invoke()); - BOOST_TEST(to_string(invocation) == "once()"); + BOOST_CHECK( ! invocation.verify() ); + BOOST_CHECK( ! invocation.exhausted() ); + BOOST_CHECK( invocation.invoke() ); + BOOST_CHECK( invocation.verify() ); + BOOST_CHECK( invocation.exhausted() ); + BOOST_CHECK( ! invocation.invoke() ); } -BOOST_AUTO_TEST_CASE(never) +BOOST_AUTO_TEST_CASE( never ) { mock::detail::never invocation; - BOOST_TEST(invocation.verify()); - BOOST_TEST(invocation.exhausted()); - BOOST_TEST(!invocation.invoke()); - BOOST_TEST(to_string(invocation) == "never()"); + BOOST_CHECK( invocation.verify() ); + BOOST_CHECK( invocation.exhausted() ); + BOOST_CHECK( ! invocation.invoke() ); } -BOOST_AUTO_TEST_CASE(at_most) +BOOST_AUTO_TEST_CASE( at_most ) { - mock::detail::at_most invocation(1); - BOOST_TEST(to_string(invocation) == "at_most( 0/1 )"); - BOOST_TEST(invocation.verify()); - BOOST_TEST(!invocation.exhausted()); - BOOST_TEST(invocation.invoke()); - BOOST_TEST(to_string(invocation) == "at_most( 1/1 )"); - BOOST_TEST(invocation.verify()); - BOOST_TEST(invocation.exhausted()); - BOOST_TEST(!invocation.invoke()); - BOOST_TEST(to_string(invocation) == "at_most( 1/1 )"); + mock::detail::at_most invocation( 1 ); + BOOST_CHECK( invocation.verify() ); + BOOST_CHECK( ! invocation.exhausted() ); + BOOST_CHECK( invocation.invoke() ); + BOOST_CHECK( invocation.verify() ); + BOOST_CHECK( invocation.exhausted() ); + BOOST_CHECK( ! invocation.invoke() ); } -BOOST_AUTO_TEST_CASE(at_least) +BOOST_AUTO_TEST_CASE( at_least ) { - mock::detail::at_least invocation(1); - BOOST_TEST(to_string(invocation) == "at_least( 0/1 )"); - BOOST_TEST(!invocation.verify()); - BOOST_TEST(!invocation.exhausted()); - BOOST_TEST(invocation.invoke()); - BOOST_TEST(invocation.verify()); - BOOST_TEST(to_string(invocation) == "at_least( 1/1 )"); - BOOST_TEST(!invocation.exhausted()); - BOOST_TEST(invocation.invoke()); - BOOST_TEST(invocation.verify()); - BOOST_TEST(to_string(invocation) == "at_least( 2/1 )"); + mock::detail::at_least invocation( 1 ); + BOOST_CHECK( ! invocation.verify() ); + BOOST_CHECK( ! invocation.exhausted() ); + BOOST_CHECK( invocation.invoke() ); + BOOST_CHECK( invocation.verify() ); + BOOST_CHECK( ! invocation.exhausted() ); + BOOST_CHECK( invocation.invoke() ); } -BOOST_AUTO_TEST_CASE(between) +BOOST_AUTO_TEST_CASE( between ) { - { - mock::detail::between invocation(1, 2); - BOOST_TEST(to_string(invocation) == "between( 0/[1,2] )"); - BOOST_TEST(!invocation.verify()); - BOOST_TEST(!invocation.exhausted()); - BOOST_TEST(invocation.invoke()); - BOOST_TEST(invocation.verify()); - BOOST_TEST(to_string(invocation) == "between( 1/[1,2] )"); - BOOST_TEST(!invocation.exhausted()); - BOOST_TEST(invocation.invoke()); - BOOST_TEST(invocation.verify()); - BOOST_TEST(to_string(invocation) == "between( 2/[1,2] )"); - BOOST_TEST(invocation.exhausted()); - BOOST_TEST(!invocation.invoke()); - BOOST_TEST(to_string(invocation) == "between( 2/[1,2] )"); - } - { - mock::detail::between invocation(2, 2); - BOOST_TEST(to_string(invocation) == "between( 0/[2,2] )"); - BOOST_TEST(!invocation.verify()); - BOOST_TEST(!invocation.exhausted()); - BOOST_TEST(invocation.invoke()); - BOOST_TEST(!invocation.verify()); - BOOST_TEST(to_string(invocation) == "between( 1/[2,2] )"); - BOOST_TEST(!invocation.exhausted()); - BOOST_TEST(invocation.invoke()); - BOOST_TEST(invocation.verify()); - BOOST_TEST(to_string(invocation) == "between( 2/[2,2] )"); - BOOST_TEST(invocation.exhausted()); - BOOST_TEST(!invocation.invoke()); - BOOST_TEST(to_string(invocation) == "between( 2/[2,2] )"); - } - - // First must be equal or less than 2nd - BOOST_CHECK_THROW(mock::detail::between invalid(2, 1), std::invalid_argument); + mock::detail::between invocation( 1, 2 ); + BOOST_CHECK( ! invocation.verify() ); + BOOST_CHECK( ! invocation.exhausted() ); + BOOST_CHECK( invocation.invoke() ); + BOOST_CHECK( invocation.verify() ); + BOOST_CHECK( ! invocation.exhausted() ); + BOOST_CHECK( invocation.invoke() ); + BOOST_CHECK( invocation.verify() ); + BOOST_CHECK( invocation.exhausted() ); + BOOST_CHECK( ! invocation.invoke() ); } diff --git a/test/detail/test_is_functor.cpp b/test/detail/test_is_functor.cpp index 0a2f5b2..a6a0f38 100644 --- a/test/detail/test_is_functor.cpp +++ b/test/detail/test_is_functor.cpp @@ -7,120 +7,149 @@ // http://www.boost.org/LICENSE_1_0.txt) #include -#include +#include #ifdef BOOST_MSVC -# pragma warning(push, 0) +#pragma warning( push, 0 ) #endif #include #include #ifdef BOOST_MSVC -# pragma warning(pop) +#pragma warning( pop ) #endif -#include -#include #include -#include -#include +#include -namespace { -struct declared_but_not_defined; -static_assert(!mock::detail::is_functor::value, "Should not be a functor"); +namespace +{ + struct declared_but_not_defined; + BOOST_MPL_ASSERT_NOT(( + mock::detail::is_functor< declared_but_not_defined, int > )); -template -void is_functor(T) -{ - static_assert(mock::detail::is_functor::value, "Should be a functor taking an int"); -} -template -void is_not_functor(T) -{ - static_assert(!mock::detail::is_functor::value, "Should not be a functor taking an int"); -} - -void f0() {} -bool f1(int) -{ - return false; -} -bool f2(std::string, int) -{ - return false; -} -} // namespace - -BOOST_AUTO_TEST_CASE(data_is_not_functor) -{ - is_not_functor(42); -} - -BOOST_AUTO_TEST_CASE(function_is_functor) -{ - is_not_functor(f0); - is_functor(f1); - is_not_functor(f2); -} - -BOOST_AUTO_TEST_CASE(function_pointer_is_functor) -{ - is_not_functor(&f0); - is_functor(&f1); - is_not_functor(&f2); -} - -// ptr_fun, bin1st is removed in C++17 -#if MOCK_CXX_VERSION < 201703L -BOOST_AUTO_TEST_CASE(std_ptr_fun_is_functor) -{ - is_functor(std::ptr_fun(&f1)); - is_not_functor(std::ptr_fun(&f2)); -} - -BOOST_AUTO_TEST_CASE(std_bind_first_is_functor) -{ - is_functor(std::bind1st(std::ptr_fun(&f2), "")); -} -#endif - -BOOST_AUTO_TEST_CASE(bind_is_functor) -{ + template< typename T > + void is_functor( T ) { -#if BOOST_VERSION >= 106000 - using namespace boost::placeholders; -#endif - is_functor(boost::bind(&f0)); - is_functor(boost::bind(&f1, _1)); - is_functor(boost::bind(&f2, "", _1)); + BOOST_MPL_ASSERT(( mock::detail::is_functor< T, int > )); } - is_functor(std::bind(&f0)); - is_functor(std::bind(&f1, std::placeholders::_1)); - is_functor(std::bind(&f2, "", std::placeholders::_1)); + template< typename T > + void is_not_functor( T ) + { + BOOST_MPL_ASSERT_NOT(( mock::detail::is_functor< T, int > )); + } + + void f0() {} + bool f1( int ) { return false; } + bool f2( std::string, int ) { return false; } } -BOOST_AUTO_TEST_CASE(boost_lambda_is_functor) +BOOST_AUTO_TEST_CASE( data_is_not_functor ) { - is_functor(boost::lambda::_1 < 42); + is_not_functor( 42 ); } -BOOST_AUTO_TEST_CASE(boost_phoenix_is_functor) +BOOST_AUTO_TEST_CASE( function_is_functor ) { - is_functor(boost::phoenix::arg_names::arg1 < 42); - is_functor(boost::phoenix::arg_names::_1 < 42); + is_functor( f0 ); + is_functor( f1 ); + is_functor( f2 ); } -BOOST_AUTO_TEST_CASE(boost_function_is_functor) +BOOST_AUTO_TEST_CASE( function_pointer_is_functor ) { - is_functor(boost::function()); + is_functor( &f0 ); + is_functor( &f1 ); + is_functor( &f2 ); } -BOOST_AUTO_TEST_CASE(std_function_is_functor) +BOOST_AUTO_TEST_CASE( std_ptr_fun_is_functor ) { - is_functor(std::function()); + is_functor( std::ptr_fun( &f1 ) ); + is_functor( std::ptr_fun( &f2 ) ); } -BOOST_AUTO_TEST_CASE(cxx11_lambda_is_functor) +BOOST_AUTO_TEST_CASE( std_bind_first_is_functor ) { - is_not_functor([]() {}); - is_functor([](int) {}); - is_not_functor([](const std::string&, int) {}); - is_not_functor([](int, const std::string&) {}); + is_functor( std::bind1st( std::ptr_fun( &f2 ), "" ) ); } + +namespace +{ + struct unary_functor0 : public std::unary_function< void, void > + {}; + struct unary_functor1 : public std::unary_function< int, void > + {}; +} + +BOOST_AUTO_TEST_CASE( std_unary_functor_is_functor ) +{ + is_functor( unary_functor0() ); + is_functor( unary_functor1() ); +} + +BOOST_AUTO_TEST_CASE( boost_bind_is_functor ) +{ + is_functor( boost::bind( &f0 ) ); + is_functor( boost::bind( &f1, _1 ) ); + is_functor( boost::bind( &f2, "", _1 ) ); +} + +BOOST_AUTO_TEST_CASE( boost_lambda_is_functor ) +{ + is_functor( boost::lambda::_1 < 42 ); +} + +BOOST_AUTO_TEST_CASE( boost_phoenix_is_functor ) +{ + is_functor( boost::phoenix::arg_names::arg1 < 42 ); + is_functor( boost::phoenix::arg_names::_1 < 42 ); +} + +BOOST_AUTO_TEST_CASE( boost_function_is_functor ) +{ + is_functor( boost::function< void() >() ); +} + +namespace +{ + struct result_type_functor + { + typedef void result_type; + }; +} + +BOOST_AUTO_TEST_CASE( class_with_result_type_is_functor ) +{ + is_functor( result_type_functor() ); +} + +namespace +{ + struct sig_functor + { + template< typename Args > + struct sig + { + typedef void type; + }; + }; +} + +BOOST_AUTO_TEST_CASE( class_with_sig_is_functor ) +{ + is_functor( sig_functor() ); +} + +#ifdef MOCK_LAMBDAS + +BOOST_AUTO_TEST_CASE( cxx11_lambda_is_functor ) +{ + is_not_functor( []() {} ); +#ifdef MOCK_DECLTYPE + is_functor( []( int ) {} ); +#else + is_not_functor( []( int ) {} ); +#endif + is_not_functor( []( const std::string&, int ) {} ); + is_not_functor( []( int, const std::string& ) {} ); +} + +#endif diff --git a/test/detail/test_signature.cpp b/test/detail/test_signature.cpp index fd4e3ef..27f4e91 100644 --- a/test/detail/test_signature.cpp +++ b/test/detail/test_signature.cpp @@ -6,87 +6,24 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) -#include -#include -#include -#include +#include +#include +#include -namespace { -struct base +namespace { - void method_1(); - float method_2(int); - // Using templates in result and argument types - std::map method_3(std::map, short); - - // Qualified methods - float qual_1(int) &; - float qual_2(int) &&; - float qual_3(int) const; - float qual_4(int) const&; - float qual_5(int) const&&; - float qual_6(int) volatile; - float qual_7(int) volatile&; - float qual_8(int) volatile&&; - float qual_9(int) const volatile; - float qual_10(int) const volatile&; - float qual_11(int) const volatile&&; -}; -} // namespace - -BOOST_AUTO_TEST_CASE(signature_traits_return_correct_values) -{ - using function1 = void(); - static_assert(std::is_same, void>::value, "!"); - static_assert(mock::detail::function_arity_t::value == 0, "!"); - - using function2 = float(int); - static_assert(std::is_same, float>::value, "!"); - static_assert(mock::detail::function_arity_t::value == 1, "!"); - static_assert(std::is_same, int>::value, "!"); - - using function3 = unsigned(short&, int, const char*, float, double, char, unsigned char, std::map); - static_assert(std::is_same, unsigned>::value, "!"); - static_assert(mock::detail::function_arity_t::value == 8, "!"); - static_assert(std::is_same, short&>::value, "!"); - static_assert(std::is_same, int>::value, "!"); - static_assert(std::is_same, const char*>::value, "!"); - static_assert(std::is_same, float>::value, "!"); - static_assert(std::is_same, double>::value, "!"); - static_assert(std::is_same, char>::value, "!"); - static_assert(std::is_same, unsigned char>::value, "!"); - static_assert(std::is_same, std::map>::value, "!"); + struct base + { + void method_1(); + float method_2( int ) const; + }; + typedef base base_type; } -BOOST_AUTO_TEST_CASE(MOCK_SIGNATURE_generates_signature) +BOOST_AUTO_TEST_CASE( mock_signature_generates_signature ) { - using base_type = base; // MOCK_SIGNATURE requires a visible base_type typedef in the current scope - static_assert(std::is_same::value, "!"); - static_assert(std::is_same::value, "!"); - static_assert(std::is_same(std::map, short), MOCK_SIGNATURE(method_3)>::value, "!"); - static_assert(std::is_same::value, "!"); - static_assert(std::is_same::value, "!"); - static_assert(std::is_same::value, "!"); - static_assert(std::is_same::value, "!"); - static_assert(std::is_same::value, "!"); - static_assert(std::is_same::value, "!"); - static_assert(std::is_same::value, "!"); - static_assert(std::is_same::value, "!"); - static_assert(std::is_same::value, "!"); - static_assert(std::is_same::value, "!"); - static_assert(std::is_same::value, "!"); -} - -BOOST_AUTO_TEST_CASE(MOCK_PROTECT_SIGNATURE_keeps_signature) -{ - // MOCK_PROTECT_SIGNATURE is basically a no-op regarding its argument - // and only required to get it through a VAR_ARGS macro - // clang-format off - static_assert(std::is_same::value, "!"); - static_assert(std::is_same::value, "!"); - static_assert(std::is_same(std::map, short), MOCK_PROTECT_SIGNATURE( - std::map(std::map, short))>::value, "!"); - // clang-format on + BOOST_MPL_ASSERT(( + boost::is_same< void(), MOCK_SIGNATURE(method_1) > )); + BOOST_MPL_ASSERT(( + boost::is_same< float( int ), MOCK_SIGNATURE(method_2) > )); } diff --git a/test/detail/test_type_name.cpp b/test/detail/test_type_name.cpp index ff643f3..292414a 100644 --- a/test/detail/test_type_name.cpp +++ b/test/detail/test_type_name.cpp @@ -7,219 +7,219 @@ // http://www.boost.org/LICENSE_1_0.txt) #include -#include -#include +#include +#include -namespace { -template -std::string to_string(const T& t) +namespace { - std::ostringstream s; - s << mock::detail::make_type_name(t); - return s.str(); + template< typename T > + std::string to_string( const T& ) + { + return boost::lexical_cast< std::string >( MOCK_TYPE_NAME(T) ); + } } -} // namespace -BOOST_AUTO_TEST_CASE(name_of_base_type_is_extracted) +BOOST_AUTO_TEST_CASE( name_of_base_type_is_extracted ) { - BOOST_CHECK_EQUAL("char", to_string('a')); - BOOST_CHECK_EQUAL("bool", to_string(true)); - BOOST_CHECK_EQUAL("int", to_string(0)); - BOOST_CHECK_EQUAL("short", to_string(0)); - BOOST_CHECK_EQUAL("long", to_string(0)); - BOOST_CHECK_EQUAL("unsigned int", to_string(0)); - BOOST_CHECK_EQUAL("unsigned short", to_string(0)); - BOOST_CHECK_EQUAL("unsigned long", to_string(0)); + BOOST_CHECK_EQUAL( "char", to_string( 'a' ) ); + BOOST_CHECK_EQUAL( "bool", to_string( true ) ); + BOOST_CHECK_EQUAL( "int", to_string< int >( 0 ) ); + BOOST_CHECK_EQUAL( "short", to_string< short >( 0 ) ); + BOOST_CHECK_EQUAL( "long", to_string< long >( 0 ) ); + BOOST_CHECK_EQUAL( "unsigned int", to_string< unsigned int >( 0 ) ); + BOOST_CHECK_EQUAL( "unsigned short", to_string< unsigned short >( 0 ) ); + BOOST_CHECK_EQUAL( "unsigned long", to_string< unsigned long >( 0 ) ); } struct my_type_in_default_namespace { - struct inner - {}; + struct inner {}; }; -BOOST_AUTO_TEST_CASE(name_of_type_in_default_namespace_is_extracted) +BOOST_AUTO_TEST_CASE( name_of_type_in_default_namespace_is_extracted ) { - BOOST_CHECK_EQUAL("my_type_in_default_namespace", to_string(my_type_in_default_namespace())); + BOOST_CHECK_EQUAL( "my_type_in_default_namespace", to_string( my_type_in_default_namespace() ) ); } -BOOST_AUTO_TEST_CASE(name_of_inner_type_from_type_in_default_namespace_is_extracted) +BOOST_AUTO_TEST_CASE( name_of_inner_type_from_type_in_default_namespace_is_extracted ) { - BOOST_CHECK_EQUAL("inner", to_string(my_type_in_default_namespace::inner())); + BOOST_CHECK_EQUAL( "inner", to_string( my_type_in_default_namespace::inner() ) ); } -template +template< typename T > struct my_template_type_in_default_namespace { - struct inner - {}; + struct inner {}; }; -BOOST_AUTO_TEST_CASE(name_of_template_type_in_default_namespace_is_extracted) +BOOST_AUTO_TEST_CASE( name_of_template_type_in_default_namespace_is_extracted ) { - BOOST_CHECK_EQUAL("my_template_type_in_default_namespace", - to_string(my_template_type_in_default_namespace())); + BOOST_CHECK_EQUAL( "my_template_type_in_default_namespace", to_string( my_template_type_in_default_namespace() ) ); } -BOOST_AUTO_TEST_CASE(name_of_inner_type_from_template_type_in_default_namespace_is_extracted) +BOOST_AUTO_TEST_CASE( name_of_inner_type_from_template_type_in_default_namespace_is_extracted ) { - BOOST_CHECK_EQUAL("inner", to_string(my_template_type_in_default_namespace::inner())); + BOOST_CHECK_EQUAL( "inner", to_string( my_template_type_in_default_namespace::inner() ) ); } -namespace { -struct my_type_in_anonymous_namespace -{}; -} // namespace - -BOOST_AUTO_TEST_CASE(name_of_type_in_anonymous_namespace_is_extracted) +namespace { - BOOST_CHECK_EQUAL("my_type_in_anonymous_namespace", to_string(my_type_in_anonymous_namespace())); + struct my_type_in_anonymous_namespace {}; } -namespace nm { -struct my_type_from_named_namespace -{}; -} // namespace nm - -BOOST_AUTO_TEST_CASE(name_of_type_from_named_namespace_is_extracted) +BOOST_AUTO_TEST_CASE( name_of_type_in_anonymous_namespace_is_extracted ) { - BOOST_CHECK_EQUAL("my_type_from_named_namespace", to_string(nm::my_type_from_named_namespace())); + BOOST_CHECK_EQUAL( "my_type_in_anonymous_namespace", to_string( my_type_in_anonymous_namespace() ) ); } -namespace nm { namespace inner { - struct my_type_in_named_inner_namespace +namespace nm +{ + struct my_type_from_named_namespace {}; +} + +BOOST_AUTO_TEST_CASE( name_of_type_from_named_namespace_is_extracted ) +{ + BOOST_CHECK_EQUAL( "my_type_from_named_namespace", to_string( nm::my_type_from_named_namespace() ) ); +} + +namespace nm +{ +namespace inner +{ + struct my_type_in_named_inner_namespace {}; +} +} + +BOOST_AUTO_TEST_CASE( name_of_type_in_named_inner_namespace_is_extracted ) +{ + BOOST_CHECK_EQUAL( "my_type_in_named_inner_namespace", to_string( nm::inner::my_type_in_named_inner_namespace() ) ); +} + +namespace +{ +namespace inner +{ + struct my_type_in_unnamed_inner_namespace {}; +} +} + +BOOST_AUTO_TEST_CASE( name_of_type_in_unnamed_inner_namespace_is_extracted ) +{ + BOOST_CHECK_EQUAL( "my_type_in_unnamed_inner_namespace", to_string( inner::my_type_in_unnamed_inner_namespace() ) ); +} + +BOOST_AUTO_TEST_CASE( name_of_local_type_is_extracted ) +{ + struct my_local_type {}; + BOOST_CHECK_EQUAL( "my_local_type", boost::lexical_cast< std::string >( MOCK_TYPE_NAME(my_local_type) ) ); +} + +namespace +{ + template< typename T > + struct my_template_type + { + struct inner {}; + }; +} + +BOOST_AUTO_TEST_CASE( name_of_template_type_in_anonymous_namespace_is_extracted ) +{ + BOOST_CHECK_EQUAL( "my_template_type", to_string( my_template_type< int >() ) ); + BOOST_CHECK_EQUAL( "my_template_type", to_string( my_template_type< std::exception >() ) ); + BOOST_CHECK_EQUAL( "my_template_type", to_string( my_template_type< int const& >() ) ); + BOOST_CHECK_EQUAL( "my_template_type", to_string( my_template_type< std::exception const& >() ) ); + BOOST_CHECK_EQUAL( "my_template_type", to_string( my_template_type< int const* >() ) ); + BOOST_CHECK_EQUAL( "my_template_type", to_string( my_template_type< std::exception const* >() ) ); + BOOST_CHECK_EQUAL( "my_template_type", to_string( my_template_type< int const*& >() ) ); + BOOST_CHECK_EQUAL( "my_template_type", to_string( my_template_type< std::exception const*& >() ) ); +} + +BOOST_AUTO_TEST_CASE( name_of_inner_type_from_template_type_in_anonymous_namespace_is_extracted ) +{ + BOOST_CHECK_EQUAL( "inner", to_string( my_template_type< int >::inner() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( my_template_type< std::exception >::inner() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( my_template_type< int const& >::inner() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( my_template_type< std::exception const& >::inner() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( my_template_type< int const* >::inner() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( my_template_type< std::exception const* >::inner() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( my_template_type< int const*& >::inner() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( my_template_type< std::exception const*& >::inner() ) ); +} + +namespace nm +{ + template< typename T > + struct my_template_type + { + struct inner {}; + }; +} + +BOOST_AUTO_TEST_CASE( name_of_template_type_in_named_namespace_is_extracted ) +{ + BOOST_CHECK_EQUAL( "my_template_type", to_string( nm::my_template_type< int >() ) ); + BOOST_CHECK_EQUAL( "my_template_type", to_string( nm::my_template_type< std::exception >() ) ); + BOOST_CHECK_EQUAL( "my_template_type", to_string( nm::my_template_type< int const& >() ) ); + BOOST_CHECK_EQUAL( "my_template_type", to_string( nm::my_template_type< std::exception const& >() ) ); + BOOST_CHECK_EQUAL( "my_template_type", to_string( nm::my_template_type< int const* >() ) ); + BOOST_CHECK_EQUAL( "my_template_type", to_string( nm::my_template_type< std::exception const* >() ) ); + BOOST_CHECK_EQUAL( "my_template_type", to_string( nm::my_template_type< int const*& >() ) ); + BOOST_CHECK_EQUAL( "my_template_type", to_string( nm::my_template_type< std::exception const*& >() ) ); +} + +BOOST_AUTO_TEST_CASE( name_of_inner_type_from_template_type_in_named_namespace_is_extracted ) +{ + BOOST_CHECK_EQUAL( "inner", to_string( nm::my_template_type< int >::inner() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( nm::my_template_type< std::exception >::inner() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( nm::my_template_type< int const& >::inner() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( nm::my_template_type< std::exception const& >::inner() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( nm::my_template_type< int const* >::inner() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( nm::my_template_type< std::exception const* >::inner() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( nm::my_template_type< int const*& >::inner() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( nm::my_template_type< std::exception const*& >::inner() ) ); +} + +namespace nm2 +{ + template< typename T > + struct my_template_type + { + template< typename U > + struct inner {}; + }; +} + +BOOST_AUTO_TEST_CASE( name_of_template_inner_type_from_template_type_in_named_namespace_is_extracted ) +{ + BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< int >::inner< int >() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< std::exception >::inner< int >() ) ); + + BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< int const& >::inner< int >() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< std::exception const& >::inner< int >() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< int const* >::inner< int >() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< std::exception const* >::inner< int >() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< int const*& >::inner< int >() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< std::exception const*& >::inner< int >() ) ); + + BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< int >::inner< int const& >() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< std::exception >::inner< int const& >() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< int >::inner< int const* >() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< std::exception >::inner< int const* >() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< int >::inner< int const*& >() ) ); + BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< std::exception >::inner< int const*& >() ) ); +} + +namespace +{ + template< typename T1, typename T2, typename T3 > + struct my_tpl {}; -}} // namespace nm::inner - -BOOST_AUTO_TEST_CASE(name_of_type_in_named_inner_namespace_is_extracted) -{ - BOOST_CHECK_EQUAL("my_type_in_named_inner_namespace", to_string(nm::inner::my_type_in_named_inner_namespace())); } -namespace { namespace inner { - struct my_type_in_unnamed_inner_namespace - {}; -}} // namespace ::inner - -BOOST_AUTO_TEST_CASE(name_of_type_in_unnamed_inner_namespace_is_extracted) +BOOST_AUTO_TEST_CASE( name_of_nested_template_with_multiple_arguments_is_extracted ) { - BOOST_CHECK_EQUAL("my_type_in_unnamed_inner_namespace", to_string(inner::my_type_in_unnamed_inner_namespace())); -} - -BOOST_AUTO_TEST_CASE(name_of_local_type_is_extracted) -{ - struct my_local_type - {}; - BOOST_CHECK_EQUAL("my_local_type", to_string(my_local_type())); -} - -namespace { -template -struct my_template_type -{ - struct inner - {}; -}; -} // namespace - -BOOST_AUTO_TEST_CASE(name_of_template_type_in_anonymous_namespace_is_extracted) -{ - BOOST_CHECK_EQUAL("my_template_type", to_string(my_template_type())); - BOOST_CHECK_EQUAL("my_template_type", to_string(my_template_type())); - BOOST_CHECK_EQUAL("my_template_type", to_string(my_template_type())); - BOOST_CHECK_EQUAL("my_template_type", to_string(my_template_type())); - BOOST_CHECK_EQUAL("my_template_type", to_string(my_template_type())); - BOOST_CHECK_EQUAL("my_template_type", to_string(my_template_type())); - BOOST_CHECK_EQUAL("my_template_type", to_string(my_template_type())); - BOOST_CHECK_EQUAL("my_template_type", to_string(my_template_type())); -} - -BOOST_AUTO_TEST_CASE(name_of_inner_type_from_template_type_in_anonymous_namespace_is_extracted) -{ - BOOST_CHECK_EQUAL("inner", to_string(my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(my_template_type::inner())); -} - -namespace nm { -template -struct my_template_type -{ - struct inner - {}; -}; -} // namespace nm - -BOOST_AUTO_TEST_CASE(name_of_template_type_in_named_namespace_is_extracted) -{ - BOOST_CHECK_EQUAL("my_template_type", to_string(nm::my_template_type())); - BOOST_CHECK_EQUAL("my_template_type", to_string(nm::my_template_type())); - BOOST_CHECK_EQUAL("my_template_type", to_string(nm::my_template_type())); - BOOST_CHECK_EQUAL("my_template_type", to_string(nm::my_template_type())); - BOOST_CHECK_EQUAL("my_template_type", to_string(nm::my_template_type())); - BOOST_CHECK_EQUAL("my_template_type", to_string(nm::my_template_type())); - BOOST_CHECK_EQUAL("my_template_type", to_string(nm::my_template_type())); - BOOST_CHECK_EQUAL("my_template_type", to_string(nm::my_template_type())); -} - -BOOST_AUTO_TEST_CASE(name_of_inner_type_from_template_type_in_named_namespace_is_extracted) -{ - BOOST_CHECK_EQUAL("inner", to_string(nm::my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(nm::my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(nm::my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(nm::my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(nm::my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(nm::my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(nm::my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(nm::my_template_type::inner())); -} - -namespace nm2 { -template -struct my_template_type -{ - template - struct inner - {}; -}; -} // namespace nm2 - -BOOST_AUTO_TEST_CASE(name_of_template_inner_type_from_template_type_in_named_namespace_is_extracted) -{ - BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); - - BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); - - BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); - BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); -} - -namespace { -template -struct my_tpl -{}; -} // namespace - -BOOST_AUTO_TEST_CASE(name_of_nested_template_with_multiple_arguments_is_extracted) -{ - BOOST_CHECK_EQUAL("vector>", to_string(std::vector())); - BOOST_CHECK_EQUAL("vector>, allocator>>>", - to_string(std::vector>())); - BOOST_CHECK_EQUAL("my_tpl, my_tpl, my_tpl>", - to_string(my_tpl, my_tpl, my_tpl>())); + BOOST_CHECK_EQUAL( "vector>", to_string( std::vector< int >() ) ); + BOOST_CHECK_EQUAL( "vector>, allocator>>>", to_string( std::vector< std::vector< int > >() ) ); + BOOST_CHECK_EQUAL( "my_tpl, my_tpl, my_tpl>", to_string( my_tpl< my_tpl< int, int, int >, my_tpl< int, int, int >, my_tpl< int, int, int > >() ) ); } diff --git a/test/fail_ambiguous_mock_method.cpp b/test/fail_ambiguous_mock_method.cpp index 5f493e0..08148ce 100644 --- a/test/fail_ambiguous_mock_method.cpp +++ b/test/fail_ambiguous_mock_method.cpp @@ -8,16 +8,17 @@ #include -namespace { -struct my_base +namespace { - virtual ~my_base() = default; - virtual void my_method() = 0; - virtual void my_method(int) = 0; -}; + struct my_base + { + virtual ~my_base() {} + virtual void my_method() = 0; + virtual void my_method( int ) = 0; + }; -MOCK_BASE_CLASS(my_class, my_base) -{ - MOCK_METHOD(my_method, 0) -}; -} // namespace + MOCK_BASE_CLASS( my_class, my_base ) + { + MOCK_METHOD( my_method, 0 ) + }; +} diff --git a/test/fail_constraint_functor_not_compatible.cpp b/test/fail_constraint_functor_not_compatible.cpp index d5534f8..51558eb 100644 --- a/test/fail_constraint_functor_not_compatible.cpp +++ b/test/fail_constraint_functor_not_compatible.cpp @@ -8,17 +8,17 @@ #include -MOCK_CLASS(my_class) +namespace { - MOCK_METHOD(my_method, 1, void(int), my_method) -}; -bool constraint(int, int) -{ - return true; -} + MOCK_CLASS( my_class ) + { + MOCK_METHOD_EXT( my_method, 1, void( int ), my_method ) + }; + bool constraint( int, int ); -void test_case() -{ - my_class c; - MOCK_EXPECT(c.my_method).with(&constraint); + void test_case() + { + my_class c; + MOCK_EXPECT( c.my_method ).with( &constraint ); + } } diff --git a/test/fail_constraint_value_not_comparable.cpp b/test/fail_constraint_value_not_comparable.cpp index 1e97da6..0d0ef8c 100644 --- a/test/fail_constraint_value_not_comparable.cpp +++ b/test/fail_constraint_value_not_comparable.cpp @@ -8,12 +8,15 @@ #include -MOCK_CLASS(my_class) +namespace { - MOCK_METHOD(my_method, 1, void(int), my_method) -}; -void test_case() -{ - my_class c; - MOCK_EXPECT(c.my_method).with("42"); + MOCK_CLASS( my_class ) + { + MOCK_METHOD_EXT( my_method, 1, void( int ), my_method ) + }; + void test_case() + { + my_class c; + MOCK_EXPECT( c.my_method ).with( "42" ); + } } diff --git a/test/fail_constraint_value_of_wrong_type_in_builtin_constraint.cpp b/test/fail_constraint_value_of_wrong_type_in_builtin_constraint.cpp index 67c97ab..f54013c 100644 --- a/test/fail_constraint_value_of_wrong_type_in_builtin_constraint.cpp +++ b/test/fail_constraint_value_of_wrong_type_in_builtin_constraint.cpp @@ -8,12 +8,15 @@ #include -MOCK_CLASS(my_class) +namespace { - MOCK_METHOD(my_method, 1, void(int), my_method) -}; -void test_case() -{ - my_class c; - MOCK_EXPECT(c.my_method).with(mock::equal("42")); + MOCK_CLASS( my_class ) + { + MOCK_METHOD_EXT( my_method, 1, void( int ), my_method ) + }; + void test_case() + { + my_class c; + MOCK_EXPECT( c.my_method ).with( mock::equal( "42" ) ); + } } diff --git a/test/fail_mismatch_type_in_returns_int_action.cpp b/test/fail_mismatch_type_in_returns_int_action.cpp index 79386f3..1147857 100644 --- a/test/fail_mismatch_type_in_returns_int_action.cpp +++ b/test/fail_mismatch_type_in_returns_int_action.cpp @@ -8,12 +8,15 @@ #include -MOCK_CLASS(my_class) +namespace { - MOCK_METHOD(my_method, 0, int(), my_method) -}; -void test_case() -{ - my_class c; - MOCK_EXPECT(c.my_method).returns(std::string()); + MOCK_CLASS( my_class ) + { + MOCK_METHOD_EXT( my_method, 0, int(), my_method ) + }; + void test_case() + { + my_class c; + MOCK_EXPECT( c.my_method ).returns( std::string() ); + } } diff --git a/test/fail_mismatch_type_in_returns_string_action.cpp b/test/fail_mismatch_type_in_returns_string_action.cpp index b3cea88..103613f 100644 --- a/test/fail_mismatch_type_in_returns_string_action.cpp +++ b/test/fail_mismatch_type_in_returns_string_action.cpp @@ -8,12 +8,15 @@ #include -MOCK_CLASS(my_class) +namespace { - MOCK_METHOD(my_method, 0, std::string(), my_method) -}; -void test_case() -{ - my_class c; - MOCK_EXPECT(c.my_method).returns(42); + MOCK_CLASS( my_class ) + { + MOCK_METHOD_EXT( my_method, 0, std::string(), my_method ) + }; + void test_case() + { + my_class c; + MOCK_EXPECT( c.my_method ).returns( 42 ); + } } diff --git a/test/fail_mismatch_type_in_returns_void_action.cpp b/test/fail_mismatch_type_in_returns_void_action.cpp index 7a09043..68b774c 100644 --- a/test/fail_mismatch_type_in_returns_void_action.cpp +++ b/test/fail_mismatch_type_in_returns_void_action.cpp @@ -8,12 +8,15 @@ #include -MOCK_CLASS(my_class) +namespace { - MOCK_METHOD(my_method, 0, void(), my_method) -}; -void test_case() -{ - my_class c; - MOCK_EXPECT(c.my_method).returns("42"); + MOCK_CLASS( my_class ) + { + MOCK_METHOD_EXT( my_method, 0, void(), my_method ) + }; + void test_case() + { + my_class c; + MOCK_EXPECT( c.my_method ).returns( "42" ); + } } diff --git a/test/fail_non_existing_base_class_method_in_mock_method.cpp b/test/fail_non_existing_base_class_method_in_mock_method.cpp index 07e483e..0e50e73 100644 --- a/test/fail_non_existing_base_class_method_in_mock_method.cpp +++ b/test/fail_non_existing_base_class_method_in_mock_method.cpp @@ -8,14 +8,15 @@ #include -namespace { -struct my_base +namespace { - virtual ~my_base() = default; -}; + struct my_base + { + virtual ~my_base() {} + }; -MOCK_BASE_CLASS(my_class, my_base) -{ - MOCK_METHOD(my_method, 0) -}; -} // namespace + MOCK_BASE_CLASS( my_class, my_base ) + { + MOCK_METHOD( my_method, 0 ) + }; +} diff --git a/test/fail_number_of_arguments_greater_than_max_constant.cpp b/test/fail_number_of_arguments_greater_than_max_constant.cpp new file mode 100644 index 0000000..7a71272 --- /dev/null +++ b/test/fail_number_of_arguments_greater_than_max_constant.cpp @@ -0,0 +1,25 @@ +// http://turtle.sourceforge.net +// +// Copyright Mathieu Champlon 2011 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include + +BOOST_STATIC_ASSERT( MOCK_MAX_ARGS == 9 ); + +namespace +{ + struct my_base + { + virtual ~my_base() {} + virtual void my_method( int, int, int, int, int, int, int, int, int, int ) = 0; + }; + + MOCK_BASE_CLASS( my_class, my_base ) + { + MOCK_METHOD( my_method, 10 ) + }; +} diff --git a/test/fail_template_argument_without_tpl_macro.cpp b/test/fail_template_argument_without_tpl_macro.cpp new file mode 100644 index 0000000..a0e700e --- /dev/null +++ b/test/fail_template_argument_without_tpl_macro.cpp @@ -0,0 +1,18 @@ +// http://turtle.sourceforge.net +// +// Copyright Mathieu Champlon 2011 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include + +namespace +{ + template< typename T > + MOCK_CLASS( my_class ) + { + MOCK_METHOD_EXT( my_method, 1, void( T ), my_method ) + }; +} diff --git a/test/fail_too_many_arguments_in_mock_method.cpp b/test/fail_too_many_arguments_in_mock_method.cpp index af18e2a..fa4ca01 100644 --- a/test/fail_too_many_arguments_in_mock_method.cpp +++ b/test/fail_too_many_arguments_in_mock_method.cpp @@ -8,15 +8,16 @@ #include -namespace { -struct my_base +namespace { - virtual ~my_base() = default; - virtual void my_method(int) = 0; -}; + struct my_base + { + virtual ~my_base() {} + virtual void my_method( int ) = 0; + }; -MOCK_BASE_CLASS(my_class, my_base) -{ - MOCK_METHOD(my_method, 2) -}; -} // namespace + MOCK_BASE_CLASS( my_class, my_base ) + { + MOCK_METHOD( my_method, 2 ) + }; +} diff --git a/test/fail_wrong_number_of_arguments_in_with.cpp b/test/fail_wrong_number_of_arguments_in_with.cpp index f527e68..dc3420f 100644 --- a/test/fail_wrong_number_of_arguments_in_with.cpp +++ b/test/fail_wrong_number_of_arguments_in_with.cpp @@ -8,12 +8,15 @@ #include -MOCK_CLASS(my_class) +namespace { - MOCK_METHOD(my_method, 1, void(int), my_method) -}; -void test_case() -{ - my_class c; - MOCK_EXPECT(c.my_method).with(42, 42); + MOCK_CLASS( my_class ) + { + MOCK_METHOD_EXT( my_method, 1, void( int ), my_method ) + }; + void test_case() + { + my_class c; + MOCK_EXPECT( c.my_method ).with( 42, 42 ); + } } diff --git a/test/mock_error.hpp b/test/mock_error.hpp index 3f4224d..bd3fbe9 100644 --- a/test/mock_error.hpp +++ b/test/mock_error.hpp @@ -11,12 +11,11 @@ #define MOCK_ERROR_POLICY mock_error #include +#include #include -#include #include -/// Container to hold data about mocked function calls (and expectation errors) -struct mock_error_data_t : mock::detail::singleton +struct mock_error_data_t : mock::detail::singleton< mock_error_data_t > { void reset() { @@ -25,7 +24,10 @@ struct mock_error_data_t : mock::detail::singleton last_message.clear(); last_context.clear(); } - bool verify() { return error_count == 0; } + bool verify() + { + return error_count == 0; + } void call() { @@ -33,7 +35,9 @@ struct mock_error_data_t : mock::detail::singleton last_message.clear(); ++call_count; } - void fail(const std::string& message, const std::string& context, const char* file, int line) + void fail( const std::string& message, + const std::string& context, + const char* file, int line ) { last_context = context; last_message = message; @@ -42,69 +46,66 @@ struct mock_error_data_t : mock::detail::singleton ++error_count; } - int call_count = 0; - int error_count = 0; - std::string last_message, last_context, last_file; - int last_line = 0; - MOCK_SINGLETON_CONS(mock_error_data_t); + int error_count; + int call_count; + std::string last_message; + std::string last_context; + std::string last_file; + int last_line; + MOCK_SINGLETON_CONS( mock_error_data_t ); }; -MOCK_SINGLETON_INST(mock_error_data) +MOCK_SINGLETON_INST( mock_error_data ) -/// Error handler that populates the mock_error_data singleton instead of failing -template +template< typename Result > struct mock_error { - static Result abort() { throw std::runtime_error("aborted"); } + static Result abort() + { + throw std::runtime_error( "aborted" ); + } - static void pass(const char* /*file*/, int /*line*/) {} + static void pass( const char* /*file*/, int /*line*/ ) + {} - template - static void call(const Context& /*context*/, const char* /*file*/, int /*line*/) + template< typename Context > + static void call( const Context& /*context*/, + const char* /*file*/, int /*line*/ ) { mock_error_data.call(); } - template - static void fail(const std::string& message, const Context& context, const char* file = "", int line = 0) + template< typename Context > + static void fail( const std::string& message, const Context& context, + const char* file = "", int line = 0 ) { - std::ostringstream s; - s << context; // Context can be streamed - mock_error_data.fail(message, s.str(), file, line); + mock_error_data.fail( message, + boost::lexical_cast< std::string >( context ), file, line ); } }; -/// Fixture to use CHECK_CALLS & CHECK_ERROR: Initializes the mock_error_data singleton -/// Verifies there are no pending verifications on end of the test struct mock_error_fixture { - mock_error_fixture() { mock_error_data.reset(); } + mock_error_fixture() + { + mock_error_data.reset(); + } ~mock_error_fixture() { - BOOST_CHECK(mock_error_data.verify()); - BOOST_CHECK_EQUAL(0, mock_error_data.call_count); + BOOST_CHECK( mock_error_data.verify() ); + BOOST_CHECK_EQUAL( 0, mock_error_data.call_count ); } }; -/// Check that the number of calls to mocked function equals the given amount -/// and resets them (for the next check and cleanup) -#define CHECK_CALLS(calls) \ - BOOST_CHECK_EQUAL(calls, mock_error_data.call_count); \ +#define CHECK_CALLS( calls ) \ + BOOST_CHECK_EQUAL( calls, mock_error_data.call_count ); \ mock_error_data.call_count = 0; -/// Similar to BOOST_CHECK_THROW: -/// Checks that running `expr` leads to an error of the set expectations, -/// that the error message equals `error`, with the given `context` -/// and `calls` mocked functions were called. -#define CHECK_ERROR(expr, error, calls, context) \ - BOOST_CHECK(mock_error_data.verify()); \ - try \ - { \ - expr; \ - } catch(...) \ - {} \ - BOOST_CHECK_EQUAL(1, mock_error_data.error_count); \ - BOOST_CHECK_EQUAL(error, mock_error_data.last_message); \ - BOOST_CHECK_EQUAL(context, mock_error_data.last_context); \ - CHECK_CALLS(calls); \ +#define CHECK_ERROR( expr, error, calls, context ) \ + BOOST_CHECK( mock_error_data.verify() ); \ + try { expr; } catch( ... ) {} \ + BOOST_CHECK_EQUAL( 1, mock_error_data.error_count ); \ + BOOST_CHECK_EQUAL( error, mock_error_data.last_message ); \ + BOOST_CHECK_EQUAL( context, mock_error_data.last_context ); \ + CHECK_CALLS( calls ); \ mock_error_data.reset(); #endif // MOCK_TEST_MOCK_ERROR_HPP_INCLUDED diff --git a/test/test_constraint.cpp b/test/test_constraint.cpp index 8e98ed9..c690d07 100644 --- a/test/test_constraint.cpp +++ b/test/test_constraint.cpp @@ -7,40 +7,36 @@ // http://www.boost.org/LICENSE_1_0.txt) #include -#include -#include +#include -namespace { -MOCK_CONSTRAINT(constraint_0, actual == 0) -MOCK_CONSTRAINT(constraint_1, expected, actual == expected) -MOCK_CONSTRAINT(constraint_2, expected_0, expected_1, actual == expected_0 || actual == expected_1) +#ifdef MOCK_VARIADIC_MACROS -template -std::string to_string(const mock::constraint& t) +namespace { - std::ostringstream s; - s << t.c_; - return s.str(); -} -} // namespace - -BOOST_AUTO_TEST_CASE(mock_constraint_works_for_0_to_2_args) -{ - BOOST_TEST(constraint_0.c_(0)); - BOOST_TEST(!constraint_0.c_(42)); - - BOOST_TEST(constraint_1(0).c_(0)); - BOOST_TEST(!constraint_1(1).c_(0)); - BOOST_TEST(!constraint_1(42).c_(1337)); - - BOOST_TEST(constraint_2(42, 1337).c_(42)); - BOOST_TEST(constraint_2(42, 1337).c_(1337)); - BOOST_TEST(!constraint_2(42, 1337).c_(99)); + MOCK_CONSTRAINT( constraint_0, actual == 0 ) + MOCK_CONSTRAINT( constraint_1, expected, actual == expected ) + MOCK_CONSTRAINT( constraint_2, expected_0, expected_1, actual == expected_0 || actual == expected_1 ) } -BOOST_AUTO_TEST_CASE(mock_constraint_outputs_human_readable_representation) +BOOST_AUTO_TEST_CASE( mock_constraint_is_supported_by_compilers_with_variadic_macros ) { - BOOST_TEST(to_string(constraint_0) == "constraint_0"); - BOOST_TEST(to_string(constraint_1(42)) == "constraint_1( 42 )"); - BOOST_TEST(to_string(constraint_2(42, 1337)) == "constraint_2( 42, 1337 )"); + BOOST_CHECK( constraint_0.c_( 0 ) ); + BOOST_CHECK( constraint_1( 0 ).c_( 0 ) ); + BOOST_CHECK( constraint_2( 0, 0 ).c_( 0 ) ); +} + +#endif // MOCK_VARIADIC_MACROS + +namespace +{ + MOCK_CONSTRAINT_EXT( constraint_0_ext, 0,, actual == 0 ) + MOCK_CONSTRAINT_EXT( constraint_1_ext, 1, ( expected ), actual == expected ) + MOCK_CONSTRAINT_EXT( constraint_2_ext, 2, ( expected_0, expected_1 ), actual == expected_0 || actual == expected_1 ) +} + +BOOST_AUTO_TEST_CASE( mock_constraint_ext_is_supported_by_all_compilers ) +{ + BOOST_CHECK( constraint_0_ext.c_( 0 ) ); + BOOST_CHECK( constraint_1_ext( 0 ).c_( 0 ) ); + BOOST_CHECK( constraint_2_ext( 0, 0 ).c_( 0 ) ); } diff --git a/test/test_constraints.cpp b/test/test_constraints.cpp index 92157df..9e918da 100644 --- a/test/test_constraints.cpp +++ b/test/test_constraints.cpp @@ -7,383 +7,417 @@ // http://www.boost.org/LICENSE_1_0.txt) #include -#include +#include +#include -BOOST_AUTO_TEST_CASE(all_comparison_constraints_can_be_instanciated) +BOOST_AUTO_TEST_CASE( all_comparison_constraints_can_be_instanciated ) { - mock::equal(0); - mock::less(0); - mock::greater(0); - mock::less_equal(0); - mock::greater_equal(0); + mock::equal( 0 ); + mock::less( 0 ); + mock::greater( 0 ); + mock::less_equal( 0 ); + mock::greater_equal( 0 ); } -BOOST_AUTO_TEST_CASE(constraints_can_be_negated_using_the_not_operator) +BOOST_AUTO_TEST_CASE( constraints_can_be_negated_using_the_not_operator ) { - !mock::any; - !mock::affirm; - !mock::negate; - !mock::evaluate; - !mock::equal(0); - !mock::less(0); - !mock::greater(0); - !mock::less_equal(0); - !mock::greater_equal(0); + ! mock::any; + ! mock::affirm; + ! mock::negate; + ! mock::evaluate; + ! mock::equal( 0 ); + ! mock::less( 0 ); + ! mock::greater( 0 ); + ! mock::less_equal( 0 ); + ! mock::greater_equal( 0 ); } -BOOST_AUTO_TEST_CASE(constraints_can_be_combined_using_the_or_operator) +BOOST_AUTO_TEST_CASE( constraints_can_be_combined_using_the_or_operator ) { - mock::less(0) || mock::greater(0); + mock::less( 0 ) || mock::greater( 0 ); } -BOOST_AUTO_TEST_CASE(constraints_can_be_combined_using_the_and_operator) +BOOST_AUTO_TEST_CASE( constraints_can_be_combined_using_the_and_operator ) { - mock::less(0) && mock::greater(0); + mock::less( 0 ) && mock::greater( 0 ); } -BOOST_AUTO_TEST_CASE(equal_constraint) +BOOST_AUTO_TEST_CASE( equal_constraint ) { - BOOST_CHECK(mock::equal(std::string("string")).c_("string")); - BOOST_CHECK(!mock::equal(std::string("string")).c_("not string")); + BOOST_CHECK( mock::equal( std::string( "string" ) ).c_( "string" ) ); + BOOST_CHECK( ! mock::equal( std::string( "string" ) ).c_( "not string" ) ); { std::string s; - auto c = mock::equal(std::cref(s)); + BOOST_AUTO( c, mock::equal( boost::cref( s ) ) ); s = "string"; - BOOST_CHECK(c.c_("string")); + BOOST_CHECK( c.c_( "string" ) ); } +#ifdef MOCK_SMART_PTR { - std::unique_ptr i; - std::unique_ptr j(new int(3)); - BOOST_CHECK(!mock::equal(i).c_(j)); - BOOST_CHECK(!mock::equal(j).c_(i)); - BOOST_CHECK(mock::equal(i).c_(i)); - BOOST_CHECK(mock::equal(j).c_(j)); + std::unique_ptr< int > i; + std::unique_ptr< int > j( new int( 3 ) ); + BOOST_CHECK( ! mock::equal( i ).c_( j ) ); + BOOST_CHECK( ! mock::equal( j ).c_( i ) ); + BOOST_CHECK( mock::equal( i ).c_( i ) ); + BOOST_CHECK( mock::equal( j ).c_( j ) ); } +#endif } -BOOST_AUTO_TEST_CASE(equal_constraint_deref) +BOOST_AUTO_TEST_CASE( equal_constraint_deref ) { { int i = 3; - BOOST_CHECK(mock::equal(3).c_(&i)); - BOOST_CHECK(!mock::equal(7).c_(&i)); + BOOST_CHECK( mock::equal( 3 ).c_( &i ) ); + BOOST_CHECK( ! mock::equal( 7 ).c_( &i ) ); } { int* i = 0; - BOOST_CHECK(!mock::equal(3).c_(i)); + BOOST_CHECK( ! mock::equal( 3 ).c_( i ) ); } +#ifdef MOCK_SMART_PTR { - std::unique_ptr j(new int(3)); - BOOST_CHECK(mock::equal(3).c_(j)); - std::unique_ptr i; - BOOST_CHECK(!mock::equal(3).c_(i)); + std::unique_ptr< int > j( new int( 3 ) ); + BOOST_CHECK( mock::equal( 3 ).c_( j ) ); + std::unique_ptr< int > i; + BOOST_CHECK( ! mock::equal( 3 ).c_( i ) ); } +#endif // MOCK_SMART_PTR } -BOOST_AUTO_TEST_CASE(equal_null_c_string) -{ - const char* const null_str = nullptr; - - BOOST_CHECK(mock::equal(null_str).c_(null_str)); - BOOST_CHECK(!mock::equal(null_str).c_("non-null string")); - BOOST_CHECK(!mock::equal("non-null-string").c_(null_str)); -} - -BOOST_AUTO_TEST_CASE(same_constraint) +BOOST_AUTO_TEST_CASE( same_constraint ) { { int i = 0; int j = 0; - BOOST_CHECK_EQUAL(i, j); - BOOST_CHECK(!mock::same(i).c_(j)); - BOOST_CHECK(mock::same(i).c_(i)); + BOOST_CHECK_EQUAL( i, j ); + BOOST_CHECK( ! mock::same( i ).c_( j ) ); + BOOST_CHECK( mock::same( i ).c_( i ) ); } { int i = 0; int j = 0; - BOOST_CHECK_EQUAL(i, j); - auto c = mock::same(i); - BOOST_CHECK(!c.c_(j)); - BOOST_CHECK(c.c_(i)); + BOOST_CHECK_EQUAL( i, j ); + mock::constraint< + mock::detail::same< + const boost::reference_wrapper< const int > + > + > c = mock::same( boost::cref( i ) ); + BOOST_CHECK( ! c.c_( j ) ); + BOOST_CHECK( c.c_( i ) ); } +#ifdef MOCK_NULLPTR { std::nullptr_t p; - BOOST_CHECK(mock::same(p).c_(p)); + BOOST_CHECK( mock::same( p ).c_( p ) ); } +#endif } -BOOST_AUTO_TEST_CASE(assign_constraint) +BOOST_AUTO_TEST_CASE( assign_constraint ) { { int i = 0; - BOOST_CHECK(mock::assign(3).c_(i)); - BOOST_CHECK_EQUAL(3, i); + BOOST_CHECK( mock::assign( 3 ).c_( i ) ); + BOOST_CHECK_EQUAL( 3, i ); } { int i = 0; - BOOST_CHECK(mock::assign(3).c_(&i)); - BOOST_CHECK_EQUAL(3, i); + BOOST_CHECK( mock::assign( 3 ).c_( &i ) ); + BOOST_CHECK_EQUAL( 3, i ); } { const int* i = 0; const int j = 1; - BOOST_CHECK(mock::assign(&j).c_(i)); - BOOST_CHECK_EQUAL(&j, i); + BOOST_CHECK( mock::assign( &j ).c_( i ) ); + BOOST_CHECK_EQUAL( &j, i ); } { int* i = 0; const int j = 1; - BOOST_CHECK(!mock::assign(j).c_(i)); - BOOST_CHECK(!i); + BOOST_CHECK( ! mock::assign( j ).c_( i ) ); + BOOST_CHECK( ! i ); } { int i = 0; int j = 1; - mock::constraint>> c = mock::assign(std::cref(j)); - BOOST_CHECK(c.c_(i)); - BOOST_CHECK_EQUAL(1, i); + mock::constraint< + mock::detail::assign< + boost::reference_wrapper< const int > + > + > c = mock::assign( boost::cref( j ) ); + BOOST_CHECK( c.c_( i ) ); + BOOST_CHECK_EQUAL( 1, i ); j = 3; - BOOST_CHECK(c.c_(i)); - BOOST_CHECK_EQUAL(3, i); + BOOST_CHECK( c.c_( i ) ); + BOOST_CHECK_EQUAL( 3, i ); } { int i = 0; int j = 1; - auto c = mock::assign(std::cref(j)); - BOOST_CHECK(c.c_(&i)); - BOOST_CHECK_EQUAL(1, i); + mock::constraint< + mock::detail::assign< + boost::reference_wrapper< const int > + > + > c = mock::assign( boost::cref( j ) ); + BOOST_CHECK( c.c_( &i ) ); + BOOST_CHECK_EQUAL( 1, i ); j = 3; - BOOST_CHECK(c.c_(&i)); - BOOST_CHECK_EQUAL(3, i); + BOOST_CHECK( c.c_( &i ) ); + BOOST_CHECK_EQUAL( 3, i ); } { const int* i = 0; int k = 1; int* j = &k; - auto c = mock::assign(std::cref(j)); - BOOST_CHECK(c.c_(i)); - BOOST_CHECK_EQUAL(j, i); + mock::constraint< + mock::detail::assign< + boost::reference_wrapper< int* const > + > + > c = mock::assign( boost::cref( j ) ); + BOOST_CHECK( c.c_( i ) ); + BOOST_CHECK_EQUAL( j, i ); j = 0; - BOOST_CHECK(c.c_(i)); - BOOST_CHECK_EQUAL(j, i); + BOOST_CHECK( c.c_( i ) ); + BOOST_CHECK_EQUAL( j, i ); } } -BOOST_AUTO_TEST_CASE(retrieve_constraint) +BOOST_AUTO_TEST_CASE( retrieve_constraint ) { { int i = 0; const int j = 1; - BOOST_CHECK(mock::retrieve(i).c_(j)); - BOOST_CHECK_EQUAL(i, j); + BOOST_CHECK( mock::retrieve( i ).c_( j ) ); + BOOST_CHECK_EQUAL( i, j ); } { int* i = 0; int j = 1; - BOOST_CHECK(mock::retrieve(i).c_(&j)); - BOOST_CHECK_EQUAL(i, &j); + BOOST_CHECK( mock::retrieve( i ).c_( &j ) ); + BOOST_CHECK_EQUAL( i, &j ); } { const int* i = 0; const int j = 1; - BOOST_CHECK(mock::retrieve(i).c_(j)); - BOOST_CHECK_EQUAL(i, &j); + BOOST_CHECK( mock::retrieve( i ).c_( j ) ); + BOOST_CHECK_EQUAL( i, &j ); } { const int* i = 0; int j = 1; - BOOST_CHECK(mock::retrieve(i).c_(j)); - BOOST_CHECK_EQUAL(i, &j); + BOOST_CHECK( mock::retrieve( i ).c_( j ) ); + BOOST_CHECK_EQUAL( i, &j ); } { int* i = 0; int j = 1; - BOOST_CHECK(mock::retrieve(i).c_(j)); - BOOST_CHECK_EQUAL(i, &j); + BOOST_CHECK( mock::retrieve( i ).c_( j ) ); + BOOST_CHECK_EQUAL( i, &j ); } { const int* i = 0; const int j = 1; - BOOST_CHECK(mock::retrieve(i).c_(j)); - BOOST_CHECK_EQUAL(i, &j); + BOOST_CHECK( mock::retrieve( i ).c_( j ) ); + BOOST_CHECK_EQUAL( i, &j ); } { int** i = 0; int* j = 0; - BOOST_CHECK(mock::retrieve(i).c_(j)); - BOOST_CHECK_EQUAL(i, &j); + BOOST_CHECK( mock::retrieve( i ).c_( j ) ); + BOOST_CHECK_EQUAL( i, &j ); } { const int** i = 0; const int* j = 0; - BOOST_CHECK(mock::retrieve(i).c_(j)); - BOOST_CHECK_EQUAL(i, &j); + BOOST_CHECK( mock::retrieve( i ).c_( j ) ); + BOOST_CHECK_EQUAL( i, &j ); } { int i = 0; const int j = 1; - BOOST_CHECK(mock::retrieve(i).c_(j)); - BOOST_CHECK_EQUAL(i, j); + BOOST_CHECK( mock::retrieve( boost::ref( i ) ).c_( j ) ); + BOOST_CHECK_EQUAL( i, j ); } { const int* i = 0; const int j = 1; - BOOST_CHECK(mock::retrieve(i).c_(j)); - BOOST_CHECK_EQUAL(i, &j); + BOOST_CHECK( mock::retrieve( boost::ref( i ) ).c_( j ) ); + BOOST_CHECK_EQUAL( i, &j ); } +#ifdef MOCK_NULLPTR { std::nullptr_t* i = 0; std::nullptr_t j; - BOOST_CHECK(mock::retrieve(i).c_(j)); - BOOST_CHECK_EQUAL(i, &j); + BOOST_CHECK( mock::retrieve( i ).c_( j ) ); + BOOST_CHECK_EQUAL( i, &j ); } +#endif +#ifdef MOCK_SMART_PTR { - std::unique_ptr i; - std::unique_ptr j(new int(3)); - BOOST_CHECK(mock::retrieve(i).c_(std::move(j))); - BOOST_REQUIRE(i); - BOOST_CHECK_EQUAL(3, *i); - BOOST_CHECK(!j); + std::unique_ptr< int > i; + std::unique_ptr< int > j( new int( 3 ) ); + BOOST_CHECK( mock::retrieve( i ).c_( boost::move( j ) ) ); + BOOST_REQUIRE( i ); + BOOST_CHECK_EQUAL( 3, *i ); + BOOST_CHECK( !j ); } +#endif } -namespace { -struct A -{}; -struct B +namespace { - B& operator=(const A&) { return *this; } -}; -} // namespace + struct A + { + }; + struct B + { + B& operator=( const A& ) + { + return *this; + } + }; +} -BOOST_AUTO_TEST_CASE(retrieve_constraint_uses_assignment_operator) +BOOST_AUTO_TEST_CASE( retrieve_constraint_uses_assignment_operator ) { B b; const A a = A(); - mock::retrieve(b).c_(a); + mock::retrieve( b ).c_( a ); } -BOOST_AUTO_TEST_CASE(affirm_constraint) +BOOST_AUTO_TEST_CASE( affirm_constraint ) { { int* i = 0; int j; - BOOST_CHECK(!mock::affirm.c_(i)); - BOOST_CHECK(mock::affirm.c_(&j)); + BOOST_CHECK( ! mock::affirm.c_( i ) ); + BOOST_CHECK( mock::affirm.c_( &j ) ); } { - std::unique_ptr i; - std::unique_ptr j(new int(3)); - BOOST_CHECK(!mock::affirm.c_(i)); - BOOST_CHECK(mock::affirm.c_(j)); +#ifdef MOCK_SMART_PTR + std::unique_ptr< int > i; + std::unique_ptr< int > j( new int( 3 ) ); + BOOST_CHECK( ! mock::affirm.c_( i ) ); + BOOST_CHECK( mock::affirm.c_( j ) ); +#endif } } -BOOST_AUTO_TEST_CASE(negate_constraint) +BOOST_AUTO_TEST_CASE( negate_constraint ) { int* i = 0; int j; - BOOST_CHECK(mock::negate.c_(i)); - BOOST_CHECK(!mock::negate.c_(&j)); + BOOST_CHECK( mock::negate.c_( i ) ); + BOOST_CHECK( ! mock::negate.c_( &j ) ); } -namespace { -bool return_true() +namespace { - return true; -} -bool return_false() -{ - return false; -} -} // namespace - -BOOST_AUTO_TEST_CASE(call_constraint) -{ - BOOST_CHECK(mock::call(&return_true).c_()); - BOOST_CHECK(!mock::call(&return_false).c_()); + bool return_true() + { + return true; + } + bool return_false() + { + return false; + } } -BOOST_AUTO_TEST_CASE(evaluate_constraint) +BOOST_AUTO_TEST_CASE( call_constraint ) { - BOOST_CHECK(mock::evaluate.c_(&return_true)); - BOOST_CHECK(!mock::evaluate.c_(&return_false)); + BOOST_CHECK( mock::call( &return_true ).c_() ); + BOOST_CHECK( ! mock::call( &return_false ).c_() ); } -BOOST_AUTO_TEST_CASE(contain_constraint_with_const_char_ptr) +BOOST_AUTO_TEST_CASE( evaluate_constraint ) { - BOOST_CHECK(mock::contain("string").c_("this is a string")); - BOOST_CHECK(mock::contain("string").c_(std::string("this is a string"))); - BOOST_CHECK(!mock::contain("not found").c_("this is a string")); - BOOST_CHECK(!mock::contain("not found").c_(std::string("this is a string"))); + BOOST_CHECK( mock::evaluate.c_( &return_true ) ); + BOOST_CHECK( ! mock::evaluate.c_( &return_false ) ); +} + +BOOST_AUTO_TEST_CASE( contain_constraint_with_const_char_ptr ) +{ + BOOST_CHECK( mock::contain( "string" ).c_( "this is a string" ) ); + BOOST_CHECK( mock::contain( "string" ).c_( std::string( "this is a string" ) ) ); + BOOST_CHECK( ! mock::contain( "not found" ).c_( "this is a string" ) ); + BOOST_CHECK( ! mock::contain( "not found" ).c_( std::string( "this is a string" ) ) ); { const char* s = 0; - auto c = mock::contain(std::cref(s)); + mock::constraint< + mock::detail::contain< + boost::reference_wrapper< const char* const > + > + > c = mock::contain( boost::cref( s ) ); s = "string"; - BOOST_CHECK(c.c_("this is a string")); - BOOST_CHECK(c.c_(std::string("this is a string"))); + BOOST_CHECK( c.c_( "this is a string" ) ); + BOOST_CHECK( c.c_( std::string( "this is a string" ) ) ); s = "not found"; - BOOST_CHECK(!c.c_("this is a string")); - BOOST_CHECK(!c.c_(std::string("this is a string"))); + BOOST_CHECK( ! c.c_( "this is a string" ) ); + BOOST_CHECK( ! c.c_( std::string( "this is a string" ) ) ); } } -BOOST_AUTO_TEST_CASE(contain_constraint_with_strings) +BOOST_AUTO_TEST_CASE( contain_constraint_with_strings ) { - BOOST_CHECK(mock::contain(std::string("string")).c_("this is a string")); - BOOST_CHECK(mock::contain(std::string("string")).c_(std::string("this is a string"))); - BOOST_CHECK(!mock::contain(std::string("not found")).c_("this is a string")); - BOOST_CHECK(!mock::contain(std::string("not found")).c_(std::string("this is a string"))); + BOOST_CHECK( mock::contain( std::string( "string" ) ).c_( "this is a string" ) ); + BOOST_CHECK( mock::contain( std::string( "string" ) ).c_( std::string( "this is a string" ) ) ); + BOOST_CHECK( ! mock::contain( std::string( "not found" ) ).c_( "this is a string" ) ); + BOOST_CHECK( ! mock::contain( std::string( "not found" ) ).c_( std::string( "this is a string" ) ) ); { std::string s; - mock::constraint>> c = - mock::contain(std::cref(s)); + mock::constraint< + mock::detail::contain< + boost::reference_wrapper< const std::string > + > + > c = mock::contain( boost::cref( s ) ); s = "string"; - BOOST_CHECK(c.c_("this is a string")); - BOOST_CHECK(c.c_(std::string("this is a string"))); + BOOST_CHECK( c.c_( "this is a string" ) ); + BOOST_CHECK( c.c_( std::string( "this is a string" ) ) ); s = "not found"; - BOOST_CHECK(!c.c_("this is a string")); - BOOST_CHECK(!c.c_(std::string("this is a string"))); + BOOST_CHECK( ! c.c_( "this is a string" ) ); + BOOST_CHECK( ! c.c_( std::string( "this is a string" ) ) ); } } -namespace { -struct type_with_overloaded_address_operator +namespace { - void operator&() {} - void operator&() const {} -}; -} // namespace + struct type_with_overloaded_address_operator + { + void operator&() {} + void operator&() const {} + }; +} -BOOST_AUTO_TEST_CASE(type_with_overloaded_address_operator_can_be_used_in_constraints) +BOOST_AUTO_TEST_CASE( type_with_overloaded_address_operator_can_be_used_in_constraints ) { type_with_overloaded_address_operator t; - mock::same(t).c_(t); - mock::retrieve(t).c_(t); + mock::same( t ).c_( t ); + mock::retrieve( t ).c_( t ); type_with_overloaded_address_operator* pt; - mock::retrieve(pt).c_(t); + mock::retrieve( pt ).c_( t ); } -BOOST_AUTO_TEST_CASE(close_constraint) +BOOST_AUTO_TEST_CASE( close_constraint ) { - BOOST_CHECK(mock::close(12.0, 0.0001).c_(12)); - BOOST_CHECK(!mock::close(12.0, 0.0001).c_(13)); + BOOST_CHECK( mock::close( 12.0, 0.0001 ).c_( 12 ) ); + BOOST_CHECK( ! mock::close( 12.0, 0.0001 ).c_( 13 ) ); } -BOOST_AUTO_TEST_CASE(close_fraction_constraint) +BOOST_AUTO_TEST_CASE( close_fraction_constraint ) { - BOOST_CHECK(mock::close_fraction(12.0, 0.0001).c_(12)); - BOOST_CHECK(!mock::close_fraction(12.0, 0.0001).c_(13)); + BOOST_CHECK( mock::close_fraction( 12.0, 0.0001 ).c_( 12 ) ); + BOOST_CHECK( ! mock::close_fraction( 12.0, 0.0001 ).c_( 13 ) ); } -BOOST_AUTO_TEST_CASE(small_constraint) +BOOST_AUTO_TEST_CASE( small_constraint ) { - BOOST_CHECK(mock::small(0.0001).c_(0.)); - BOOST_CHECK(!mock::small(0.0001).c_(12.)); + BOOST_CHECK( mock::small( 0.0001 ).c_( 0. ) ); + BOOST_CHECK( ! mock::small( 0.0001 ).c_( 12. ) ); } -BOOST_AUTO_TEST_CASE(near_constraint) +BOOST_AUTO_TEST_CASE( near_constraint ) { - BOOST_CHECK(mock::near(12.0, 0.0001).c_(12)); - BOOST_CHECK(!mock::near(12.0, 0.0001).c_(13)); + BOOST_CHECK( mock::near( 12.0, 0.0001 ).c_( 12 ) ); + BOOST_CHECK( ! mock::near( 12.0, 0.0001 ).c_( 13 ) ); } diff --git a/test/test_exception.cpp b/test/test_exception.cpp index 6525a01..818ddeb 100644 --- a/test/test_exception.cpp +++ b/test/test_exception.cpp @@ -8,16 +8,18 @@ #define MOCK_USE_BOOST_TEST #include -#include +#include -BOOST_AUTO_TEST_CASE(a_mock_exception_is_not_an_std_exception_to_not_mess_with_user_exceptions) +BOOST_AUTO_TEST_CASE( a_mock_exception_is_not_an_std_exception_to_not_mess_with_user_exceptions ) { try { throw mock::exception(); - } catch(std::exception&) + } + catch( std::exception& ) { - BOOST_FAIL("mock::exception must not be an std::exception"); - } catch(mock::exception&) + BOOST_FAIL( "mock::exception must not be an std::exception" ); + } + catch( mock::exception& ) {} } diff --git a/test/test_integration.cpp b/test/test_integration.cpp index ef0ca9b..8cc3557 100644 --- a/test/test_integration.cpp +++ b/test/test_integration.cpp @@ -9,756 +9,771 @@ #include "mock_error.hpp" #include "undefined.hpp" #include +#include +#include #include -#include +#include #include -#include -namespace { -struct my_custom_mock +namespace { - MOCK_METHOD(my_method, 0, void(), my_tag) -}; -} // namespace + struct my_custom_mock + { + MOCK_METHOD_EXT( my_method, 0, void(), my_tag ) + }; +} -BOOST_FIXTURE_TEST_CASE(custom_mock_object_without_macros_and_without_inheriting_from_object, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( custom_mock_object_without_macros_and_without_inheriting_from_object, mock_error_fixture ) { my_custom_mock m; - MOCK_EXPECT(m.my_tag).once(); + MOCK_EXPECT( m.my_tag ).once(); m.my_method(); - CHECK_CALLS(1); + CHECK_CALLS( 1 ); } -namespace { -struct my_custom_mock_object +namespace { - MOCK_METHOD(my_method, 0, void(), my_tag) -}; -} // namespace + struct my_custom_mock_object + { + MOCK_METHOD_EXT( my_method, 0, void(), my_tag ) + }; +} -BOOST_FIXTURE_TEST_CASE(custom_mock_object_without_macros, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( custom_mock_object_without_macros, mock_error_fixture ) { my_custom_mock_object m; - MOCK_EXPECT(m.my_tag).once(); + MOCK_EXPECT( m.my_tag ).once(); m.my_method(); - CHECK_CALLS(1); + CHECK_CALLS( 1 ); } -namespace { -MOCK_CLASS(my_mock) +namespace { - MOCK_METHOD(my_method, 1, int(int), my_tag) -}; -} // namespace + MOCK_CLASS( my_mock ) + { + MOCK_METHOD_EXT( my_method, 1, int( int ), my_tag ) + }; +} -BOOST_FIXTURE_TEST_CASE(basic_mock_object_usage, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( basic_mock_object_usage, mock_error_fixture ) { my_mock m; { - MOCK_EXPECT(m.my_tag).once().returns(0); - BOOST_CHECK_EQUAL(0, m.my_method(13)); - CHECK_CALLS(1); + MOCK_EXPECT( m.my_tag ).once().returns( 0 ); + BOOST_CHECK_EQUAL( 0, m.my_method( 13 ) ); + CHECK_CALLS( 1 ); } mock::verify(); mock::reset(); { - MOCK_EXPECT(m.my_tag).once().with(42).returns(7); - BOOST_CHECK_EQUAL(7, m.my_method(42)); - CHECK_CALLS(1); + MOCK_EXPECT( m.my_tag ).once().with( 42 ).returns( 7 ); + BOOST_CHECK_EQUAL( 7, m.my_method( 42 ) ); + CHECK_CALLS( 1 ); } mock::verify(); mock::reset(); { - MOCK_EXPECT(m.my_tag).once().returns(51); - BOOST_CHECK_EQUAL(51, m.my_method(27)); - CHECK_CALLS(1); + MOCK_EXPECT( m.my_tag ).once().returns( 51 ); + BOOST_CHECK_EQUAL( 51, m.my_method( 27 ) ); + CHECK_CALLS( 1 ); } } -namespace { -class my_ambiguited_interface +namespace { -public: - my_ambiguited_interface() = default; - my_ambiguited_interface(const my_ambiguited_interface&) = delete; - my_ambiguited_interface& operator=(const my_ambiguited_interface&) = delete; - virtual ~my_ambiguited_interface() = default; - virtual void my_method() = 0; - virtual void my_method(int) = 0; -}; + class my_ambiguited_interface : boost::noncopyable + { + public: + virtual ~my_ambiguited_interface() + {} + virtual void my_method() = 0; + virtual void my_method( int ) = 0; + }; -MOCK_BASE_CLASS(my_ambiguited_mock, my_ambiguited_interface) -{ - MOCK_METHOD(my_method, 0, void(), my_tag1) - MOCK_METHOD(my_method, 1, void(int), my_tag_2) -}; -} // namespace + MOCK_BASE_CLASS( my_ambiguited_mock, my_ambiguited_interface ) + { + MOCK_METHOD_EXT( my_method, 0, void(), my_tag1 ) + MOCK_METHOD_EXT( my_method, 1, void( int ), my_tag_2 ) + }; +} -BOOST_FIXTURE_TEST_CASE(mock_object_method_disambiguation, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( mock_object_method_disambiguation, mock_error_fixture ) { my_ambiguited_mock m; - MOCK_EXPECT(m.my_tag1); + MOCK_EXPECT( m.my_tag1 ); m.my_method(); - CHECK_ERROR(m.my_method(12), "unexpected call", 1, "?.my_ambiguited_mock::my_tag_2( 12 )"); + CHECK_ERROR( m.my_method( 12 ), "unexpected call", 1, "?.my_ambiguited_mock::my_tag_2( 12 )" ); } -namespace { -class my_const_ambiguited_interface +namespace { -public: - my_const_ambiguited_interface() = default; - my_const_ambiguited_interface(const my_const_ambiguited_interface&) = delete; - my_const_ambiguited_interface& operator=(const my_const_ambiguited_interface&) = delete; - virtual ~my_const_ambiguited_interface() = default; - virtual void my_method() = 0; - virtual void my_method() const = 0; -}; + class my_const_ambiguited_interface : boost::noncopyable + { + public: + virtual ~my_const_ambiguited_interface() + {} + virtual void my_method() = 0; + virtual void my_method() const = 0; + }; -MOCK_BASE_CLASS(my_const_ambiguited_mock, my_const_ambiguited_interface) -{ - MOCK_NON_CONST_METHOD(my_method, 0, void(), tag1) - MOCK_CONST_METHOD(my_method, 0, void(), tag_2) -}; -} // namespace + MOCK_BASE_CLASS( my_const_ambiguited_mock, my_const_ambiguited_interface ) + { + MOCK_NON_CONST_METHOD_EXT( my_method, 0, void(), tag1 ) + MOCK_CONST_METHOD_EXT( my_method, 0, void(), tag_2 ) + }; +} -BOOST_FIXTURE_TEST_CASE(mock_object_method_const_disambiguation, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( mock_object_method_const_disambiguation, mock_error_fixture ) { my_const_ambiguited_mock mock; - MOCK_EXPECT(mock.tag1); - BOOST_CHECK_NO_THROW(mock.my_method()); + MOCK_EXPECT( mock.tag1 ); + BOOST_CHECK_NO_THROW( mock.my_method() ); const my_const_ambiguited_mock const_mock; - CHECK_ERROR(const_mock.my_method(), "unexpected call", 1, "?.my_const_ambiguited_mock::tag_2()"); + CHECK_ERROR( const_mock.my_method(), "unexpected call", 1, "?.my_const_ambiguited_mock::tag_2()" ); } -namespace { -MOCK_CLASS(my_undefined_mock) +namespace { - MOCK_METHOD(m, 1, void(undefined&), t) -}; -} // namespace + MOCK_CLASS( my_undefined_mock ) + { + MOCK_METHOD_EXT( m, 1, void( undefined& ), t ) + }; +} -BOOST_FIXTURE_TEST_CASE(mock_object_method_with_declared_but_not_defined_parameter_is_valid, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( mock_object_method_with_declared_but_not_defined_parameter_is_valid, mock_error_fixture ) { my_undefined_mock mock; - MOCK_EXPECT(mock.t); + MOCK_EXPECT( mock.t ); } -namespace { -MOCK_FUNCTOR(gf, int(float, const std::string&)); -} - -BOOST_FIXTURE_TEST_CASE(mock_functor_in_namespace_is_supported, mock_error_fixture) +namespace { - std::function func; - MOCK_EXPECT(gf).once().with(3, "op").returns(42); + MOCK_FUNCTOR( gf, int( float, const std::string& ) ); +} + +BOOST_FIXTURE_TEST_CASE( mock_functor_in_namespace_is_supported, mock_error_fixture ) +{ + boost::function< int( float, const std::string& ) > func; + MOCK_EXPECT( gf ).once().with( 3, "op" ).returns( 42 ); func = gf; - BOOST_CHECK_EQUAL(42, func(3, "op")); - CHECK_CALLS(1); + BOOST_CHECK_EQUAL( 42, func( 3, "op" ) ); + CHECK_CALLS( 1 ); } -BOOST_FIXTURE_TEST_CASE(mock_functor_in_function_is_supported, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( mock_functor_in_function_is_supported, mock_error_fixture ) { - std::function func; + boost::function< int( float, const std::string& ) > func; { - MOCK_FUNCTOR(f, int(float, const std::string&)); - MOCK_EXPECT(f).once().with(3, "op").returns(42); + MOCK_FUNCTOR( f, int( float, const std::string& ) ); + MOCK_EXPECT( f ).once().with( 3, "op" ).returns( 42 ); func = f; } - BOOST_CHECK_EQUAL(42, func(3, "op")); - CHECK_CALLS(1); + BOOST_CHECK_EQUAL( 42, func( 3, "op" ) ); + CHECK_CALLS( 1 ); } -namespace { -struct functor_fixture : mock_error_fixture +namespace { - MOCK_FUNCTOR(f, int(float, const std::string&)); -}; -} // namespace - -BOOST_FIXTURE_TEST_CASE(mock_functor_in_fixture_is_supported, functor_fixture) -{ - MOCK_EXPECT(f).once().with(3, "op").returns(42); - BOOST_CHECK_EQUAL(42, f(3.f, "op")); - CHECK_CALLS(1); + struct functor_fixture : mock_error_fixture + { + MOCK_FUNCTOR( f, int( float, const std::string& ) ); + }; } -namespace { -template -struct my_template_mock +BOOST_FIXTURE_TEST_CASE( mock_functor_in_fixture_is_supported, functor_fixture ) { - MOCK_METHOD(my_method, 0, void(), my_tag) - MOCK_METHOD(my_method, 2, void(T, std::string), my_tpl_tag) - MOCK_METHOD(my_other_method, 0, void(), my_other_tag) -}; -} // namespace - -BOOST_FIXTURE_TEST_CASE(mocking_a_template_class_method_is_supported, mock_error_fixture) -{ - my_template_mock m; - MOCK_EXPECT(m.my_tpl_tag).with(3, ""); - m.my_method(3, ""); - BOOST_CHECK(MOCK_VERIFY(m.my_tpl_tag)); - CHECK_CALLS(1); + MOCK_EXPECT( f ).once().with( 3, "op" ).returns( 42 ); + BOOST_CHECK_EQUAL( 42, f( 3.f, "op" ) ); + CHECK_CALLS( 1 ); } -namespace { -template -struct my_template_base_class +namespace { - virtual ~my_template_base_class() = default; - virtual void my_method(T) = 0; - virtual void my_other_method() = 0; -}; -template -MOCK_BASE_CLASS(my_template_base_class_mock, my_template_base_class) -{ - MOCK_METHOD(my_method, 1, void(T), my_method) - MOCK_METHOD(my_other_method, 0, void(), my_other_method) -}; -} // namespace - -BOOST_FIXTURE_TEST_CASE(mocking_a_template_base_class_method_is_supported, mock_error_fixture) -{ - my_template_base_class_mock m; - MOCK_EXPECT(m.my_method).once().with(3); - m.my_method(3); - BOOST_CHECK(MOCK_VERIFY(m.my_method)); - CHECK_CALLS(1); + template< typename T > + struct my_template_mock + { + MOCK_METHOD_EXT( my_method, 0, void(), my_tag ) + MOCK_METHOD_EXT_TPL( my_method, 2, void( T, std::string ), my_tpl_tag ) + MOCK_METHOD_EXT_TPL( my_other_method, 0, void(), my_other_tag ) + }; } -namespace { -class my_observer +BOOST_FIXTURE_TEST_CASE( mocking_a_template_class_method_is_supported, mock_error_fixture ) { -public: - my_observer() = default; - my_observer(const my_observer&) = delete; - my_observer& operator=(const my_observer&) = delete; - virtual ~my_observer() = default; - virtual void notify(int value) = 0; -}; + my_template_mock< int > m; + MOCK_EXPECT( m.my_tpl_tag ).with( 3, "" ); + m.my_method( 3, "" ); + BOOST_CHECK( MOCK_VERIFY( m.my_tpl_tag ) ); + CHECK_CALLS( 1 ); +} -class my_manager +namespace { -public: - my_manager() = default; - my_manager(const my_manager&) = delete; - my_manager& operator=(const my_manager&) = delete; - virtual ~my_manager() = default; - virtual my_observer& get_observer() const = 0; -}; + template< typename T > + struct my_template_base_class + { + virtual ~my_template_base_class() + {} + virtual void my_method( T ) = 0; + virtual void my_other_method() = 0; + }; + template< typename T > + MOCK_BASE_CLASS( my_template_base_class_mock, my_template_base_class< T > ) + { + MOCK_METHOD_EXT_TPL( my_method, 1, void( T ), my_method ) + MOCK_METHOD_EXT_TPL( my_other_method, 0, void(), my_other_method ) + }; +} -class my_subject +BOOST_FIXTURE_TEST_CASE( mocking_a_template_base_class_method_is_supported, mock_error_fixture ) { -public: - explicit my_subject(my_manager& f) : o_(f.get_observer()), value_(0) {} - void increment() { o_.notify(++value_); } + my_template_base_class_mock< int > m; + MOCK_EXPECT( m.my_method ).once().with( 3 ); + m.my_method( 3 ); + BOOST_CHECK( MOCK_VERIFY( m.my_method ) ); + CHECK_CALLS( 1 ); +} -private: - my_observer& o_; - int value_; -}; - -MOCK_BASE_CLASS(my_mock_observer, my_observer) +namespace { - MOCK_METHOD(notify, 1) -}; + class my_observer : boost::noncopyable + { + public: + virtual ~my_observer() + {} + virtual void notify( int value ) = 0; + }; -MOCK_BASE_CLASS(my_mock_manager, my_manager) -{ - MOCK_METHOD(get_observer, 0) -}; + class my_manager : boost::noncopyable + { + public: + virtual ~my_manager() + {} + virtual my_observer& get_observer() const = 0; + }; -struct fixture : mock_error_fixture -{ - my_mock_manager manager; - my_mock_observer observer; -}; -} // namespace + class my_subject : boost::noncopyable + { + public: + explicit my_subject( my_manager& f ) + : o_( f.get_observer() ) + , value_( 0 ) + {} + void increment() + { + o_.notify( ++value_ ); + } + private: + my_observer& o_; + int value_; + }; -BOOST_FIXTURE_TEST_CASE(basic_mock_object_collaboration_usage, fixture) + MOCK_BASE_CLASS( my_mock_observer, my_observer ) + { + MOCK_METHOD( notify, 1 ) + }; + + MOCK_BASE_CLASS( my_mock_manager, my_manager ) + { + MOCK_METHOD( get_observer, 0 ) + }; + + struct fixture : mock_error_fixture + { + my_mock_manager manager; + my_mock_observer observer; + }; +} + +BOOST_FIXTURE_TEST_CASE( basic_mock_object_collaboration_usage, fixture ) { - MOCK_EXPECT(manager.get_observer).returns(std::ref(observer)); - my_subject subject(manager); - MOCK_EXPECT(observer.notify).once().with(1); + MOCK_EXPECT( manager.get_observer ).returns( boost::ref( observer ) ); + my_subject subject( manager ); + MOCK_EXPECT( observer.notify ).once().with( 1 ); subject.increment(); - MOCK_EXPECT(observer.notify).once().with(2); + MOCK_EXPECT( observer.notify ).once().with( 2 ); subject.increment(); - MOCK_EXPECT(observer.notify).once().with(3); + MOCK_EXPECT( observer.notify ).once().with( 3 ); subject.increment(); - CHECK_CALLS(4); + CHECK_CALLS( 4 ); } -namespace { -MOCK_CLASS(my_constructed_class) +namespace { - MOCK_CONSTRUCTOR(my_constructed_class, 2, (int, const std::string&), constructor) -}; -} // namespace - -BOOST_FIXTURE_TEST_CASE(mocking_a_constructor, mock_error_fixture) -{ - MOCK_EXPECT(my_constructed_class::constructor).with(42, "some text").once(); - my_constructed_class(42, "some text"); - BOOST_CHECK(MOCK_VERIFY(my_constructed_class::constructor)); - CHECK_CALLS(1); + MOCK_CLASS( my_constructed_class ) + { + MOCK_CONSTRUCTOR( my_constructed_class, 2, ( int, const std::string& ), constructor ) + }; } -namespace { -template -MOCK_CLASS(my_constructed_template_class) +BOOST_FIXTURE_TEST_CASE( mocking_a_constructor, mock_error_fixture ) { - MOCK_CONSTRUCTOR(my_constructed_template_class, 2, (T, const std::string&), constructor) -}; -} // namespace - -BOOST_FIXTURE_TEST_CASE(mocking_a_template_class_constructor, mock_error_fixture) -{ - MOCK_EXPECT(my_constructed_template_class::constructor).with(42, "some text").once(); - my_constructed_template_class(42, "some text"); - BOOST_CHECK(MOCK_VERIFY(my_constructed_template_class::constructor)); - CHECK_CALLS(1); + MOCK_EXPECT( my_constructed_class::constructor ).with( 42, "some text" ).once(); + my_constructed_class( 42, "some text" ); + BOOST_CHECK( MOCK_VERIFY( my_constructed_class::constructor ) ); + CHECK_CALLS( 1 ); } -namespace { -MOCK_CLASS(my_destroyed_class) +namespace { - MOCK_DESTRUCTOR(~my_destroyed_class, destructor) -}; -} // namespace + template< typename T > + MOCK_CLASS( my_constructed_template_class ) + { + MOCK_CONSTRUCTOR_TPL( my_constructed_template_class, 2, ( T, const std::string& ), constructor ) + }; +} -BOOST_FIXTURE_TEST_CASE(mocking_a_destructor, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( mocking_a_template_class_constructor, mock_error_fixture ) +{ + MOCK_EXPECT( my_constructed_template_class< int >::constructor ).with( 42, "some text" ).once(); + my_constructed_template_class< int >( 42, "some text" ); + BOOST_CHECK( MOCK_VERIFY( my_constructed_template_class< int >::constructor ) ); + CHECK_CALLS( 1 ); +} + +namespace +{ + MOCK_CLASS( my_destroyed_class ) + { + MOCK_DESTRUCTOR( ~my_destroyed_class, destructor ) + }; +} + +BOOST_FIXTURE_TEST_CASE( mocking_a_destructor, mock_error_fixture ) { { my_destroyed_class c; - MOCK_EXPECT(c.destructor).once(); + MOCK_EXPECT( c.destructor ).once(); } - CHECK_CALLS(1); + CHECK_CALLS( 1 ); } -BOOST_FIXTURE_TEST_CASE(failed_expectation_in_mocked_destructor_does_not_throw, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( failed_expectation_in_mocked_destructor_does_not_throw, mock_error_fixture ) { CHECK_ERROR( - try { - my_destroyed_class c; - throw std::runtime_error("should not crash"); - } catch(std::runtime_error&){}, - "unexpected call", - 0, - "?.my_destroyed_class::destructor()"); + try + { + my_destroyed_class c; + throw std::runtime_error( "should not crash" ); + } + catch( std::runtime_error& ) + { + }, + "unexpected call", 0, "?.my_destroyed_class::destructor()" ); } -BOOST_FIXTURE_TEST_CASE(failed_sequence_in_mocked_destructor_does_not_throw, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( failed_sequence_in_mocked_destructor_does_not_throw, mock_error_fixture ) { mock::sequence s; my_custom_mock m; CHECK_ERROR( - { - my_destroyed_class c; - MOCK_EXPECT(c.destructor).once().in(s); - MOCK_EXPECT(m.my_tag).once().in(s); - m.my_method(); - }, - "sequence failed", - 1, - "c.my_destroyed_class::destructor()\n. once()"); + { + my_destroyed_class c; + MOCK_EXPECT( c.destructor ).once().in( s ); + MOCK_EXPECT( m.my_tag ).once().in( s ); + m.my_method(); + }, + "sequence failed", 1, "c.my_destroyed_class::destructor()\n. once()" ); } -namespace { -MOCK_CLASS(boost_optional) +namespace { - MOCK_METHOD(method, 0, boost::optional(), tag) -}; -} // namespace + MOCK_CLASS( boost_optional ) + { + MOCK_METHOD_EXT( method, 0, boost::optional< my_observer& >(), tag ) + }; +} -BOOST_FIXTURE_TEST_CASE(boost_optional_on_base_class_reference_as_return_type_is_supported, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( boost_optional_on_base_class_reference_as_return_type_is_supported, mock_error_fixture ) { boost_optional b; my_mock_observer o; - MOCK_EXPECT(b.tag).once().returns(std::ref(o)); + MOCK_EXPECT( b.tag ).once().returns( boost::ref( o ) ); b.method(); - CHECK_CALLS(1); + CHECK_CALLS( 1 ); } -namespace { -bool serialized = false; +namespace +{ + bool serialized = false; -struct custom_argument -{ - friend std::ostream& operator<<(std::ostream& s, custom_argument) + struct custom_argument { - serialized = true; - return s; - } -}; -struct custom_constraint -{ - template - friend bool operator==(Actual, custom_constraint) + friend std::ostream& operator<<( std::ostream& s, custom_argument ) + { + serialized = true; + return s; + } + }; + struct custom_constraint { - return true; - } - friend std::ostream& operator<<(std::ostream& s, custom_constraint) - { - serialized = true; - return s; - } -}; -} // namespace - -BOOST_FIXTURE_TEST_CASE(constraints_and_arguments_are_serialized_lazily, mock_error_fixture) -{ - MOCK_FUNCTOR(f, void(const custom_argument&)); - MOCK_EXPECT(f).with(custom_constraint()); - f(custom_argument()); - BOOST_CHECK(!serialized); - CHECK_CALLS(1); + template< typename Actual > + friend bool operator==( Actual, custom_constraint ) + { + return true; + } + friend std::ostream& operator<<( std::ostream& s, custom_constraint ) + { + serialized = true; + return s; + } + }; } -namespace { -struct custom_constraint_with_non_const_operator +BOOST_FIXTURE_TEST_CASE( constraints_and_arguments_are_serialized_lazily, mock_error_fixture ) { - template - bool operator()(Actual actual) - { - return actual == 42; - } -}; -} // namespace - -BOOST_FIXTURE_TEST_CASE(custom_constraint_function_operator_does_not_need_to_be_const, mock_error_fixture) -{ - MOCK_FUNCTOR(f, void(float)); - MOCK_EXPECT(f).with( - mock::constraint(custom_constraint_with_non_const_operator())); - f(42); - CHECK_CALLS(1); + MOCK_FUNCTOR( f, void( const custom_argument& ) ); + MOCK_EXPECT( f ).with( custom_constraint() ); + f( custom_argument() ); + BOOST_CHECK( ! serialized ); + CHECK_CALLS( 1 ); } -BOOST_FIXTURE_TEST_CASE(boost_reference_wrapper_is_supported_in_value_constraint, mock_error_fixture) +namespace { - MOCK_FUNCTOR(f, void(const std::string&)); + struct custom_constraint_with_non_const_operator + { + template< typename Actual > + bool operator()( Actual actual ) + { + return actual == 42; + } + }; +} + +BOOST_FIXTURE_TEST_CASE( custom_constraint_function_operator_does_not_need_to_be_const, mock_error_fixture ) +{ + MOCK_FUNCTOR( f, void( float ) ); + MOCK_EXPECT( f ).with( mock::constraint< custom_constraint_with_non_const_operator >( custom_constraint_with_non_const_operator() ) ); + f( 42 ); + CHECK_CALLS( 1 ); +} + +BOOST_FIXTURE_TEST_CASE( boost_reference_wrapper_is_supported_in_value_constraint, mock_error_fixture ) +{ + MOCK_FUNCTOR( f, void( const std::string& ) ); std::string s; - MOCK_EXPECT(f).once().with(std::cref(s)); + MOCK_EXPECT( f ).once().with( boost::cref( s ) ); s = "string"; - f("string"); - CHECK_CALLS(1); + f( "string" ); + CHECK_CALLS( 1 ); } -namespace { -template -void nothing(T) -{} - -struct member_pointer_mock_class +namespace { - MOCK_CONST_METHOD(my_method, 0, void(), my_method) -}; -} // namespace + template< typename T > + void nothing( T ) + {} -BOOST_FIXTURE_TEST_CASE(member_pointer_on_mock_method_is_valid, mock_error_fixture) -{ - nothing(&member_pointer_mock_class::my_method); + struct member_pointer_mock_class + { + MOCK_CONST_METHOD_EXT( my_method, 0, void(), my_method ) + }; } -namespace { -MOCK_FUNCTION(free_function, 1, void(int), free_function) +BOOST_FIXTURE_TEST_CASE( member_pointer_on_mock_method_is_valid, mock_error_fixture ) +{ + nothing( &member_pointer_mock_class::my_method ); } -BOOST_FIXTURE_TEST_CASE(a_free_function_can_be_mocked, mock_error_fixture) +namespace { - MOCK_EXPECT(free_function).once(); + MOCK_FUNCTION( free_function, 1, void( int ), free_function ) +} + +BOOST_FIXTURE_TEST_CASE( a_free_function_can_be_mocked, mock_error_fixture ) +{ + MOCK_EXPECT( free_function ).once(); CHECK_ERROR( - BOOST_CHECK(!MOCK_VERIFY(free_function)), "verification failed", 0, "free_function\n. once().with( any )"); - free_function(42); - CHECK_CALLS(1); - BOOST_CHECK(MOCK_VERIFY(free_function)); - MOCK_RESET(free_function); + BOOST_CHECK( ! MOCK_VERIFY( free_function ) ), + "verification failed", 0, "free_function\n. once().with( any )" ); + free_function( 42 ); + CHECK_CALLS( 1 ); + BOOST_CHECK( MOCK_VERIFY( free_function ) ); + MOCK_RESET( free_function ); } -namespace { -struct some_class : mock::object +namespace { - MOCK_STATIC_METHOD(some_static_method, 1, void(int), some_static_method) -}; -} // namespace - -BOOST_FIXTURE_TEST_CASE(a_static_method_can_be_mocked, mock_error_fixture) -{ - MOCK_EXPECT(some_class::some_static_method).once(); - CHECK_ERROR(BOOST_CHECK(!MOCK_VERIFY(some_class::some_static_method)), - "verification failed", - 0, - "some_class::some_static_method\n. once().with( any )"); - some_class::some_static_method(42); - CHECK_CALLS(1); - BOOST_CHECK(MOCK_VERIFY(some_class::some_static_method)); - MOCK_RESET(some_class::some_static_method); + struct some_class : mock::object + { + MOCK_STATIC_METHOD( some_static_method, 1, void( int ), some_static_method ) + }; } -BOOST_FIXTURE_TEST_CASE(a_static_method_is_not_reset_when_resetting_an_instance_of_the_class, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( a_static_method_can_be_mocked, mock_error_fixture ) { - MOCK_EXPECT(some_class::some_static_method).once(); + MOCK_EXPECT( some_class::some_static_method ).once(); + CHECK_ERROR( + BOOST_CHECK( ! MOCK_VERIFY( some_class::some_static_method ) ), + "verification failed", 0, "some_class::some_static_method\n. once().with( any )" ); + some_class::some_static_method( 42 ); + CHECK_CALLS( 1 ); + BOOST_CHECK( MOCK_VERIFY( some_class::some_static_method ) ); + MOCK_RESET( some_class::some_static_method ); +} + +BOOST_FIXTURE_TEST_CASE( a_static_method_is_not_reset_when_resetting_an_instance_of_the_class, mock_error_fixture ) +{ + MOCK_EXPECT( some_class::some_static_method ).once(); some_class c; - mock::reset(c); - CHECK_ERROR(BOOST_CHECK(!MOCK_VERIFY(some_class::some_static_method)), - "verification failed", - 0, - "some_class::some_static_method\n. once().with( any )"); - MOCK_RESET(some_class::some_static_method); + mock::reset( c ); + CHECK_ERROR( + BOOST_CHECK( ! MOCK_VERIFY( some_class::some_static_method ) ), + "verification failed", 0, "some_class::some_static_method\n. once().with( any )" ); + MOCK_RESET( some_class::some_static_method ); } -namespace { -template -struct some_template_class +namespace { - MOCK_STATIC_METHOD(some_static_method, 1, void(T), some_static_method) -}; -} // namespace - -BOOST_FIXTURE_TEST_CASE(a_static_method_in_a_template_class_can_be_mocked, mock_error_fixture) -{ - MOCK_EXPECT(some_template_class::some_static_method).once(); - CHECK_ERROR(BOOST_CHECK(!MOCK_VERIFY(some_template_class::some_static_method)), - "verification failed", - 0, - "some_template_class::some_static_method\n. once().with( any )"); - some_template_class::some_static_method(42); - BOOST_CHECK(mock::verify()); - BOOST_CHECK(MOCK_VERIFY(some_template_class::some_static_method)); - MOCK_RESET(some_template_class::some_static_method); - CHECK_CALLS(1); + template< typename T > + struct some_template_class + { + MOCK_STATIC_METHOD_TPL( some_static_method, 1, void( T ), some_static_method ) + }; } -namespace { -MOCK_CLASS(mock_class) +BOOST_FIXTURE_TEST_CASE( a_static_method_in_a_template_class_can_be_mocked, mock_error_fixture ) { - MOCK_METHOD(m, 0, void(), t); -}; -} // namespace + MOCK_EXPECT( some_template_class< int >::some_static_method ).once(); + CHECK_ERROR( + BOOST_CHECK( ! MOCK_VERIFY( some_template_class< int >::some_static_method ) ), + "verification failed", 0, "some_template_class< int >::some_static_method\n. once().with( any )" ); + some_template_class< int >::some_static_method( 42 ); + BOOST_CHECK( mock::verify() ); + BOOST_CHECK( MOCK_VERIFY( some_template_class< int >::some_static_method ) ); + MOCK_RESET( some_template_class< int >::some_static_method ); + CHECK_CALLS( 1 ); +} -BOOST_FIXTURE_TEST_CASE(resetting_referenced_mock_class_does_not_crash, mock_error_fixture) +namespace { - MOCK_FUNCTOR(f, mock_class()); + MOCK_CLASS( mock_class ) + { + MOCK_METHOD_EXT( m, 0, void(), t ); + }; +} + +BOOST_FIXTURE_TEST_CASE( resetting_referenced_mock_class_does_not_crash, mock_error_fixture ) +{ + MOCK_FUNCTOR( f, mock_class() ); { mock_class c; - MOCK_EXPECT(f).returns(c); - MOCK_EXPECT(c.t); + MOCK_EXPECT( f ).returns( c ); + MOCK_EXPECT( c.t ); } mock::reset(); } -namespace { -MOCK_CLASS(mock_class2) +namespace { - MOCK_METHOD(m, 0, mock_class2(), t); -}; -} // namespace + MOCK_CLASS( mock_class2 ) + { + MOCK_METHOD_EXT( m, 0, mock_class2(), t ); + }; +} -BOOST_FIXTURE_TEST_CASE(resetting_self_referenced_mock_class_does_not_crash, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( resetting_self_referenced_mock_class_does_not_crash, mock_error_fixture ) { { mock_class2 c; - MOCK_EXPECT(c.t).returns(c); + MOCK_EXPECT( c.t ).returns( c ); } mock::reset(); } -namespace { -template -struct my_base -{}; -MOCK_BASE_CLASS(my_comma_mock, my_base) -{}; -MOCK_BASE_CLASS(my_boost_pp_comma_mock, my_base) -{}; -} // namespace +namespace +{ + template< typename T1, typename T2 > + struct my_base + {}; + MOCK_BASE_CLASS( my_comma_mock, my_base< int BOOST_PP_COMMA() int > ) + {}; +} #ifdef MOCK_THREAD_SAFE -# include +#include -namespace { -void create_class() +namespace { - my_mock m; - MOCK_EXPECT(m.my_tag).once().with(3).returns(42); - try + void create_class() { - m.my_method(3); - } catch(...) - {} + my_mock m; + MOCK_EXPECT( m.my_tag ).once().with( 3 ).returns( 42 ); + try + { + m.my_method( 3 ); + } + catch( ... ) + {} + } } -} // namespace -BOOST_FIXTURE_TEST_CASE(mock_class_creation_is_thread_safe, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( mock_class_creation_is_thread_safe, mock_error_fixture ) { boost::thread_group group; - for(int i = 0; i < 100; ++i) - group.create_thread(&create_class); + for( int i = 0; i < 100; ++i ) + group.create_thread( &create_class ); group.join_all(); - CHECK_CALLS(100); + CHECK_CALLS( 100 ); } -namespace { -void create_functor(int i) +namespace { - mock::detail::functor f; - boost::this_thread::sleep(boost::posix_time::milliseconds(100)); - mock::detail::functor f_mock; - MOCK_EXPECT(f).once().with(i); - try + void create_functor( int i ) { - f(i); - } catch(...) - {} + mock::detail::functor< void( int ) > f; + boost::this_thread::sleep( boost::posix_time::milliseconds( 100 ) ); + mock::detail::functor< void( int ) > f_mock; + MOCK_EXPECT( f ).once().with( i ); + try + { + f( i ); + } + catch( ... ) + {} + } } -} // namespace -BOOST_FIXTURE_TEST_CASE(mock_functor_creation_is_thread_safe, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( mock_functor_creation_is_thread_safe, mock_error_fixture ) { boost::thread_group group; - for(int i = 0; i < 100; ++i) - group.create_thread([i]() { create_functor(i); }); + for( int i = 0; i < 100; ++i ) + group.create_thread( boost::bind( &create_functor, i ) ); group.join_all(); - CHECK_CALLS(100); + CHECK_CALLS( 100 ); } -namespace { -void iterate(my_mock& m) +namespace { - MOCK_EXPECT(m.my_tag).once().with(3).returns(42); - BOOST_CHECK_EQUAL(42, m.my_method(3)); + void iterate( my_mock& m ) + { + MOCK_EXPECT( m.my_tag ).once().with( 3 ).returns( 42 ); + BOOST_CHECK_EQUAL( 42, m.my_method( 3 ) ); + } } -} // namespace -BOOST_FIXTURE_TEST_CASE(mock_class_is_thread_safe, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( mock_class_is_thread_safe, mock_error_fixture ) { my_mock m; boost::thread_group group; - for(int i = 0; i < 100; ++i) - group.create_thread([&m]() { iterate(m); }); + for( int i = 0; i < 100; ++i ) + group.create_thread( boost::bind( &iterate, boost::ref( m ) ) ); group.join_all(); - CHECK_CALLS(100); + CHECK_CALLS( 100 ); } #endif // MOCK_THREAD_SAFE -namespace { -MOCK_CLASS(my_multi_mock) +namespace { - MOCK_METHOD(m1, 1, void(int), m1); - MOCK_METHOD(m2, 2, void(int, int), m2); -}; -} // namespace + MOCK_CLASS( my_multi_mock ) + { + MOCK_METHOD_EXT( m1, 1, void( int ), m1 ); + MOCK_METHOD_EXT( m2, 2, void( int, int ), m2 ); + }; +} -BOOST_FIXTURE_TEST_CASE(mock_method_accepts_multi_constraint, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( mock_method_accepts_multi_constraint, mock_error_fixture ) { my_multi_mock m; - MOCK_FUNCTOR(f, bool(int, int)); - MOCK_EXPECT(m.m2).once().with(f); - MOCK_EXPECT(f).once().with(1, 2).returns(true); - m.m2(1, 2); - CHECK_CALLS(2); + MOCK_FUNCTOR( f, bool( int, int ) ); + MOCK_EXPECT( m.m2 ).once().with( f ); + MOCK_EXPECT( f ).once().with( 1, 2 ).returns( true ); + m.m2( 1, 2 ); + CHECK_CALLS( 2 ); } -namespace { -struct my_polymorphic_constraint +namespace { - template - bool operator()(T1, T2) const + struct my_polymorphic_constraint { - return true; - } -}; -} // namespace + template< typename T1, typename T2 > + bool operator()( T1, T2 ) const + { + return true; + } + }; +} -BOOST_FIXTURE_TEST_CASE(mock_method_accepts_polymorphic_multi_constraint, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( mock_method_accepts_polymorphic_multi_constraint, mock_error_fixture ) { my_multi_mock m; - MOCK_EXPECT(m.m2).once().with(my_polymorphic_constraint()); - m.m2(1, 2); - CHECK_CALLS(1); + MOCK_EXPECT( m.m2 ).once().with( my_polymorphic_constraint() ); + m.m2( 1, 2 ); + CHECK_CALLS( 1 ); } -BOOST_FIXTURE_TEST_CASE(std_unique_ptr_argument_is_supported_in_action, mock_error_fixture) +#ifdef MOCK_SMART_PTR + +BOOST_FIXTURE_TEST_CASE( std_unique_ptr_argument_is_supported_in_action, mock_error_fixture ) { - MOCK_FUNCTOR(f, void(std::unique_ptr)); - std::unique_ptr p; - MOCK_EXPECT(f).once().calls([](std::unique_ptr) {}); - f(std::unique_ptr(new int(7))); - CHECK_CALLS(1); + MOCK_FUNCTOR( f, void( std::unique_ptr< int > ) ); + std::unique_ptr< int > p; + MOCK_EXPECT( f ).once().calls( + []( std::unique_ptr< int > ) + { + } ); + f( std::unique_ptr< int >( new int( 7 ) ) ); + CHECK_CALLS( 1 ); } -BOOST_FIXTURE_TEST_CASE(std_unique_ptr_argument_is_supported_in_equal_constraint, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( std_unique_ptr_argument_is_supported_in_equal_constraint, mock_error_fixture ) { { - MOCK_FUNCTOR(f, void(std::unique_ptr)); - MOCK_EXPECT(f).once().with(mock::equal(7)); - f(std::unique_ptr(new int(7))); - CHECK_CALLS(1); + MOCK_FUNCTOR( f, void( std::unique_ptr< int > ) ); + MOCK_EXPECT( f ).once().with( mock::equal( 7 ) ); + f( std::unique_ptr< int >( new int( 7 ) ) ); + CHECK_CALLS( 1 ); } { - MOCK_FUNCTOR(f, void(std::unique_ptr)); - MOCK_EXPECT(f).once().with(7); - f(std::unique_ptr(new int(7))); - CHECK_CALLS(1); + MOCK_FUNCTOR( f, void( std::unique_ptr< int > ) ); + MOCK_EXPECT( f ).once().with( 7 ); + f( std::unique_ptr< int >( new int( 7 ) ) ); + CHECK_CALLS( 1 ); } } -BOOST_FIXTURE_TEST_CASE(std_unique_ptr_argument_is_supported_in_retrieve_constraint, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( std_unique_ptr_argument_is_supported_in_retrieve_constraint, mock_error_fixture ) { { - MOCK_FUNCTOR(f, void(std::unique_ptr)); - MOCK_EXPECT(f).once().with(nullptr); - f(0); - CHECK_CALLS(1); + MOCK_FUNCTOR( f, void( std::unique_ptr< int > ) ); + MOCK_EXPECT( f ).once().with( nullptr ); + f( 0 ); + CHECK_CALLS( 1 ); } { - std::unique_ptr i; - MOCK_FUNCTOR(f, void(std::unique_ptr)); - MOCK_EXPECT(f).once().with(mock::retrieve(i)); - std::unique_ptr j(new int(7)); - f(std::move(j)); - BOOST_CHECK(!j); - BOOST_REQUIRE(i); - BOOST_CHECK_EQUAL(7, *i); - CHECK_CALLS(1); + std::unique_ptr< int > i; + MOCK_FUNCTOR( f, void( std::unique_ptr< int > ) ); + MOCK_EXPECT( f ).once().with( mock::retrieve( i ) ); + std::unique_ptr< int > j( new int( 7 ) ); + f( std::move( j ) ); + BOOST_CHECK( !j ); + BOOST_REQUIRE( i ); + BOOST_CHECK_EQUAL( 7, *i ); + CHECK_CALLS( 1 ); } { - std::unique_ptr i; - MOCK_FUNCTOR(f, void(std::unique_ptr, std::unique_ptr, std::unique_ptr)); - MOCK_EXPECT(f).once().with(nullptr, nullptr, nullptr); - MOCK_EXPECT(f).once().with(nullptr, mock::retrieve(i), nullptr); - f(nullptr, nullptr, nullptr); - std::unique_ptr j(new int(7)); - f(nullptr, std::move(j), nullptr); - BOOST_CHECK(!j); - BOOST_REQUIRE(i); - BOOST_CHECK_EQUAL(7, *i); - CHECK_CALLS(2); + std::unique_ptr< int > i; + MOCK_FUNCTOR( f, void( std::unique_ptr< int > ) ); + MOCK_EXPECT( f ).once().with( nullptr ); + MOCK_EXPECT( f ).once().with( mock::retrieve( i ) ); + f( 0 ); + std::unique_ptr< int > j( new int( 7 ) ); + f( std::move( j ) ); + BOOST_CHECK( !j ); + BOOST_REQUIRE( i ); + BOOST_CHECK_EQUAL( 7, *i ); + CHECK_CALLS( 2 ); } } struct my_unique_ptr_class { - MOCK_CONSTRUCTOR(my_unique_ptr_class, 1, (std::unique_ptr), constructor) - MOCK_METHOD(m, 1, void(std::unique_ptr), m) - MOCK_STATIC_METHOD(ms, 1, void(std::unique_ptr), ms) + MOCK_CONSTRUCTOR( my_unique_ptr_class, 1, ( std::unique_ptr< int > ), constructor ) + MOCK_METHOD_EXT( m, 1, void( std::unique_ptr< int > ), m ) + MOCK_STATIC_METHOD( ms, 1, void( std::unique_ptr< int > ), ms ) }; -BOOST_FIXTURE_TEST_CASE(unique_ptr_works_in_class, mock_error_fixture) -{ - MOCK_EXPECT(my_unique_ptr_class::constructor).once().with(nullptr); - MOCK_EXPECT(my_unique_ptr_class::ms).once().with(7); - my_unique_ptr_class instance(nullptr); - auto j = std::make_unique(7); - my_unique_ptr_class::ms(std::move(j)); - BOOST_TEST(!j); // Otherwise it wasn't a value parameter and we leak memory - MOCK_EXPECT(instance.ms).once().with(42); - j = std::make_unique(42); - instance.ms(std::move(j)); - BOOST_TEST(!j); // Same here - - BOOST_TEST(mock::verify()); - CHECK_CALLS(3); -} +#endif diff --git a/test/test_log.cpp b/test/test_log.cpp index 94db5c4..4915534 100644 --- a/test/test_log.cpp +++ b/test/test_log.cpp @@ -7,635 +7,678 @@ // http://www.boost.org/LICENSE_1_0.txt) #include +#include #include -#include -#include +#include #include +#include +#include #ifdef BOOST_MSVC -# pragma warning(push, 0) +#pragma warning( push, 0 ) #endif -#include #include +#include #ifdef BOOST_MSVC -# pragma warning(pop) +#pragma warning( pop ) #endif #ifndef BOOST_MSVC // this produces an ICE with all versions of MSVC -# include -# include +#include +#include #endif -#include +#include +#include #include -#include #include #include -#include #include -#include -// Convention: -// "Serializable: Implements operator<<(std::ostream&, ...) -// "Streamable": Implements operator<<(mock::stream&, ...) -// "Mock Streamable": Implements operator<<(stream&, ...) in namespace mock - -namespace { -template -std::string to_string(const T& t) +namespace { - std::ostringstream s; - s << mock::format(t); - return s.str(); + template< typename T > + std::string to_string( const T& t ) + { + std::stringstream s; + s << mock::format( t ); + return s.str(); + } + template< typename T > + std::string to_string( T* t ) + { + std::stringstream s; + s << mock::format( t ); + return s.str(); + } } -template -std::string to_string(T* t) -{ - std::ostringstream s; - s << mock::format(t); - return s.str(); -} -} // namespace -BOOST_AUTO_TEST_CASE(pointer_yields_its_value_when_serialized) +BOOST_AUTO_TEST_CASE( pointer_yields_its_value_when_serialized ) { { int i = 0; - std::ostringstream s; - s << &i; - const std::string pointerValue = s.str(); - BOOST_CHECK_EQUAL(pointerValue, to_string(&i)); + BOOST_CHECK_NE( "?", to_string( &i ) ); + BOOST_CHECK_EQUAL( boost::lexical_cast< std::string >( &i ), to_string( &i ) ); } { const int i = 0; - std::ostringstream s; - s << &i; - const std::string pointerValue = s.str(); - BOOST_CHECK_EQUAL(pointerValue, to_string(&i)); + BOOST_CHECK_NE( "?", to_string( &i ) ); + BOOST_CHECK_EQUAL( boost::lexical_cast< std::string >( &i ), to_string( &i ) ); } } -BOOST_AUTO_TEST_CASE(base_type_yields_its_value_when_serialized) +BOOST_AUTO_TEST_CASE( base_type_yields_its_value_when_serialized ) { - BOOST_CHECK_EQUAL("42", to_string(42)); + BOOST_CHECK_EQUAL( "42", to_string( 42 ) ); } -BOOST_AUTO_TEST_CASE(booleans_are_serialized_as_bool_alpha) +BOOST_AUTO_TEST_CASE( booleans_are_serialized_as_bool_alpha ) { - BOOST_CHECK_EQUAL("true", to_string(true)); - BOOST_CHECK_EQUAL("false", to_string(false)); + BOOST_CHECK_EQUAL( "true", to_string( true ) ); + BOOST_CHECK_EQUAL( "false", to_string( false ) ); } -BOOST_AUTO_TEST_CASE(strings_are_serialized_with_double_quotes) +BOOST_AUTO_TEST_CASE( strings_are_serialized_with_double_quotes ) { - BOOST_CHECK_EQUAL("\"string\"", to_string("string")); - BOOST_CHECK_EQUAL("\"string\"", to_string(std::string("string"))); + BOOST_CHECK_EQUAL( "\"string\"", to_string( "string" ) ); + BOOST_CHECK_EQUAL( "\"string\"", to_string( std::string( "string" ) ) ); } -BOOST_AUTO_TEST_CASE(null_c_strings_are_serialized_to_nullptr) +namespace { - const char* const null_str = nullptr; - BOOST_CHECK_EQUAL("nullptr", to_string(null_str)); - BOOST_CHECK_EQUAL("\"nullptr\"", to_string("nullptr")); + struct non_serializable + {}; } -namespace { -struct non_serializable -{}; -} // namespace - -BOOST_AUTO_TEST_CASE(non_serializable_type_yields_a_question_mark_when_serialized) +BOOST_AUTO_TEST_CASE( non_serializable_type_yields_a_question_mark_when_serialized ) { - BOOST_CHECK_EQUAL("?", to_string(non_serializable())); + BOOST_CHECK_EQUAL( "?", to_string( non_serializable() ) ); } -namespace { -struct serializable -{}; -std::ostream& operator<<(std::ostream& s, const serializable&) +namespace { - return s << "serializable"; -} -} // namespace - -BOOST_AUTO_TEST_CASE(serializable_type_yields_its_value_when_serialized) -{ - BOOST_CHECK_EQUAL("serializable", to_string(serializable())); + struct serializable + {}; + std::ostream& operator<<( std::ostream& s, const serializable& ) + { + return s << "serializable"; + } } -namespace { -struct streamable -{}; -BOOST_ATTRIBUTE_UNUSED std::ostream& operator<<(std::ostream& s, const streamable&) +BOOST_AUTO_TEST_CASE( serializable_type_yields_its_value_when_serialized ) { - BOOST_FAIL("should not have been called"); - return s; -} -mock::stream& operator<<(mock::stream& s, const streamable&) -{ - return s << "streamable"; -} -} // namespace - -BOOST_AUTO_TEST_CASE(streamable_type_yields_its_value_when_serialized) -{ - BOOST_CHECK_EQUAL("streamable", to_string(streamable())); + BOOST_CHECK_EQUAL( "serializable", to_string( serializable() ) ); } -namespace { -struct mock_streamable -{}; -BOOST_ATTRIBUTE_UNUSED std::ostream& operator<<(std::ostream& s, const mock_streamable&) +namespace { - BOOST_FAIL("should not have been called"); - return s; -} -} // namespace -namespace mock { -stream& operator<<(stream& s, const mock_streamable&) -{ - return s << "mock_streamable"; -} -} // namespace mock - -BOOST_AUTO_TEST_CASE(mock_streamable_type_yields_its_value_when_serialized) -{ - BOOST_CHECK_EQUAL("mock_streamable", to_string(mock_streamable())); + struct streamable + {}; + std::ostream& operator<<( std::ostream& s, const streamable& ) + { + BOOST_FAIL( "should not have been called" ); + return s; + } + mock::stream& operator<<( mock::stream& s, const streamable& ) + { + return s << "streamable"; + } } -namespace { -struct derived_from_serializable : serializable -{}; -} // namespace +BOOST_AUTO_TEST_CASE( streamable_type_yields_its_value_when_serialized ) +{ + BOOST_CHECK_EQUAL( "streamable", to_string( streamable() ) ); +} -BOOST_AUTO_TEST_CASE(type_derived_from_serializable_yields_a_question_mark_when_serialized) +namespace +{ + struct mock_streamable + {}; + std::ostream& operator<<( std::ostream& s, const mock_streamable& ) + { + BOOST_FAIL( "should not have been called" ); + return s; + } +} +namespace mock +{ + stream& operator<<( stream& s, const mock_streamable& ) + { + return s << "mock_streamable"; + } +} // mock + +BOOST_AUTO_TEST_CASE( mock_streamable_type_yields_its_value_when_serialized ) +{ + BOOST_CHECK_EQUAL( "mock_streamable", to_string( mock_streamable() ) ); +} + +namespace +{ + struct derived_from_serializable : serializable + {}; +} + +BOOST_AUTO_TEST_CASE( type_derived_from_serializable_yields_a_question_mark_when_serialized ) { #ifdef MOCK_USE_CONVERSIONS - BOOST_CHECK_EQUAL("serializable", to_string(derived_from_serializable())); + BOOST_CHECK_EQUAL( "serializable", to_string( derived_from_serializable() ) ); #else - BOOST_CHECK_EQUAL("?", to_string(derived_from_serializable())); + BOOST_CHECK_EQUAL( "?", to_string( derived_from_serializable() ) ); #endif } -namespace { -struct derived_from_streamable : streamable -{}; -} // namespace +namespace +{ + struct derived_from_streamable : streamable + {}; +} -BOOST_AUTO_TEST_CASE(type_derived_from_streamable_yields_a_question_mark_when_serialized) +BOOST_AUTO_TEST_CASE( type_derived_from_streamable_yields_a_question_mark_when_serialized ) { #ifdef MOCK_USE_CONVERSIONS - BOOST_CHECK_EQUAL("streamable", to_string(derived_from_streamable())); + BOOST_CHECK_EQUAL( "streamable", to_string( derived_from_streamable() ) ); #else - BOOST_CHECK_EQUAL("?", to_string(derived_from_streamable())); + BOOST_CHECK_EQUAL( "?", to_string( derived_from_streamable() ) ); #endif } -namespace { -// Class which can be converted to many other types making implicit conversions ambiguous -struct ambiguous_convertible -{ - operator float() const; - operator int() const; - operator serializable() const; - operator streamable() const; - template - operator T() const; -}; -} // namespace +#ifndef MOCK_USE_CONVERSIONS // all this does not compile with conversions activated, which is precisely the purpose of having this compilation flag -#ifndef MOCK_USE_CONVERSIONS // all this does not compile with conversions activated, which is precisely the purpose of - // having this compilation flag - -namespace { -struct convertible_to_base +namespace { - operator int() const; -}; -} // namespace - -BOOST_AUTO_TEST_CASE(type_convertible_to_base_yields_a_question_mark_when_serialized) -{ - BOOST_CHECK_EQUAL("?", to_string(convertible_to_base())); + struct convertible_to_base + { + operator int() const; + }; } -namespace { -struct convertible_to_serializable +BOOST_AUTO_TEST_CASE( type_convertible_to_base_yields_a_question_mark_when_serialized ) { - operator serializable() const; -}; -} // namespace - -BOOST_AUTO_TEST_CASE(type_convertible_to_serializable_yields_a_question_mark_when_serialized) -{ - BOOST_CHECK_EQUAL("?", to_string(convertible_to_serializable())); + BOOST_CHECK_EQUAL( "?", to_string( convertible_to_base() ) ); } -namespace { -struct convertible_to_streamable +namespace { - operator streamable() const; -}; -} // namespace - -BOOST_AUTO_TEST_CASE(type_convertible_to_streamable_yields_a_question_mark_when_serialized) -{ - BOOST_CHECK_EQUAL("?", to_string(convertible_to_streamable())); + struct convertible_to_serializable + { + operator serializable() const; + }; } -BOOST_AUTO_TEST_CASE(type_ambiguous_convertible_yields_a_question_mark_when_serialized) +BOOST_AUTO_TEST_CASE( type_convertible_to_serializable_yields_a_question_mark_when_serialized ) { - BOOST_CHECK_EQUAL("?", to_string(ambiguous_convertible())); + BOOST_CHECK_EQUAL( "?", to_string( convertible_to_serializable() ) ); } -namespace { -struct ambiguous_convertible_serializable : public ambiguous_convertible -{}; -std::ostream& operator<<(std::ostream& s, const ambiguous_convertible_serializable&) +namespace { - return s << "ambiguous_convertible_serializable"; + struct convertible_to_streamable + { + operator streamable() const; + }; } -} // namespace -BOOST_AUTO_TEST_CASE(type_convertible_serializable_yields_its_value_when_serialized) +BOOST_AUTO_TEST_CASE( type_convertible_to_streamable_yields_a_question_mark_when_serialized ) { - BOOST_CHECK_EQUAL("ambiguous_convertible_serializable", to_string(ambiguous_convertible_serializable())); + BOOST_CHECK_EQUAL( "?", to_string( convertible_to_streamable() ) ); +} + +namespace +{ + struct ambiguous_convertible + { + operator float() const; + operator int() const; + operator serializable() const; + operator streamable() const; + template< typename T > operator T() const; + }; +} + +BOOST_AUTO_TEST_CASE( type_ambiguous_convertible_yields_a_question_mark_when_serialized ) +{ + BOOST_CHECK_EQUAL( "?", to_string( ambiguous_convertible() ) ); +} + +namespace +{ + struct ambiguous_convertible_serializable + { + operator float() const; + operator int() const; + operator serializable() const; + operator streamable() const; + template< typename T > operator T() const; + }; + std::ostream& operator<<( std::ostream& s, const ambiguous_convertible_serializable& ) + { + return s << "ambiguous_convertible_serializable"; + } +} + +BOOST_AUTO_TEST_CASE( type_convertible_serializable_yields_its_value_when_serialized ) +{ + BOOST_CHECK_EQUAL( "ambiguous_convertible_serializable", to_string( ambiguous_convertible_serializable() ) ); } #endif // MOCK_USE_CONVERSIONS -namespace { -struct ambiguous_convertible_streamable : public ambiguous_convertible -{}; -BOOST_ATTRIBUTE_UNUSED std::ostream& operator<<(std::ostream& s, const ambiguous_convertible_streamable&) +namespace { - BOOST_FAIL("should not have been called"); - return s; -} -mock::stream& operator<<(mock::stream& s, const ambiguous_convertible_streamable&) -{ - return s << "ambiguous_convertible_streamable"; -} -} // namespace - -BOOST_AUTO_TEST_CASE(type_ambiguous_convertible_streamable_yields_its_value_when_serialized) -{ - BOOST_CHECK_EQUAL("ambiguous_convertible_streamable", to_string(ambiguous_convertible_streamable())); -} - -namespace { -struct ambiguous_convertible_mock_streamable -{ - operator float() const; - operator int() const; - operator serializable() const; - operator streamable() const; - template - operator T() const; -}; -BOOST_ATTRIBUTE_UNUSED std::ostream& operator<<(std::ostream& s, const ambiguous_convertible_mock_streamable&) -{ - BOOST_FAIL("should not have been called"); - return s; -} -} // namespace -namespace mock { -stream& operator<<(stream& s, const ambiguous_convertible_mock_streamable&) -{ - return s << "ambiguous_convertible_mock_streamable"; -} -} // namespace mock - -BOOST_AUTO_TEST_CASE(type_ambiguous_convertible_mock_streamable_yields_its_value_when_serialized) -{ - BOOST_CHECK_EQUAL("ambiguous_convertible_mock_streamable", to_string(ambiguous_convertible_mock_streamable())); -} - -namespace { -template -struct template_serializable -{}; -template -std::ostream& operator<<(std::ostream& s, const template_serializable&) -{ - return s << "template_serializable"; -} -} // namespace - -BOOST_AUTO_TEST_CASE(template_type_serializable_yields_its_value_when_serialized) -{ - BOOST_CHECK_EQUAL("template_serializable", to_string(template_serializable())); -} - -namespace { -template -struct template_streamable -{}; -template -std::ostream& operator<<(std::ostream& s, const template_streamable&) -{ - BOOST_FAIL("should not have been called"); - return s; -} -template -mock::stream& operator<<(mock::stream& s, const template_streamable&) -{ - return s << "template_streamable"; -} -} // namespace - -BOOST_AUTO_TEST_CASE(template_template_streamable_yields_its_value_when_serialized) -{ - BOOST_CHECK_EQUAL("template_streamable", to_string(template_streamable())); -} - -namespace { -template -struct template_mock_streamable -{}; -template -std::ostream& operator<<(std::ostream& s, const template_mock_streamable&) -{ - BOOST_FAIL("should not have been called"); - return s; -} -} // namespace -namespace mock { -template -stream& operator<<(stream& s, const template_mock_streamable&) -{ - return s << "template_mock_streamable"; -} -} // namespace mock - -BOOST_AUTO_TEST_CASE(template_mock_streamable_yields_its_value_when_serialized) -{ - BOOST_CHECK_EQUAL("template_mock_streamable", to_string(template_mock_streamable())); -} - -BOOST_AUTO_TEST_CASE(std_pairs_are_serialized) -{ - BOOST_CHECK_EQUAL("(3,42)", to_string(std::make_pair(3, 42.f))); -} - -BOOST_AUTO_TEST_CASE(boost_shared_ptr_are_serialized) -{ - BOOST_CHECK_NE("?", to_string(boost::shared_ptr())); - BOOST_CHECK_NE("?", to_string(boost::shared_ptr(new int(42)))); -} - -BOOST_AUTO_TEST_CASE(boost_weak_ptr_are_serialized) -{ - BOOST_CHECK_NE("?", to_string(boost::weak_ptr(boost::shared_ptr()))); - BOOST_CHECK_NE("?", to_string(boost::weak_ptr(boost::shared_ptr(new int(42))))); -} - -BOOST_AUTO_TEST_CASE(std_shared_ptr_are_serialized) -{ - BOOST_CHECK_NE("?", to_string(std::shared_ptr())); - BOOST_CHECK_NE("?", to_string(std::shared_ptr(new int(42)))); -} - -BOOST_AUTO_TEST_CASE(std_weak_ptr_are_serialized) -{ - BOOST_CHECK_NE("?", to_string(std::weak_ptr(std::shared_ptr()))); - BOOST_CHECK_NE("?", to_string(std::weak_ptr(std::shared_ptr(new int(42))))); -} - -BOOST_AUTO_TEST_CASE(std_unique_ptr_are_serialized) -{ - BOOST_CHECK_NE("?", to_string(std::unique_ptr())); - BOOST_CHECK_NE("?", to_string(std::unique_ptr(new int(42)))); -} - -BOOST_AUTO_TEST_CASE(std_deques_are_serialized) -{ - std::deque d; - d.push_back(12); - d.push_back(42); - BOOST_CHECK_EQUAL("(12,42)", to_string(d)); -} - -BOOST_AUTO_TEST_CASE(std_lists_are_serialized) -{ - std::list l; - l.push_back(12); - l.push_back(42); - BOOST_CHECK_EQUAL("(12,42)", to_string(l)); -} - -BOOST_AUTO_TEST_CASE(std_vectors_are_serialized) -{ - std::vector v; - v.push_back(12); - v.push_back(42); - BOOST_CHECK_EQUAL("(12,42)", to_string(v)); -} - -BOOST_AUTO_TEST_CASE(std_maps_are_serialized) -{ - std::map m; - m[12] = "15"; - m[42] = "46"; - BOOST_CHECK_EQUAL("((12,\"15\"),(42,\"46\"))", to_string(m)); -} - -BOOST_AUTO_TEST_CASE(std_multimaps_are_serialized) -{ - std::multimap m; - m.insert(std::make_pair(12, "15")); - m.insert(std::make_pair(42, "46")); - BOOST_CHECK_EQUAL("((12,\"15\"),(42,\"46\"))", to_string(m)); -} - -BOOST_AUTO_TEST_CASE(std_sets_are_serialized) -{ - std::set s; - s.insert(12); - s.insert(42); - BOOST_CHECK_EQUAL("(12,42)", to_string(s)); -} - -BOOST_AUTO_TEST_CASE(std_multisets_are_serialized) -{ - std::multiset s; - s.insert(12); - s.insert(42); - BOOST_CHECK_EQUAL("(12,42)", to_string(s)); -} - -BOOST_AUTO_TEST_CASE(std_deques_of_vectors_are_serialized) -{ - std::deque> v; - std::vector v1, v2; - v1.push_back(12); - v2.push_back(42); - v2.push_back(77); - v.push_back(v1); - v.push_back(v2); - BOOST_CHECK_EQUAL("((12),(42,77))", to_string(v)); -} - -BOOST_AUTO_TEST_CASE(std_vectors_of_deques_are_serialized) -{ - std::vector> v; - std::deque v1, v2; - v1.push_back(12); - v2.push_back(42); - v2.push_back(77); - v.push_back(v1); - v.push_back(v2); - BOOST_CHECK_EQUAL("((12),(42,77))", to_string(v)); -} - -BOOST_AUTO_TEST_CASE(boost_assign_list_of_are_serialized) -{ - BOOST_CHECK_EQUAL("(12,42)", to_string(boost::assign::list_of(12)(42))); -} - -BOOST_AUTO_TEST_CASE(boost_assign_map_list_of_are_serialized) -{ - BOOST_CHECK_EQUAL("((12,\"16\"),(42,\"43\"))", to_string(boost::assign::map_list_of(12, "16")(42, "43"))); -} - -BOOST_AUTO_TEST_CASE(std_reference_wrappers_are_serialized) -{ - const int i = 3; - BOOST_CHECK_EQUAL("3", to_string(std::cref(i))); - BOOST_CHECK_EQUAL("\"string\"", to_string(std::cref("string"))); -} - -namespace { -void callable_builtin() {} -} // namespace - -BOOST_AUTO_TEST_CASE(callable_builtin_yields_a_question_mark_when_serialized) -{ - BOOST_CHECK_EQUAL("?", to_string(callable_builtin)); - BOOST_CHECK_EQUAL("?", to_string(&callable_builtin)); -} - -namespace { -struct serialized_using_format -{}; -std::ostream& operator<<(std::ostream& s, const serialized_using_format&) -{ - return s << mock::format("string"); -} -} // namespace - -BOOST_AUTO_TEST_CASE(type_can_use_format_when_serialized) -{ - BOOST_CHECK_EQUAL("\"string\"", to_string(serialized_using_format())); -} - -namespace { -struct streamed_using_format -{}; -mock::stream& operator<<(mock::stream& s, const streamed_using_format&) -{ - return s << mock::format("string"); -} -} // namespace - -BOOST_AUTO_TEST_CASE(type_can_use_format_when_streamed) -{ - BOOST_CHECK_EQUAL("\"string\"", to_string(streamed_using_format())); -} - -namespace { -struct std_string_streamed -{}; -mock::stream& operator<<(mock::stream& s, const std_string_streamed&) -{ - return s << std::string("string"); -} -} // namespace - -BOOST_AUTO_TEST_CASE(std_string_streamed_is_not_a_container) -{ - BOOST_CHECK_EQUAL("string", to_string(std_string_streamed())); -} - -namespace mock { namespace detail { - template - struct template_serializable - {}; - template - std::ostream& operator<<(std::ostream& s, const template_serializable&) + struct ambiguous_convertible_streamable { - return s << "mock::detail::template_serializable"; - } -}} // namespace mock::detail - -BOOST_AUTO_TEST_CASE(mock_detail_template_type_serializable_yields_its_value_when_serialized) -{ - BOOST_CHECK_EQUAL("mock::detail::template_serializable", to_string(mock::detail::template_serializable())); -} - -namespace mock { namespace detail { - template - struct template_streamable - {}; - template - std::ostream& operator<<(std::ostream& s, const template_streamable&) + operator float() const; + operator int() const; + operator serializable() const; + operator streamable() const; + template< typename T > operator T() const; + }; + std::ostream& operator<<( std::ostream& s, const ambiguous_convertible_streamable& ) { - BOOST_FAIL("should not have been called"); + BOOST_FAIL( "should not have been called" ); return s; } - template - mock::stream& operator<<(mock::stream& s, const template_streamable&) + mock::stream& operator<<( mock::stream& s, const ambiguous_convertible_streamable& ) { - return s << "mock::detail::template_streamable"; + return s << "ambiguous_convertible_streamable"; } -}} // namespace mock::detail - -BOOST_AUTO_TEST_CASE(mock_detail_template_template_streamable_yields_its_value_when_serialized) -{ - BOOST_CHECK_EQUAL("mock::detail::template_streamable", to_string(mock::detail::template_streamable())); } -BOOST_AUTO_TEST_CASE(unsigned_char_is_serialized_as_int) +BOOST_AUTO_TEST_CASE( type_ambiguous_convertible_streamable_yields_its_value_when_serialized ) { - BOOST_CHECK_EQUAL(std::to_string(static_cast('a')), to_string('a')); + BOOST_CHECK_EQUAL( "ambiguous_convertible_streamable", to_string( ambiguous_convertible_streamable() ) ); } -namespace { -bool some_function() +namespace { - return false; + struct ambiguous_convertible_mock_streamable + { + operator float() const; + operator int() const; + operator serializable() const; + operator streamable() const; + template< typename T > operator T() const; + }; + std::ostream& operator<<( std::ostream& s, const ambiguous_convertible_mock_streamable& ) + { + BOOST_FAIL( "should not have been called" ); + return s; + } } -} // namespace - -BOOST_AUTO_TEST_CASE(boost_phoenix_functor_yields_question_mark_when_serialized) +namespace mock { - BOOST_CHECK_EQUAL("?", to_string(boost::phoenix::bind(&some_function))); - BOOST_CHECK_EQUAL("?", to_string(boost::phoenix::arg_names::_1 < 42)); + stream& operator<<( stream& s, const ambiguous_convertible_mock_streamable& ) + { + return s << "ambiguous_convertible_mock_streamable"; + } +} // mock + +BOOST_AUTO_TEST_CASE( type_ambiguous_convertible_mock_streamable_yields_its_value_when_serialized ) +{ + BOOST_CHECK_EQUAL( "ambiguous_convertible_mock_streamable", to_string( ambiguous_convertible_mock_streamable() ) ); } -BOOST_AUTO_TEST_CASE(bind_functor_yields_question_mark_when_serialized) +namespace { - BOOST_CHECK_EQUAL("?", to_string(boost::bind(&some_function))); - BOOST_CHECK_EQUAL("?", to_string(std::bind(&some_function))); + template< typename T > + struct template_serializable + {}; + template< typename T > + std::ostream& operator<<( std::ostream& s, const template_serializable< T >& ) + { + return s << "template_serializable"; + } } -#ifndef BOOST_MSVC // this produces an ICE with all versions of MSVC - -BOOST_AUTO_TEST_CASE(boost_lambda_functor_yields_question_mark_when_serialized) +BOOST_AUTO_TEST_CASE( template_type_serializable_yields_its_value_when_serialized ) { - BOOST_CHECK_EQUAL("?", to_string(boost::lambda::bind(&some_function))); - BOOST_CHECK_EQUAL("?", to_string(boost::lambda::_1 < 42)); + BOOST_CHECK_EQUAL( "template_serializable", to_string( template_serializable< int >() ) ); +} + +namespace +{ + template< typename T > + struct template_streamable + {}; + template< typename T > + std::ostream& operator<<( std::ostream& s, const template_streamable< T >& ) + { + BOOST_FAIL( "should not have been called" ); + return s; + } + template< typename T > + mock::stream& operator<<( mock::stream& s, const template_streamable< T >& ) + { + return s << "template_streamable"; + } +} + +BOOST_AUTO_TEST_CASE( template_template_streamable_yields_its_value_when_serialized ) +{ + BOOST_CHECK_EQUAL( "template_streamable", to_string( template_streamable< int >() ) ); +} + +namespace +{ + template< typename T > + struct template_mock_streamable + {}; + template< typename T > + std::ostream& operator<<( std::ostream& s, const template_mock_streamable< T >& ) + { + BOOST_FAIL( "should not have been called" ); + return s; + } +} +namespace mock +{ + template< typename T > + stream& operator<<( stream& s, const template_mock_streamable< T >& ) + { + return s << "template_mock_streamable"; + } +} // mock + +BOOST_AUTO_TEST_CASE( template_mock_streamable_yields_its_value_when_serialized ) +{ + BOOST_CHECK_EQUAL( "template_mock_streamable", to_string( template_mock_streamable< int >() ) ); +} + +BOOST_AUTO_TEST_CASE( std_pairs_are_serialized ) +{ + BOOST_CHECK_EQUAL( "(3,42)", to_string( std::make_pair( 3, 42.f ) ) ); +} + +#ifdef MOCK_AUTO_PTR + +BOOST_AUTO_TEST_CASE( std_auto_ptr_are_serialized ) +{ + BOOST_CHECK_NE( "?", to_string( std::auto_ptr< int >() ) ); + BOOST_CHECK_NE( "?", to_string( std::auto_ptr< int >( new int( 42 ) ) ) ); +} + +#endif // MOCK_AUTO_PTR + +BOOST_AUTO_TEST_CASE( boost_shared_ptr_are_serialized ) +{ + BOOST_CHECK_NE( "?", to_string( boost::shared_ptr< int >() ) ); + BOOST_CHECK_NE( "?", to_string( boost::shared_ptr< int >( new int( 42 ) ) ) ); +} + +BOOST_AUTO_TEST_CASE( boost_weak_ptr_are_serialized ) +{ + BOOST_CHECK_NE( "?", to_string( boost::weak_ptr< int >( boost::shared_ptr< int >() ) ) ); + BOOST_CHECK_NE( "?", to_string( boost::weak_ptr< int >( boost::shared_ptr< int >( new int( 42 ) ) ) ) ); +} + +#ifdef MOCK_SMART_PTR + +BOOST_AUTO_TEST_CASE( std_shared_ptr_are_serialized ) +{ + BOOST_CHECK_NE( "?", to_string( std::shared_ptr< int >() ) ); + BOOST_CHECK_NE( "?", to_string( std::shared_ptr< int >( new int( 42 ) ) ) ); +} + +BOOST_AUTO_TEST_CASE( std_weak_ptr_are_serialized ) +{ + BOOST_CHECK_NE( "?", to_string( std::weak_ptr< int >( std::shared_ptr< int >() ) ) ); + BOOST_CHECK_NE( "?", to_string( std::weak_ptr< int >( std::shared_ptr< int >( new int( 42 ) ) ) ) ); +} + +BOOST_AUTO_TEST_CASE( std_unique_ptr_are_serialized ) +{ + BOOST_CHECK_NE( "?", to_string( std::unique_ptr< int >() ) ); + BOOST_CHECK_NE( "?", to_string( std::unique_ptr< int >( new int( 42 ) ) ) ); } #endif -BOOST_AUTO_TEST_CASE(nullptr_is_serialized) +BOOST_AUTO_TEST_CASE( std_deques_are_serialized ) { - BOOST_CHECK_EQUAL("nullptr", to_string(nullptr)); + std::deque< int > d; + d.push_back( 12 ); + d.push_back( 42 ); + BOOST_CHECK_EQUAL( "(12,42)", to_string( d ) ); } -BOOST_AUTO_TEST_CASE(mock_boost_optional_yields_its_value_when_serialized) +BOOST_AUTO_TEST_CASE( std_lists_are_serialized ) { - BOOST_CHECK_EQUAL("7", to_string(boost::optional(7))); - BOOST_CHECK_EQUAL("?", to_string(boost::optional(non_serializable()))); - BOOST_CHECK_EQUAL("none", to_string(boost::optional())); - BOOST_CHECK_EQUAL("none", to_string(boost::optional())); - BOOST_CHECK_EQUAL("none", to_string(boost::none)); + std::list< int > l; + l.push_back( 12 ); + l.push_back( 42 ); + BOOST_CHECK_EQUAL( "(12,42)", to_string( l ) ); +} + +BOOST_AUTO_TEST_CASE( std_vectors_are_serialized ) +{ + std::vector< int > v; + v.push_back( 12 ); + v.push_back( 42 ); + BOOST_CHECK_EQUAL( "(12,42)", to_string( v ) ); +} + +BOOST_AUTO_TEST_CASE( std_maps_are_serialized ) +{ + std::map< int, std::string > m; + m[ 12 ] = "12"; + m[ 42 ] = "42"; + BOOST_CHECK_EQUAL( "((12,\"12\"),(42,\"42\"))", to_string( m ) ); +} + +BOOST_AUTO_TEST_CASE( std_multimaps_are_serialized ) +{ + std::multimap< int, std::string > m; + m.insert( std::make_pair( 12, "12" )); + m.insert( std::make_pair( 42, "42" )); + BOOST_CHECK_EQUAL( "((12,\"12\"),(42,\"42\"))", to_string( m ) ); +} + +BOOST_AUTO_TEST_CASE( std_sets_are_serialized ) +{ + std::set< int > s; + s.insert( 12 ); + s.insert( 42 ); + BOOST_CHECK_EQUAL( "(12,42)", to_string( s ) ); +} + +BOOST_AUTO_TEST_CASE( std_multisets_are_serialized ) +{ + std::multiset< int > s; + s.insert( 12 ); + s.insert( 42 ); + BOOST_CHECK_EQUAL( "(12,42)", to_string( s ) ); +} + +BOOST_AUTO_TEST_CASE( std_deques_of_vectors_are_serialized ) +{ + std::deque< std::vector< int > > v; + std::vector< int > v1, v2; + v1.push_back( 12 ); + v2.push_back( 42 ); + v2.push_back( 77 ); + v.push_back( v1 ); + v.push_back( v2 ); + BOOST_CHECK_EQUAL( "((12),(42,77))", to_string( v ) ); +} + +BOOST_AUTO_TEST_CASE( std_vectors_of_deques_are_serialized ) +{ + std::vector< std::deque< int > > v; + std::deque< int > v1, v2; + v1.push_back( 12 ); + v2.push_back( 42 ); + v2.push_back( 77 ); + v.push_back( v1 ); + v.push_back( v2 ); + BOOST_CHECK_EQUAL( "((12),(42,77))", to_string( v ) ); +} + +BOOST_AUTO_TEST_CASE( boost_assign_list_of_are_serialized ) +{ + BOOST_CHECK_EQUAL( "(12,42)", to_string( boost::assign::list_of( 12 )( 42 ) ) ); +} + +BOOST_AUTO_TEST_CASE( boost_assign_map_list_of_are_serialized ) +{ + BOOST_CHECK_EQUAL( "((12,\"12\"),(42,\"42\"))", to_string( boost::assign::map_list_of( 12, "12" )( 42, "42" ) ) ); +} + +BOOST_AUTO_TEST_CASE( boost_reference_wrappers_are_serialized ) +{ + const int i = 3; + BOOST_CHECK_EQUAL( "3", to_string( boost::cref( i ) ) ); + BOOST_CHECK_EQUAL( "\"string\"", to_string( boost::cref( "string" ) ) ); +} + +namespace +{ + void callable_builtin() + {} +} + +BOOST_AUTO_TEST_CASE( callable_builtin_yields_a_question_mark_when_serialized ) +{ + BOOST_CHECK_EQUAL( "?", to_string( callable_builtin ) ); + BOOST_CHECK_EQUAL( "?", to_string( &callable_builtin ) ); +} + +namespace +{ + struct serialized_using_format + {}; + std::ostream& operator<<( std::ostream& s, const serialized_using_format& ) + { + return s << mock::format( "string" ); + } +} + +BOOST_AUTO_TEST_CASE( type_can_use_format_when_serialized ) +{ + BOOST_CHECK_EQUAL( "\"string\"", to_string( serialized_using_format() ) ); +} + +namespace +{ + struct streamed_using_format + {}; + mock::stream& operator<<( mock::stream& s, const streamed_using_format& ) + { + return s << mock::format( "string" ); + } +} + +BOOST_AUTO_TEST_CASE( type_can_use_format_when_streamed ) +{ + BOOST_CHECK_EQUAL( "\"string\"", to_string( streamed_using_format() ) ); +} + +namespace +{ + struct std_string_streamed + {}; + mock::stream& operator<<( mock::stream& s, const std_string_streamed& ) + { + return s << std::string( "string" ); + } +} + +BOOST_AUTO_TEST_CASE( std_string_streamed_is_not_a_container ) +{ + BOOST_CHECK_EQUAL( "string", to_string( std_string_streamed() ) ); +} + +namespace mock +{ +namespace detail +{ + template< typename T > + struct template_serializable + {}; + template< typename T > + std::ostream& operator<<( std::ostream& s, const template_serializable< T >& ) + { + return s << "mock::detail::template_serializable"; + } +} +} // mock + +BOOST_AUTO_TEST_CASE( mock_detail_template_type_serializable_yields_its_value_when_serialized ) +{ + BOOST_CHECK_EQUAL( "mock::detail::template_serializable", to_string( mock::detail::template_serializable< int >() ) ); +} + +namespace mock +{ +namespace detail +{ + template< typename T > + struct template_streamable + {}; + template< typename T > + std::ostream& operator<<( std::ostream& s, const template_streamable< T >& ) + { + BOOST_FAIL( "should not have been called" ); + return s; + } + template< typename T > + mock::stream& operator<<( mock::stream& s, const template_streamable< T >& ) + { + return s << "mock::detail::template_streamable"; + } +} +} // mock + +BOOST_AUTO_TEST_CASE( mock_detail_template_template_streamable_yields_its_value_when_serialized ) +{ + BOOST_CHECK_EQUAL( "mock::detail::template_streamable", to_string( mock::detail::template_streamable< int >() ) ); +} + +BOOST_AUTO_TEST_CASE( unsigned_char_is_serialized_as_int ) +{ + BOOST_CHECK_EQUAL( boost::lexical_cast< std::string >( static_cast< int >( 'a' ) ), to_string< unsigned char >( 'a' ) ); +} + +namespace +{ + bool some_function() + { + return false; + } +} + +BOOST_AUTO_TEST_CASE( boost_phoenix_functor_yields_question_mark_when_serialized ) +{ + BOOST_CHECK_EQUAL( "?", to_string( boost::phoenix::bind( &some_function ) ) ); + BOOST_CHECK_EQUAL( "?", to_string( boost::phoenix::arg_names::_1 < 42 ) ); +} + +BOOST_AUTO_TEST_CASE( boost_bind_functor_yields_question_mark_when_serialized ) +{ + BOOST_CHECK_EQUAL( "?", to_string( boost::bind( &some_function ) ) ); +} + +#ifndef BOOST_MSVC // this produces an ICE with all versions of MSVC + +BOOST_AUTO_TEST_CASE( boost_lambda_functor_yields_question_mark_when_serialized ) +{ + BOOST_CHECK_EQUAL( "?", to_string( boost::lambda::bind( &some_function ) ) ); + BOOST_CHECK_EQUAL( "?", to_string( boost::lambda::_1 < 42 ) ); +} + +#endif + +#ifdef MOCK_NULLPTR + +BOOST_AUTO_TEST_CASE( nullptr_is_serialized ) +{ + BOOST_CHECK_EQUAL( "nullptr", to_string( nullptr ) ); +} + +#endif + +BOOST_AUTO_TEST_CASE( mock_boost_optional_yields_its_value_when_serialized ) +{ + BOOST_CHECK_EQUAL( "7", to_string( boost::optional< int >( 7 ) ) ); + BOOST_CHECK_EQUAL( "?", to_string( boost::optional< non_serializable >( non_serializable() ) ) ); + BOOST_CHECK_EQUAL( "none", to_string( boost::optional< int >() ) ); + BOOST_CHECK_EQUAL( "none", to_string( boost::optional< non_serializable >() ) ); + BOOST_CHECK_EQUAL( "none", to_string( boost::none ) ); } diff --git a/test/test_matcher.cpp b/test/test_matcher.cpp index 5a53cb3..c28648e 100644 --- a/test/test_matcher.cpp +++ b/test/test_matcher.cpp @@ -6,164 +6,73 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) -#include -#include -#include -#include -#include +#include +#include -namespace { -template -bool match(Expected expected, Actual actual) +namespace { - return mock::matcher(expected)(actual); -} -} // namespace - -BOOST_AUTO_TEST_CASE(int_and_int_can_be_compared) -{ - BOOST_CHECK(match(3, 3)); - BOOST_CHECK(!match(3, 4)); - BOOST_CHECK(!match(4, 3)); + template< typename Expected, typename Actual > + bool match( Expected expected, Actual actual ) + { + return mock::matcher< Actual, Expected >( expected )( actual ); + } } -BOOST_AUTO_TEST_CASE(ref_to_int_and_int_can_be_compared) +BOOST_AUTO_TEST_CASE( int_and_int_can_be_compared ) +{ + BOOST_CHECK( match( 3, 3 ) ); + BOOST_CHECK( ! match( 3, 4 ) ); + BOOST_CHECK( ! match( 4, 3 ) ); +} + +BOOST_AUTO_TEST_CASE( ref_to_int_and_int_can_be_compared ) { const int i = 3; - BOOST_CHECK(match(3, std::cref(i))); - BOOST_CHECK(!match(4, std::cref(i))); + BOOST_CHECK( match( 3, boost::cref( i ) ) ); + BOOST_CHECK( ! match( 4, boost::cref( i ) ) ); } -namespace { -struct fixture +namespace { - fixture() : text("same text") + struct fixture { - // Get a pointer to unique memory containing "same text" - actual = text.c_str(); - } - const char* actual; + fixture() + : text( "same text" ) + , actual( text.c_str() ) + { + const char* static_string = "same text"; + BOOST_REQUIRE( actual != static_string ); + BOOST_REQUIRE( actual == std::string( static_string ) ); + } + std::string text; + const char* actual; + }; +} -private: - std::string text; -}; -} // namespace - -BOOST_FIXTURE_TEST_CASE(const_char_pointer_and_const_char_pointer_can_be_compared, fixture) +BOOST_FIXTURE_TEST_CASE( const_char_pointer_and_const_char_pointer_can_be_compared, fixture ) { const char* expected = "same text"; - BOOST_REQUIRE(expected != actual); - BOOST_REQUIRE(std::string(expected) == actual); - - BOOST_CHECK(match(expected, actual)); + BOOST_CHECK( match( expected, actual ) ); const char* unexpected = "different text"; - BOOST_CHECK(!match(unexpected, actual)); + BOOST_CHECK( ! match( actual, unexpected ) ); } -BOOST_FIXTURE_TEST_CASE(const_char_pointer_and_string_literal_can_be_compared, fixture) +BOOST_FIXTURE_TEST_CASE( const_char_pointer_and_string_literal_can_be_compared, fixture ) { - BOOST_CHECK(match("same text", actual)); - BOOST_CHECK(!match("different text", actual)); + BOOST_CHECK( match( "same text", actual ) ); + BOOST_CHECK( ! match( "different text", actual ) ); } -BOOST_FIXTURE_TEST_CASE(const_char_pointer_and_const_char_array_can_be_compared, fixture) +BOOST_FIXTURE_TEST_CASE( const_char_pointer_and_const_char_array_can_be_compared, fixture ) { - const char expected[] = "same text"; - BOOST_REQUIRE(expected != actual); - BOOST_CHECK(match(expected, actual)); - const char unexpected[] = "different text"; - BOOST_CHECK(!match(unexpected, actual)); + const char expected[10] = "same text"; + BOOST_CHECK( match( expected, actual ) ); + const char unexpected[15] = "different text"; + BOOST_CHECK( ! match( unexpected, actual ) ); } -BOOST_FIXTURE_TEST_CASE(const_char_pointer_and_std_string_can_be_compared, fixture) +BOOST_FIXTURE_TEST_CASE( const_char_pointer_and_std_string_can_be_compared, fixture ) { - BOOST_CHECK(match(std::string("same text"), actual)); - BOOST_CHECK(match(actual, std::string("same text"))); - BOOST_CHECK(!match(std::string("different text"), actual)); - BOOST_CHECK(!match(actual, std::string("different text"))); -} - -BOOST_AUTO_TEST_CASE(null_const_char_pointers_can_be_compared) -{ - const char* const null_str = nullptr; - BOOST_CHECK(match(null_str, null_str)); - BOOST_CHECK(!match(null_str, "non-null string")); - BOOST_CHECK(!match("non-null string", null_str)); -} - -namespace { -template -std::string serialize(const T& t) -{ - std::ostringstream s; - s << t; - return s.str(); -} -} // namespace - -BOOST_AUTO_TEST_CASE(default_matcher_is_serialized_to_any) -{ - using mock::detail::default_matcher; - BOOST_TEST(serialize(default_matcher<>{}) == ""); - BOOST_TEST(serialize(default_matcher{}) == "any"); - BOOST_TEST(serialize(default_matcher{}) == "any, any"); - BOOST_TEST(serialize(default_matcher{}) == "any, any, any, any, any"); -} - -namespace { -struct custom_constraint -{ - int expected_; - custom_constraint(int expected = 42) : expected_(expected) {} - friend std::ostream& operator<<(std::ostream& s, const custom_constraint& c) - { - return s << "custom" << c.expected_; - } - bool operator()(int actual) { return actual == expected_; } -}; - -bool custom_constraint_func(int) -{ - return false; -} -} // namespace - -BOOST_AUTO_TEST_CASE(single_matcher_serializes) -{ - using mock::detail::single_matcher; - BOOST_TEST(serialize(single_matcher(1)) == "1"); - BOOST_TEST(serialize(single_matcher(1, 2)) == "1, 2"); - BOOST_TEST( - serialize(single_matcher, int, int), int, int, int, int, int>( - 1, 2, custom_constraint(), 4, 5)) == "1, 2, custom42, 4, 5"); -} - -BOOST_AUTO_TEST_CASE(string_matcher_serializes) -{ - using mock::detail::single_matcher; - BOOST_TEST(serialize(single_matcher("foo")) == "\"foo\""); - BOOST_TEST(serialize(single_matcher("foo")) == "\"foo\""); - BOOST_TEST(serialize(single_matcher("foo")) == "\"foo\""); - BOOST_TEST(serialize(single_matcher("foo")) == "\"foo\""); - BOOST_TEST(serialize(single_matcher("foo")) == "\"foo\""); - BOOST_TEST(serialize(single_matcher("foo")) == "\"foo\""); - BOOST_TEST(serialize(single_matcher("foo")) == "\"foo\""); - // Mixed types - BOOST_TEST(serialize(single_matcher("bar", 2)) == "\"bar\", 2"); -} - -BOOST_AUTO_TEST_CASE(functor_matcher_serializes) -{ - using mock::detail::single_matcher; - using Functor = decltype(custom_constraint_func); - BOOST_TEST(serialize(single_matcher(custom_constraint_func)) == "?"); - BOOST_TEST(serialize(single_matcher(custom_constraint_func)) == "?"); - // Mixed types - BOOST_TEST(serialize(single_matcher(custom_constraint_func, 2)) == "?, 2"); -} - -BOOST_AUTO_TEST_CASE(multi_matcher_serializes) -{ - using mock::detail::multi_matcher; - BOOST_TEST(serialize(multi_matcher(custom_constraint(1337))) == "custom1337"); + BOOST_CHECK( match( std::string( "same text" ), actual ) ); + BOOST_CHECK( ! match( std::string( "different text" ), actual ) ); } diff --git a/test/test_max_args.cpp b/test/test_max_args.cpp index a062548..970a25f 100644 --- a/test/test_max_args.cpp +++ b/test/test_max_args.cpp @@ -8,33 +8,32 @@ #include "mock_error.hpp" #include +#include #include -#include -#define IDENTITY(z, n, text) text -// Number of arguments is (now) unlimited, so take any high value here -#define NUM_TEST_ARGS 100 +#define IDENTITY(z, n, d) d -namespace { -struct my_custom_mock +namespace { - MOCK_METHOD(method, NUM_TEST_ARGS, void(BOOST_PP_ENUM(NUM_TEST_ARGS, IDENTITY, int)), tag) - MOCK_METHOD(method2, NUM_TEST_ARGS, int(BOOST_PP_ENUM(NUM_TEST_ARGS, IDENTITY, int)), tag_2) -}; -} // namespace - -BOOST_FIXTURE_TEST_CASE(call_mock_method_with_max_number_of_args, mock_error_fixture) -{ - my_custom_mock m; - MOCK_EXPECT(m.tag).once().with(BOOST_PP_ENUM(NUM_TEST_ARGS, IDENTITY, 0)); - m.method(BOOST_PP_ENUM(NUM_TEST_ARGS, IDENTITY, 0)); - CHECK_CALLS(1); + struct my_custom_mock + { + MOCK_METHOD_EXT( method, MOCK_MAX_ARGS, void( BOOST_PP_ENUM(MOCK_MAX_ARGS, IDENTITY, int) ), tag ) + MOCK_METHOD_EXT( method2, MOCK_MAX_ARGS, int( BOOST_PP_ENUM(MOCK_MAX_ARGS, IDENTITY, int) ), tag_2 ) + }; } -BOOST_FIXTURE_TEST_CASE(call_mock_method_with_max_number_of_args_and_a_return_value, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( call_mock_method_with_max_number_of_args, mock_error_fixture ) { my_custom_mock m; - MOCK_EXPECT(m.tag_2).once().with(BOOST_PP_ENUM(NUM_TEST_ARGS, IDENTITY, 0)).returns(42); - BOOST_CHECK_EQUAL(42, m.method2(BOOST_PP_ENUM(NUM_TEST_ARGS, IDENTITY, 0))); - CHECK_CALLS(1); + MOCK_EXPECT( m.tag ).once().with( BOOST_PP_ENUM(MOCK_MAX_ARGS, IDENTITY, 0) ); + m.method( BOOST_PP_ENUM(MOCK_MAX_ARGS, IDENTITY, 0) ); + CHECK_CALLS( 1 ); +} + +BOOST_FIXTURE_TEST_CASE( call_mock_method_with_max_number_of_args_and_a_return_value, mock_error_fixture ) +{ + my_custom_mock m; + MOCK_EXPECT( m.tag_2 ).once().with( BOOST_PP_ENUM(MOCK_MAX_ARGS, IDENTITY, 0) ).returns( 42 ); + BOOST_CHECK_EQUAL( 42, m.method2( BOOST_PP_ENUM(MOCK_MAX_ARGS, IDENTITY, 0) ) ); + CHECK_CALLS( 1 ); } diff --git a/test/test_mock.cpp b/test/test_mock.cpp index a61c305..3aa7473 100644 --- a/test/test_mock.cpp +++ b/test/test_mock.cpp @@ -8,390 +8,457 @@ #include "mock_error.hpp" #include -#include -#include +#include +#include +#include -namespace { -template -void my_function(T& t) +namespace { - t.my_method("some parameter"); + template< typename T > + void my_function( T& t ) + { + t.my_method( "some parameter" ); + } + MOCK_CLASS( mock_class ) + { + MOCK_METHOD_EXT( my_method, 1, void( const std::string& ), my_tag ) + }; } -MOCK_CLASS(mock_class) -{ - MOCK_METHOD(my_method, 1, void(const std::string&), my_tag) -}; -} // namespace -BOOST_FIXTURE_TEST_CASE(mock_object_for_static_polymorphism, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( mock_object_for_static_polymorphism, mock_error_fixture ) { const mock_class m; - MOCK_EXPECT(m.my_tag).once().with("some parameter"); - my_function(m); - CHECK_CALLS(1); + MOCK_EXPECT( m.my_tag ).once().with( "some parameter" ); + my_function( m ); + CHECK_CALLS( 1 ); } -namespace { -MOCK_CLASS(mock_class_with_operator) +namespace { - MOCK_CONST_METHOD(operator+=, 1, mock_class_with_operator &(int), addition) -}; -} // namespace + MOCK_CLASS( mock_class_with_operator ) + { + MOCK_CONST_METHOD_EXT( operator+=, 1, mock_class_with_operator&( int ), addition ) + }; +} -BOOST_FIXTURE_TEST_CASE(mock_addition_operator, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( mock_addition_operator, mock_error_fixture ) { mock_class_with_operator m; - MOCK_EXPECT(m.addition).once().returns(std::ref(m)); + MOCK_EXPECT( m.addition ).once().returns( boost::ref( m ) ); m += 1; - CHECK_CALLS(1); + CHECK_CALLS( 1 ); } -namespace { -MOCK_CLASS(mock_class_with_conversion_operator) +namespace { - MOCK_CONVERSION_OPERATOR(operator, int, conversion) -}; -} // namespace + MOCK_CLASS( mock_class_with_conversion_operator ) + { + MOCK_CONVERSION_OPERATOR( operator, int, conversion ) + }; +} -BOOST_FIXTURE_TEST_CASE(mock_conversion_operator, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( mock_conversion_operator, mock_error_fixture ) { mock_class_with_conversion_operator m; - MOCK_EXPECT(m.conversion).once().returns(42); - BOOST_CHECK_EQUAL(42, static_cast(m)); - CHECK_CALLS(1); + MOCK_EXPECT( m.conversion ).once().returns( 42 ); + BOOST_CHECK_EQUAL( 42, static_cast< int >( m ) ); + CHECK_CALLS( 1 ); } -namespace { -template -MOCK_CLASS(mock_template_class_with_conversion_operator) +namespace { - MOCK_CONVERSION_OPERATOR(operator, T, conversion) -}; -} // namespace - -BOOST_FIXTURE_TEST_CASE(mock_template_conversion_operator, mock_error_fixture) -{ - mock_template_class_with_conversion_operator m; - MOCK_EXPECT(m.conversion).once().returns(42); - BOOST_CHECK_EQUAL(42, static_cast(m)); - CHECK_CALLS(1); + template< typename T > + MOCK_CLASS( mock_template_class_with_conversion_operator ) + { + MOCK_CONVERSION_OPERATOR_TPL( operator, T, conversion ) + }; } -namespace { -MOCK_CLASS(mock_class_with_const_conversion_operator) +BOOST_FIXTURE_TEST_CASE( mock_template_conversion_operator, mock_error_fixture ) { - MOCK_CONST_CONVERSION_OPERATOR(operator, int, conversion) -}; -} // namespace + mock_template_class_with_conversion_operator< int > m; + MOCK_EXPECT( m.conversion ).once().returns( 42 ); + BOOST_CHECK_EQUAL( 42, static_cast< int >( m ) ); + CHECK_CALLS( 1 ); +} -BOOST_FIXTURE_TEST_CASE(mock_const_conversion_operator, mock_error_fixture) +namespace +{ + MOCK_CLASS( mock_class_with_const_conversion_operator ) + { + MOCK_CONST_CONVERSION_OPERATOR( operator, int, conversion ) + }; +} + +BOOST_FIXTURE_TEST_CASE( mock_const_conversion_operator, mock_error_fixture ) { mock_class_with_const_conversion_operator m; - MOCK_EXPECT(m.conversion).once().returns(42); + MOCK_EXPECT( m.conversion ).once().returns( 42 ); int i = m; - BOOST_CHECK_EQUAL(42, i); - CHECK_CALLS(1); + BOOST_CHECK_EQUAL( 42, i ); + CHECK_CALLS( 1 ); } -namespace { -MOCK_CLASS(mock_class_with_non_const_conversion_operator) +namespace { - MOCK_CONST_CONVERSION_OPERATOR(operator, int, conversion) -}; -} // namespace + MOCK_CLASS( mock_class_with_non_const_conversion_operator ) + { + MOCK_CONST_CONVERSION_OPERATOR( operator, int, conversion ) + }; +} -BOOST_FIXTURE_TEST_CASE(mock_non_const_conversion_operator, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( mock_non_const_conversion_operator, mock_error_fixture ) { mock_class_with_non_const_conversion_operator m; - MOCK_EXPECT(m.conversion).once().returns(42); + MOCK_EXPECT( m.conversion ).once().returns( 42 ); int i = m; - BOOST_CHECK_EQUAL(42, i); - CHECK_CALLS(1); + BOOST_CHECK_EQUAL( 42, i ); + CHECK_CALLS( 1 ); } -namespace { -template -MOCK_CLASS(mock_template_class_with_const_conversion_operator) +namespace { - MOCK_CONST_CONVERSION_OPERATOR(operator, T, conversion) -}; -} // namespace - -BOOST_FIXTURE_TEST_CASE(mock_template_const_conversion_operator, mock_error_fixture) -{ - mock_template_class_with_const_conversion_operator m; - MOCK_EXPECT(m.conversion).once().returns(42); - BOOST_CHECK_EQUAL(42, static_cast(m)); - CHECK_CALLS(1); + template< typename T > + MOCK_CLASS( mock_template_class_with_const_conversion_operator ) + { + MOCK_CONST_CONVERSION_OPERATOR_TPL( operator, T, conversion ) + }; } -namespace { -template -MOCK_CLASS(mock_template_class_with_non_const_conversion_operator) +BOOST_FIXTURE_TEST_CASE( mock_template_const_conversion_operator, mock_error_fixture ) { - MOCK_NON_CONST_CONVERSION_OPERATOR(operator, T, conversion) -}; -} // namespace - -BOOST_FIXTURE_TEST_CASE(mock_template_non_const_conversion_operator, mock_error_fixture) -{ - mock_template_class_with_non_const_conversion_operator m; - MOCK_EXPECT(m.conversion).once().returns(42); - BOOST_CHECK_EQUAL(42, static_cast(m)); - CHECK_CALLS(1); + mock_template_class_with_const_conversion_operator< int > m; + MOCK_EXPECT( m.conversion ).once().returns( 42 ); + BOOST_CHECK_EQUAL( 42, static_cast< int >( m ) ); + CHECK_CALLS( 1 ); } -namespace { -MOCK_CLASS(my_mock) +namespace { - MOCK_CONST_METHOD(my_method, 1, void(int), my_method) - MOCK_CONST_METHOD(my_method_2, 1, void(int), my_method_2) -}; -} // namespace + template< typename T > + MOCK_CLASS( mock_template_class_with_non_const_conversion_operator ) + { + MOCK_NON_CONST_CONVERSION_OPERATOR_TPL( operator, T, conversion ) + }; +} -BOOST_FIXTURE_TEST_CASE(MOCK_CONST_METHOD_macro_defines_a_bindable_method, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( mock_template_non_const_conversion_operator, mock_error_fixture ) +{ + mock_template_class_with_non_const_conversion_operator< int > m; + MOCK_EXPECT( m.conversion ).once().returns( 42 ); + BOOST_CHECK_EQUAL( 42, static_cast< int >( m ) ); + CHECK_CALLS( 1 ); +} + +namespace +{ + MOCK_CLASS( my_mock ) + { + MOCK_CONST_METHOD_EXT( my_method, 1, void( int ), my_method ) + MOCK_CONST_METHOD_EXT( my_method_2, 1, void( int ), my_method_2 ) + }; +} + +BOOST_FIXTURE_TEST_CASE( MOCK_CONST_METHOD_EXT_macro_defines_a_bindable_method, mock_error_fixture ) { my_mock m; - const auto f = std::bind(&my_mock::my_method, &m, 42); - (void)f; + boost::bind( &my_mock::my_method, &m, 42 ); } -BOOST_FIXTURE_TEST_CASE(MOCK_VERIFY_macro, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( MOCK_VERIFY_macro, mock_error_fixture ) { my_mock m; - MOCK_VERIFY(m.my_method); + MOCK_VERIFY( m.my_method ); } -BOOST_FIXTURE_TEST_CASE(MOCK_RESET_macro, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( MOCK_RESET_macro, mock_error_fixture ) { my_mock m; - MOCK_RESET(m.my_method); + MOCK_RESET( m.my_method ); } -BOOST_FIXTURE_TEST_CASE(MOCK_EXPECT_macro, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( MOCK_EXPECT_macro, mock_error_fixture ) { my_mock m; - MOCK_EXPECT(m.my_method).once().with(42); - m.my_method(42); - CHECK_CALLS(1); + MOCK_EXPECT( m.my_method ).once().with( 42 ); + m.my_method( 42 ); + CHECK_CALLS( 1 ); } -namespace { -template -std::string to_string(const T& t) +namespace { - std::stringstream s; - s << t; - return s.str(); + template< typename T > + std::string to_string( const T& t ) + { + std::stringstream s; + s << t; + return s.str(); + } } -} // namespace -BOOST_FIXTURE_TEST_CASE(mock_object_is_named, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( mock_object_is_named, mock_error_fixture ) { my_mock m; - BOOST_CHECK_EQUAL("?.my_mock::my_method", to_string(MOCK_ANONYMOUS_HELPER(m.my_method))); - BOOST_CHECK_EQUAL("?.my_mock::my_method_2", to_string(MOCK_ANONYMOUS_HELPER(m.my_method_2))); - BOOST_CHECK_EQUAL("m.my_mock::my_method", to_string(MOCK_HELPER(m.my_method))); - BOOST_CHECK_EQUAL("m.my_mock::my_method_2", to_string(MOCK_ANONYMOUS_HELPER(m.my_method_2))); - BOOST_CHECK_EQUAL("m.my_mock::my_method", to_string(MOCK_ANONYMOUS_HELPER(m.my_method))); - BOOST_CHECK_EQUAL("m.my_mock::my_method", to_string(MOCK_HELPER(m.my_method))); + BOOST_CHECK_EQUAL( "?.my_mock::my_method", to_string( MOCK_ANONYMOUS_HELPER( m.my_method ) ) ); + BOOST_CHECK_EQUAL( "?.my_mock::my_method_2", to_string( MOCK_ANONYMOUS_HELPER( m.my_method_2 ) ) ); + BOOST_CHECK_EQUAL( "m.my_mock::my_method", to_string( MOCK_HELPER( m.my_method ) ) ); + BOOST_CHECK_EQUAL( "m.my_mock::my_method_2", to_string( MOCK_ANONYMOUS_HELPER( m.my_method_2 ) ) ); + BOOST_CHECK_EQUAL( "m.my_mock::my_method", to_string( MOCK_ANONYMOUS_HELPER( m.my_method ) ) ); + BOOST_CHECK_EQUAL( "m.my_mock::my_method", to_string( MOCK_HELPER( m.my_method ) ) ); } -BOOST_FIXTURE_TEST_CASE(mock_object_shared_pointer_is_named, mock_error_fixture) +#ifdef MOCK_AUTO_PTR + +BOOST_FIXTURE_TEST_CASE( mock_object_auto_pointer_is_named, mock_error_fixture ) { - std::shared_ptr m(new my_mock); - BOOST_CHECK_EQUAL("?.my_mock::my_method", to_string(MOCK_ANONYMOUS_HELPER(m->my_method))); - BOOST_CHECK_EQUAL("m->my_mock::my_method", to_string(MOCK_HELPER(m->my_method))); - BOOST_CHECK_EQUAL("m->my_mock::my_method", to_string(MOCK_ANONYMOUS_HELPER(m->my_method))); - BOOST_CHECK_EQUAL("m->my_mock::my_method", to_string(MOCK_HELPER(m->my_method))); + std::auto_ptr< my_mock > m( new my_mock ); + BOOST_CHECK_EQUAL( "?.my_mock::my_method", to_string( MOCK_ANONYMOUS_HELPER( m->my_method ) ) ); + BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_HELPER( m->my_method ) ) ); + BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_ANONYMOUS_HELPER( m->my_method ) ) ); + BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_HELPER( m->my_method ) ) ); } -BOOST_FIXTURE_TEST_CASE(mock_object_const_shared_pointer_is_named, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( mock_object_const_auto_pointer_is_named, mock_error_fixture ) { - const std::shared_ptr m(new my_mock); - BOOST_CHECK_EQUAL("?.my_mock::my_method", to_string(MOCK_ANONYMOUS_HELPER(m->my_method))); - BOOST_CHECK_EQUAL("m->my_mock::my_method", to_string(MOCK_HELPER(m->my_method))); - BOOST_CHECK_EQUAL("m->my_mock::my_method", to_string(MOCK_ANONYMOUS_HELPER(m->my_method))); - BOOST_CHECK_EQUAL("m->my_mock::my_method", to_string(MOCK_HELPER(m->my_method))); + const std::auto_ptr< my_mock > m( new my_mock ); + BOOST_CHECK_EQUAL( "?.my_mock::my_method", to_string( MOCK_ANONYMOUS_HELPER( m->my_method ) ) ); + BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_HELPER( m->my_method ) ) ); + BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_ANONYMOUS_HELPER( m->my_method ) ) ); + BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_HELPER( m->my_method ) ) ); } -namespace { -struct my_custom_mock -{ - MOCK_METHOD(my_method, 0, void(), my_tag) - MOCK_METHOD(my_method_2, 0, void(), my_tag_2) -}; -} // namespace +#endif // MOCK_AUTO_PTR -BOOST_FIXTURE_TEST_CASE(custom_mock_object_without_macros_and_without_inheriting_from_object_is_named, - mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( mock_object_shared_pointer_is_named, mock_error_fixture ) +{ + boost::shared_ptr< my_mock > m( new my_mock ); + BOOST_CHECK_EQUAL( "?.my_mock::my_method", to_string( MOCK_ANONYMOUS_HELPER( m->my_method ) ) ); + BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_HELPER( m->my_method ) ) ); + BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_ANONYMOUS_HELPER( m->my_method ) ) ); + BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_HELPER( m->my_method ) ) ); +} + +BOOST_FIXTURE_TEST_CASE( mock_object_const_shared_pointer_is_named, mock_error_fixture ) +{ + const boost::shared_ptr< my_mock > m( new my_mock ); + BOOST_CHECK_EQUAL( "?.my_mock::my_method", to_string( MOCK_ANONYMOUS_HELPER( m->my_method ) ) ); + BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_HELPER( m->my_method ) ) ); + BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_ANONYMOUS_HELPER( m->my_method ) ) ); + BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_HELPER( m->my_method ) ) ); +} + +namespace +{ + struct my_custom_mock + { + MOCK_METHOD_EXT( my_method, 0, void(), my_tag ) + MOCK_METHOD_EXT( my_method_2, 0, void(), my_tag_2 ) + }; +} + +BOOST_FIXTURE_TEST_CASE( custom_mock_object_without_macros_and_without_inheriting_from_object_is_named, mock_error_fixture ) { my_custom_mock m; - BOOST_CHECK_EQUAL("?.my_custom_mock::my_tag", to_string(MOCK_ANONYMOUS_HELPER(m.my_tag))); - BOOST_CHECK_EQUAL("?.my_custom_mock::my_tag_2", to_string(MOCK_ANONYMOUS_HELPER(m.my_tag_2))); - BOOST_CHECK_EQUAL("m.my_custom_mock::my_tag", to_string(MOCK_HELPER(m.my_tag))); - BOOST_CHECK_EQUAL("m.my_custom_mock::my_tag_2", to_string(MOCK_ANONYMOUS_HELPER(m.my_tag_2))); - BOOST_CHECK_EQUAL("m.my_custom_mock::my_tag", to_string(MOCK_ANONYMOUS_HELPER(m.my_tag))); - BOOST_CHECK_EQUAL("m.my_custom_mock::my_tag", to_string(MOCK_HELPER(m.my_tag))); + BOOST_CHECK_EQUAL( "?.my_custom_mock::my_tag", to_string( MOCK_ANONYMOUS_HELPER( m.my_tag ) ) ); + BOOST_CHECK_EQUAL( "?.my_custom_mock::my_tag_2", to_string( MOCK_ANONYMOUS_HELPER( m.my_tag_2 ) ) ); + BOOST_CHECK_EQUAL( "m.my_custom_mock::my_tag", to_string( MOCK_HELPER( m.my_tag ) ) ); + BOOST_CHECK_EQUAL( "m.my_custom_mock::my_tag_2", to_string( MOCK_ANONYMOUS_HELPER( m.my_tag_2 ) ) ); + BOOST_CHECK_EQUAL( "m.my_custom_mock::my_tag", to_string( MOCK_ANONYMOUS_HELPER( m.my_tag ) ) ); + BOOST_CHECK_EQUAL( "m.my_custom_mock::my_tag", to_string( MOCK_HELPER( m.my_tag ) ) ); } -namespace { -struct my_custom_mock_object : mock::object +namespace { - MOCK_METHOD(my_method, 0, void(), my_tag) - MOCK_METHOD(my_method_2, 0, void(), my_tag_2) -}; -} // namespace + struct my_custom_mock_object : mock::object + { + MOCK_METHOD_EXT( my_method, 0, void(), my_tag ) + MOCK_METHOD_EXT( my_method_2, 0, void(), my_tag_2 ) + }; +} -BOOST_FIXTURE_TEST_CASE(custom_mock_object_without_macros_is_named, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( custom_mock_object_without_macros_is_named, mock_error_fixture ) { my_custom_mock_object m; - BOOST_CHECK_EQUAL("?.my_custom_mock_object::my_tag", to_string(MOCK_ANONYMOUS_HELPER(m.my_tag))); - BOOST_CHECK_EQUAL("?.my_custom_mock_object::my_tag_2", to_string(MOCK_ANONYMOUS_HELPER(m.my_tag_2))); - BOOST_CHECK_EQUAL("m.my_custom_mock_object::my_tag", to_string(MOCK_HELPER(m.my_tag))); - BOOST_CHECK_EQUAL("m.my_custom_mock_object::my_tag_2", to_string(MOCK_ANONYMOUS_HELPER(m.my_tag_2))); - BOOST_CHECK_EQUAL("m.my_custom_mock_object::my_tag", to_string(MOCK_ANONYMOUS_HELPER(m.my_tag))); - BOOST_CHECK_EQUAL("m.my_custom_mock_object::my_tag", to_string(MOCK_HELPER(m.my_tag))); + BOOST_CHECK_EQUAL( "?.my_custom_mock_object::my_tag", to_string( MOCK_ANONYMOUS_HELPER( m.my_tag ) ) ); + BOOST_CHECK_EQUAL( "?.my_custom_mock_object::my_tag_2", to_string( MOCK_ANONYMOUS_HELPER( m.my_tag_2 ) ) ); + BOOST_CHECK_EQUAL( "m.my_custom_mock_object::my_tag", to_string( MOCK_HELPER( m.my_tag ) ) ); + BOOST_CHECK_EQUAL( "m.my_custom_mock_object::my_tag_2", to_string( MOCK_ANONYMOUS_HELPER( m.my_tag_2 ) ) ); + BOOST_CHECK_EQUAL( "m.my_custom_mock_object::my_tag", to_string( MOCK_ANONYMOUS_HELPER( m.my_tag ) ) ); + BOOST_CHECK_EQUAL( "m.my_custom_mock_object::my_tag", to_string( MOCK_HELPER( m.my_tag ) ) ); } -BOOST_FIXTURE_TEST_CASE(mock_functor, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( mock_functor, mock_error_fixture ) { - MOCK_FUNCTOR(f1, void()); - MOCK_FUNCTOR(f2, int(const std::string&)); + MOCK_FUNCTOR( f1, void() ); + MOCK_FUNCTOR( f2, int( const std::string& ) ); } -namespace { -template -struct tpl_functor_class +namespace { - MOCK_FUNCTOR(f, void(T)); -}; -} // namespace - -BOOST_FIXTURE_TEST_CASE(mock_functor_reset, mock_error_fixture) -{ - MOCK_FUNCTOR(f, void()); - MOCK_RESET(f); - mock::reset(f); + template< typename T > + struct tpl_functor_class + { + MOCK_FUNCTOR_TPL( f, void( T ) ); + }; } -BOOST_FIXTURE_TEST_CASE(mock_functor_verify, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( mock_functor_reset, mock_error_fixture ) { - MOCK_FUNCTOR(f, void()); - MOCK_VERIFY(f); - mock::verify(f); + MOCK_FUNCTOR( f, void() ); + MOCK_RESET( f ); + mock::reset( f ); } -BOOST_FIXTURE_TEST_CASE(mock_functor_is_named, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( mock_functor_verify, mock_error_fixture ) { - MOCK_FUNCTOR(f, void()); - BOOST_CHECK_EQUAL("f", to_string(MOCK_HELPER(f))); + MOCK_FUNCTOR( f, void() ); + MOCK_VERIFY( f ); + mock::verify( f ); } -namespace { -MOCK_FUNCTION(mock_function, 1, float(int), mock_function) +BOOST_FIXTURE_TEST_CASE( mock_functor_is_named, mock_error_fixture ) +{ + MOCK_FUNCTOR( f, void() ); + BOOST_CHECK_EQUAL( "f", to_string( MOCK_HELPER( f ) ) ); } -BOOST_FIXTURE_TEST_CASE(mock_function_is_named, mock_error_fixture) +namespace { - BOOST_CHECK_EQUAL("mock_function", to_string(MOCK_HELPER(mock_function))); + MOCK_FUNCTION( mock_function, 1, float( int ), mock_function ) } -namespace { -MOCK_CLASS(static_function_class) +BOOST_FIXTURE_TEST_CASE( mock_function_is_named, mock_error_fixture ) { - MOCK_STATIC_METHOD(f, 1, float(int), f) -}; -} // namespace - -BOOST_FIXTURE_TEST_CASE(mock_static_function_is_named, mock_error_fixture) -{ - BOOST_CHECK_EQUAL("static_function_class::f", to_string(MOCK_HELPER(static_function_class::f))); + BOOST_CHECK_EQUAL( "mock_function", to_string( MOCK_HELPER( mock_function ) ) ); } -namespace { -MOCK_CLASS(round_parenthesized_signature) +namespace { - MOCK_METHOD(m0, 0, MOCK_PROTECT_SIGNATURE(std::map()), m0) - MOCK_STATIC_METHOD(m1, 0, MOCK_PROTECT_SIGNATURE(std::map()), m1) - MOCK_FUNCTOR(f0, MOCK_PROTECT_SIGNATURE(std::map())); -}; -MOCK_FUNCTION(fun0, 0, MOCK_PROTECT_SIGNATURE(std::map()), fun0) -} // namespace + MOCK_CLASS( static_function_class ) + { + MOCK_STATIC_METHOD( f, 1, float( int ), f ) + }; +} -namespace { -struct base +BOOST_FIXTURE_TEST_CASE( mock_static_function_is_named, mock_error_fixture ) { - virtual ~base() = default; + BOOST_CHECK_EQUAL( "static_function_class::f", to_string( MOCK_HELPER( static_function_class::f ) ) ); +} - virtual void m1() = 0; - virtual void m10() const = 0; - virtual void m11() = 0; -}; - -MOCK_BASE_CLASS(variadic, base) +namespace { - MOCK_METHOD(m1, 0) - MOCK_METHOD(m2, 0, void()) - MOCK_METHOD(m3, 0, void(), m3) - MOCK_CONST_METHOD(m10, 0) - MOCK_CONST_METHOD(m4, 0, void()) - MOCK_CONST_METHOD(m5, 0, void(), m5) - MOCK_NON_CONST_METHOD(m11, 0) - MOCK_NON_CONST_METHOD(m6, 0, void()) - MOCK_NON_CONST_METHOD(m7, 0, void(), m7) - MOCK_STATIC_METHOD(m8, 0, void()) - MOCK_STATIC_METHOD(m9, 0, void(), m9) -}; + MOCK_CLASS( round_parenthesized_signature ) + { + MOCK_METHOD_EXT( m0, 0, BOOST_IDENTITY_TYPE((std::map< int, int >())), m0 ) + MOCK_STATIC_METHOD( m1, 0, BOOST_IDENTITY_TYPE((std::map< int, int >())), m1 ) + MOCK_FUNCTOR( f0, BOOST_IDENTITY_TYPE((std::map< int, int >())) ); + }; + MOCK_FUNCTION( fun0, 0, BOOST_IDENTITY_TYPE((std::map< int, int >())), fun0 ) +} -template -MOCK_BASE_CLASS(variadic_tpl, base) +#ifdef MOCK_VARIADIC_MACROS + +namespace { - MOCK_METHOD(m1, 0, void()) - MOCK_METHOD(m2, 0, T()) - MOCK_METHOD(m3, 0, T(), m3) - MOCK_CONST_METHOD(m4, 0, T()) - MOCK_CONST_METHOD(m5, 0, T(), m5) - MOCK_NON_CONST_METHOD(m6, 0, T()) - MOCK_NON_CONST_METHOD(m7, 0, T(), m7) - MOCK_STATIC_METHOD(m8, 0, T()) - MOCK_STATIC_METHOD(m9, 0, T(), m9) -}; + struct base + { + virtual ~base() + {} -MOCK_BASE_CLASS(comma_base, std::map) -{}; + virtual void m1() = 0; + }; -MOCK_FUNCTION(fun1, 0, void()) -MOCK_FUNCTION(fun2, 0, void(), fun2) -MOCK_FUNCTION(fun3, 0, MOCK_PROTECT_SIGNATURE(std::map())) + MOCK_BASE_CLASS( variadic, base ) + { + MOCK_METHOD( m1, 0 ) + MOCK_METHOD( m2, 0, void() ) + MOCK_METHOD( m3, 0, void(), m3 ) + MOCK_CONST_METHOD( m4, 0, void() ) + MOCK_CONST_METHOD( m5, 0, void(), m5 ) + MOCK_NON_CONST_METHOD( m6, 0, void() ) + MOCK_NON_CONST_METHOD( m7, 0, void(), m7 ) + MOCK_STATIC_METHOD( m8, 0, void() ) + MOCK_STATIC_METHOD( m9, 0, void(), m9 ) + }; -MOCK_FUNCTOR(f_variadic, std::map()); -} // namespace + template< typename T > + MOCK_BASE_CLASS( variadic_tpl, base ) + { + MOCK_METHOD( m1, 0, void() ) + MOCK_METHOD_TPL( m2, 0, T() ) + MOCK_METHOD_TPL( m3, 0, T(), m3 ) + MOCK_CONST_METHOD_TPL( m4, 0, T() ) + MOCK_CONST_METHOD_TPL( m5, 0, T(), m5 ) + MOCK_NON_CONST_METHOD_TPL( m6, 0, T() ) + MOCK_NON_CONST_METHOD_TPL( m7, 0, T(), m7 ) + MOCK_STATIC_METHOD_TPL( m8, 0, T() ) + MOCK_STATIC_METHOD_TPL( m9, 0, T(), m9 ) + }; + + MOCK_BASE_CLASS( comma_base, std::map< int, int > ) + {}; + + MOCK_FUNCTION( fun1, 0, void() ) + MOCK_FUNCTION( fun2, 0, void(), fun2 ) + MOCK_FUNCTION( fun3, 0, BOOST_IDENTITY_TYPE((std::map< int, int >())) ) + + MOCK_FUNCTOR( f_variadic, std::map< int, int >() ); +} + +#else // MOCK_VARIADIC_MACROS + +namespace +{ + struct base + { + virtual ~base() + {} + + virtual void m1() = 0; + }; + + MOCK_BASE_CLASS( derived, base ) + { + MOCK_METHOD( m1, 0 ) + }; + + template< typename T > + MOCK_BASE_CLASS( derived_tpl, base ) + { + MOCK_METHOD_EXT( m1, 0, void(), m1 ) + }; +} + +#endif // MOCK_VARIADIC_MACROS #ifdef BOOST_MSVC -# define MOCK_STDCALL __stdcall +# define MOCK_STDCALL __stdcall #else -# define MOCK_STDCALL +# define MOCK_STDCALL #endif -namespace stdcall { -struct base +namespace stdcall { - virtual ~base() = default; + struct base + { + virtual ~base() + {} - virtual void MOCK_STDCALL m1() = 0; -}; + virtual void MOCK_STDCALL m1() = 0; + }; -MOCK_BASE_CLASS(derived, base) -{ - MOCK_CONSTRUCTOR(MOCK_STDCALL derived, 0, (), derived) - MOCK_DESTRUCTOR(MOCK_STDCALL ~derived, derived) - MOCK_CONVERSION_OPERATOR(MOCK_STDCALL operator, int, to_int) - MOCK_METHOD(MOCK_STDCALL m1, 0, void(), m1) - MOCK_METHOD(MOCK_STDCALL m2, 0, void(), m2) - MOCK_METHOD(MOCK_STDCALL m3, 0, void(), m3) - MOCK_STATIC_METHOD(MOCK_STDCALL m4, 0, void(), m4) -}; + MOCK_BASE_CLASS( derived, base ) + { + MOCK_CONSTRUCTOR( MOCK_STDCALL derived, 0, (), derived ) + MOCK_DESTRUCTOR( MOCK_STDCALL ~derived, derived ) + MOCK_CONVERSION_OPERATOR( MOCK_STDCALL operator, int, to_int ) + MOCK_METHOD_EXT( MOCK_STDCALL m1, 0, void(), m1 ) + MOCK_METHOD_EXT( MOCK_STDCALL m2, 0, void(), m2 ) +#ifdef MOCK_VARIADIC_MACROS + MOCK_METHOD( MOCK_STDCALL m3, 0, void(), m3 ) +#endif + MOCK_STATIC_METHOD( MOCK_STDCALL m4, 0, void(), m4 ) + }; -MOCK_FUNCTION(MOCK_STDCALL f, 0, void(), f) -} // namespace stdcall + MOCK_FUNCTION( MOCK_STDCALL f, 0, void(), f ) +} diff --git a/test/test_object.cpp b/test/test_object.cpp index 2c1e202..84e1094 100644 --- a/test/test_object.cpp +++ b/test/test_object.cpp @@ -7,81 +7,102 @@ // http://www.boost.org/LICENSE_1_0.txt) #include "mock_error.hpp" -#include #include #include -#include -#include +#include +#include +#include -namespace { -struct object : mock::object -{}; - -object static_o; -} // namespace - -BOOST_FIXTURE_TEST_CASE(verifying_an_empty_object_succeeds, mock_error_fixture) +namespace { - object o; - BOOST_CHECK(mock::verify(o)); + struct object : mock::object + {}; + + object static_o; } -namespace { -struct fixture : mock_error_fixture +BOOST_FIXTURE_TEST_CASE( verifying_an_empty_object_succeeds, mock_error_fixture ) { - fixture() { mock::detail::configure(o, e, "instance", mock::detail::make_type_name(o), "name"); } object o; - mock::detail::function e; -}; -} // namespace - -BOOST_FIXTURE_TEST_CASE(verifying_an_object_containing_a_failing_expectation_fails, fixture) -{ - e.expect().once(); - CHECK_ERROR(BOOST_CHECK(!mock::verify(o)), "verification failed", 0, "instanceobject::name\n. once()"); - mock::reset(o); - BOOST_CHECK(mock::verify(o)); + BOOST_CHECK( mock::verify( o ) ); } -BOOST_FIXTURE_TEST_CASE(verifying_all_objects_with_one_of_them_containing_a_failing_expectation_fails, fixture) +namespace +{ + struct fixture : mock_error_fixture + { + fixture() + { + mock::detail::configure( o, e, "instance", MOCK_TYPE_NAME(o), "name" ); + } + object o; + mock::detail::function< void() > e; + }; +} + +BOOST_FIXTURE_TEST_CASE( verifying_an_object_containing_a_failing_expectation_fails, fixture ) { e.expect().once(); - CHECK_ERROR(BOOST_CHECK(!mock::verify()), "verification failed", 0, "instanceobject::name\n. once()"); + CHECK_ERROR( + BOOST_CHECK( ! mock::verify( o ) ), + "verification failed", 0, "instanceobject::name\n. once()" ); + mock::reset( o ); + BOOST_CHECK( mock::verify( o ) ); +} + +BOOST_FIXTURE_TEST_CASE( verifying_all_objects_with_one_of_them_containing_a_failing_expectation_fails, fixture ) +{ + e.expect().once(); + CHECK_ERROR( + BOOST_CHECK( ! mock::verify() ), + "verification failed", 0, "instanceobject::name\n. once()" ); mock::reset(); - BOOST_CHECK(mock::verify()); + BOOST_CHECK( mock::verify() ); } -BOOST_FIXTURE_TEST_CASE(resetting_an_object_containing_a_failing_expectation_and_verifying_it_succeeds, fixture) +BOOST_FIXTURE_TEST_CASE( resetting_an_object_containing_a_failing_expectation_and_verifying_it_succeeds, fixture ) { e.expect().once(); - mock::reset(o); - BOOST_CHECK(mock::verify(o)); + mock::reset( o ); + BOOST_CHECK( mock::verify( o ) ); } -BOOST_FIXTURE_TEST_CASE(an_object_is_assignable_by_sharing_its_state, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( an_object_is_assignable_by_sharing_its_state, mock_error_fixture ) { object o1; - mock::detail::function e; + mock::detail::function< void() > e; { object o2; - mock::detail::configure(o2, e, "instance", mock::detail::make_type_name(o2), "name"); + mock::detail::configure( o2, e, "instance", MOCK_TYPE_NAME(o2), "name" ); e.expect().once(); o1 = o2; - CHECK_ERROR(BOOST_CHECK(!mock::verify(o1)), "verification failed", 0, "instanceobject::name\n. once()"); - CHECK_ERROR(BOOST_CHECK(!mock::verify(o2)), "verification failed", 0, "instanceobject::name\n. once()"); + CHECK_ERROR( + BOOST_CHECK( ! mock::verify( o1 ) ), + "verification failed", 0, "instanceobject::name\n. once()" ); + CHECK_ERROR( + BOOST_CHECK( ! mock::verify( o2 ) ), + "verification failed", 0, "instanceobject::name\n. once()" ); } - CHECK_ERROR(BOOST_CHECK(!mock::verify(o1)), "verification failed", 0, "instanceobject::name\n. once()"); + CHECK_ERROR( + BOOST_CHECK( ! mock::verify( o1 ) ), + "verification failed", 0, "instanceobject::name\n. once()" ); } -BOOST_FIXTURE_TEST_CASE(an_object_is_copiable_by_sharing_its_state, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( an_object_is_copiable_by_sharing_its_state, mock_error_fixture ) { - auto o2 = std::make_unique(); - const object o1(*o2); - mock::detail::function e; - mock::detail::configure(*o2, e, "instance", mock::detail::make_type_name(*o2), "name"); + boost::scoped_ptr< object > o2( new object ); + const object o1( *o2 ); + mock::detail::function< void() > e; + mock::detail::configure( *o2, e, "instance", MOCK_TYPE_NAME(*o2), "name" ); e.expect().once(); - CHECK_ERROR(BOOST_CHECK(!mock::verify(*o2)), "verification failed", 0, "instanceobject::name\n. once()"); - CHECK_ERROR(BOOST_CHECK(!mock::verify(o1)), "verification failed", 0, "instanceobject::name\n. once()"); + CHECK_ERROR( + BOOST_CHECK( ! mock::verify( *o2 ) ), + "verification failed", 0, "instanceobject::name\n. once()" ); + CHECK_ERROR( + BOOST_CHECK( ! mock::verify( o1 ) ), + "verification failed", 0, "instanceobject::name\n. once()" ); o2.reset(); - CHECK_ERROR(BOOST_CHECK(!mock::verify(o1)), "verification failed", 0, "instanceobject::name\n. once()"); + CHECK_ERROR( + BOOST_CHECK( ! mock::verify( o1 ) ), + "verification failed", 0, "instanceobject::name\n. once()" ); } diff --git a/test/test_sequence.cpp b/test/test_sequence.cpp index 1f6ae98..d14de02 100644 --- a/test/test_sequence.cpp +++ b/test/test_sequence.cpp @@ -7,115 +7,108 @@ // http://www.boost.org/LICENSE_1_0.txt) #include "mock_error.hpp" -#include #include -#include -#include +#include +#include -BOOST_FIXTURE_TEST_CASE(registering_to_a_sequence_and_calling_out_of_order_throws, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( registering_to_a_sequence_and_calling_out_of_order_throws, mock_error_fixture ) { mock::sequence s; - mock::detail::function e; - e.expect().once().with(1).in(s); - e.expect().once().with(2).in(s); - BOOST_CHECK_NO_THROW(e(2)); - CHECK_ERROR(e(1), "sequence failed", 1, "?( 1 )\n. once().with( 1 )\nv once().with( 2 )"); + mock::detail::function< void( int ) > e; + e.expect().once().with( 1 ).in( s ); + e.expect().once().with( 2 ).in( s ); + BOOST_CHECK_NO_THROW( e( 2 ) ); + CHECK_ERROR( e( 1 ), "sequence failed", 1, "?( 1 )\n. once().with( 1 )\nv once().with( 2 )" ); } -BOOST_FIXTURE_TEST_CASE(registering_to_a_sequence_and_calling_out_of_order_multiple_invocations_throws, - mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( registering_to_a_sequence_and_calling_out_of_order_multiple_invocations_throws, mock_error_fixture ) { mock::sequence s; - mock::detail::function e; - e.expect().with(1).in(s); - e.expect().once().with(2).in(s); - BOOST_CHECK_NO_THROW(e(1)); - BOOST_CHECK_NO_THROW(e(2)); - CHECK_ERROR(e(1), "sequence failed", 2, "?( 1 )\n. unlimited().with( 1 )\nv once().with( 2 )"); + mock::detail::function< void( int ) > e; + e.expect().with( 1 ).in( s ); + e.expect().once().with( 2 ).in( s ); + BOOST_CHECK_NO_THROW( e( 1 ) ); + BOOST_CHECK_NO_THROW( e( 2 ) ); + CHECK_ERROR( e( 1 ), "sequence failed", 2, "?( 1 )\n. unlimited().with( 1 )\nv once().with( 2 )" ); } -BOOST_FIXTURE_TEST_CASE(registering_to_a_sequence_and_calling_in_order_is_valid, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( registering_to_a_sequence_and_calling_in_order_is_valid, mock_error_fixture ) { mock::sequence s; - mock::detail::function e; - e.expect().once().with(1).in(s); - e.expect().once().with(2).in(s); - BOOST_CHECK_NO_THROW(e(1)); - BOOST_CHECK_NO_THROW(e(2)); - BOOST_CHECK(e.verify()); - CHECK_CALLS(2); + mock::detail::function< void( int ) > e; + e.expect().once().with( 1 ).in( s ); + e.expect().once().with( 2 ).in( s ); + BOOST_CHECK_NO_THROW( e( 1 ) ); + BOOST_CHECK_NO_THROW( e( 2 ) ); + BOOST_CHECK( e.verify() ); + CHECK_CALLS( 2 ); } -BOOST_FIXTURE_TEST_CASE(registering_to_a_sequence_and_multiply_calling_in_order_is_valid, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( registering_to_a_sequence_and_multiply_calling_in_order_is_valid, mock_error_fixture ) { mock::sequence s; - mock::detail::function e; - e.expect().exactly(2).with(1).in(s); - e.expect().exactly(2).with(2).in(s); - BOOST_CHECK_NO_THROW(e(1)); - BOOST_CHECK_NO_THROW(e(1)); - BOOST_CHECK_NO_THROW(e(2)); - BOOST_CHECK_NO_THROW(e(2)); - BOOST_CHECK(e.verify()); - CHECK_CALLS(4); + mock::detail::function< void( int ) > e; + e.expect().exactly( 2 ).with( 1 ).in( s ); + e.expect().exactly( 2 ).with( 2 ).in( s ); + BOOST_CHECK_NO_THROW( e( 1 ) ); + BOOST_CHECK_NO_THROW( e( 1 ) ); + BOOST_CHECK_NO_THROW( e( 2 ) ); + BOOST_CHECK_NO_THROW( e( 2 ) ); + BOOST_CHECK( e.verify() ); + CHECK_CALLS( 4 ); } -BOOST_FIXTURE_TEST_CASE(registering_to_a_sequence_enforces_call_order_verification_between_two_different_expectations, - mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( registering_to_a_sequence_enforces_call_order_verification_between_two_different_expectations, mock_error_fixture ) { mock::sequence s; - mock::detail::function e1, e2; - e1.expect().once().in(s); - e2.expect().once().in(s); - BOOST_CHECK_NO_THROW(e2()); - CHECK_ERROR(e1(), "sequence failed", 1, "?()\n. once()"); + mock::detail::function< void() > e1, e2; + e1.expect().once().in( s ); + e2.expect().once().in( s ); + BOOST_CHECK_NO_THROW( e2() ); + CHECK_ERROR( e1(), "sequence failed", 1, "?()\n. once()" ); } -BOOST_FIXTURE_TEST_CASE(destroying_a_sequence_does_not_remove_order_call_enforcement, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( destroying_a_sequence_does_not_remove_order_call_enforcement, mock_error_fixture ) { - mock::detail::function e1, e2; + mock::detail::function< void() > e1, e2; { mock::sequence s; - e1.expect().once().in(s); - e2.expect().once().in(s); + e1.expect().once().in( s ); + e2.expect().once().in( s ); } - BOOST_CHECK_NO_THROW(e2()); - CHECK_ERROR(e1(), "sequence failed", 1, "?()\n. once()"); + BOOST_CHECK_NO_THROW( e2() ); + CHECK_ERROR( e1(), "sequence failed", 1, "?()\n. once()" ); } -BOOST_FIXTURE_TEST_CASE(resetting_an_expectation_removes_it_from_order_call_enforcement, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( resetting_an_expectation_removes_it_from_order_call_enforcement, mock_error_fixture ) { mock::sequence s; - mock::detail::function e1, e2; - e1.expect().once().in(s); - e2.expect().once().in(s); + mock::detail::function< void() > e1, e2; + e1.expect().once().in( s ); + e2.expect().once().in( s ); e1.reset(); - BOOST_CHECK_NO_THROW(e2()); - BOOST_CHECK(e1.verify()); - BOOST_CHECK(e2.verify()); - CHECK_CALLS(1); + BOOST_CHECK_NO_THROW( e2() ); + BOOST_CHECK( e1.verify() ); + BOOST_CHECK( e2.verify() ); + CHECK_CALLS( 1 ); } -BOOST_FIXTURE_TEST_CASE(an_expectation_can_be_used_in_several_sequences, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( an_expectation_can_be_used_in_several_sequences, mock_error_fixture ) { - std::array s; - mock::detail::function e; - // One can use any amount of sequences if wanted - // clang-format off - e.expect().once().in(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9], - s[10], s[11], s[12], s[13], s[14], s[15], s[16], s[17], s[18], s[19]); - // clang-format on - BOOST_CHECK_NO_THROW(e()); - BOOST_CHECK(e.verify()); - CHECK_CALLS(1); + mock::sequence s1, s2; + mock::detail::function< void() > e; + e.expect().once().in( s1, s2 ); + BOOST_CHECK_NO_THROW( e() ); + BOOST_CHECK( e.verify() ); + CHECK_CALLS( 1 ); } -BOOST_FIXTURE_TEST_CASE(a_result_specification_is_set_after_a_sequence, mock_error_fixture) +BOOST_FIXTURE_TEST_CASE( a_result_specification_is_set_after_a_sequence, mock_error_fixture ) { mock::sequence s; - mock::detail::function e; - e.expect().once().in(s).returns(3); - BOOST_CHECK_EQUAL(3, e()); - BOOST_CHECK(e.verify()); - CHECK_CALLS(1); + mock::detail::function< int() > e; + e.expect().once().in( s ).returns( 3 ); + BOOST_CHECK_EQUAL( 3, e() ); + BOOST_CHECK( e.verify() ); + CHECK_CALLS( 1 ); }