Subversion Repositories s80186

$$ -*- mode: c++; -*-

$$ This is a Pump source file.  Please use Pump to convert it to

$$ gmock-generated-function-mockers.h.

$$

$var n = 10  $$ The maximum arity we support.

// Copyright 2007, Google Inc.

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//     * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

// Author: wan@google.com (Zhanyong Wan)

// Google Mock - a framework for writing C++ mock classes.

//

// This file implements function mockers of various arities.

#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_

#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_

#include "gmock/gmock-spec-builders.h"

#include "gmock/internal/gmock-internal-utils.h"

#if GTEST_HAS_STD_FUNCTION_

# include 

#endif

namespace testing {

namespace internal {

template 

class FunctionMockerBase;

// Note: class FunctionMocker really belongs to the ::testing

// namespace.  However if we define it in ::testing, MSVC will

// complain when classes in ::testing::internal declare it as a

// friend class template.  To workaround this compiler bug, we define

// FunctionMocker in ::testing::internal and import it into ::testing.

template 

class FunctionMocker;

$range i 0..n

$for i [[

$range j 1..i

$var typename_As = [[$for j [[, typename A$j]]]]

$var As = [[$for j, [[A$j]]]]

$var as = [[$for j, [[a$j]]]]

$var Aas = [[$for j, [[A$j a$j]]]]

$var ms = [[$for j, [[m$j]]]]

$var matchers = [[$for j, [[const Matcher& m$j]]]]

template 

class FunctionMocker : public

    internal::FunctionMockerBase {

 public:

  typedef R F($As);

  typedef typename internal::Function::ArgumentTuple ArgumentTuple;

  MockSpec& With($matchers) {

$if i >= 1 [[

    this->current_spec().SetMatchers(::testing::make_tuple($ms));

]]

    return this->current_spec();

  }

  R Invoke($Aas) {

    // Even though gcc and MSVC don't enforce it, 'this->' is required

    // by the C++ standard [14.6.4] here, as the base class type is

    // dependent on the template argument (and thus shouldn't be

    // looked into when resolving InvokeWith).

    return this->InvokeWith(ArgumentTuple($as));

  }

};

]]

}  // namespace internal

// The style guide prohibits "using" statements in a namespace scope

// inside a header file.  However, the FunctionMocker class template

// is meant to be defined in the ::testing namespace.  The following

// line is just a trick for working around a bug in MSVC 8.0, which

// cannot handle it if we define FunctionMocker in ::testing.

using internal::FunctionMocker;

// GMOCK_RESULT_(tn, F) expands to the result type of function type F.

// We define this as a variadic macro in case F contains unprotected

// commas (the same reason that we use variadic macros in other places

// in this file).

// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!

#define GMOCK_RESULT_(tn, ...) \

    tn ::testing::internal::Function<__VA_ARGS__>::Result

// The type of argument N of the given function type.

// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!

#define GMOCK_ARG_(tn, N, ...) \

    tn ::testing::internal::Function<__VA_ARGS__>::Argument##N

// The matcher type for argument N of the given function type.

// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!

#define GMOCK_MATCHER_(tn, N, ...) \

    const ::testing::Matcher&

// The variable for mocking the given method.

// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!

#define GMOCK_MOCKER_(arity, constness, Method) \

    GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)

$for i [[

$range j 1..i

$var arg_as = [[$for j, \

      [[GMOCK_ARG_(tn, $j, __VA_ARGS__) gmock_a$j]]]]

$var as = [[$for j, [[gmock_a$j]]]]

$var matcher_as = [[$for j, \

                     [[GMOCK_MATCHER_(tn, $j, __VA_ARGS__) gmock_a$j]]]]

// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!

#define GMOCK_METHOD$i[[]]_(tn, constness, ct, Method, ...) \

  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \

      $arg_as) constness { \

    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \

        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value == $i), \

        this_method_does_not_take_$i[[]]_argument[[$if i != 1 [[s]]]]); \

    GMOCK_MOCKER_($i, constness, Method).SetOwnerAndName(this, #Method); \

    return GMOCK_MOCKER_($i, constness, Method).Invoke($as); \

  } \

  ::testing::MockSpec<__VA_ARGS__>& \

      gmock_##Method($matcher_as) constness { \

    GMOCK_MOCKER_($i, constness, Method).RegisterOwner(this); \

    return GMOCK_MOCKER_($i, constness, Method).With($as); \

  } \

  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_($i, constness, Method)

]]

