diff options
Diffstat (limited to 'chromium/testing/generate_gmock_mutant.py')
| -rwxr-xr-x | chromium/testing/generate_gmock_mutant.py | 457 |
1 files changed, 457 insertions, 0 deletions
diff --git a/chromium/testing/generate_gmock_mutant.py b/chromium/testing/generate_gmock_mutant.py new file mode 100755 index 00000000000..6d814f08297 --- /dev/null +++ b/chromium/testing/generate_gmock_mutant.py @@ -0,0 +1,457 @@ +#!/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. +// 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. + # These are not for WIN64 (x86_64) because there is only one calling + # convention in WIN64. + # Functor for method with __stdcall calling conventions. + print "#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)" + 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 // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)\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()) |