Menu
▾
▴
[MO-java-dev] CVS: mockobjects-java/src/core/com/mockobjects/dynamic Mock.java,1.3,1.4
|
From: Steve F. <sm...@us...> - 2002-10-27 11:46:04
|
Update of /cvsroot/mockobjects/mockobjects-java/src/core/com/mockobjects/dynamic In directory usw-pr-cvs1:/tmp/cvs-serv15671/src/core/com/mockobjects/dynamic Modified Files: Mock.java Log Message: layout and twiddly refactorings Index: Mock.java =================================================================== RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/com/mockobjects/dynamic/Mock.java,v retrieving revision 1.3 retrieving revision 1.4 diff -u -r1.3 -r1.4 --- Mock.java 25 Oct 2002 22:06:59 -0000 1.3 +++ Mock.java 27 Oct 2002 11:45:59 -0000 1.4 @@ -1,5 +1,5 @@ /* Copyright (c) 2002 Nat Pryce. All rights reserved. - * + * * Created on February 10, 2002, 11:06 PM */ package com.mockobjects.dynamic; @@ -14,31 +14,34 @@ import java.util.*; -/** A convenient class for creating simple +/** + * A convenient class for creating simple * <a href="http://www.mockobjects.com">mock objects</a>. */ -public class Mock +public class Mock extends Assert implements InvocationHandler, Verifiable { public static final Object VOID = new Object(); - /** A convenient constant for defining expectations for methods that + /** + * A convenient constant for defining expectations for methods that * have no methods. */ public static final Predicate[] NO_ARGS = new Predicate[0]; - + private String _name; private Map _expectations = new HashMap(); private Set _not_called_expectations = new HashSet(); private Map _order_constraints = new HashMap(); private Set _called_methods = new HashSet(); private boolean _strict = false; - + private Map _default_results = new HashMap(); - - - /** Creates a named Mock object, The name will be included in the messages + + + /** + * Creates a named Mock object, The name will be included in the messages * of exceptions thrown to indicate violated expectations. */ public Mock( String name ) { @@ -53,8 +56,9 @@ setupDefaultResult( char.class, new Character('\0') ); setupDefaultResult( String.class, "" ); } - - /** Creates a Mock object and automatically assigns a name to it. The assigned + + /** + * Creates a Mock object and automatically assigns a name to it. The assigned * name will include the name of the concrete class and a unique identifier of * this instance, but will not be particularly user friendly when included in * error messages. Therefore, it is recommended that you explictly name mock @@ -64,16 +68,18 @@ this(null); _name = super.toString(); } - - /** Returns the Mock's name. + + /** + * Returns the Mock's name. */ public String toString() { return _name; } - - /** Is the mock in strict mode? In strict mode the mock will throw + + /** + * Is the mock in strict mode? In strict mode the mock will throw * {@link junit.framework.AssertionFailedError} exceptions when - * unexpected method calls are made. Otherwise, the mock ignore + * unexpected method calls are made. Otherwise, the mock ignore * the call or return default arguments. */ public boolean isStrict() { @@ -83,11 +89,12 @@ public void setStrict( boolean strict ) { _strict = strict; } - - /** Mock the behaviour of a method without requiring that the method + + /** + * Mock the behaviour of a method without requiring that the method * actually be called. Note: the ExpectedCall may check the arguments * of the call but should usually not do so. - * + * * @param call * The call to be mocked. */ @@ -96,11 +103,12 @@ _not_called_expectations.remove( call.getMethodName() ); _called_methods.add( call.getMethodName() ); } - - /** Set up calls to <var>method</var> to return <var>result</var>, + + /** + * Set up calls to <var>method</var> to return <var>result</var>, * but do not define any expectations upon arguments to those calls. * Arguments of calls to <var>method</var> will be ignored. - * + * * @param method_name * The name of the method that will be called. * @param result @@ -111,8 +119,9 @@ public void setupResult( String method_name, Object result ) { setup( new ExpectedReturn( method_name, null, result ) ); } - - /** Set up calls to <var>method</var> to throw <var>exception</var>, + + /** + * Set up calls to <var>method</var> to throw <var>exception</var>, * but do not define any expectations upon arguments to those calls. * Arguments of calls to <var>method</var> will be ignored. * @@ -124,12 +133,13 @@ public void setupThrow( String method_name, Throwable exception ) { setup( new ExpectedThrow( method_name, null, exception ) ); } - - /** Set up the value returned by methods that have the given result + + /** + * Set up the value returned by methods that have the given result * type, if no result or exception has been explicitly defined for * the called method by {@link #setupResult}, {@link #setupThrow}, * {@link #expectReturn} or {@link #expectThrow}. - * + * * @param result_type * The result type of methods to be mocked. * @param result_value @@ -139,8 +149,9 @@ public void setupDefaultResult( Class result_type, Object result_value ) { _default_results.put( result_type, result_value ); } - - /** Expect a method call and mock the behaviour of that call. + + /** + * Expect a method call and mock the behaviour of that call. * * @param call * An object describing the expected call and mocking its behaviour. @@ -150,9 +161,10 @@ _not_called_expectations.remove( call.getMethodName() ); _called_methods.remove( call.getMethodName() ); } - - /** Expect a method call and return a result when it is called. - * + + /** + * Expect a method call and return a result when it is called. + * * @param method * The name of the method that will be called. * @param args @@ -167,8 +179,9 @@ public void expectReturn( String method, Predicate[] args, Object result ) { expect( new ExpectedReturn( method, args, result ) ); } - - /** Expect a method call and return a result when it is called. + + /** + * Expect a method call and return a result when it is called. * * @param method * The name of the method that will be called. @@ -183,7 +196,8 @@ expectReturn(method, P.args(P.eq(arg)), result); } - /** Expect a method call with no parameters and return a result when it is called. + /** + * Expect a method call with no parameters and return a result when it is called. * * @param method * The name of the method that will be called. @@ -196,8 +210,9 @@ expectReturn(method, NO_ARGS, result ); } - /** Expect a call to a method with a void return type. - * + /** + * Expect a call to a method with a void return type. + * * @param method * The name of the method that will be called. * @param args @@ -209,7 +224,8 @@ expect( new ExpectedReturn( method, args, VOID ) ); } - /** Expect a call to a method with a void return type. + /** + * Expect a call to a method with a void return type. * * @param method * The name of the method that will be called. @@ -220,7 +236,8 @@ expectVoid(method, P.args(P.eq(arg))); } - /** Expect a call to a method with a void return type and no parameters + /** + * Expect a call to a method with a void return type and no parameters * * @param method * The name of the method that will be called. @@ -229,8 +246,9 @@ expectVoid(method, NO_ARGS); } - /** Expect a method call and throw an exception or error when it is called. - * + /** + * Expect a method call and throw an exception or error when it is called. + * * @param method * The name of the method that will be called. * @param args @@ -243,8 +261,9 @@ public void expectThrow( String method, Predicate[] args, Throwable exception ) { expect( new ExpectedThrow( method, args, exception ) ); } - - /** Expect a method call and throw an exception or error when it is called. + + /** + * Expect a method call and throw an exception or error when it is called. * * @param method * The name of the method that will be called. @@ -257,7 +276,8 @@ expectThrow( method, P.args(P.eq(arg)), exception ); } - /** Expect a method call with no parameters and throw an exception or error when it is called. + /** + * Expect a method call with no parameters and throw an exception or error when it is called. * * @param method * The name of the method that will be called. @@ -268,61 +288,62 @@ expectThrow( method, NO_ARGS, exception ); } - /** Expect a method not to be called. + /** + * Expect a method not to be called. * An {@link junit.framework.AssertionFailedError} will be thrown if * the method is called. - * + * * @param method * The name of the method that will not be called. */ public void expectNotCalled( String method ) { _not_called_expectations.add(method); } - - /** Define an order between two calls. The method named + + /** + * Define an order between two calls. The method named * <var>subsequent_method</var> <em>must</em> be called after * the method namd <var>preceding_method</var>, otherwise an * {@link junit.framework.AssertionFailedError} will be thrown. */ public void order( String preceding_method, String subsequent_method ) { - Set preceding_calls; - if( _order_constraints.containsKey(subsequent_method) ) { - preceding_calls = (Set)_order_constraints.get(subsequent_method); - } else { + Set preceding_calls = orderConstraintsFor(subsequent_method); + if( null == preceding_calls) { preceding_calls = new HashSet(); _order_constraints.put( subsequent_method, preceding_calls ); } - + preceding_calls.add( preceding_method ); } - - /** Called by the {@link java.lang.reflect.Proxy} to mock the behaviour of an + + /** + * Called by the {@link java.lang.reflect.Proxy} to mock the behaviour of an * invoked method and check expectations. */ public Object invoke( Object obj, Method method, Object[] args ) throws Throwable { _called_methods.add( method.getName() ); - + try { - return getClass().getMethod( + return getClass().getMethod( method.getName(), method.getParameterTypes() ).invoke( this, args ); } catch( NoSuchMethodException ex ) { return mockCall( method, args ); } } - + protected Object mockCall( Method method, Object[] args ) throws Throwable { String method_name = method.getName(); - + assertCanBeCalled( method_name ); - + if( _expectations.containsKey( method_name ) ) { ExpectedCall expected = (ExpectedCall)_expectations.get(method_name); - + checkCallOrder( method_name ); if( expected.isTestingArguments() ) { checkArguments( expected, args ); @@ -348,39 +369,38 @@ private void checkCallOrder( String method_name ) { if( _order_constraints.containsKey(method_name) ) { - assertMethodsHaveBeenCalled( - (Set)_order_constraints.get(method_name) ); + assertMethodsHaveBeenCalled(orderConstraintsFor(method_name) ); } } - + + private Set orderConstraintsFor(String method_name) { + return (Set)_order_constraints.get(method_name); + } + private void checkArguments( ExpectedCall expected, Object[] args ) { int arg_count = (args == null) ? 0 : args.length; assertEquals( _name + ": wrong number of arguments to " + expected.getMethodName() + " method", expected.getArgumentCount(), arg_count ); - + for( int i = 0; i < arg_count; i++ ) { Object arg = args[i]; if( !expected.testArgument( i, arg ) ) { fail( _name + ": unexpected argument " + (i+1) + " to " + expected.getMethodName() + " method" + - ", expected " + expected.describeArgument(i) + + ", expected " + expected.describeArgument(i) + ", was " + arg ); } } } - - private Object defaultResult( Class return_type ) { - if( _default_results.containsKey(return_type) ) { - return _default_results.get(return_type); - } else { - return null; - } + + private Object defaultResult(Class return_type) { + return _default_results.get(return_type); } - - /** Fails if not all the expected calls have been made to this mock object. - * + + /** + * Fails if not all the expected calls have been made to this mock object. * @throws junit.framework.AssertionFailedError * Not all expected calls were made to this mock object. */ @@ -389,29 +409,29 @@ } private void assertAllExpectedMethodsCalled() { - + assertMethodsHaveBeenCalled( _expectations.keySet() ); } - + private void assertMethodsHaveBeenCalled( Set method_names ) { Iterator i = method_names.iterator(); while( i.hasNext() ) { assertHasBeenCalled( (String)i.next() ); } } - - private void assertCanBeCalled( String method_name ) { - if( _not_called_expectations.contains(method_name) ) { - fail(_name + ": unexpected call to method " + method_name ); - } - } - + private void assertHasBeenCalled( String method_name ) { if( !_called_methods.contains(method_name) ) { fail( _name + ": method " + method_name + " was not called" ); } } - + + private void assertCanBeCalled( String method_name ) { + if( _not_called_expectations.contains(method_name) ) { + fail(_name + ": unexpected call to method " + method_name ); + } + } + public Object createInterface( Class interface_class ) { return createInterface(interface_class, this); } |