PageRenderTime 112ms CodeModel.GetById 14ms app.highlight 86ms RepoModel.GetById 2ms app.codeStats 0ms

/testlibs/gmock/include/gmock/gmock-generated-matchers.h

https://github.com/deltaforge/nebu-app-hadoop
C Header | 2054 lines | 1602 code | 160 blank | 292 comment | 15 complexity | e8fb88ad9132634af60059773166abb2 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1// This file was GENERATED by command:
   2//     pump.py gmock-generated-matchers.h.pump
   3// DO NOT EDIT BY HAND!!!
   4
   5// Copyright 2008, Google Inc.
   6// All rights reserved.
   7//
   8// Redistribution and use in source and binary forms, with or without
   9// modification, are permitted provided that the following conditions are
  10// met:
  11//
  12//     * Redistributions of source code must retain the above copyright
  13// notice, this list of conditions and the following disclaimer.
  14//     * Redistributions in binary form must reproduce the above
  15// copyright notice, this list of conditions and the following disclaimer
  16// in the documentation and/or other materials provided with the
  17// distribution.
  18//     * Neither the name of Google Inc. nor the names of its
  19// contributors may be used to endorse or promote products derived from
  20// this software without specific prior written permission.
  21//
  22// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  26// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  27// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  28// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  32// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33
  34// Google Mock - a framework for writing C++ mock classes.
  35//
  36// This file implements some commonly used variadic matchers.
  37
  38#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
  39#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
  40
  41#include <sstream>
  42#include <string>
  43#include <vector>
  44#include "gmock/gmock-matchers.h"
  45
  46namespace testing {
  47namespace internal {
  48
  49// The type of the i-th (0-based) field of Tuple.
  50#define GMOCK_FIELD_TYPE_(Tuple, i) \
  51    typename ::std::tr1::tuple_element<i, Tuple>::type
  52
  53// TupleFields<Tuple, k0, ..., kn> is for selecting fields from a
  54// tuple of type Tuple.  It has two members:
  55//
  56//   type: a tuple type whose i-th field is the ki-th field of Tuple.
  57//   GetSelectedFields(t): returns fields k0, ..., and kn of t as a tuple.
  58//
  59// For example, in class TupleFields<tuple<bool, char, int>, 2, 0>, we have:
  60//
  61//   type is tuple<int, bool>, and
  62//   GetSelectedFields(make_tuple(true, 'a', 42)) is (42, true).
  63
  64template <class Tuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
  65    int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
  66    int k9 = -1>
  67class TupleFields;
  68
  69// This generic version is used when there are 10 selectors.
  70template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
  71    int k7, int k8, int k9>
  72class TupleFields {
  73 public:
  74  typedef ::std::tr1::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
  75      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
  76      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
  77      GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
  78      GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8),
  79      GMOCK_FIELD_TYPE_(Tuple, k9)> type;
  80  static type GetSelectedFields(const Tuple& t) {
  81    using ::std::tr1::get;
  82    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
  83        get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t), get<k9>(t));
  84  }
  85};
  86
  87// The following specialization is used for 0 ~ 9 selectors.
  88
  89template <class Tuple>
  90class TupleFields<Tuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
  91 public:
  92  typedef ::std::tr1::tuple<> type;
  93  static type GetSelectedFields(const Tuple& /* t */) {
  94    using ::std::tr1::get;
  95    return type();
  96  }
  97};
  98
  99template <class Tuple, int k0>
 100class TupleFields<Tuple, k0, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
 101 public:
 102  typedef ::std::tr1::tuple<GMOCK_FIELD_TYPE_(Tuple, k0)> type;
 103  static type GetSelectedFields(const Tuple& t) {
 104    using ::std::tr1::get;
 105    return type(get<k0>(t));
 106  }
 107};
 108
 109template <class Tuple, int k0, int k1>
 110class TupleFields<Tuple, k0, k1, -1, -1, -1, -1, -1, -1, -1, -1> {
 111 public:
 112  typedef ::std::tr1::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
 113      GMOCK_FIELD_TYPE_(Tuple, k1)> type;
 114  static type GetSelectedFields(const Tuple& t) {
 115    using ::std::tr1::get;
 116    return type(get<k0>(t), get<k1>(t));
 117  }
 118};
 119
 120template <class Tuple, int k0, int k1, int k2>
 121class TupleFields<Tuple, k0, k1, k2, -1, -1, -1, -1, -1, -1, -1> {
 122 public:
 123  typedef ::std::tr1::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
 124      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2)> type;
 125  static type GetSelectedFields(const Tuple& t) {
 126    using ::std::tr1::get;
 127    return type(get<k0>(t), get<k1>(t), get<k2>(t));
 128  }
 129};
 130
 131template <class Tuple, int k0, int k1, int k2, int k3>
 132class TupleFields<Tuple, k0, k1, k2, k3, -1, -1, -1, -1, -1, -1> {
 133 public:
 134  typedef ::std::tr1::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
 135      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
 136      GMOCK_FIELD_TYPE_(Tuple, k3)> type;
 137  static type GetSelectedFields(const Tuple& t) {
 138    using ::std::tr1::get;
 139    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t));
 140  }
 141};
 142
 143template <class Tuple, int k0, int k1, int k2, int k3, int k4>
 144class TupleFields<Tuple, k0, k1, k2, k3, k4, -1, -1, -1, -1, -1> {
 145 public:
 146  typedef ::std::tr1::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
 147      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
 148      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4)> type;
 149  static type GetSelectedFields(const Tuple& t) {
 150    using ::std::tr1::get;
 151    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t));
 152  }
 153};
 154
 155template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5>
 156class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, -1, -1, -1, -1> {
 157 public:
 158  typedef ::std::tr1::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
 159      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
 160      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
 161      GMOCK_FIELD_TYPE_(Tuple, k5)> type;
 162  static type GetSelectedFields(const Tuple& t) {
 163    using ::std::tr1::get;
 164    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
 165        get<k5>(t));
 166  }
 167};
 168
 169template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6>
 170class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, -1, -1, -1> {
 171 public:
 172  typedef ::std::tr1::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
 173      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
 174      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
 175      GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6)> type;
 176  static type GetSelectedFields(const Tuple& t) {
 177    using ::std::tr1::get;
 178    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
 179        get<k5>(t), get<k6>(t));
 180  }
 181};
 182
 183template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
 184    int k7>
 185class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, -1, -1> {
 186 public:
 187  typedef ::std::tr1::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
 188      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
 189      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
 190      GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
 191      GMOCK_FIELD_TYPE_(Tuple, k7)> type;
 192  static type GetSelectedFields(const Tuple& t) {
 193    using ::std::tr1::get;
 194    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
 195        get<k5>(t), get<k6>(t), get<k7>(t));
 196  }
 197};
 198
 199template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
 200    int k7, int k8>
 201class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, -1> {
 202 public:
 203  typedef ::std::tr1::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
 204      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
 205      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
 206      GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
 207      GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8)> type;
 208  static type GetSelectedFields(const Tuple& t) {
 209    using ::std::tr1::get;
 210    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
 211        get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t));
 212  }
 213};
 214
 215#undef GMOCK_FIELD_TYPE_
 216
 217// Implements the Args() matcher.
 218template <class ArgsTuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
 219    int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
 220    int k9 = -1>
 221class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
 222 public:
 223  // ArgsTuple may have top-level const or reference modifiers.
 224  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple;
 225  typedef typename internal::TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5,
 226      k6, k7, k8, k9>::type SelectedArgs;
 227  typedef Matcher<const SelectedArgs&> MonomorphicInnerMatcher;
 228
 229  template <typename InnerMatcher>
 230  explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
 231      : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {}
 232
 233  virtual bool MatchAndExplain(ArgsTuple args,
 234                               MatchResultListener* listener) const {
 235    const SelectedArgs& selected_args = GetSelectedArgs(args);
 236    if (!listener->IsInterested())
 237      return inner_matcher_.Matches(selected_args);
 238
 239    PrintIndices(listener->stream());
 240    *listener << "are " << PrintToString(selected_args);
 241
 242    StringMatchResultListener inner_listener;
 243    const bool match = inner_matcher_.MatchAndExplain(selected_args,
 244                                                      &inner_listener);
 245    PrintIfNotEmpty(inner_listener.str(), listener->stream());
 246    return match;
 247  }
 248
 249  virtual void DescribeTo(::std::ostream* os) const {
 250    *os << "are a tuple ";
 251    PrintIndices(os);
 252    inner_matcher_.DescribeTo(os);
 253  }
 254
 255  virtual void DescribeNegationTo(::std::ostream* os) const {
 256    *os << "are a tuple ";
 257    PrintIndices(os);
 258    inner_matcher_.DescribeNegationTo(os);
 259  }
 260
 261 private:
 262  static SelectedArgs GetSelectedArgs(ArgsTuple args) {
 263    return TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5, k6, k7, k8,
 264        k9>::GetSelectedFields(args);
 265  }
 266
 267  // Prints the indices of the selected fields.
 268  static void PrintIndices(::std::ostream* os) {
 269    *os << "whose fields (";
 270    const int indices[10] = { k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 };
 271    for (int i = 0; i < 10; i++) {
 272      if (indices[i] < 0)
 273        break;
 274
 275      if (i >= 1)
 276        *os << ", ";
 277
 278      *os << "#" << indices[i];
 279    }
 280    *os << ") ";
 281  }
 282
 283  const MonomorphicInnerMatcher inner_matcher_;
 284
 285  GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl);
 286};
 287
 288template <class InnerMatcher, int k0 = -1, int k1 = -1, int k2 = -1,
 289    int k3 = -1, int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1,
 290    int k8 = -1, int k9 = -1>
 291class ArgsMatcher {
 292 public:
 293  explicit ArgsMatcher(const InnerMatcher& inner_matcher)
 294      : inner_matcher_(inner_matcher) {}
 295
 296  template <typename ArgsTuple>
 297  operator Matcher<ArgsTuple>() const {
 298    return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, k0, k1, k2, k3, k4, k5,
 299        k6, k7, k8, k9>(inner_matcher_));
 300  }
 301
 302 private:
 303  const InnerMatcher inner_matcher_;
 304
 305  GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
 306};
 307
 308// Implements ElementsAre() of 1-10 arguments.
 309
 310template <typename T1>
 311class ElementsAreMatcher1 {
 312 public:
 313  explicit ElementsAreMatcher1(const T1& e1) : e1_(e1) {}
 314
 315  template <typename Container>
 316  operator Matcher<Container>() const {
 317    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
 318    typedef typename internal::StlContainerView<RawContainer>::type::value_type
 319        Element;
 320
 321    // Nokia's Symbian Compiler has a nasty bug where the object put
 322    // in a one-element local array is not destructed when the array
 323    // goes out of scope.  This leads to obvious badness as we've
 324    // added the linked_ptr in it to our other linked_ptrs list.
 325    // Hence we implement ElementsAreMatcher1 specially to avoid using
 326    // a local array.
 327    const Matcher<const Element&> matcher =
 328        MatcherCast<const Element&>(e1_);
 329    return MakeMatcher(new ElementsAreMatcherImpl<Container>(&matcher, 1));
 330  }
 331
 332 private:
 333  const T1& e1_;
 334
 335  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher1);
 336};
 337
 338template <typename T1, typename T2>
 339class ElementsAreMatcher2 {
 340 public:
 341  ElementsAreMatcher2(const T1& e1, const T2& e2) : e1_(e1), e2_(e2) {}
 342
 343  template <typename Container>
 344  operator Matcher<Container>() const {
 345    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
 346    typedef typename internal::StlContainerView<RawContainer>::type::value_type
 347        Element;
 348
 349    const Matcher<const Element&> matchers[] = {
 350      MatcherCast<const Element&>(e1_),
 351      MatcherCast<const Element&>(e2_),
 352    };
 353
 354    return MakeMatcher(new ElementsAreMatcherImpl<Container>(matchers, 2));
 355  }
 356
 357 private:
 358  const T1& e1_;
 359  const T2& e2_;
 360
 361  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher2);
 362};
 363
 364template <typename T1, typename T2, typename T3>
 365class ElementsAreMatcher3 {
 366 public:
 367  ElementsAreMatcher3(const T1& e1, const T2& e2, const T3& e3) : e1_(e1),
 368      e2_(e2), e3_(e3) {}
 369
 370  template <typename Container>
 371  operator Matcher<Container>() const {
 372    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
 373    typedef typename internal::StlContainerView<RawContainer>::type::value_type
 374        Element;
 375
 376    const Matcher<const Element&> matchers[] = {
 377      MatcherCast<const Element&>(e1_),
 378      MatcherCast<const Element&>(e2_),
 379      MatcherCast<const Element&>(e3_),
 380    };
 381
 382    return MakeMatcher(new ElementsAreMatcherImpl<Container>(matchers, 3));
 383  }
 384
 385 private:
 386  const T1& e1_;
 387  const T2& e2_;
 388  const T3& e3_;
 389
 390  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher3);
 391};
 392
 393template <typename T1, typename T2, typename T3, typename T4>
 394class ElementsAreMatcher4 {
 395 public:
 396  ElementsAreMatcher4(const T1& e1, const T2& e2, const T3& e3,
 397      const T4& e4) : e1_(e1), e2_(e2), e3_(e3), e4_(e4) {}
 398
 399  template <typename Container>
 400  operator Matcher<Container>() const {
 401    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
 402    typedef typename internal::StlContainerView<RawContainer>::type::value_type
 403        Element;
 404
 405    const Matcher<const Element&> matchers[] = {
 406      MatcherCast<const Element&>(e1_),
 407      MatcherCast<const Element&>(e2_),
 408      MatcherCast<const Element&>(e3_),
 409      MatcherCast<const Element&>(e4_),
 410    };
 411
 412    return MakeMatcher(new ElementsAreMatcherImpl<Container>(matchers, 4));
 413  }
 414
 415 private:
 416  const T1& e1_;
 417  const T2& e2_;
 418  const T3& e3_;
 419  const T4& e4_;
 420
 421  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher4);
 422};
 423
 424template <typename T1, typename T2, typename T3, typename T4, typename T5>
 425class ElementsAreMatcher5 {
 426 public:
 427  ElementsAreMatcher5(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
 428      const T5& e5) : e1_(e1), e2_(e2), e3_(e3), e4_(e4), e5_(e5) {}
 429
 430  template <typename Container>
 431  operator Matcher<Container>() const {
 432    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
 433    typedef typename internal::StlContainerView<RawContainer>::type::value_type
 434        Element;
 435
 436    const Matcher<const Element&> matchers[] = {
 437      MatcherCast<const Element&>(e1_),
 438      MatcherCast<const Element&>(e2_),
 439      MatcherCast<const Element&>(e3_),
 440      MatcherCast<const Element&>(e4_),
 441      MatcherCast<const Element&>(e5_),
 442    };
 443
 444    return MakeMatcher(new ElementsAreMatcherImpl<Container>(matchers, 5));
 445  }
 446
 447 private:
 448  const T1& e1_;
 449  const T2& e2_;
 450  const T3& e3_;
 451  const T4& e4_;
 452  const T5& e5_;
 453
 454  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher5);
 455};
 456
 457template <typename T1, typename T2, typename T3, typename T4, typename T5,
 458    typename T6>
 459class ElementsAreMatcher6 {
 460 public:
 461  ElementsAreMatcher6(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
 462      const T5& e5, const T6& e6) : e1_(e1), e2_(e2), e3_(e3), e4_(e4),
 463      e5_(e5), e6_(e6) {}
 464
 465  template <typename Container>
 466  operator Matcher<Container>() const {
 467    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
 468    typedef typename internal::StlContainerView<RawContainer>::type::value_type
 469        Element;
 470
 471    const Matcher<const Element&> matchers[] = {
 472      MatcherCast<const Element&>(e1_),
 473      MatcherCast<const Element&>(e2_),
 474      MatcherCast<const Element&>(e3_),
 475      MatcherCast<const Element&>(e4_),
 476      MatcherCast<const Element&>(e5_),
 477      MatcherCast<const Element&>(e6_),
 478    };
 479
 480    return MakeMatcher(new ElementsAreMatcherImpl<Container>(matchers, 6));
 481  }
 482
 483 private:
 484  const T1& e1_;
 485  const T2& e2_;
 486  const T3& e3_;
 487  const T4& e4_;
 488  const T5& e5_;
 489  const T6& e6_;
 490
 491  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher6);
 492};
 493
 494template <typename T1, typename T2, typename T3, typename T4, typename T5,
 495    typename T6, typename T7>
 496class ElementsAreMatcher7 {
 497 public:
 498  ElementsAreMatcher7(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
 499      const T5& e5, const T6& e6, const T7& e7) : e1_(e1), e2_(e2), e3_(e3),
 500      e4_(e4), e5_(e5), e6_(e6), e7_(e7) {}
 501
 502  template <typename Container>
 503  operator Matcher<Container>() const {
 504    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
 505    typedef typename internal::StlContainerView<RawContainer>::type::value_type
 506        Element;
 507
 508    const Matcher<const Element&> matchers[] = {
 509      MatcherCast<const Element&>(e1_),
 510      MatcherCast<const Element&>(e2_),
 511      MatcherCast<const Element&>(e3_),
 512      MatcherCast<const Element&>(e4_),
 513      MatcherCast<const Element&>(e5_),
 514      MatcherCast<const Element&>(e6_),
 515      MatcherCast<const Element&>(e7_),
 516    };
 517
 518    return MakeMatcher(new ElementsAreMatcherImpl<Container>(matchers, 7));
 519  }
 520
 521 private:
 522  const T1& e1_;
 523  const T2& e2_;
 524  const T3& e3_;
 525  const T4& e4_;
 526  const T5& e5_;
 527  const T6& e6_;
 528  const T7& e7_;
 529
 530  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher7);
 531};
 532
 533template <typename T1, typename T2, typename T3, typename T4, typename T5,
 534    typename T6, typename T7, typename T8>
 535class ElementsAreMatcher8 {
 536 public:
 537  ElementsAreMatcher8(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
 538      const T5& e5, const T6& e6, const T7& e7, const T8& e8) : e1_(e1),
 539      e2_(e2), e3_(e3), e4_(e4), e5_(e5), e6_(e6), e7_(e7), e8_(e8) {}
 540
 541  template <typename Container>
 542  operator Matcher<Container>() const {
 543    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
 544    typedef typename internal::StlContainerView<RawContainer>::type::value_type
 545        Element;
 546
 547    const Matcher<const Element&> matchers[] = {
 548      MatcherCast<const Element&>(e1_),
 549      MatcherCast<const Element&>(e2_),
 550      MatcherCast<const Element&>(e3_),
 551      MatcherCast<const Element&>(e4_),
 552      MatcherCast<const Element&>(e5_),
 553      MatcherCast<const Element&>(e6_),
 554      MatcherCast<const Element&>(e7_),
 555      MatcherCast<const Element&>(e8_),
 556    };
 557
 558    return MakeMatcher(new ElementsAreMatcherImpl<Container>(matchers, 8));
 559  }
 560
 561 private:
 562  const T1& e1_;
 563  const T2& e2_;
 564  const T3& e3_;
 565  const T4& e4_;
 566  const T5& e5_;
 567  const T6& e6_;
 568  const T7& e7_;
 569  const T8& e8_;
 570
 571  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher8);
 572};
 573
 574template <typename T1, typename T2, typename T3, typename T4, typename T5,
 575    typename T6, typename T7, typename T8, typename T9>
 576class ElementsAreMatcher9 {
 577 public:
 578  ElementsAreMatcher9(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
 579      const T5& e5, const T6& e6, const T7& e7, const T8& e8,
 580      const T9& e9) : e1_(e1), e2_(e2), e3_(e3), e4_(e4), e5_(e5), e6_(e6),
 581      e7_(e7), e8_(e8), e9_(e9) {}
 582
 583  template <typename Container>
 584  operator Matcher<Container>() const {
 585    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
 586    typedef typename internal::StlContainerView<RawContainer>::type::value_type
 587        Element;
 588
 589    const Matcher<const Element&> matchers[] = {
 590      MatcherCast<const Element&>(e1_),
 591      MatcherCast<const Element&>(e2_),
 592      MatcherCast<const Element&>(e3_),
 593      MatcherCast<const Element&>(e4_),
 594      MatcherCast<const Element&>(e5_),
 595      MatcherCast<const Element&>(e6_),
 596      MatcherCast<const Element&>(e7_),
 597      MatcherCast<const Element&>(e8_),
 598      MatcherCast<const Element&>(e9_),
 599    };
 600
 601    return MakeMatcher(new ElementsAreMatcherImpl<Container>(matchers, 9));
 602  }
 603
 604 private:
 605  const T1& e1_;
 606  const T2& e2_;
 607  const T3& e3_;
 608  const T4& e4_;
 609  const T5& e5_;
 610  const T6& e6_;
 611  const T7& e7_;
 612  const T8& e8_;
 613  const T9& e9_;
 614
 615  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher9);
 616};
 617
 618template <typename T1, typename T2, typename T3, typename T4, typename T5,
 619    typename T6, typename T7, typename T8, typename T9, typename T10>
 620class ElementsAreMatcher10 {
 621 public:
 622  ElementsAreMatcher10(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
 623      const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9,
 624      const T10& e10) : e1_(e1), e2_(e2), e3_(e3), e4_(e4), e5_(e5), e6_(e6),
 625      e7_(e7), e8_(e8), e9_(e9), e10_(e10) {}
 626
 627  template <typename Container>
 628  operator Matcher<Container>() const {
 629    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
 630    typedef typename internal::StlContainerView<RawContainer>::type::value_type
 631        Element;
 632
 633    const Matcher<const Element&> matchers[] = {
 634      MatcherCast<const Element&>(e1_),
 635      MatcherCast<const Element&>(e2_),
 636      MatcherCast<const Element&>(e3_),
 637      MatcherCast<const Element&>(e4_),
 638      MatcherCast<const Element&>(e5_),
 639      MatcherCast<const Element&>(e6_),
 640      MatcherCast<const Element&>(e7_),
 641      MatcherCast<const Element&>(e8_),
 642      MatcherCast<const Element&>(e9_),
 643      MatcherCast<const Element&>(e10_),
 644    };
 645
 646    return MakeMatcher(new ElementsAreMatcherImpl<Container>(matchers, 10));
 647  }
 648
 649 private:
 650  const T1& e1_;
 651  const T2& e2_;
 652  const T3& e3_;
 653  const T4& e4_;
 654  const T5& e5_;
 655  const T6& e6_;
 656  const T7& e7_;
 657  const T8& e8_;
 658  const T9& e9_;
 659  const T10& e10_;
 660
 661  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher10);
 662};
 663
 664}  // namespace internal
 665
 666// Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected
 667// fields of it matches a_matcher.  C++ doesn't support default
 668// arguments for function templates, so we have to overload it.
 669template <typename InnerMatcher>
 670inline internal::ArgsMatcher<InnerMatcher>
 671Args(const InnerMatcher& matcher) {
 672  return internal::ArgsMatcher<InnerMatcher>(matcher);
 673}
 674
 675template <int k1, typename InnerMatcher>
 676inline internal::ArgsMatcher<InnerMatcher, k1>
 677Args(const InnerMatcher& matcher) {
 678  return internal::ArgsMatcher<InnerMatcher, k1>(matcher);
 679}
 680
 681template <int k1, int k2, typename InnerMatcher>
 682inline internal::ArgsMatcher<InnerMatcher, k1, k2>
 683Args(const InnerMatcher& matcher) {
 684  return internal::ArgsMatcher<InnerMatcher, k1, k2>(matcher);
 685}
 686
 687template <int k1, int k2, int k3, typename InnerMatcher>
 688inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3>
 689Args(const InnerMatcher& matcher) {
 690  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3>(matcher);
 691}
 692
 693template <int k1, int k2, int k3, int k4, typename InnerMatcher>
 694inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>
 695Args(const InnerMatcher& matcher) {
 696  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>(matcher);
 697}
 698
 699template <int k1, int k2, int k3, int k4, int k5, typename InnerMatcher>
 700inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>
 701Args(const InnerMatcher& matcher) {
 702  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>(matcher);
 703}
 704
 705template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerMatcher>
 706inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>
 707Args(const InnerMatcher& matcher) {
 708  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>(matcher);
 709}
 710
 711template <int k1, int k2, int k3, int k4, int k5, int k6, int k7,
 712    typename InnerMatcher>
 713inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7>
 714Args(const InnerMatcher& matcher) {
 715  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6,
 716      k7>(matcher);
 717}
 718
 719template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
 720    typename InnerMatcher>
 721inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8>
 722Args(const InnerMatcher& matcher) {
 723  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7,
 724      k8>(matcher);
 725}
 726
 727template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
 728    int k9, typename InnerMatcher>
 729inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9>
 730Args(const InnerMatcher& matcher) {
 731  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
 732      k9>(matcher);
 733}
 734
 735template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
 736    int k9, int k10, typename InnerMatcher>
 737inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9,
 738    k10>
 739Args(const InnerMatcher& matcher) {
 740  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
 741      k9, k10>(matcher);
 742}
 743
 744// ElementsAre(e0, e1, ..., e_n) matches an STL-style container with
 745// (n + 1) elements, where the i-th element in the container must
 746// match the i-th argument in the list.  Each argument of
 747// ElementsAre() can be either a value or a matcher.  We support up to
 748// 10 arguments.
 749//
 750// NOTE: Since ElementsAre() cares about the order of the elements, it
 751// must not be used with containers whose elements's order is
 752// undefined (e.g. hash_map).
 753
 754inline internal::ElementsAreMatcher0 ElementsAre() {
 755  return internal::ElementsAreMatcher0();
 756}
 757
 758template <typename T1>
 759inline internal::ElementsAreMatcher1<T1> ElementsAre(const T1& e1) {
 760  return internal::ElementsAreMatcher1<T1>(e1);
 761}
 762
 763template <typename T1, typename T2>
 764inline internal::ElementsAreMatcher2<T1, T2> ElementsAre(const T1& e1,
 765    const T2& e2) {
 766  return internal::ElementsAreMatcher2<T1, T2>(e1, e2);
 767}
 768
 769template <typename T1, typename T2, typename T3>
 770inline internal::ElementsAreMatcher3<T1, T2, T3> ElementsAre(const T1& e1,
 771    const T2& e2, const T3& e3) {
 772  return internal::ElementsAreMatcher3<T1, T2, T3>(e1, e2, e3);
 773}
 774
 775template <typename T1, typename T2, typename T3, typename T4>
 776inline internal::ElementsAreMatcher4<T1, T2, T3, T4> ElementsAre(const T1& e1,
 777    const T2& e2, const T3& e3, const T4& e4) {
 778  return internal::ElementsAreMatcher4<T1, T2, T3, T4>(e1, e2, e3, e4);
 779}
 780
 781template <typename T1, typename T2, typename T3, typename T4, typename T5>
 782inline internal::ElementsAreMatcher5<T1, T2, T3, T4,
 783    T5> ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
 784    const T5& e5) {
 785  return internal::ElementsAreMatcher5<T1, T2, T3, T4, T5>(e1, e2, e3, e4, e5);
 786}
 787
 788template <typename T1, typename T2, typename T3, typename T4, typename T5,
 789    typename T6>
 790inline internal::ElementsAreMatcher6<T1, T2, T3, T4, T5,
 791    T6> ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
 792    const T5& e5, const T6& e6) {
 793  return internal::ElementsAreMatcher6<T1, T2, T3, T4, T5, T6>(e1, e2, e3, e4,
 794      e5, e6);
 795}
 796
 797template <typename T1, typename T2, typename T3, typename T4, typename T5,
 798    typename T6, typename T7>
 799inline internal::ElementsAreMatcher7<T1, T2, T3, T4, T5, T6,
 800    T7> ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
 801    const T5& e5, const T6& e6, const T7& e7) {
 802  return internal::ElementsAreMatcher7<T1, T2, T3, T4, T5, T6, T7>(e1, e2, e3,
 803      e4, e5, e6, e7);
 804}
 805
 806template <typename T1, typename T2, typename T3, typename T4, typename T5,
 807    typename T6, typename T7, typename T8>
 808inline internal::ElementsAreMatcher8<T1, T2, T3, T4, T5, T6, T7,
 809    T8> ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
 810    const T5& e5, const T6& e6, const T7& e7, const T8& e8) {
 811  return internal::ElementsAreMatcher8<T1, T2, T3, T4, T5, T6, T7, T8>(e1, e2,
 812      e3, e4, e5, e6, e7, e8);
 813}
 814
 815template <typename T1, typename T2, typename T3, typename T4, typename T5,
 816    typename T6, typename T7, typename T8, typename T9>
 817inline internal::ElementsAreMatcher9<T1, T2, T3, T4, T5, T6, T7, T8,
 818    T9> ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
 819    const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9) {
 820  return internal::ElementsAreMatcher9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(e1,
 821      e2, e3, e4, e5, e6, e7, e8, e9);
 822}
 823
 824template <typename T1, typename T2, typename T3, typename T4, typename T5,
 825    typename T6, typename T7, typename T8, typename T9, typename T10>
 826inline internal::ElementsAreMatcher10<T1, T2, T3, T4, T5, T6, T7, T8, T9,
 827    T10> ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
 828    const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9,
 829    const T10& e10) {
 830  return internal::ElementsAreMatcher10<T1, T2, T3, T4, T5, T6, T7, T8, T9,
 831      T10>(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10);
 832}
 833
 834// ElementsAreArray(array) and ElementAreArray(array, count) are like
 835// ElementsAre(), except that they take an array of values or
 836// matchers.  The former form infers the size of 'array', which must
 837// be a static C-style array.  In the latter form, 'array' can either
 838// be a static array or a pointer to a dynamically created array.
 839
 840template <typename T>
 841inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
 842    const T* first, size_t count) {
 843  return internal::ElementsAreArrayMatcher<T>(first, count);
 844}
 845
 846template <typename T, size_t N>
 847inline internal::ElementsAreArrayMatcher<T>
 848ElementsAreArray(const T (&array)[N]) {
 849  return internal::ElementsAreArrayMatcher<T>(array, N);
 850}
 851
 852// AllOf(m1, m2, ..., mk) matches any value that matches all of the given
 853// sub-matchers.  AllOf is called fully qualified to prevent ADL from firing.
 854
 855template <typename Matcher1, typename Matcher2>
 856inline internal::BothOfMatcher<Matcher1, Matcher2>
 857AllOf(Matcher1 m1, Matcher2 m2) {
 858  return internal::BothOfMatcher<Matcher1, Matcher2>(m1, m2);
 859}
 860
 861template <typename Matcher1, typename Matcher2, typename Matcher3>
 862inline internal::BothOfMatcher<Matcher1, internal::BothOfMatcher<Matcher2,
 863    Matcher3> >
 864AllOf(Matcher1 m1, Matcher2 m2, Matcher3 m3) {
 865  return ::testing::AllOf(m1, ::testing::AllOf(m2, m3));
 866}
 867
 868template <typename Matcher1, typename Matcher2, typename Matcher3,
 869    typename Matcher4>
 870inline internal::BothOfMatcher<Matcher1, internal::BothOfMatcher<Matcher2,
 871    internal::BothOfMatcher<Matcher3, Matcher4> > >
 872AllOf(Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4) {
 873  return ::testing::AllOf(m1, ::testing::AllOf(m2, m3, m4));
 874}
 875
 876template <typename Matcher1, typename Matcher2, typename Matcher3,
 877    typename Matcher4, typename Matcher5>
 878inline internal::BothOfMatcher<Matcher1, internal::BothOfMatcher<Matcher2,
 879    internal::BothOfMatcher<Matcher3, internal::BothOfMatcher<Matcher4,
 880    Matcher5> > > >
 881AllOf(Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5) {
 882  return ::testing::AllOf(m1, ::testing::AllOf(m2, m3, m4, m5));
 883}
 884
 885template <typename Matcher1, typename Matcher2, typename Matcher3,
 886    typename Matcher4, typename Matcher5, typename Matcher6>
 887inline internal::BothOfMatcher<Matcher1, internal::BothOfMatcher<Matcher2,
 888    internal::BothOfMatcher<Matcher3, internal::BothOfMatcher<Matcher4,
 889    internal::BothOfMatcher<Matcher5, Matcher6> > > > >
 890AllOf(Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5,
 891    Matcher6 m6) {
 892  return ::testing::AllOf(m1, ::testing::AllOf(m2, m3, m4, m5, m6));
 893}
 894
 895template <typename Matcher1, typename Matcher2, typename Matcher3,
 896    typename Matcher4, typename Matcher5, typename Matcher6, typename Matcher7>
 897inline internal::BothOfMatcher<Matcher1, internal::BothOfMatcher<Matcher2,
 898    internal::BothOfMatcher<Matcher3, internal::BothOfMatcher<Matcher4,
 899    internal::BothOfMatcher<Matcher5, internal::BothOfMatcher<Matcher6,
 900    Matcher7> > > > > >
 901AllOf(Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5,
 902    Matcher6 m6, Matcher7 m7) {
 903  return ::testing::AllOf(m1, ::testing::AllOf(m2, m3, m4, m5, m6, m7));
 904}
 905
 906template <typename Matcher1, typename Matcher2, typename Matcher3,
 907    typename Matcher4, typename Matcher5, typename Matcher6, typename Matcher7,
 908    typename Matcher8>
 909inline internal::BothOfMatcher<Matcher1, internal::BothOfMatcher<Matcher2,
 910    internal::BothOfMatcher<Matcher3, internal::BothOfMatcher<Matcher4,
 911    internal::BothOfMatcher<Matcher5, internal::BothOfMatcher<Matcher6,
 912    internal::BothOfMatcher<Matcher7, Matcher8> > > > > > >
 913AllOf(Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5,
 914    Matcher6 m6, Matcher7 m7, Matcher8 m8) {
 915  return ::testing::AllOf(m1, ::testing::AllOf(m2, m3, m4, m5, m6, m7, m8));
 916}
 917
 918template <typename Matcher1, typename Matcher2, typename Matcher3,
 919    typename Matcher4, typename Matcher5, typename Matcher6, typename Matcher7,
 920    typename Matcher8, typename Matcher9>
 921inline internal::BothOfMatcher<Matcher1, internal::BothOfMatcher<Matcher2,
 922    internal::BothOfMatcher<Matcher3, internal::BothOfMatcher<Matcher4,
 923    internal::BothOfMatcher<Matcher5, internal::BothOfMatcher<Matcher6,
 924    internal::BothOfMatcher<Matcher7, internal::BothOfMatcher<Matcher8,
 925    Matcher9> > > > > > > >
 926AllOf(Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5,
 927    Matcher6 m6, Matcher7 m7, Matcher8 m8, Matcher9 m9) {
 928  return ::testing::AllOf(m1, ::testing::AllOf(m2, m3, m4, m5, m6, m7, m8, m9));
 929}
 930
 931template <typename Matcher1, typename Matcher2, typename Matcher3,
 932    typename Matcher4, typename Matcher5, typename Matcher6, typename Matcher7,
 933    typename Matcher8, typename Matcher9, typename Matcher10>
 934inline internal::BothOfMatcher<Matcher1, internal::BothOfMatcher<Matcher2,
 935    internal::BothOfMatcher<Matcher3, internal::BothOfMatcher<Matcher4,
 936    internal::BothOfMatcher<Matcher5, internal::BothOfMatcher<Matcher6,
 937    internal::BothOfMatcher<Matcher7, internal::BothOfMatcher<Matcher8,
 938    internal::BothOfMatcher<Matcher9, Matcher10> > > > > > > > >
 939AllOf(Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5,
 940    Matcher6 m6, Matcher7 m7, Matcher8 m8, Matcher9 m9, Matcher10 m10) {
 941  return ::testing::AllOf(m1, ::testing::AllOf(m2, m3, m4, m5, m6, m7, m8, m9,
 942      m10));
 943}
 944
 945// AnyOf(m1, m2, ..., mk) matches any value that matches any of the given
 946// sub-matchers.  AnyOf is called fully qualified to prevent ADL from firing.
 947
 948template <typename Matcher1, typename Matcher2>
 949inline internal::EitherOfMatcher<Matcher1, Matcher2>
 950AnyOf(Matcher1 m1, Matcher2 m2) {
 951  return internal::EitherOfMatcher<Matcher1, Matcher2>(m1, m2);
 952}
 953
 954template <typename Matcher1, typename Matcher2, typename Matcher3>
 955inline internal::EitherOfMatcher<Matcher1, internal::EitherOfMatcher<Matcher2,
 956    Matcher3> >
 957AnyOf(Matcher1 m1, Matcher2 m2, Matcher3 m3) {
 958  return ::testing::AnyOf(m1, ::testing::AnyOf(m2, m3));
 959}
 960
 961template <typename Matcher1, typename Matcher2, typename Matcher3,
 962    typename Matcher4>
 963inline internal::EitherOfMatcher<Matcher1, internal::EitherOfMatcher<Matcher2,
 964    internal::EitherOfMatcher<Matcher3, Matcher4> > >
 965AnyOf(Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4) {
 966  return ::testing::AnyOf(m1, ::testing::AnyOf(m2, m3, m4));
 967}
 968
 969template <typename Matcher1, typename Matcher2, typename Matcher3,
 970    typename Matcher4, typename Matcher5>
 971inline internal::EitherOfMatcher<Matcher1, internal::EitherOfMatcher<Matcher2,
 972    internal::EitherOfMatcher<Matcher3, internal::EitherOfMatcher<Matcher4,
 973    Matcher5> > > >
 974AnyOf(Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5) {
 975  return ::testing::AnyOf(m1, ::testing::AnyOf(m2, m3, m4, m5));
 976}
 977
 978template <typename Matcher1, typename Matcher2, typename Matcher3,
 979    typename Matcher4, typename Matcher5, typename Matcher6>
 980inline internal::EitherOfMatcher<Matcher1, internal::EitherOfMatcher<Matcher2,
 981    internal::EitherOfMatcher<Matcher3, internal::EitherOfMatcher<Matcher4,
 982    internal::EitherOfMatcher<Matcher5, Matcher6> > > > >
 983AnyOf(Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5,
 984    Matcher6 m6) {
 985  return ::testing::AnyOf(m1, ::testing::AnyOf(m2, m3, m4, m5, m6));
 986}
 987
 988template <typename Matcher1, typename Matcher2, typename Matcher3,
 989    typename Matcher4, typename Matcher5, typename Matcher6, typename Matcher7>
 990inline internal::EitherOfMatcher<Matcher1, internal::EitherOfMatcher<Matcher2,
 991    internal::EitherOfMatcher<Matcher3, internal::EitherOfMatcher<Matcher4,
 992    internal::EitherOfMatcher<Matcher5, internal::EitherOfMatcher<Matcher6,
 993    Matcher7> > > > > >
 994AnyOf(Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5,
 995    Matcher6 m6, Matcher7 m7) {
 996  return ::testing::AnyOf(m1, ::testing::AnyOf(m2, m3, m4, m5, m6, m7));
 997}
 998
 999template <typename Matcher1, typename Matcher2, typename Matcher3,
