Update gmock and gtest.

testing/gmock/include/gmock/gmock-spec-builders.h

 // 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
@@ skipping 124 matching lines @@
 // This template class implements a default action spec (i.e. an
 // ON_CALL() statement).
 template <typename F>
 class DefaultActionSpec {
  public:
   typedef typename Function<F>::ArgumentTuple ArgumentTuple;
   typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
 
   // Constructs a DefaultActionSpec object from the information inside
   // the parenthesis of an ON_CALL() statement.
-  DefaultActionSpec(const char* file, int line,
+  DefaultActionSpec(const char* a_file, int a_line,
                     const ArgumentMatcherTuple& matchers)
-      : file_(file),
-        line_(line),
+      : file_(a_file),
+        line_(a_line),
         matchers_(matchers),
         // By default, extra_matcher_ should match anything.  However,
         // we cannot initialize it with _ as that triggers a compiler
         // bug in Symbian's C++ compiler (cannot decide between two
         // overloaded constructors of Matcher<const ArgumentTuple&>).
         extra_matcher_(A<const ArgumentTuple&>()),
         last_clause_(kNone) {
   }
 
   // Where in the source file was the default action spec defined?
@@ skipping 30 matching lines @@
     return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
   }
 
   // Returns the action specified by the user.
   const Action<F>& GetAction() const {
     AssertSpecProperty(last_clause_ == kWillByDefault,
                        ".WillByDefault() must appear exactly "
                        "once in an ON_CALL().");
     return action_;
   }
+
  private:
   // Gives each clause in the ON_CALL() statement a name.
   enum Clause {
     // Do not change the order of the enum members!  The run-time
     // syntax checking relies on it.
     kNone,
     kWith,
     kWillByDefault,
   };
 
@@ skipping 345 matching lines @@
 //   types (e.g. all pre-requisites of a particular expectation, all
 //   expectations in a sequence).  Therefore these expectation objects
 //   must share a common base class.
 //
 //   2. We can avoid binary code bloat by moving methods not depending
 //   on the template argument of Expectation to the base class.
 //
 // This class is internal and mustn't be used by user code directly.
 class ExpectationBase {
  public:
-  ExpectationBase(const char* file, int line);
+  // source_text is the EXPECT_CALL(...) source that created this Expectation.
+  ExpectationBase(const char* file, int line, const string& source_text);
 
   virtual ~ExpectationBase();
 
   // Where in the source file was the expectation spec defined?
   const char* file() const { return file_; }
   int line() const { return line_; }
-
+  const char* source_text() const { return source_text_.c_str(); }
   // Returns the cardinality specified in the expectation spec.
   const Cardinality& cardinality() const { return cardinality_; }
 
   // Describes the source file location of this expectation.
   void DescribeLocationTo(::std::ostream* os) const {
     *os << file() << ":" << line() << ": ";
   }
 
   // Describes how many times a function call matching this
   // expectation has occurred.
   // L >= g_gmock_mutex
   virtual void DescribeCallCountTo(::std::ostream* os) const = 0;
+
  protected:
   friend class ::testing::Expectation;
 
   enum Clause {
     // Don't change the order of the enum members!
     kNone,
     kWith,
     kTimes,
     kInSequence,
     kAfter,
@@ skipping 18 matching lines @@
 
   // Explicitly specifies the cardinality of this expectation.  Used
   // by the subclasses to implement the .Times() clause.
   void SpecifyCardinality(const Cardinality& cardinality);
 
   // Returns true iff the user specified the cardinality explicitly
   // using a .Times().
   bool cardinality_specified() const { return cardinality_specified_; }
 
   // Sets the cardinality of this expectation spec.
-  void set_cardinality(const Cardinality& cardinality) {
-    cardinality_ = cardinality;
+  void set_cardinality(const Cardinality& a_cardinality) {
+    cardinality_ = a_cardinality;
   }
 
   // The following group of methods should only be called after the
   // EXPECT_CALL() statement, and only when g_gmock_mutex is held by
   // the current thread.
 
   // Retires all pre-requisites of this expectation.
   // L >= g_gmock_mutex
   void RetireAllPreRequisites();
 
@@ skipping 56 matching lines @@
 
  private:
   friend class ::testing::Sequence;
   friend class ::testing::internal::ExpectationTester;
 
   template <typename Function>
   friend class TypedExpectation;
 
   // This group of fields are part of the spec and won't change after
   // an EXPECT_CALL() statement finishes.
-  const char* file_;  // The file that contains the expectation.
-  int line_;          // The line number of the expectation.
+  const char* file_;          // The file that contains the expectation.
+  int line_;                  // The line number of the expectation.
+  const string source_text_;  // The EXPECT_CALL(...) source text.
   // True iff the cardinality is specified explicitly.
   bool cardinality_specified_;
   Cardinality cardinality_;            // The cardinality of the expectation.
   // The immediate pre-requisites (i.e. expectations that must be
   // satisfied before this expectation can be matched) of this
   // expectation.  We use linked_ptr in the set because we want an
   // Expectation object to be co-owned by its FunctionMocker and its
   // successors.  This allows multiple mock objects to be deleted at
   // different times.
   ExpectationSet immediate_prerequisites_;
 
   // This group of fields are the current state of the expectation,
   // and can change as the mock function is called.
   int call_count_;  // How many times this expectation has been invoked.
   bool retired_;    // True iff this expectation has retired.
+
+  GTEST_DISALLOW_ASSIGN_(ExpectationBase);
 };  // class ExpectationBase
 
 // Impements an expectation for the given function type.
 template <typename F>
 class TypedExpectation : public ExpectationBase {
  public:
   typedef typename Function<F>::ArgumentTuple ArgumentTuple;
   typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
   typedef typename Function<F>::Result Result;
 
-  TypedExpectation(FunctionMockerBase<F>* owner, const char* file, int line,
+  TypedExpectation(FunctionMockerBase<F>* owner,
+                   const char* a_file, int a_line, const string& a_source_text,
                    const ArgumentMatcherTuple& m)
-      : ExpectationBase(file, line),
+      : ExpectationBase(a_file, a_line, a_source_text),
         owner_(owner),
         matchers_(m),
+        extra_matcher_specified_(false),
         // By default, extra_matcher_ should match anything.  However,
         // we cannot initialize it with _ as that triggers a compiler
         // bug in Symbian's C++ compiler (cannot decide between two
         // overloaded constructors of Matcher<const ArgumentTuple&>).
         extra_matcher_(A<const ArgumentTuple&>()),
         repeated_action_specified_(false),
         repeated_action_(DoDefault()),
         retires_on_saturation_(false),
         last_clause_(kNone),
         action_count_checked_(false) {}
@@ skipping 11 matching lines @@
                          ".With() cannot appear "
                          "more than once in an EXPECT_CALL().");
     } else {
       ExpectSpecProperty(last_clause_ < kWith,
                          ".With() must be the first "
                          "clause in an EXPECT_CALL().");
     }
     last_clause_ = kWith;
 
     extra_matcher_ = m;
+    extra_matcher_specified_ = true;
     return *this;
   }
 
   // Implements the .Times() clause.
-  TypedExpectation& Times(const Cardinality& cardinality) {
+  TypedExpectation& Times(const Cardinality& a_cardinality) {
     if (last_clause_ ==kTimes) {
       ExpectSpecProperty(false,
                          ".Times() cannot appear "
                          "more than once in an EXPECT_CALL().");
     } else {
       ExpectSpecProperty(last_clause_ < kTimes,
                          ".Times() cannot appear after "
                          ".InSequence(), .WillOnce(), .WillRepeatedly(), "
                          "or .RetiresOnSaturation().");
     }
     last_clause_ = kTimes;
 
-    ExpectationBase::SpecifyCardinality(cardinality);
+    ExpectationBase::SpecifyCardinality(a_cardinality);
     return *this;
   }
 
   // Implements the .Times() clause.
   TypedExpectation& Times(int n) {
     return Times(Exactly(n));
   }
 
   // Implements the .InSequence() clause.
   TypedExpectation& InSequence(const Sequence& s) {
@@ skipping 140 matching lines @@
     Cardinality::DescribeActualCallCountTo(call_count(), os);
 
     // Describes the state of the expectation (e.g. is it satisfied?
     // is it active?).
     *os << " - " << (IsOverSaturated() ? "over-saturated" :
                      IsSaturated() ? "saturated" :
                      IsSatisfied() ? "satisfied" : "unsatisfied")
         << " and "
         << (is_retired() ? "retired" : "active");
   }
+
+  void MaybeDescribeExtraMatcherTo(::std::ostream* os) {
+    if (extra_matcher_specified_) {
+      *os << "    Expected args: ";
+      extra_matcher_.DescribeTo(os);
+      *os << "\n";
+    }
+  }
+
  private:
   template <typename Function>
   friend class FunctionMockerBase;
 
   // Returns an Expectation object that references and co-owns this
   // expectation.
   virtual Expectation GetHandle() {
     return owner_->GetHandleOf(this);
   }
 
@@ skipping 76 matching lines @@
            "call_count() is <= 0 when GetCurrentAction() is "
            "called - this should never happen.");
 
     const int action_count = static_cast<int>(actions().size());
     if (action_count > 0 && !repeated_action_specified_ &&
         count > action_count) {
       // If there is at least one WillOnce() and no WillRepeatedly(),
       // we warn the user when the WillOnce() clauses ran out.
       ::std::stringstream ss;
       DescribeLocationTo(&ss);
-      ss << "Actions ran out.\n"
+      ss << "Actions ran out in " << source_text() << "...\n"
          << "Called " << count << " times, but only "
          << action_count << " WillOnce()"
          << (action_count == 1 ? " is" : "s are") << " specified - ";
       mocker->DescribeDefaultActionTo(args, &ss);
       Log(WARNING, ss.str(), 1);
     }
 
     return count <= action_count ? actions()[count - 1] : repeated_action();
   }
 
@@ skipping 23 matching lines @@
     }
 
     IncrementCallCount();
     RetireAllPreRequisites();
 
     if (retires_on_saturation() && IsSaturated()) {
       Retire();
     }
 
     // Must be done after IncrementCount()!
