Subversion Repositories s80186

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

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

$$ gmock-generated-actions.h.

$$

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

$$ }} This line fixes auto-indentation of the following code in Emacs.

// Copyright 2008, Google Inc.

// All rights reserved.

//

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

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

// met:

//

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

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

//     * Redistributions in binary form must reproduce the above

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

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

// distribution.

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

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

// this software without specific prior written permission.

//

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

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

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

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

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

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

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

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

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

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

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

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

//

// This file implements some commonly used variadic matchers.

#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_

#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_

#include 

#include 

#include 

#include 

#include "gmock/gmock-matchers.h"

namespace testing {

namespace internal {

$range i 0..n-1

// The type of the i-th (0-based) field of Tuple.

#define GMOCK_FIELD_TYPE_(Tuple, i) \

    typename ::testing::tuple_element::type

// TupleFields is for selecting fields from a

// tuple of type Tuple.  It has two members:

//

//   type: a tuple type whose i-th field is the ki-th field of Tuple.

//   GetSelectedFields(t): returns fields k0, ..., and kn of t as a tuple.

//

// For example, in class TupleFields, 2, 0>, we have:

//

//   type is tuple, and

//   GetSelectedFields(make_tuple(true, 'a', 42)) is (42, true).

template 

class TupleFields;

// This generic version is used when there are $n selectors.

template 

class TupleFields {

 public:

  typedef ::testing::tuple<$for i, [[GMOCK_FIELD_TYPE_(Tuple, k$i)]]> type;

  static type GetSelectedFields(const Tuple& t) {

    return type($for i, [[get(t)]]);

  }

};

// The following specialization is used for 0 ~ $(n-1) selectors.

$for i [[

$$ }}}

$range j 0..i-1

$range k 0..n-1

template 

class TupleFields {

 public:

  typedef ::testing::tuple<$for j, [[GMOCK_FIELD_TYPE_(Tuple, k$j)]]> type;

  static type GetSelectedFields(const Tuple& $if i==0 [[/* t */]] $else [[t]]) {

    return type($for j, [[get(t)]]);

  }

};

]]

#undef GMOCK_FIELD_TYPE_

// Implements the Args() matcher.

$var ks = [[$for i, [[k$i]]]]

template 

class ArgsMatcherImpl : public MatcherInterface {

 public:

  // ArgsTuple may have top-level const or reference modifiers.

  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple;

  typedef typename internal::TupleFields::type SelectedArgs;

  typedef Matcher MonomorphicInnerMatcher;

  template 

  explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)

      : inner_matcher_(SafeMatcherCast(inner_matcher)) {}

  virtual bool MatchAndExplain(ArgsTuple args,

                               MatchResultListener* listener) const {

    const SelectedArgs& selected_args = GetSelectedArgs(args);

    if (!listener->IsInterested())

      return inner_matcher_.Matches(selected_args);

    PrintIndices(listener->stream());

    *listener << "are " << PrintToString(selected_args);

    StringMatchResultListener inner_listener;

    const bool match = inner_matcher_.MatchAndExplain(selected_args,

                                                      &inner_listener);

    PrintIfNotEmpty(inner_listener.str(), listener->stream());

    return match;

  }

  virtual void DescribeTo(::std::ostream* os) const {

    *os << "are a tuple ";

    PrintIndices(os);

    inner_matcher_.DescribeTo(os);

  }

  virtual void DescribeNegationTo(::std::ostream* os) const {

    *os << "are a tuple ";

    PrintIndices(os);

    inner_matcher_.DescribeNegationTo(os);

  }

 private:

  static SelectedArgs GetSelectedArgs(ArgsTuple args) {

    return TupleFields::GetSelectedFields(args);

  }

  // Prints the indices of the selected fields.

  static void PrintIndices(::std::ostream* os) {

    *os << "whose fields (";

    const int indices[$n] = { $ks };

    for (int i = 0; i < $n; i++) {

      if (indices[i] < 0)

        break;

      if (i >= 1)

        *os << ", ";

      *os << "#" << indices[i];

    }

    *os << ") ";

  }

  const MonomorphicInnerMatcher inner_matcher_;

  GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl);

};