1000    typename Matcher4, typename Matcher5, typename Matcher6, typename Matcher7,
1001    typename Matcher8>
1002inline internal::EitherOfMatcher<Matcher1, internal::EitherOfMatcher<Matcher2,
1003    internal::EitherOfMatcher<Matcher3, internal::EitherOfMatcher<Matcher4,
1004    internal::EitherOfMatcher<Matcher5, internal::EitherOfMatcher<Matcher6,
1005    internal::EitherOfMatcher<Matcher7, Matcher8> > > > > > >
1006AnyOf(Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5,
1007    Matcher6 m6, Matcher7 m7, Matcher8 m8) {
1008  return ::testing::AnyOf(m1, ::testing::AnyOf(m2, m3, m4, m5, m6, m7, m8));
1009}
1010
1011template <typename Matcher1, typename Matcher2, typename Matcher3,
1012    typename Matcher4, typename Matcher5, typename Matcher6, typename Matcher7,
1013    typename Matcher8, typename Matcher9>
1014inline internal::EitherOfMatcher<Matcher1, internal::EitherOfMatcher<Matcher2,
1015    internal::EitherOfMatcher<Matcher3, internal::EitherOfMatcher<Matcher4,
1016    internal::EitherOfMatcher<Matcher5, internal::EitherOfMatcher<Matcher6,
1017    internal::EitherOfMatcher<Matcher7, internal::EitherOfMatcher<Matcher8,
1018    Matcher9> > > > > > > >
1019AnyOf(Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5,
1020    Matcher6 m6, Matcher7 m7, Matcher8 m8, Matcher9 m9) {
1021  return ::testing::AnyOf(m1, ::testing::AnyOf(m2, m3, m4, m5, m6, m7, m8, m9));
1022}
1023
1024template <typename Matcher1, typename Matcher2, typename Matcher3,
1025    typename Matcher4, typename Matcher5, typename Matcher6, typename Matcher7,
1026    typename Matcher8, typename Matcher9, typename Matcher10>
1027inline internal::EitherOfMatcher<Matcher1, internal::EitherOfMatcher<Matcher2,
1028    internal::EitherOfMatcher<Matcher3, internal::EitherOfMatcher<Matcher4,
1029    internal::EitherOfMatcher<Matcher5, internal::EitherOfMatcher<Matcher6,
1030    internal::EitherOfMatcher<Matcher7, internal::EitherOfMatcher<Matcher8,
1031    internal::EitherOfMatcher<Matcher9, Matcher10> > > > > > > > >
1032AnyOf(Matcher1 m1, Matcher2 m2, Matcher3 m3, Matcher4 m4, Matcher5 m5,
1033    Matcher6 m6, Matcher7 m7, Matcher8 m8, Matcher9 m9, Matcher10 m10) {
1034  return ::testing::AnyOf(m1, ::testing::AnyOf(m2, m3, m4, m5, m6, m7, m8, m9,
1035      m10));
1036}
1037
1038}  // namespace testing
1039
1040
1041// The MATCHER* family of macros can be used in a namespace scope to
1042// define custom matchers easily.
1043//
1044// Basic Usage
1045// ===========
1046//
1047// The syntax
1048//
1049//   MATCHER(name, description_string) { statements; }
1050//
1051// defines a matcher with the given name that executes the statements,
1052// which must return a bool to indicate if the match succeeds.  Inside
1053// the statements, you can refer to the value being matched by 'arg',
1054// and refer to its type by 'arg_type'.
1055//
1056// The description string documents what the matcher does, and is used
1057// to generate the failure message when the match fails.  Since a
1058// MATCHER() is usually defined in a header file shared by multiple
1059// C++ source files, we require the description to be a C-string
1060// literal to avoid possible side effects.  It can be empty, in which
1061// case we'll use the sequence of words in the matcher name as the
1062// description.
1063//
1064// For example:
1065//
1066//   MATCHER(IsEven, "") { return (arg % 2) == 0; }
1067//
1068// allows you to write
1069//
1070//   // Expects mock_foo.Bar(n) to be called where n is even.
1071//   EXPECT_CALL(mock_foo, Bar(IsEven()));
1072//
1073// or,
1074//
1075//   // Verifies that the value of some_expression is even.
1076//   EXPECT_THAT(some_expression, IsEven());
1077//
1078// If the above assertion fails, it will print something like:
1079//
1080//   Value of: some_expression
1081//   Expected: is even
1082//     Actual: 7
1083//
1084// where the description "is even" is automatically calculated from the
1085// matcher name IsEven.
1086//
1087// Argument Type
1088// =============
1089//
1090// Note that the type of the value being matched (arg_type) is
1091// determined by the context in which you use the matcher and is
1092// supplied to you by the compiler, so you don't need to worry about
1093// declaring it (nor can you).  This allows the matcher to be
1094// polymorphic.  For example, IsEven() can be used to match any type
1095// where the value of "(arg % 2) == 0" can be implicitly converted to
1096// a bool.  In the "Bar(IsEven())" example above, if method Bar()
1097// takes an int, 'arg_type' will be int; if it takes an unsigned long,
1098// 'arg_type' will be unsigned long; and so on.
1099//
1100// Parameterizing Matchers
1101// =======================
1102//
1103// Sometimes you'll want to parameterize the matcher.  For that you
1104// can use another macro:
1105//
1106//   MATCHER_P(name, param_name, description_string) { statements; }
1107//
1108// For example:
1109//
1110//   MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; }
1111//
1112// will allow you to write:
1113//
1114//   EXPECT_THAT(Blah("a"), HasAbsoluteValue(n));
1115//
1116// which may lead to this message (assuming n is 10):
1117//
1118//   Value of: Blah("a")
1119//   Expected: has absolute value 10
1120//     Actual: -9
1121//
1122// Note that both the matcher description and its parameter are
1123// printed, making the message human-friendly.
1124//
1125// In the matcher definition body, you can write 'foo_type' to
1126// reference the type of a parameter named 'foo'.  For example, in the
1127// body of MATCHER_P(HasAbsoluteValue, value) above, you can write
1128// 'value_type' to refer to the type of 'value'.
1129//
1130// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P10 to
1131// support multi-parameter matchers.
1132//
1133// Describing Parameterized Matchers
1134// =================================
1135//
1136// The last argument to MATCHER*() is a string-typed expression.  The
1137// expression can reference all of the matcher's parameters and a
1138// special bool-typed variable named 'negation'.  When 'negation' is
1139// false, the expression should evaluate to the matcher's description;
1140// otherwise it should evaluate to the description of the negation of
1141// the matcher.  For example,
1142//
1143//   using testing::PrintToString;
1144//
1145//   MATCHER_P2(InClosedRange, low, hi,
1146//       string(negation ? "is not" : "is") + " in range [" +
1147//       PrintToString(low) + ", " + PrintToString(hi) + "]") {
1148//     return low <= arg && arg <= hi;
1149//   }
1150//   ...
1151//   EXPECT_THAT(3, InClosedRange(4, 6));
1152//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
1153//
1154// would generate two failures that contain the text:
1155//
1156//   Expected: is in range [4, 6]
1157//   ...
1158//   Expected: is not in range [2, 4]
1159//
1160// If you specify "" as the description, the failure message will
1161// contain the sequence of words in the matcher name followed by the
1162// parameter values printed as a tuple.  For example,
1163//
1164//   MATCHER_P2(InClosedRange, low, hi, "") { ... }
1165//   ...
1166//   EXPECT_THAT(3, InClosedRange(4, 6));
1167//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
1168//
1169// would generate two failures that contain the text:
1170//
1171//   Expected: in closed range (4, 6)
1172//   ...
1173//   Expected: not (in closed range (2, 4))
1174//
1175// Types of Matcher Parameters
1176// ===========================
1177//
1178// For the purpose of typing, you can view
1179//
1180//   MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... }
1181//
1182// as shorthand for
1183//
1184//   template <typename p1_type, ..., typename pk_type>
1185//   FooMatcherPk<p1_type, ..., pk_type>
1186//   Foo(p1_type p1, ..., pk_type pk) { ... }
1187//
1188// When you write Foo(v1, ..., vk), the compiler infers the types of
1189// the parameters v1, ..., and vk for you.  If you are not happy with
1190// the result of the type inference, you can specify the types by
1191// explicitly instantiating the template, as in Foo<long, bool>(5,
1192// false).  As said earlier, you don't get to (or need to) specify
1193// 'arg_type' as that's determined by the context in which the matcher
1194// is used.  You can assign the result of expression Foo(p1, ..., pk)
1195// to a variable of type FooMatcherPk<p1_type, ..., pk_type>.  This
1196// can be useful when composing matchers.
1197//
1198// While you can instantiate a matcher template with reference types,
1199// passing the parameters by pointer usually makes your code more
1200// readable.  If, however, you still want to pass a parameter by
1201// reference, be aware that in the failure message generated by the
1202// matcher you will see the value of the referenced object but not its
1203// address.
1204//
1205// Explaining Match Results
1206// ========================
1207//
1208// Sometimes the matcher description alone isn't enough to explain why
1209// the match has failed or succeeded.  For example, when expecting a
1210// long string, it can be very helpful to also print the diff between
1211// the expected string and the actual one.  To achieve that, you can
1212// optionally stream additional information to a special variable
1213// named result_listener, whose type is a pointer to class
1214// MatchResultListener:
1215//
1216//   MATCHER_P(EqualsLongString, str, "") {
1217//     if (arg == str) return true;
1218//
1219//     *result_listener << "the difference: "
1220///                     << DiffStrings(str, arg);
1221//     return false;
1222//   }
1223//
1224// Overloading Matchers
1225// ====================
1226//
1227// You can overload matchers with different numbers of parameters:
1228//
1229//   MATCHER_P(Blah, a, description_string1) { ... }
1230//   MATCHER_P2(Blah, a, b, description_string2) { ... }
1231//
1232// Caveats
1233// =======
1234//
1235// When defining a new matcher, you should also consider implementing
1236// MatcherInterface or using MakePolymorphicMatcher().  These
1237// approaches require more work than the MATCHER* macros, but also
1238// give you more control on the types of the value being matched and
1239// the matcher parameters, which may leads to better compiler error
1240// messages when the matcher is used wrong.  They also allow
1241// overloading matchers based on parameter types (as opposed to just
1242// based on the number of parameters).
1243//
1244// MATCHER*() can only be used in a namespace scope.  The reason is
1245// that C++ doesn't yet allow function-local types to be used to
1246// instantiate templates.  The up-coming C++0x standard will fix this.
1247// Once that's done, we'll consider supporting using MATCHER*() inside
1248// a function.
1249//
1250// More Information
1251// ================
1252//
1253// To learn more about using these macros, please search for 'MATCHER'
1254// on http://code.google.com/p/googlemock/wiki/CookBook.
1255
1256#define MATCHER(name, description)\
1257  class name##Matcher {\
1258   public:\
1259    template <typename arg_type>\
1260    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1261     public:\
1262      gmock_Impl()\
1263           {}\
1264      virtual bool MatchAndExplain(\
1265          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
1266      virtual void DescribeTo(::std::ostream* gmock_os) const {\
1267        *gmock_os << FormatDescription(false);\
1268      }\
1269      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1270        *gmock_os << FormatDescription(true);\
1271      }\
1272     private:\
1273      ::testing::internal::string FormatDescription(bool negation) const {\
1274        const ::testing::internal::string gmock_description = (description);\
1275        if (!gmock_description.empty())\
1276          return gmock_description;\
1277        return ::testing::internal::FormatMatcherDescription(\
1278            negation, #name,\
1279            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1280                ::std::tr1::tuple<>()));\
1281      }\
1282      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1283    };\
1284    template <typename arg_type>\
1285    operator ::testing::Matcher<arg_type>() const {\
1286      return ::testing::Matcher<arg_type>(\
1287          new gmock_Impl<arg_type>());\
1288    }\
1289    name##Matcher() {\
1290    }\
1291   private:\
1292    GTEST_DISALLOW_ASSIGN_(name##Matcher);\
1293  };\
1294  inline name##Matcher name() {\
1295    return name##Matcher();\
1296  }\
1297  template <typename arg_type>\
1298  bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(\
1299      arg_type arg,\
1300      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1301          const
1302
1303#define MATCHER_P(name, p0, description)\
1304  template <typename p0##_type>\
1305  class name##MatcherP {\
1306   public:\
1307    template <typename arg_type>\
1308    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1309     public:\
1310      explicit gmock_Impl(p0##_type gmock_p0)\
1311           : p0(gmock_p0) {}\
1312      virtual bool MatchAndExplain(\
1313          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
1314      virtual void DescribeTo(::std::ostream* gmock_os) const {\
1315        *gmock_os << FormatDescription(false);\
1316      }\
1317      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1318        *gmock_os << FormatDescription(true);\
1319      }\
1320      p0##_type p0;\
1321     private:\
1322      ::testing::internal::string FormatDescription(bool negation) const {\
1323        const ::testing::internal::string gmock_description = (description);\
1324        if (!gmock_description.empty())\
1325          return gmock_description;\
1326        return ::testing::internal::FormatMatcherDescription(\
1327            negation, #name,\
1328            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1329                ::std::tr1::tuple<p0##_type>(p0)));\
1330      }\
1331      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1332    };\
1333    template <typename arg_type>\
1334    operator ::testing::Matcher<arg_type>() const {\
1335      return ::testing::Matcher<arg_type>(\
1336          new gmock_Impl<arg_type>(p0));\
1337    }\
1338    name##MatcherP(p0##_type gmock_p0) : p0(gmock_p0) {\
1339    }…

Large files files are truncated, but you can click here to view the full file