-    *what << "Expected mock function call.\n";
+    *what << "Mock function call matches " << source_text() <<"...\n";
     return GetCurrentAction(mocker, args);
   }
 
   // Checks the action count (i.e. the number of WillOnce() and
   // WillRepeatedly() clauses) against the cardinality if this hasn't
   // been done before.  Prints a warning if there are too many or too
   // few actions.
   // L < mutex_
   void CheckActionCountIfNotDone() const {
     bool should_check = false;
@@ skipping 24 matching lines @@
       } else if (0 < action_count && action_count < lower_bound &&
                  !repeated_action_specified_) {
         too_many = false;
       } else {
         return;
       }
 
       ::std::stringstream ss;
       DescribeLocationTo(&ss);
       ss << "Too " << (too_many ? "many" : "few")
-         << " actions specified.\n"
+         << " actions specified in " << source_text() << "...\n"
          << "Expected to be ";
       cardinality().DescribeTo(&ss);
       ss << ", but has " << (too_many ? "" : "only ")
          << action_count << " WillOnce()"
          << (action_count == 1 ? "" : "s");
       if (repeated_action_specified_) {
         ss << " and a WillRepeatedly()";
       }
       ss << ".";
       Log(WARNING, ss.str(), -1);  // -1 means "don't print stack trace".
     }
   }
 
   // All the fields below won't change once the EXPECT_CALL()
   // statement finishes.
   FunctionMockerBase<F>* const owner_;
   ArgumentMatcherTuple matchers_;