template 

class ArgsMatcher {

 public:

  explicit ArgsMatcher(const InnerMatcher& inner_matcher)

      : inner_matcher_(inner_matcher) {}

  template 

  operator Matcher() const {

    return MakeMatcher(new ArgsMatcherImpl(inner_matcher_));

  }

 private:

  const InnerMatcher inner_matcher_;

  GTEST_DISALLOW_ASSIGN_(ArgsMatcher);

};

// A set of metafunctions for computing the result type of AllOf.

// AllOf(m1, ..., mN) returns

// AllOfResultN::type.

// Although AllOf isn't defined for one argument, AllOfResult1 is defined

// to simplify the implementation.

template 

struct AllOfResult1 {

  typedef M1 type;

};

$range i 1..n

$range i 2..n

$for i [[

$range j 2..i

$var m = i/2

$range k 1..m

$range t m+1..i

template 

struct AllOfResult$i {

  typedef BothOfMatcher<

      typename AllOfResult$m<$for k, [[M$k]]>::type,

      typename AllOfResult$(i-m)<$for t, [[M$t]]>::type

  > type;

};

]]

// A set of metafunctions for computing the result type of AnyOf.

// AnyOf(m1, ..., mN) returns

// AnyOfResultN::type.

// Although AnyOf isn't defined for one argument, AnyOfResult1 is defined

// to simplify the implementation.

template 

struct AnyOfResult1 {

  typedef M1 type;

};

$range i 1..n

$range i 2..n

$for i [[

$range j 2..i

$var m = i/2

$range k 1..m

$range t m+1..i

template 

struct AnyOfResult$i {

  typedef EitherOfMatcher<

      typename AnyOfResult$m<$for k, [[M$k]]>::type,

      typename AnyOfResult$(i-m)<$for t, [[M$t]]>::type

  > type;

};

]]

}  // namespace internal

// Args(a_matcher) matches a tuple if the selected

// fields of it matches a_matcher.  C++ doesn't support default

// arguments for function templates, so we have to overload it.

$range i 0..n

$for i [[

$range j 1..i

template <$for j [[int k$j, ]]typename InnerMatcher>

inline internal::ArgsMatcher

Args(const InnerMatcher& matcher) {

  return internal::ArgsMatcher(matcher);

}

]]

// ElementsAre(e_1, e_2, ... e_n) matches an STL-style container with

// n elements, where the i-th element in the container must

// match the i-th argument in the list.  Each argument of

// ElementsAre() can be either a value or a matcher.  We support up to

// $n arguments.

//

// The use of DecayArray in the implementation allows ElementsAre()

// to accept string literals, whose type is const char[N], but we

// want to treat them as const char*.

//

// NOTE: Since ElementsAre() cares about the order of the elements, it

// must not be used with containers whose elements's order is

// undefined (e.g. hash_map).

$range i 0..n

$for i [[

$range j 1..i

$if i>0 [[

template <$for j, [[typename T$j]]>

]]

inline internal::ElementsAreMatcher<

    ::testing::tuple<

$for j, [[

        typename internal::DecayArray::type]]> >

ElementsAre($for j, [[const T$j& e$j]]) {

  typedef ::testing::tuple<

$for j, [[

      typename internal::DecayArray::type]]> Args;

  return internal::ElementsAreMatcher(Args($for j, [[e$j]]));

}

]]

// UnorderedElementsAre(e_1, e_2, ..., e_n) is an ElementsAre extension

// that matches n elements in any order.  We support up to n=$n arguments.

$range i 0..n

