Update monet.

testing/generate_gmock_mutant.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import string
 import sys
 
 HEADER = """\
 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
@@ skipping 95 matching lines @@
 // EXPECT_CALL(mock, DemiurgeCreated(_)).Times(1)
 //    .WillOnce(Invoke(CreateFunctor(&mock, &Mock::StoreDemiurge)));
 //
 // EXPECT_CALL(mock, OnRequest(_, StrEq("Moby Dick")))
 //    .Times(AnyNumber())
 //    .WillAlways(WithArgs<0>(Invoke(
 //        CreateFunctor(&mock->demiurge_, &Demiurge::DecreaseMonsters))));
 //
 
 #include "base/memory/linked_ptr.h"
-#include "base/tuple.h"  // for Tuple
+#include "base/tuple.h"
 
 namespace testing {"""
 
 MUTANT = """\
 
 // Interface that is exposed to the consumer, that does the actual calling
 // of the method.
 template <typename R, typename Params>
 class MutantRunner {
  public:
@@ skipping 68 matching lines @@
 // Redirects operator() to MutantRunner<Params>::Run()
 template <typename R, typename Params>
 struct MutantFunctor {
   explicit MutantFunctor(MutantRunner<R, Params>*  cb) : impl_(cb) {
   }
 
   ~MutantFunctor() {
   }
 
   inline R operator()() {
-    return impl_->RunWithParams(Tuple<>());
+    return impl_->RunWithParams(base::Tuple<>());
   }
 
   template <typename Arg1>
   inline R operator()(const Arg1& a) {
     return impl_->RunWithParams(Params(a));
   }
 
   template <typename Arg1, typename Arg2>
   inline R operator()(const Arg1& a, const Arg2& b) {
     return impl_->RunWithParams(Params(a, b));
@@ skipping 53 matching lines @@
 # params - X1,.. , A1, ..
 # args - const P1& p1 ..
 # call_args - p1, p2, p3..
 CREATE_METHOD_FUNCTOR_TEMPLATE = """\
 template <typename R, typename T, typename U, %(template_params)s>
 inline MutantFunctor<R, %(calltime)s>
 CreateFunctor(T* obj, R (U::*method)(%(params)s), %(args)s) {
   MutantRunner<R, %(calltime)s>* t =
       new Mutant<R, T, R (U::*)(%(params)s),
                  %(prebound)s, %(calltime)s>
-          (obj, method, MakeTuple(%(call_args)s));
+          (obj, method, base::MakeTuple(%(call_args)s));
   return MutantFunctor<R, %(calltime)s>(t);
 }
 """
 
 CREATE_FUNCTION_FUNCTOR_TEMPLATE = """\
 template <typename R, %(template_params)s>
 inline MutantFunctor<R, %(calltime)s>
 CreateFunctor(R (*function)(%(params)s), %(args)s) {
   MutantRunner<R, %(calltime)s>* t =
       new MutantFunction<R, R (*)(%(params)s),
                          %(prebound)s, %(calltime)s>
-          (function, MakeTuple(%(call_args)s));
+          (function, base::MakeTuple(%(call_args)s));
   return MutantFunctor<R, %(calltime)s>(t);
 }
 """
 
 def SplitLine(line, width):
   """Splits a single line at comma, at most |width| characters long."""
-  if len(line) < width:
+  if len(line) <= width:
     return (line, None)
   n = 1 + line[:width].rfind(",")
   if n == 0:  # If comma cannot be found give up and return the entire line.
     return (line, None)
   # Assume there is a space after the comma
   assert line[n] == " "
   return (line[:n], line[n + 1:])
 
 
 def Wrap(s, width, subsequent_offset):
@@ skipping 36 matching lines @@
   """
   it = string.hexdigits[start:n + start]
   return ", ".join(ExpandPattern(pattern, it))
 
 
 def Merge(a):
   return ", ".join(filter(len, a))
 
 
 def GenTuple(pattern, n):
-  return Clean("Tuple<%s>" % (Gen(pattern, n, 1)))
+  return Clean("base::Tuple<%s>" % (Gen(pattern, n, 1)))
 
 
 def FixCode(s):
   lines = Clean(s).splitlines()
-  # Wrap sometimes very long 1st and 3rd line at 80th column.
+  # Wrap sometimes very long 1st line to be inside the "template <"
   lines[0] = Wrap(lines[0], 80, 10)
-  lines[2] = Wrap(lines[2], 80, 4)
+
+  # Wrap all subsequent lines to 6 spaces arbitrarily. This is a 2-space line
+  # indent, plus a 4 space continuation indent.
+  for line in xrange(1, len(lines)):
+    lines[line] = Wrap(lines[line], 80, 6)
   return "\n".join(lines)
 
 
 def GenerateDispatch(prebound, calltime):
   print "\n// %d - %d" % (prebound, calltime)
   args = {
       "template_params": Merge([Gen("typename P%", prebound, 1),
                                 Gen("typename C%", calltime, 1)]),
       "prebound": GenTuple("P%", prebound),
       "calltime": GenTuple("C%", calltime),
-      "args": Merge([Gen("get<%>(p)", prebound, 0),
-                     Gen("get<%>(c)", calltime, 0)]),
+      "args": Merge([Gen("base::get<%>(p)", prebound, 0),
+                     Gen("base::get<%>(c)", calltime, 0)]),
   }
 
   print FixCode(DISPATCH_TO_METHOD_TEMPLATE % args)
   print FixCode(DISPATCH_TO_FUNCTION_TEMPLATE % args)
 
 
 def GenerateCreateFunctor(prebound, calltime):
   print "// %d - %d" % (prebound, calltime)
   args = {
       "calltime": GenTuple("A%", calltime),
@@ skipping 52 matching lines @@
   print MUTANT
   for prebound in xrange(0, 6 + 1):
     for args in xrange(0, 6 + 1):
       GenerateCreateFunctor(prebound, args)
   print FOOTER
   return 0
 
 
 if __name__ == "__main__":
   sys.exit(main())