01/12/2005
The use of mock objects is a widely employed unit testing strategy. It shields external and unnecessary factors from testing and helps developers focus on a specific function to be tested.
java.lang.reflect.Proxy
, which can create dynamic proxy classes/objects according to given interfaces. But it has an inherent limitation from its use of
Proxy
: it can create mock objects only for interfaces.
Mocquer is a similar mock tool, but one that extends the functionality of EasyMock to support mock object creation for classes as well as interfaces.
Introduction to Mocquer
Mocquer is based on the Dunamis project, which is used to generate dynamic delegation classes/objects for specific interfaces/classes. For convenience, it follows the class and method naming conventions of EasyMock, but uses a different approach internally.
MockControl
is the main class in the Mocquer project. It is used to control the the mock object life cycle and behavior definition. There are four kinds methods in this class.
- Life Cycle Control Methods
public void replay(); public void verify(); public void reset();
The mock object has three states in its life cycle: preparing, working, and checking. Figure 1 shows the mock object life cycle.
Initially, the mock object is in the preparing state. The mock object's behavior can be defined in this state.
Figure 1. Mock object life cyclereplay()
changes the mock object's state to the working state. All method invocations on the mock object in this state will follow the behavior defined in the preparing state. Afterverify()
is called, the mock object is in the checking state.MockControl
will compare the mock object's predefined behavior and actual behavior to see whether they match. The match rule depends on which kind ofMockControl
is used; this will be explained in a moment. The developer can usereplay()
to reuse the predefined behavior if needed. Callreset()
, in any state, to clear the history state and change to the initial preparing state. - Factory Methods
public static MockControl createNiceControl(...); public static MockControl createControl(...); public static MockControl createStrictControl(...);
Mocquer provides three kinds of
MockControls
:Nice
,Normal
, andStrict
. The developer can choose an appropriateMockControl
in his or her test case, according to what is to be tested (the test point) and how the test will be carried out (the test strategy). TheNice
MockControl
is the loosest. It does not care about the order of method invocation on the mock object, or about unexpected method invocations, which just return a default value (that depends on the method's return value). TheNormal
MockControl
is stricter than theNice
MockControl
, as an unexpected method invocation on the mock object will lead to anAssertionFailedError
. TheStrict
MockControl
is, naturally, the strictest. If the order of method invocation on the mock object in the working state is different than that in the preparing state, anAssertionFailedError
will be thrown. The table below shows the differences between these three kinds ofMockControl
.Nice
Normal
Strict
Unexpected Order Doesn't care Doesn't care AssertionFailedError
Unexpected Method Default value AssertionFailedError
AssertionFailedError
There are two versions for each factory method.
public static MockControl createXXXControl(Class clazz); public static MockControl createXXXControl(Class clazz, Class[] argTypes, Object[] args);
If the class to be mocked is an interface or it has a public/protected default constructor, the first version is enough. Otherwise, the second version factory method is used to specify the signature and provide arguments to the desired constructor. For example, assuming
ClassWithNoDefaultConstructor
is a class without a default constructor:public class ClassWithNoDefaultConstructor { public ClassWithNoDefaultConstructor(int i) { ... } ... }
The
MockControl
can be obtained through:MockControl control = MockControl.createControl( ClassWithNoDefaultConstructor.class, new Class[]{Integer.TYPE}, new Object[]{new Integer(0)});
- Mock object getter method
public Object getMock();
Each
MockControl
contains a reference to the generated mock object. The developer can use this method to get the mock object and cast it to the real type.//get mock control MockControl control = MockControl.createControl(Foo.class); //Get the mock object from mock control Foo foo = (Foo) control.getMock();
- Behavior definition methods
public void setReturnValue(... value); public void setThrowable(Throwable throwable); public void setVoidCallable(); public void setDefaultReturnValue(... value); public void setDefaultThrowable(Throwable throwable); public void setDefaultVoidCallable(); public void setMatcher(ArgumentsMatcher matcher); public void setDefaultMatcher(ArgumentsMatcher matcher);
MockControl
allows the developer to define the mock object's behavior per each method invocation on it. When in the preparing state, the developer can call one of the mock object's methods first to specify which method invocation's behavior is to be defined. Then, the developer can use one of the behavior definition methods to specify the behavior. For example, take the followingFoo
class:
The behavior of the mock object can be defined as in the following://Foo.java public class Foo { public void dummy() throw ParseException { ... } public String bar(int i) { ... } public boolean isSame(String[] strs) { ... } public void add(StringBuffer sb, String s) { ... } }
//get mock control MockControl control = MockControl.createControl(Foo.class); //get mock object Foo foo = (Foo)control.getMock(); //begin behavior definition //specify which method invocation's behavior //to be defined. foo.bar(10); //define the behavior -- return "ok" when the //argument is 10 control.setReturnValue("ok"); ... //end behavior definition control.replay(); ...
Most of the more than 50 methods in
MockControl
are behavior definition methods. They can be grouped into following categories.setReturnValue()
These methods are used to specify that the last method invocation should return a value as the parameter. There are seven versions of
setReturnValue()
, each of which takes a primitive type as its parameter, such assetReturnValue(int i)
orsetReturnValue(float f)
.setReturnValue(Object obj)
is used for a method that takes an object instead of a primitive. If the given value does not match the method's return type, anAssertionFailedError
will be thrown.It is also possible to add the number of expected invocations into the behavior definition. This is called the invocation times limitation.
MockControl control = ... Foo foo = (Foo)control.getMock(); ... foo.bar(10); //define the behavior -- return "ok" when the //argument is 10. And this method is expected //to be called just once. setReturnValue("ok", 1); ...
The code segment above specifies that the method invocation,
bar(10)
, can only occur once. How about providing a range?... foo.bar(10); //define the behavior -- return "ok" when the //argument is 10. And this method is expected //to be called at least once and at most 3 //times. setReturnValue("ok", 1, 3); ...
Now
bar(10)
is limited to be called at least once and at most, three times. More appealingly, aRange
can be given to specify the limitation.... foo.bar(10); //define the behavior -- return "ok" when the //argument is 10. And this method is expected //to be called at least once. setReturnValue("ok", Range.ONE_OR_MORE); ...
Range.ONE_OR_MORE
is a pre-definedRange
instance, which means the method should be called at least once. If there is no invocation-count limitation specified insetReturnValue()
, such assetReturnValue("Hello")
, it will useRange.ONE_OR_MORE
as its default invocation-count limitation. There are another two predefinedRange
instances:Range.ONE
(exactly once) andRange.ZERO_OR_MORE
(there's no limit on how many times you can call it).There is also a special set return value method:
setDefaultReturnValue()
. It defines the return value of the method invocation despite the method parameter values. The invocation times limitation isRange.ONE_OR_MORE
. This is known as the method parameter values insensitive feature.... foo.bar(10); //define the behavior -- return "ok" when calling //bar(int) despite the argument value. setDefaultReturnValue("ok"); ...
setThrowable
setThrowable(Throwable throwable)
is used to define the method invocation's exception throwing behavior. If the given throwable does not match the exception declaration of the method, anAssertionFailedError
will be thrown. The invocation times limitation and method parameter values insensitive features can also be applied.... try { foo.dummy(); } catch (Exception e) { //skip } //define the behavior -- throw ParseException //when call dummy(). And this method is expected //to be called exactly once. control.setThrowable(new ParseException("", 0), 1); ...
setVoidCallable()
setVoidCallable()
is used for a method that has avoid
return type. The invocation times limitation and method parameter values insensitive features can also be applied.... try { foo.dummy(); } catch (Exception e) { //skip } //define the behavior -- no return value //when calling dummy(). And this method is expected //to be called at least once. control.setVoidCallable(); ...
- Set
ArgumentsMatcher
In the working state, the
MockControl
will search the predefined behavior when any method invocation has happened on the mock object. There are three factors in the search criteria: method signature, parameter value, and invocation times limitation. The first and third factors are fixed. The second factor can be skipped by the parameter values insensitive feature described above. More flexibly, it is also possible to customize the parameter value match rule.setMatcher()
can be used in the preparing state with a customizedArgumentsMatcher
.public interface ArgumentsMatcher { public boolean matches(Object[] expected, Object[] actual); }
The only method in
ArgumentsMatcher
,matches()
, takes two arguments. One is the expected parameter values array (null, if the parameter values insensitive feature applied). The other is the actual parameter values array. A true return value means that the parameter values match.... foo.isSame(null); //set the argument match rule -- always match //no matter what parameter is given control.setMatcher(MockControl.ALWAYS_MATCHER); //define the behavior -- return true when call //isSame(). And this method is expected //to be called at least once. control.setReturnValue(true, 1); ...
There are three predefined
ArgumentsMatcher
instances inMockControl
.MockControl.ALWAYS_MATCHER
always returns true when matching, no matter what parameter values are given.MockControl.EQUALS_MATCHER
callsequals()
on each element in the parameter value array.MockControl.ARRAY_MATCHER
is almost the same asMockControl.EQUALS_MATCHER
, except that it callsArrays.equals()
instead ofequals()
when the element in the parameter value array is an array type. Of course, the developer can implement his or her ownArgumentsMatcher
.A side effect of a customized
ArgumentsMatcher
is that it defines the method invocation's out parameter value.... //just to demonstrate the function //of out parameter value definition foo.add(new String[]{null, null}); //set the argument match rule -- always //match no matter what parameter given. //Also defined the value of out param. control.setMatcher(new ArgumentsMatcher() { public boolean matches(Object[] expected, Object[] actual) { ((StringBuffer)actual[0]) .append(actual[1]); return true; } }); //define the behavior of add(). //This method is expected to be called at //least once. control.setVoidCallable(true, 1); ...
setDefaultMatcher()
sets theMockControl
's defaultArgumentsMatcher
instance. If no specificArgumentsMatcher
is given, the defaultArgumentsMatcher
will be used. This method should be called before any method invocation behavior definition. Otherwise, anAssertionFailedError
will be thrown.
If//get mock control MockControl control = ...; //get mock object Foo foo = (Foo)control.getMock(); //set default ArgumentsMatcher control.setDefaultMatcher( MockControl.ALWAYS_MATCHER); //begin behavior definition foo.bar(10); control.setReturnValue("ok"); ...
setDefaultMatcher()
is not used,MockControl.ARRAY_MATCHER
is the system defaultArgumentsMatcher
.