$for i [[

$range j 1..i

$if i>0 [[

template <$for j, [[typename T$j]]>

]]

inline internal::UnorderedElementsAreMatcher<

    ::testing::tuple<

$for j, [[

        typename internal::DecayArray::type]]> >

UnorderedElementsAre($for j, [[const T$j& e$j]]) {

  typedef ::testing::tuple<

$for j, [[

      typename internal::DecayArray::type]]> Args;

  return internal::UnorderedElementsAreMatcher(Args($for j, [[e$j]]));

}

]]

// AllOf(m1, m2, ..., mk) matches any value that matches all of the given

// sub-matchers.  AllOf is called fully qualified to prevent ADL from firing.

$range i 2..n

$for i [[

$range j 1..i

$var m = i/2

$range k 1..m

$range t m+1..i

template <$for j, [[typename M$j]]>

inline typename internal::AllOfResult$i<$for j, [[M$j]]>::type

AllOf($for j, [[M$j m$j]]) {

  return typename internal::AllOfResult$i<$for j, [[M$j]]>::type(

      $if m == 1 [[m1]] $else [[::testing::AllOf($for k, [[m$k]])]],

      $if m+1 == i [[m$i]] $else [[::testing::AllOf($for t, [[m$t]])]]);

}

]]

// AnyOf(m1, m2, ..., mk) matches any value that matches any of the given

// sub-matchers.  AnyOf is called fully qualified to prevent ADL from firing.

$range i 2..n

$for i [[

$range j 1..i

$var m = i/2

$range k 1..m

$range t m+1..i

template <$for j, [[typename M$j]]>

inline typename internal::AnyOfResult$i<$for j, [[M$j]]>::type

AnyOf($for j, [[M$j m$j]]) {

  return typename internal::AnyOfResult$i<$for j, [[M$j]]>::type(

      $if m == 1 [[m1]] $else [[::testing::AnyOf($for k, [[m$k]])]],

      $if m+1 == i [[m$i]] $else [[::testing::AnyOf($for t, [[m$t]])]]);

}

]]

}  // namespace testing

$$ } // This Pump meta comment fixes auto-indentation in Emacs. It will not

$$   // show up in the generated code.

// The MATCHER* family of macros can be used in a namespace scope to

// define custom matchers easily.

//

// Basic Usage

// ===========

//

// The syntax

//

//   MATCHER(name, description_string) { statements; }

//

// defines a matcher with the given name that executes the statements,

// which must return a bool to indicate if the match succeeds.  Inside

// the statements, you can refer to the value being matched by 'arg',

// and refer to its type by 'arg_type'.

//

// The description string documents what the matcher does, and is used

// to generate the failure message when the match fails.  Since a

// MATCHER() is usually defined in a header file shared by multiple

// C++ source files, we require the description to be a C-string

// literal to avoid possible side effects.  It can be empty, in which

// case we'll use the sequence of words in the matcher name as the

// description.

//

// For example:

//

//   MATCHER(IsEven, "") { return (arg % 2) == 0; }

//

// allows you to write

//

//   // Expects mock_foo.Bar(n) to be called where n is even.

//   EXPECT_CALL(mock_foo, Bar(IsEven()));

//

// or,

//

//   // Verifies that the value of some_expression is even.

//   EXPECT_THAT(some_expression, IsEven());

//

// If the above assertion fails, it will print something like:

//

//   Value of: some_expression

//   Expected: is even

//     Actual: 7

//

// where the description "is even" is automatically calculated from the

// matcher name IsEven.

//

// Argument Type

// =============

//

// Note that the type of the value being matched (arg_type) is

// determined by the context in which you use the matcher and is

// supplied to you by the compiler, so you don't need to worry about

// declaring it (nor can you).  This allows the matcher to be

// polymorphic.  For example, IsEven() can be used to match any type

// where the value of "(arg % 2) == 0" can be implicitly converted to

// a bool.  In the "Bar(IsEven())" example above, if method Bar()

