The Tor Browser / file revision

 #!/usr/bin/env python

 # Copyright (c) 2011 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) 2011 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.

 // This file automatically generated by testing/generate_gmock_mutant.py.

 // DO NOT EDIT.

 #ifndef TESTING_GMOCK_MUTANT_H_

 #define TESTING_GMOCK_MUTANT_H_

 // The intention of this file is to make possible using GMock actions in

 // all of its syntactic beauty. Classes and helper functions can be used as

 // more generic variants of Task and Callback classes (see base/task.h)

 // Mutant supports both pre-bound arguments (like Task) and call-time

 // arguments (like Callback) - hence the name. :-)

 //

 // DispatchToMethod/Function supports two sets of arguments: pre-bound (P) and

 // call-time (C). The arguments as well as the return type are templatized.

 // DispatchToMethod/Function will also try to call the selected method or

 // function even if provided pre-bound arguments does not match exactly with

 // the function signature hence the X1, X2 ... XN parameters in CreateFunctor.

 // DispatchToMethod will try to invoke method that may not belong to the

 // object's class itself but to the object's class base class.

 //

 // Additionally you can bind the object at calltime by binding a pointer to

 // pointer to the object at creation time - before including this file you

 // have to #define GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING.

 //

 // TODO(stoyan): It's yet not clear to me should we use T& and T&* instead

 // of T* and T** when we invoke CreateFunctor to match the EXPECT_CALL style.

 //

 //

 // Sample usage with gMock:

 //

 // struct Mock : public ObjectDelegate {

 //   MOCK_METHOD2(string, OnRequest(int n, const string& request));

 //   MOCK_METHOD1(void, OnQuit(int exit_code));

 //   MOCK_METHOD2(void, LogMessage(int level, const string& message));

 //

 //   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) {

 //     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)

 //   .WillOnce(Invoke(CreateFunctor(&mock, &Mock::HandleFlowers,

 //       string("orchids"))));

 //

 //

 // // No pre-bound arguments, two call-time arguments passed

 // // directly to DoLogMessage

 // EXPECT_CALL(mock, OnLogMessage(_, _))

 //   .Times(AnyNumber())

 //   .WillAlways(Invoke(CreateFunctor, &mock, &Mock::DoLogMessage));

 //

 //

 // // In this case we have a single pre-bound argument - 3. We ignore

 // // all of the arguments of OnQuit.

 // EXCEPT_CALL(mock, OnQuit(_))

 //   .Times(1)

 //   .WillOnce(InvokeWithoutArgs(CreateFunctor(

 //       &mock, &Mock::QuitMessageLoop, 3)));

 //

 // MessageLoop loop;

 // loop.Run();

 //

 //

 //  // Here is another example of how we can set an action that invokes

 //  // method of an object that is not yet created.

 // struct Mock : public ObjectDelegate {

 //   MOCK_METHOD1(void, DemiurgeCreated(Demiurge*));

 //   MOCK_METHOD2(void, OnRequest(int count, const string&));

 //

 //   void StoreDemiurge(Demiurge* w) {

 //     demiurge_ = w;

 //   }

 //

 //   Demiurge* demiurge;

 // }

 //

 // 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

 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:

   virtual R RunWithParams(const Params& params) = 0;

   virtual ~MutantRunner() {}

 };

 // Mutant holds pre-bound arguments (like Task). Like Callback

 // allows call-time arguments. You bind a pointer to the object

 // at creation time.

 template <typename R, typename T, typename Method,

           typename PreBound, typename Params>

 class Mutant : public MutantRunner<R, Params> {

  public:

   Mutant(T* obj, Method method, const PreBound& pb)

       : obj_(obj), method_(method), pb_(pb) {

   }

   // MutantRunner implementation

   virtual R RunWithParams(const Params& params) {

     return DispatchToMethod<R>(this->obj_, this->method_, pb_, params);

   }

   T* obj_;

   Method method_;

   PreBound pb_;

 };

 template <typename R, typename Function, typename PreBound, typename Params>

 class MutantFunction : public MutantRunner<R, Params> {

  public:

   MutantFunction(Function function, const PreBound& pb)

       : function_(function), pb_(pb) {

   }

   // MutantRunner implementation

   virtual R RunWithParams(const Params& params) {

     return DispatchToFunction<R>(function_, pb_, params);

   }

   Function function_;

   PreBound pb_;

 };

 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING

 // MutantLateBind is like Mutant, but you bind a pointer to a pointer

 // to the object. This way you can create actions for an object

 // that is not yet created (has only storage for a pointer to it).

 template <typename R, typename T, typename Method,

           typename PreBound, typename Params>

 class MutantLateObjectBind : public MutantRunner<R, Params> {

  public:

   MutantLateObjectBind(T** obj, Method method, const PreBound& pb)

       : obj_(obj), method_(method), pb_(pb) {

   }

   // MutantRunner implementation.

   virtual R RunWithParams(const Params& params) {

     EXPECT_THAT(*this->obj_, testing::NotNull());

     if (NULL == *this->obj_)

       return R();

     return DispatchToMethod<R>( *this->obj_, this->method_, pb_, params);

   }

   T** obj_;

   Method method_;

   PreBound pb_;

 };

 #endif

 // Simple MutantRunner<> wrapper acting as a functor.

 // 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(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));

   }

   template <typename Arg1, typename Arg2, typename Arg3>

   inline R operator()(const Arg1& a, const Arg2& b, const Arg3& c) {

     return impl_->RunWithParams(Params(a, b, c));

   }

   template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>

   inline R operator()(const Arg1& a, const Arg2& b, const Arg3& c,

                          const Arg4& d) {

     return impl_->RunWithParams(Params(a, b, c, d));

   }

  private:

   // We need copy constructor since MutantFunctor is copied few times

   // inside GMock machinery, hence no DISALLOW_EVIL_CONTRUCTORS

   MutantFunctor();

   linked_ptr<MutantRunner<R, Params> > impl_;

 };

 """

 FOOTER = """\

 }  // namespace testing

 #endif  // TESTING_GMOCK_MUTANT_H_"""

 # Templates for DispatchToMethod/DispatchToFunction functions.

 # template_params - typename P1, typename P2.. typename C1..

 # 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 - 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>

           (obj, method, 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));

   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:

     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=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):

   """Expands pattern replacing '%' with sequential integers.

   Expanded patterns will be joined with comma separator.

   GenAlphs("X%", 3) will return "X1, X2, X3".

   """

   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%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),

                                 Gen("typename C%", calltime)]),

       "prebound": GenTuple("P%", prebound),

       "calltime": GenTuple("C%", calltime),

       "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), 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"

   mutant2 = mutant.replace("CreateFunctor(T* obj,", "CreateFunctor(T** obj,")

   mutant2 = mutant2.replace("new Mutant", "new MutantLateObjectBind")

   mutant2 = mutant2.replace(" " * 17 + "Tuple", " " * 31 + "Tuple")

   print mutant2

   print "#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING\n"

   # OS_WIN specific. Same functors but with stdcall calling conventions.

   # Functor for method with __stdcall calling conventions.

   print "#if defined (OS_WIN)"

   stdcall_method = CREATE_METHOD_FUNCTOR_TEMPLATE

   stdcall_method = stdcall_method.replace("U::", "__stdcall U::")

   stdcall_method = FixCode(stdcall_method % args)

   print stdcall_method

   # Functor for free function with __stdcall calling conventions.

   stdcall_function = CREATE_FUNCTION_FUNCTOR_TEMPLATE

   stdcall_function = stdcall_function.replace("R (*", "R (__stdcall *");

   print "\n", FixCode(stdcall_function % args)

   print "#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING"

   stdcall2 = stdcall_method;

   stdcall2 = stdcall2.replace("CreateFunctor(T* obj,", "CreateFunctor(T** obj,")

   stdcall2 = stdcall2.replace("new Mutant", "new MutantLateObjectBind")

   stdcall2 = stdcall2.replace(" " * 17 + "Tuple", " " * 31 + "Tuple")

   print stdcall2

   print "#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING"

   print "#endif  // OS_WIN\n"

 def main():

   print HEADER

   for prebound in xrange(0, 6 + 1):

     for args in xrange(0, 6 + 1):

       GenerateDispatch(prebound, args)

   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())