Home | History | Annotate | Download | only in gmock 
      1 $$ -*- mode: c++; -*-
      2 $$ This is a Pump source file.  Please use Pump to convert it to
      3 $$ gmock-generated-function-mockers.h.
      4 $$
      5 $var n = 10  $$ The maximum arity we support.
      6 // Copyright 2007, Google Inc.
      7 // All rights reserved.
      8 //
      9 // Redistribution and use in source and binary forms, with or without
     10 // modification, are permitted provided that the following conditions are
     11 // met:
     12 //
     13 //     * Redistributions of source code must retain the above copyright
     14 // notice, this list of conditions and the following disclaimer.
     15 //     * Redistributions in binary form must reproduce the above
     16 // copyright notice, this list of conditions and the following disclaimer
     17 // in the documentation and/or other materials provided with the
     18 // distribution.
     19 //     * Neither the name of Google Inc. nor the names of its
     20 // contributors may be used to endorse or promote products derived from
     21 // this software without specific prior written permission.
     22 //
     23 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     24 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     25 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     26 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     27 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     28 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     29 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     30 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     31 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     32 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     33 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     34 //
     35 // Author: wan (a] google.com (Zhanyong Wan)
     36 
     37 // Google Mock - a framework for writing C++ mock classes.
     38 //
     39 // This file implements function mockers of various arities.
     40 
     41 #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
     42 #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
     43 
     44 #include "gmock/gmock-spec-builders.h"
     45 #include "gmock/internal/gmock-internal-utils.h"
     46 
     47 namespace testing {
     48 namespace internal {
     49 
     50 template <typename F>
     51 class FunctionMockerBase;
     52 
     53 // Note: class FunctionMocker really belongs to the ::testing
     54 // namespace.  However if we define it in ::testing, MSVC will
     55 // complain when classes in ::testing::internal declare it as a
     56 // friend class template.  To workaround this compiler bug, we define
     57 // FunctionMocker in ::testing::internal and import it into ::testing.
     58 template <typename F>
     59 class FunctionMocker;
     60 
     61 
     62 $range i 0..n
     63 $for i [[
     64 $range j 1..i
     65 $var typename_As = [[$for j [[, typename A$j]]]]
     66 $var As = [[$for j, [[A$j]]]]
     67 $var as = [[$for j, [[a$j]]]]
     68 $var Aas = [[$for j, [[A$j a$j]]]]
     69 $var ms = [[$for j, [[m$j]]]]
     70 $var matchers = [[$for j, [[const Matcher<A$j>& m$j]]]]
     71 template <typename R$typename_As>
     72 class FunctionMocker<R($As)> : public
     73     internal::FunctionMockerBase<R($As)> {
     74  public:
     75   typedef R F($As);
     76   typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
     77 
     78   MockSpec<F>& With($matchers) {
     79 
     80 $if i >= 1 [[
     81     this->current_spec().SetMatchers(::std::tr1::make_tuple($ms));
     82 
     83 ]]
     84     return this->current_spec();
     85   }
     86 
     87   R Invoke($Aas) {
     88     // Even though gcc and MSVC don't enforce it, 'this->' is required
     89     // by the C++ standard [14.6.4] here, as the base class type is
     90     // dependent on the template argument (and thus shouldn't be
     91     // looked into when resolving InvokeWith).
     92     return this->InvokeWith(ArgumentTuple($as));
     93   }
     94 };
     95 
     96 
     97 ]]
     98 }  // namespace internal
     99 
    100 // The style guide prohibits "using" statements in a namespace scope
    101 // inside a header file.  However, the FunctionMocker class template
    102 // is meant to be defined in the ::testing namespace.  The following
    103 // line is just a trick for working around a bug in MSVC 8.0, which
    104 // cannot handle it if we define FunctionMocker in ::testing.
    105 using internal::FunctionMocker;
    106 
    107 // The result type of function type F.
    108 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
    109 #define GMOCK_RESULT_(tn, F) tn ::testing::internal::Function<F>::Result
    110 
    111 // The type of argument N of function type F.
    112 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
    113 #define GMOCK_ARG_(tn, F, N) tn ::testing::internal::Function<F>::Argument##N
    114 
    115 // The matcher type for argument N of function type F.
    116 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
    117 #define GMOCK_MATCHER_(tn, F, N) const ::testing::Matcher<GMOCK_ARG_(tn, F, N)>&
    118 
    119 // The variable for mocking the given method.
    120 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
    121 #define GMOCK_MOCKER_(arity, constness, Method) \
    122     GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)
    123 
    124 
    125 $for i [[
    126 $range j 1..i
    127 $var arg_as = [[$for j, \
    128                                  [[GMOCK_ARG_(tn, F, $j) gmock_a$j]]]]
    129 $var as = [[$for j, [[gmock_a$j]]]]
    130 $var matcher_as = [[$for j, \
    131                      [[GMOCK_MATCHER_(tn, F, $j) gmock_a$j]]]]
    132 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
    133 #define GMOCK_METHOD$i[[]]_(tn, constness, ct, Method, F) \
    134   GMOCK_RESULT_(tn, F) ct Method($arg_as) constness { \
    135     GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
    136         tn ::testing::internal::Function<F>::ArgumentTuple>::value == $i, \
    137         this_method_does_not_take_$i[[]]_argument[[$if i != 1 [[s]]]]); \
    138     GMOCK_MOCKER_($i, constness, Method).SetOwnerAndName(this, #Method); \
    139     return GMOCK_MOCKER_($i, constness, Method).Invoke($as); \
    140   } \
    141   ::testing::MockSpec<F>& \
    142       gmock_##Method($matcher_as) constness { \
    143     GMOCK_MOCKER_($i, constness, Method).RegisterOwner(this); \
    144     return GMOCK_MOCKER_($i, constness, Method).With($as); \
    145   } \
    146   mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_($i, constness, Method)
    147 
    148 
    149 ]]
    150 $for i [[
    151 #define MOCK_METHOD$i(m, F) GMOCK_METHOD$i[[]]_(, , , m, F)
    152 
    153 ]]
    154 
    155 
    156 $for i [[
    157 #define MOCK_CONST_METHOD$i(m, F) GMOCK_METHOD$i[[]]_(, const, , m, F)
    158 
    159 ]]
    160 
    161 
    162 $for i [[
    163 #define MOCK_METHOD$i[[]]_T(m, F) GMOCK_METHOD$i[[]]_(typename, , , m, F)
    164 
    165 ]]
    166 
    167 
    168 $for i [[
    169 #define MOCK_CONST_METHOD$i[[]]_T(m, F) [[]]
    170 GMOCK_METHOD$i[[]]_(typename, const, , m, F)
    171 
    172 ]]
    173 
    174 
    175 $for i [[
    176 #define MOCK_METHOD$i[[]]_WITH_CALLTYPE(ct, m, F) [[]]
    177 GMOCK_METHOD$i[[]]_(, , ct, m, F)
    178 
    179 ]]
    180 
    181 
    182 $for i [[
    183 #define MOCK_CONST_METHOD$i[[]]_WITH_CALLTYPE(ct, m, F) \
    184     GMOCK_METHOD$i[[]]_(, const, ct, m, F)
    185 
    186 ]]
    187 
    188 
    189 $for i [[
    190 #define MOCK_METHOD$i[[]]_T_WITH_CALLTYPE(ct, m, F) \
    191     GMOCK_METHOD$i[[]]_(typename, , ct, m, F)
    192 
    193 ]]
    194 
    195 
    196 $for i [[
    197 #define MOCK_CONST_METHOD$i[[]]_T_WITH_CALLTYPE(ct, m, F) \
    198     GMOCK_METHOD$i[[]]_(typename, const, ct, m, F)
    199 
    200 ]]
    201 
    202 // A MockFunction<F> class has one mock method whose type is F.  It is
    203 // useful when you just want your test code to emit some messages and
    204 // have Google Mock verify the right messages are sent (and perhaps at
    205 // the right times).  For example, if you are exercising code:
    206 //
    207 //   Foo(1);
    208 //   Foo(2);
    209 //   Foo(3);
    210 //
    211 // and want to verify that Foo(1) and Foo(3) both invoke
    212 // mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write:
    213 //
    214 // TEST(FooTest, InvokesBarCorrectly) {
    215 //   MyMock mock;
    216 //   MockFunction<void(string check_point_name)> check;
    217 //   {
    218 //     InSequence s;
    219 //
    220 //     EXPECT_CALL(mock, Bar("a"));
    221 //     EXPECT_CALL(check, Call("1"));
    222 //     EXPECT_CALL(check, Call("2"));
    223 //     EXPECT_CALL(mock, Bar("a"));
    224 //   }
    225 //   Foo(1);
    226 //   check.Call("1");
    227 //   Foo(2);
    228 //   check.Call("2");
    229 //   Foo(3);
    230 // }
    231 //
    232 // The expectation spec says that the first Bar("a") must happen
    233 // before check point "1", the second Bar("a") must happen after check
    234 // point "2", and nothing should happen between the two check
    235 // points. The explicit check points make it easy to tell which
    236 // Bar("a") is called by which call to Foo().
    237 template <typename F>
    238 class MockFunction;
    239 
    240 
    241 $for i [[
    242 $range j 0..i-1
    243 template <typename R$for j [[, typename A$j]]>
    244 class MockFunction<R($for j, [[A$j]])> {
    245  public:
    246   MockFunction() {}
    247 
    248   MOCK_METHOD$i[[]]_T(Call, R($for j, [[A$j]]));
    249 
    250  private:
    251   GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
    252 };
    253 
    254 
    255 ]]
    256 }  // namespace testing
    257 
    258 #endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
    259