// takes an int, 'arg_type' will be int; if it takes an unsigned long,

// 'arg_type' will be unsigned long; and so on.

//

// Parameterizing Matchers

// =======================

//

// Sometimes you'll want to parameterize the matcher.  For that you

// can use another macro:

//

//   MATCHER_P(name, param_name, description_string) { statements; }

//

// For example:

//

//   MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; }

//

// will allow you to write:

//

//   EXPECT_THAT(Blah("a"), HasAbsoluteValue(n));

//

// which may lead to this message (assuming n is 10):

//

//   Value of: Blah("a")

//   Expected: has absolute value 10

//     Actual: -9

//

// Note that both the matcher description and its parameter are

// printed, making the message human-friendly.

//

// In the matcher definition body, you can write 'foo_type' to

// reference the type of a parameter named 'foo'.  For example, in the

// body of MATCHER_P(HasAbsoluteValue, value) above, you can write

// 'value_type' to refer to the type of 'value'.

//

// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P$n to

// support multi-parameter matchers.

//

// Describing Parameterized Matchers

// =================================

//

// The last argument to MATCHER*() is a string-typed expression.  The

// expression can reference all of the matcher's parameters and a

// special bool-typed variable named 'negation'.  When 'negation' is

// false, the expression should evaluate to the matcher's description;

// otherwise it should evaluate to the description of the negation of

// the matcher.  For example,

//

//   using testing::PrintToString;

//

//   MATCHER_P2(InClosedRange, low, hi,

//       string(negation ? "is not" : "is") + " in range [" +

//       PrintToString(low) + ", " + PrintToString(hi) + "]") {

//     return low <= arg && arg <= hi;

//   }

//   ...

//   EXPECT_THAT(3, InClosedRange(4, 6));

//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));

//

// would generate two failures that contain the text:

//

//   Expected: is in range [4, 6]

//   ...

//   Expected: is not in range [2, 4]

//

// If you specify "" as the description, the failure message will

// contain the sequence of words in the matcher name followed by the

// parameter values printed as a tuple.  For example,

//

//   MATCHER_P2(InClosedRange, low, hi, "") { ... }

//   ...

//   EXPECT_THAT(3, InClosedRange(4, 6));

//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));

//

// would generate two failures that contain the text:

//

//   Expected: in closed range (4, 6)

//   ...

//   Expected: not (in closed range (2, 4))

//

// Types of Matcher Parameters

// ===========================

//

// For the purpose of typing, you can view

//

//   MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... }

//

// as shorthand for

//

//   template 

//   FooMatcherPk

//   Foo(p1_type p1, ..., pk_type pk) { ... }

//

// When you write Foo(v1, ..., vk), the compiler infers the types of

// the parameters v1, ..., and vk for you.  If you are not happy with

// the result of the type inference, you can specify the types by

// explicitly instantiating the template, as in Foo(5,

// false).  As said earlier, you don't get to (or need to) specify

// 'arg_type' as that's determined by the context in which the matcher

// is used.  You can assign the result of expression Foo(p1, ..., pk)

// to a variable of type FooMatcherPk.  This

// can be useful when composing matchers.

//

// While you can instantiate a matcher template with reference types,

// passing the parameters by pointer usually makes your code more

// readable.  If, however, you still want to pass a parameter by

// reference, be aware that in the failure message generated by the

// matcher you will see the value of the referenced object but not its

// address.

//

// Explaining Match Results

// ========================

//

// Sometimes the matcher description alone isn't enough to explain why

// the match has failed or succeeded.  For example, when expecting a

// long string, it can be very helpful to also print the diff between

// the expected string and the actual one.  To achieve that, you can

// optionally stream additional information to a special variable

// named result_listener, whose type is a pointer to class

// MatchResultListener:

//

//   MATCHER_P(EqualsLongString, str, "") {

//     if (arg == str) return true;

//

//     *result_listener << "the difference: "