+  bool extra_matcher_specified_;
   Matcher<const ArgumentTuple&> extra_matcher_;
   std::vector<Action<F> > actions_;
   bool repeated_action_specified_;  // True if a WillRepeatedly() was specified.
   Action<F> repeated_action_;
   bool retires_on_saturation_;
   Clause last_clause_;
   mutable bool action_count_checked_;  // Under mutex_.
   mutable Mutex mutex_;  // Protects action_count_checked_.
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TypedExpectation);
 };  // class TypedExpectation
 
 // A MockSpec object is used by ON_CALL() or EXPECT_CALL() for
 // specifying the default behavior of, or expectation on, a mock
 // function.
 
 // Note: class MockSpec 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 MockSpec in
@@ skipping 17 matching lines @@
       const char* file, int line, const char* obj, const char* call) {
     LogWithLocation(internal::INFO, file, line,
         string("ON_CALL(") + obj + ", " + call + ") invoked");
     return function_mocker_->AddNewDefaultActionSpec(file, line, matchers_);
   }
 
   // Adds a new expectation spec to the function mocker and returns
   // the newly created spec.
   internal::TypedExpectation<F>& InternalExpectedAt(
       const char* file, int line, const char* obj, const char* call) {
-    LogWithLocation(internal::INFO, file, line,
-        string("EXPECT_CALL(") + obj + ", " + call + ") invoked");
-    return function_mocker_->AddNewExpectation(file, line, matchers_);
+    const string source_text(string("EXPECT_CALL(") + obj + ", " + call + ")");
+    LogWithLocation(internal::INFO, file, line, source_text + " invoked");
+    return function_mocker_->AddNewExpectation(
+        file, line, source_text, matchers_);
   }
 
  private:
   template <typename Function>
   friend class internal::FunctionMocker;
 
   void SetMatchers(const ArgumentMatcherTuple& matchers) {
     matchers_ = matchers;
   }
 
   // Logs a message including file and line number information.
   void LogWithLocation(testing::internal::LogSeverity severity,
                        const char* file, int line,
                        const string& message) {
     ::std::ostringstream s;
     s << file << ":" << line << ": " << message << ::std::endl;
     Log(severity, s.str(), 0);
   }
 
   // The function mocker that owns this spec.
   internal::FunctionMockerBase<F>* const function_mocker_;
   // The argument matchers specified in the spec.
   ArgumentMatcherTuple matchers_;
