Revert "Update legacy Tuple-using code."

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 38 matching lines @@
 //   string HandleFlowers(const string& reply, int n, const string& request) {
 //     string result = SStringPrintf("In request of %d %s ", n, request);
 //     for (int i = 0; i < n; ++i) result.append(reply)
 //     return result;
 //   }
 //
 //   void DoLogMessage(int level, const string& message) {
 //   }
 //
 //   void QuitMessageLoop(int seconds) {
-//     base::MessageLoop* loop = base::MessageLoop::current();
-//     loop->PostDelayedTask(FROM_HERE, base::MessageLoop::QuitClosure(),
+//     MessageLoop* loop = MessageLoop::current();
+//     loop->PostDelayedTask(FROM_HERE, MessageLoop::QuitClosure(),
 //                           1000 * seconds);
 //   }
 // };
 //
 // Mock mock;
 // // Will invoke mock.HandleFlowers("orchids", n, request)
 // // "orchids" is a pre-bound argument, and <n> and <request> are call-time
 // // arguments - they are not known until the OnRequest mock is invoked.
 // EXPECT_CALL(mock, OnRequest(Ge(5), StartsWith("flower"))
 //   .Times(1)
@@ skipping 124 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(Tuple0());
   }
 
   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 18 matching lines @@
 };
 """
 
 FOOTER = """\
 }  // namespace testing
 
 #endif  // TESTING_GMOCK_MUTANT_H_"""
 
 # Templates for DispatchToMethod/DispatchToFunction functions.
 # template_params - typename P1, typename P2.. typename C1..
-# prebound - Tuple<P1, .. PN>
-# calltime - Tuple<C1, .. CN>
+# prebound - TupleN<P1, .. PN>
+# calltime - TupleN<C1, .. CN>
 # args - p.a, p.b.., c.a, c.b..
 DISPATCH_TO_METHOD_TEMPLATE = """\
 template <typename R, typename T, typename Method, %(template_params)s>
 inline R DispatchToMethod(T* obj, Method method,
                           const %(prebound)s& p,
                           const %(calltime)s& c) {
   return (obj->*method)(%(args)s);
 }
 """
 
 DISPATCH_TO_FUNCTION_TEMPLATE = """\
 template <typename R, typename Function, %(template_params)s>
 inline R DispatchToFunction(Function function,
                             const %(prebound)s& p,
                             const %(calltime)s& c) {
   return (*function)(%(args)s);
 }
 """
 
 # Templates for CreateFunctor functions.
 # template_params - typename P1, typename P2.. typename C1.. typename X1..
-# prebound - Tuple<P1, .. PN>
-# calltime - Tuple<A1, .. AN>
+# prebound - TupleN<P1, .. PN>
+# calltime - TupleN<A1, .. AN>
 # 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>
@@ skipping 19 matching lines @@
   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):
+def Wrap(s, width, subsequent_offset=4):
   """Wraps a single line |s| at commas so every line is at most |width|
      characters long.
   """
   w = []
   spaces = " " * subsequent_offset
   while s:
     (f, s) = SplitLine(s, width)
     w.append(f)
     if s:
       s = spaces  + s
   return "\n".join(w)
 
 
 def Clean(s):
   """Cleans artifacts from generated C++ code.
 
   Our simple string formatting/concatenation may introduce extra commas.
   """
+  s = s.replace("<>", "")
   s = s.replace(", >", ">")
   s = s.replace(", )", ")")
+  s = s.replace(">>", "> >")
   return s
 
 
 def ExpandPattern(pattern, it):
   """Return list of expanded pattern strings.
 
   Each string is created by replacing all '%' in |pattern| with element of |it|.
   """
   return [pattern.replace("%", x) for x in it]
 
 
-def Gen(pattern, n, start):
-  """Expands pattern replacing '%' with sequential integers starting with start.
+def Gen(pattern, n):
+  """Expands pattern replacing '%' with sequential integers.
 
   Expanded patterns will be joined with comma separator.
-  Gen("X%", 3, 1) will return "X1, X2, X3".
+  GenAlphs("X%", 3) will return "X1, X2, X3".
   """
-  it = string.hexdigits[start:n + start]
+  it = string.hexdigits[1:n + 1]
   return ", ".join(ExpandPattern(pattern, it))
 
 
+def GenAlpha(pattern, n):
+  """Expands pattern replacing '%' with sequential small ASCII letters.
+
+  Expanded patterns will be joined with comma separator.
+  GenAlphs("X%", 3) will return "Xa, Xb, Xc".
+  """
+  it = string.ascii_lowercase[0:n]
+  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("Tuple%d<%s>" % (n, Gen(pattern, n)))
 
 
 def FixCode(s):
   lines = Clean(s).splitlines()
   # Wrap sometimes very long 1st and 3rd line at 80th column.
   lines[0] = Wrap(lines[0], 80, 10)
   lines[2] = Wrap(lines[2], 80, 4)
   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)]),
+      "template_params": Merge([Gen("typename P%", prebound),
+                                Gen("typename C%", calltime)]),
       "prebound": GenTuple("P%", prebound),
       "calltime": GenTuple("C%", calltime),
-      "args": Merge([Gen("get<%>(p)", prebound, 0),
-                     Gen("get<%>(c)", calltime, 0)]),
+      "args": Merge([GenAlpha("p.%", prebound), GenAlpha("c.%", calltime)]),
   }
 
   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),
       "prebound": GenTuple("P%", prebound),
-      "params": Merge([Gen("X%", prebound, 1), Gen("A%", calltime, 1)]),
-      "args": Gen("const P%& p%", prebound, 1),
-      "call_args": Gen("p%", prebound, 1),
-      "template_params": Merge([Gen("typename P%", prebound, 1),
-                                Gen("typename A%", calltime, 1),
-                                Gen("typename X%", prebound, 1)])
+      "params": Merge([Gen("X%", prebound), Gen("A%", calltime)]),
+      "args": Gen("const P%& p%", prebound),
+      "call_args": Gen("p%", prebound),
+      "template_params": Merge([Gen("typename P%", prebound),
+                                Gen("typename A%", calltime),
+                                Gen("typename X%", prebound)])
   }
 
   mutant = FixCode(CREATE_METHOD_FUNCTOR_TEMPLATE % args)
   print mutant
 
   # Slightly different version for free function call.
   print "\n", FixCode(CREATE_FUNCTION_FUNCTOR_TEMPLATE % args)
 
   # Functor with pointer to a pointer of the object.
   print "\n#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING"
@@ skipping 35 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())