///                     << DiffStrings(str, arg);

//     return false;

//   }

//

// Overloading Matchers

// ====================

//

// You can overload matchers with different numbers of parameters:

//

//   MATCHER_P(Blah, a, description_string1) { ... }

//   MATCHER_P2(Blah, a, b, description_string2) { ... }

//

// Caveats

// =======

//

// When defining a new matcher, you should also consider implementing

// MatcherInterface or using MakePolymorphicMatcher().  These

// approaches require more work than the MATCHER* macros, but also

// give you more control on the types of the value being matched and

// the matcher parameters, which may leads to better compiler error

// messages when the matcher is used wrong.  They also allow

// overloading matchers based on parameter types (as opposed to just

// based on the number of parameters).

//

// MATCHER*() can only be used in a namespace scope.  The reason is

// that C++ doesn't yet allow function-local types to be used to

// instantiate templates.  The up-coming C++0x standard will fix this.

// Once that's done, we'll consider supporting using MATCHER*() inside

// a function.

//

// More Information

// ================

//

// To learn more about using these macros, please search for 'MATCHER'

// on http://code.google.com/p/googlemock/wiki/CookBook.

$range i 0..n

$for i

[[

$var macro_name = [[$if i==0 [[MATCHER]] $elif i==1 [[MATCHER_P]]

                                         $else [[MATCHER_P$i]]]]

$var class_name = [[name##Matcher[[$if i==0 [[]] $elif i==1 [[P]]

                                                 $else [[P$i]]]]]]

$range j 0..i-1

$var template = [[$if i==0 [[]] $else [[

  template <$for j, [[typename p$j##_type]]>\

]]]]

$var ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]]

$var impl_ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]]

$var impl_inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(gmock_p$j)]]]]]]

$var inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(gmock_p$j)]]]]]]

$var params = [[$for j, [[p$j]]]]

$var param_types = [[$if i==0 [[]] $else [[<$for j, [[p$j##_type]]>]]]]

$var param_types_and_names = [[$for j, [[p$j##_type p$j]]]]

$var param_field_decls = [[$for j

[[

      p$j##_type p$j;\

]]]]

$var param_field_decls2 = [[$for j

[[

    p$j##_type p$j;\

]]]]

#define $macro_name(name$for j [[, p$j]], description)\$template

  class $class_name {\

   public:\

    template \

    class gmock_Impl : public ::testing::MatcherInterface {\

     public:\

      [[$if i==1 [[explicit ]]]]gmock_Impl($impl_ctor_param_list)\

          $impl_inits {}\

      virtual bool MatchAndExplain(\

          arg_type arg, ::testing::MatchResultListener* result_listener) const;\

      virtual void DescribeTo(::std::ostream* gmock_os) const {\

        *gmock_os << FormatDescription(false);\

      }\

      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\

        *gmock_os << FormatDescription(true);\

      }\$param_field_decls

     private:\

      ::testing::internal::string FormatDescription(bool negation) const {\

        const ::testing::internal::string gmock_description = (description);\

        if (!gmock_description.empty())\

          return gmock_description;\

        return ::testing::internal::FormatMatcherDescription(\

            negation, #name, \

            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\

                ::testing::tuple<$for j, [[p$j##_type]]>($for j, [[p$j]])));\

      }\

      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\

    };\

    template \

    operator ::testing::Matcher() const {\

      return ::testing::Matcher(\

          new gmock_Impl($params));\

    }\

    [[$if i==1 [[explicit ]]]]$class_name($ctor_param_list)$inits {\

    }\$param_field_decls2

   private:\

    GTEST_DISALLOW_ASSIGN_($class_name);\

  };\$template

  inline $class_name$param_types name($param_types_and_names) {\

    return $class_name$param_types($params);\

  }\$template

  template \

  bool $class_name$param_types::gmock_Impl::MatchAndExplain(\

      arg_type arg, \

      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\

          const

]]

#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_