+
+  GTEST_DISALLOW_ASSIGN_(MockSpec);
 };  // class MockSpec
 
 // MSVC warns about using 'this' in base member initializer list, so
 // we need to temporarily disable the warning.  We have to do it for
 // the entire class to suppress the warning, even though it's about
 // the constructor only.
 
 #ifdef _MSC_VER
 #pragma warning(push)          // Saves the current warning state.
 #pragma warning(disable:4355)  // Temporarily disables warning 4355.
 #endif  // _MSV_VER
 
 // C++ treats the void type specially.  For example, you cannot define
 // a void-typed variable or pass a void value to a function.
 // ActionResultHolder<T> holds a value of type T, where T must be a
 // copyable type or void (T doesn't need to be default-constructable).
 // It hides the syntactic difference between void and other types, and
 // is used to unify the code for invoking both void-returning and
 // non-void-returning mock functions.  This generic definition is used
 // when T is not void.
 template <typename T>
 class ActionResultHolder {
  public:
-  explicit ActionResultHolder(T value) : value_(value) {}
+  explicit ActionResultHolder(T a_value) : value_(a_value) {}
 
   // The compiler-generated copy constructor and assignment operator
   // are exactly what we need, so we don't need to define them.
 
   T value() const { return value_; }
 
   // Prints the held value as an action's result to os.
   void PrintAsActionResult(::std::ostream* os) const {
     *os << "\n          Returns: ";
     UniversalPrinter<T>::Print(value_, os);
@@ skipping 13 matching lines @@
   // Performs the given action and returns the result in a
   // ActionResultHolder.
   template <typename Function, typename Arguments>
   static ActionResultHolder PerformAction(const Action<Function>& action,
                                           const Arguments& args) {
     return ActionResultHolder(action.Perform(args));
   }
 
  private:
   T value_;
+
+  // T could be a reference type, so = isn't supported.
+  GTEST_DISALLOW_ASSIGN_(ActionResultHolder);
 };
 
 // Specialization for T = void.
 template <>
 class ActionResultHolder<void> {
  public:
   ActionResultHolder() {}
   void value() const {}
   void PrintAsActionResult(::std::ostream* /* os */) const {}
 
@@ skipping 128 matching lines @@
   const char* Name() const {
     const char* name;
     {
       // We protect name_ under g_gmock_mutex in case this mock
       // function is called from two threads concurrently.
       MutexLock l(&g_gmock_mutex);
       name = name_;
     }
     return name;
   }
+
  protected:
   template <typename Function>
   friend class MockSpec;
 
   // Returns the result of invoking this mock function with the given
   // arguments.  This function can be safely called from multiple
   // threads concurrently.
   // L < g_gmock_mutex
   Result InvokeWith(const ArgumentTuple& args);
 
   // Adds and returns a default action spec for this mock function.
   // L < g_gmock_mutex
   DefaultActionSpec<F>& AddNewDefaultActionSpec(
       const char* file, int line,
       const ArgumentMatcherTuple& m) {
     Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
     default_actions_.push_back(DefaultActionSpec<F>(file, line, m));
     return default_actions_.back();
   }
 
   // Adds and returns an expectation spec for this mock function.
   // L < g_gmock_mutex
   TypedExpectation<F>& AddNewExpectation(
-      const char* file, int line,
+      const char* file,
+      int line,
+      const string& source_text,
       const ArgumentMatcherTuple& m) {
     Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
     const linked_ptr<TypedExpectation<F> > expectation(
-        new TypedExpectation<F>(this, file, line, m));
+        new TypedExpectation<F>(this, file, line, source_text, m));
     expectations_.push_back(expectation);
 
     // Adds this expectation into the implicit sequence if there is one.
     Sequence* const implicit_sequence = g_gmock_implicit_sequence.get();
     if (implicit_sequence != NULL) {
       implicit_sequence->AddExpectation(Expectation(expectation));
     }
 
     return *expectation;
   }
 
   // The current spec (either default action spec or expectation spec)
   // being described on this function mocker.
   MockSpec<F>& current_spec() { return current_spec_; }
+
  private:
   template <typename Func> friend class TypedExpectation;
 
   typedef std::vector<internal::linked_ptr<TypedExpectation<F> > >
   TypedExpectations;
 
   // Returns an Expectation object that references and co-owns exp,
   // which must be an expectation on this mock function.
   Expectation GetHandleOf(TypedExpectation<F>* exp) {
     for (typename TypedExpectations::const_iterator it = expectations_.begin();
@@ skipping 105 matching lines @@
     g_gmock_mutex.AssertHeld();
     const int count = static_cast<int>(expectations_.size());
     *why << "Google Mock tried the following " << count << " "
          << (count == 1 ? "expectation, but it didn't match" :
              "expectations, but none matched")
          << ":\n";
     for (int i = 0; i < count; i++) {
       *why << "\n";
       expectations_[i]->DescribeLocationTo(why);
       if (count > 1) {
-        *why << "tried expectation #" << i;
+        *why << "tried expectation #" << i << ": ";
       }
-      *why << "\n";
+      *why << expectations_[i]->source_text() << "...\n";
       expectations_[i]->DescribeMatchResultTo(args, why);
       expectations_[i]->DescribeCallCountTo(why);
     }
   }
 
   // Address of the mock object this mock method belongs to.  Only
   // valid after this mock method has been called or
   // ON_CALL/EXPECT_CALL has been invoked on it.
   const void* mock_obj_;  // Protected by g_gmock_mutex.
 
@@ skipping 44 matching lines @@
     TypedExpectation<F>* const exp = it->get();
 
     if (exp->IsOverSaturated()) {
       // There was an upper-bound violation.  Since the error was
       // already reported when it occurred, there is no need to do
       // anything here.
       expectations_met = false;
     } else if (!exp->IsSatisfied()) {
       expectations_met = false;
       ::std::stringstream ss;
-      ss << "Actual function call count doesn't match this expectation.\n";
+      ss  << "Actual function call count doesn't match "
+          << exp->source_text() << "...\n";
       // No need to show the source file location of the expectation
       // in the description, as the Expect() call that follows already
       // takes care of it.
+      exp->MaybeDescribeExtraMatcherTo(&ss);
       exp->DescribeCallCountTo(&ss);
       Expect(false, exp->file(), exp->line(), ss.str());
     }
   }
   expectations_.clear();
   return expectations_met;
 }
 
 // Reports an uninteresting call (whose description is in msg) in the
 // manner specified by 'reaction'.
@@ skipping 143 matching lines @@
 #define GMOCK_ON_CALL_IMPL_(obj, call) \
     ((obj).gmock_##call).InternalDefaultActionSetAt(__FILE__, __LINE__, \
                                                     #obj, #call)
 #define ON_CALL(obj, call) GMOCK_ON_CALL_IMPL_(obj, call)
 
 #define GMOCK_EXPECT_CALL_IMPL_(obj, call) \
     ((obj).gmock_##call).InternalExpectedAt(__FILE__, __LINE__, #obj, #call)
 #define EXPECT_CALL(obj, call) GMOCK_EXPECT_CALL_IMPL_(obj, call)
 
 #endif  // GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_