The Tor Browser: comparison media/webrtc/trunk/testing/generate_gmock

--1:000000000000
+:9fc260e31145
+#!/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())

The Tor Browser / file comparison

comparison: media/webrtc/trunk/testing/generate_gmock_mutant.py

media/webrtc/trunk/testing/generate_gmock_mutant.py