$for i [[

#define MOCK_METHOD$i(m, ...) GMOCK_METHOD$i[[]]_(, , , m, __VA_ARGS__)

]]

$for i [[

#define MOCK_CONST_METHOD$i(m, ...) GMOCK_METHOD$i[[]]_(, const, , m, __VA_ARGS__)

]]

$for i [[

#define MOCK_METHOD$i[[]]_T(m, ...) GMOCK_METHOD$i[[]]_(typename, , , m, __VA_ARGS__)

]]

$for i [[

#define MOCK_CONST_METHOD$i[[]]_T(m, ...) \

    GMOCK_METHOD$i[[]]_(typename, const, , m, __VA_ARGS__)

]]

$for i [[

#define MOCK_METHOD$i[[]]_WITH_CALLTYPE(ct, m, ...) \

    GMOCK_METHOD$i[[]]_(, , ct, m, __VA_ARGS__)

]]

$for i [[

#define MOCK_CONST_METHOD$i[[]]_WITH_CALLTYPE(ct, m, ...) \

    GMOCK_METHOD$i[[]]_(, const, ct, m, __VA_ARGS__)

]]

$for i [[

#define MOCK_METHOD$i[[]]_T_WITH_CALLTYPE(ct, m, ...) \

    GMOCK_METHOD$i[[]]_(typename, , ct, m, __VA_ARGS__)

]]

$for i [[

#define MOCK_CONST_METHOD$i[[]]_T_WITH_CALLTYPE(ct, m, ...) \

    GMOCK_METHOD$i[[]]_(typename, const, ct, m, __VA_ARGS__)

]]

// A MockFunction class has one mock method whose type is F.  It is

// useful when you just want your test code to emit some messages and

// have Google Mock verify the right messages are sent (and perhaps at

// the right times).  For example, if you are exercising code:

//

//   Foo(1);

//   Foo(2);

//   Foo(3);

//

// and want to verify that Foo(1) and Foo(3) both invoke

// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write:

//

// TEST(FooTest, InvokesBarCorrectly) {

//   MyMock mock;

//   MockFunction check;

//   {

//     InSequence s;

//

//     EXPECT_CALL(mock, Bar("a"));

//     EXPECT_CALL(check, Call("1"));

//     EXPECT_CALL(check, Call("2"));

//     EXPECT_CALL(mock, Bar("a"));

//   }

//   Foo(1);

//   check.Call("1");

//   Foo(2);

//   check.Call("2");

//   Foo(3);

// }

//

// The expectation spec says that the first Bar("a") must happen

// before check point "1", the second Bar("a") must happen after check

// point "2", and nothing should happen between the two check

// points. The explicit check points make it easy to tell which

// Bar("a") is called by which call to Foo().

//

// MockFunction can also be used to exercise code that accepts

// std::function callbacks. To do so, use AsStdFunction() method

// to create std::function proxy forwarding to original object's Call.

// Example:

//

// TEST(FooTest, RunsCallbackWithBarArgument) {

//   MockFunction callback;

//   EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1));

//   Foo(callback.AsStdFunction());

// }

template 

class MockFunction;

$for i [[

$range j 0..i-1

$var ArgTypes = [[$for j, [[A$j]]]]

$var ArgNames = [[$for j, [[a$j]]]]

$var ArgDecls = [[$for j, [[A$j a$j]]]]

template 

class MockFunction {

 public:

  MockFunction() {}

  MOCK_METHOD$i[[]]_T(Call, R($ArgTypes));

#if GTEST_HAS_STD_FUNCTION_

  std::function AsStdFunction() {

    return [this]($ArgDecls) -> R {

      return this->Call($ArgNames);

    };

  }

#endif  // GTEST_HAS_STD_FUNCTION_

 private:

  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);

};

]]

}  // namespace testing

#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_