[MO-java-dev] CVS: mockobjects-java/src/core/com/mockobjects/dynamic BaseCallCollectionBuilder.java,NONE,1.1.2.1 CallSelection.java,NONE,1.1.2.1 NameMatcher.java,NONE,1.1.2.1 CompositeCallable.java,NONE,1.1.2.1 Stub.java,NONE,1.1.2.1 CallDecorator.java,NONE,1.1.2.1 ArgumentMatcher.java,NONE,1.1.2.1 ActiveCall.java,NONE,1.1.2.1 CallCollectionBuilder.java,NONE,1.1.2.1 C.java,1.3,1.3.2.1 Callable.java,1.3,1.3.2.1 ThrowStub.java,1.3,1.3.2.1 CallCollection.java,1.3,1.3.2.1 ReturnStub.java,1.3,1.3.2.1 VoidStub.java,1.3,1.3.2.1 DefaultCallFactory.java,1.5,1.5.2.1 CallOnceExpectation.java,1.2,1.2.2.1 CallSequence.java,1.6,1.6.2.1 Mock.java,1.23,1.23.2.1 DynamicUtil.java,1.2,1.2.2.1 CallFactory.java,1.4,1.4.2.1 OrderedMock.java,1.3,1.3.2.1 CallBag.java,1.4,NONE AnyConstraintMatcher.java,1.2,NONE ConstraintMatcher.java,1.2,NONE CallableAddable.java,1.2,NONE CallStub.java,1.3,NONE FullConstraintMatcher.java,1.2,NONE CallSignature.java,1.2,NONE

[Steve F. <sm...@us...>]

Update of /cvsroot/mockobjects/mockobjects-java/src/core/com/mockobjects/dynamic
In directory sc8-pr-cvs1:/tmp/cvs-serv11585/src/core/com/mockobjects/dynamic

Modified Files:
      Tag: Nat_reworks_dynamics_from_0_09
	C.java Callable.java ThrowStub.java CallCollection.java 
	ReturnStub.java VoidStub.java DefaultCallFactory.java 
	CallOnceExpectation.java CallSequence.java Mock.java 
	DynamicUtil.java CallFactory.java OrderedMock.java 
Added Files:
      Tag: Nat_reworks_dynamics_from_0_09
	BaseCallCollectionBuilder.java CallSelection.java 
	NameMatcher.java CompositeCallable.java Stub.java 
	CallDecorator.java ArgumentMatcher.java ActiveCall.java 
	CallCollectionBuilder.java 
Removed Files:
      Tag: Nat_reworks_dynamics_from_0_09
	CallBag.java AnyConstraintMatcher.java ConstraintMatcher.java 
	CallableAddable.java CallStub.java FullConstraintMatcher.java 
	CallSignature.java 
Log Message:
Branched and added Nat's latest reworking of the dynamic libraries

--- NEW FILE: BaseCallCollectionBuilder.java ---
package com.mockobjects.dynamic;

import com.mockobjects.Verifiable;
import com.mockobjects.constraint.Constraint;


/** The BaseCallCollectionBuilder class acts as a template for the
 *  {@link CallCollectionBuilder class}.  All parameters of type
 *  Object of methods in this class are overloaded for primitive types 
 *  in the CallCollectionBuilder class.
 */
public abstract class BaseCallCollectionBuilder 
    implements CompositeCallable, Verifiable
{
	private CallFactory callFactory;
	private CompositeCallable composite;
    
    
	public BaseCallCollectionBuilder( CallFactory callFactory, CompositeCallable composite ) {
		this.callFactory = callFactory;
		this.composite = composite;
	}
    
    public BaseCallCollectionBuilder( CompositeCallable composite ) {
        this( new DefaultCallFactory(), composite );
    }
    
    public void addCallable( Callable callable ) {
        composite.addCallable( callable );
    }
    
    public String getDescription() {
        return composite.getDescription();
    }

    public Object call( ActiveCall call ) throws Throwable {
        return composite.call( call );
    }

    public boolean matches( ActiveCall call ) {
        return composite.matches( call );
    }

    public void reset() {
        this.composite.reset();
    }
    
	public void verify() {
        composite.verify();
	}
    
    public void expect( String methodName, Constraint[] args, Callable stub ) {
        addCallable(
            callFactory.createCallOnceExpectation(
                callFactory.createArgumentMatcher( methodName, args,
                stub )));
    }
    
    public void expectVoid( String methodName, Constraint[] args ) {
        expect( methodName, args, callFactory.createVoidStub() );
    }
    
	public void expectVoid( String methodName ) {
		expectVoid( methodName, C.NO_ARGS );
	}
	
	public void expectVoid(String methodName, Object singleEqualArg ) {
		expectVoid( methodName, C.args(C.eq(singleEqualArg)) );
	}
    
    public void expectVoid(String methodName, Constraint singleConstraint ) {
        expectVoid( methodName, new Constraint[]{ singleConstraint } );
    }
    
    public void expectAndReturn( String methodName, Constraint[] args, Object result) {
        expect( methodName, args, callFactory.createReturnStub(result) );
    }
    
	public void expectAndReturn(String methodName, Object result ) {
		this.expectAndReturn(methodName, C.NO_ARGS, result);
	}
	    
	public void expectAndReturn(String methodName, Object singleEqualArg, Object result) {
		this.expectAndReturn(methodName, C.args(C.eq(singleEqualArg)), result);
	}

    public void expectAndReturn(String methodName, Constraint singleConstraint, Object result) {
        this.expectAndReturn( methodName, new Constraint[]{singleConstraint}, 
                              result);
    }

    public void expectAndThrow(String methodName, Constraint[] args, Throwable exception) {
        expect( methodName, args, callFactory.createThrowStub(exception) );
    }
    
	public void expectAndThrow( String methodName, Throwable exception ) {
		expectAndThrow(methodName, C.NO_ARGS, exception);
	}
	
	public void expectAndThrow( String methodName, 
                                Object singleEqualArg, 
                                Throwable exception ) 
    {
		expectAndThrow( methodName, C.args(C.eq(singleEqualArg)), exception );
	}
	
    public void expectAndThrow( String methodName, 
                                Constraint singleConstraint, 
                                Throwable exception ) 
    {
        this.expectAndThrow( methodName, 
                             new Constraint[]{ singleConstraint },
                             exception );
    }

    public void match( String methodName, Constraint[] args, Callable stub ) {
        composite.addCallable(
            callFactory.createArgumentMatcher( methodName, args, 
                stub ) );
    }
    
    public void matchAndReturn(String methodName, Constraint[] args, Object result) {
        match( methodName, args, callFactory.createReturnStub(result));
    }
    
	public void matchAndReturn(String methodName, Object result) {
		matchAndReturn( methodName, C.NO_ARGS, result );
	}
	
    public void matchAndReturn( String methodName, 
                                Constraint singleConstraint, 
                                Object result ) 
    {
        matchAndReturn( methodName, new Constraint[]{singleConstraint},
                        result);
    }
    
	public void matchAndReturn(String methodName, Object singleEqualArg, Object result) {
		this.matchAndReturn(methodName, C.args(C.eq(singleEqualArg)), result);
	}
	
    public void matchAndThrow(String methodName, Constraint[] args, Throwable throwable) {
        match( methodName, args, callFactory.createThrowStub(throwable) );
    }
    
	public void matchAndThrow(String methodName, Throwable throwable) {
		this.matchAndThrow(methodName, C.NO_ARGS, throwable);
	}
	
	public void matchAndThrow(String methodName, Object singleEqualArg, Throwable throwable) {
		this.matchAndThrow(methodName, C.args(C.eq(singleEqualArg)), throwable);
	}
	
    public CallCollectionBuilder newCallSelection() {
        return addCallCollection( callFactory.createCallSelection() );
    }
        
    public CallCollectionBuilder newCallSequence() {
        return addCallCollection( callFactory.createCallSequence() );
    }
    
    
    private CallCollectionBuilder addCallCollection( CompositeCallable collection ) {
        composite.addCallable(collection);
        return callFactory.createCallCollectionBuilder( collection );    
    }
}

--- NEW FILE: CallSelection.java ---
/*
 * Created on 04-Apr-2003
 */
package com.mockobjects.dynamic;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;


public class CallSelection extends CallCollection 
{
	private List calls = new ArrayList();
    
    
	public CallSelection() {
	}

    public void reset() {
        calls.clear();
    }

	public Object call( ActiveCall call )
		throws Throwable 
    {
		Callable matchingCall = findMatchingCall( call );
        
		if(matchingCall == null) {
			throw createUnexpectedCallError(call);
		}
    	
        return matchingCall.call( call );
	}
    
	private Callable findMatchingCall( ActiveCall call ) {
        ListIterator i = calls.listIterator( calls.size() );
        
		while( i.hasPrevious() ) {
			Callable element = (Callable) i.previous();
            
			if (element.matches(call)) {
				return element;
			}
		}

		return null;
	}

	public String getDescription() {
		if (calls.isEmpty()) {
			return "no methods";
		} else {
			StringBuffer buf = new StringBuffer();

			buf.append("one of:\n");

			for (Iterator i = calls.iterator(); i.hasNext();) {
				buf.append(((Callable) i.next()).getDescription());
				buf.append("\n");
			}

			return buf.toString();
		}
	}

	public boolean matches( ActiveCall call ) {
		for( Iterator i = calls.iterator(); i.hasNext(); ) {
            Callable element = (Callable)i.next();
            
            if( element.matches( call ) ) {
                return true;
            }
        }
        
        return false;
	}

	public void verify() {
		for (Iterator call = calls.iterator(); call.hasNext();) {
			Callable element = (Callable) call.next();
			element.verify();
		}
	}

	public void addCallable(Callable call) {
		calls.add(call);
	}
}
--- NEW FILE: NameMatcher.java ---
/** Created on Jun 11, 2003 by npryce
 *  Copyright (c) B13media Ltd.
 */
package com.mockobjects.dynamic;


public class NameMatcher
    extends CallDecorator
{
    private String methodName;
    
    public NameMatcher( String methodName, Callable delegate ) {
        super(delegate);
        this.methodName = methodName;
    }
    
    public boolean matches( ActiveCall call ) {
        return methodName.equals( call.getName() ) && 
               super.matches( call );
    }
    
    public String getDescription() {
        return getMethodName();
    }
    
    public String getMethodName() {
        return methodName;
    }
}

--- NEW FILE: CompositeCallable.java ---
package com.mockobjects.dynamic;

public interface CompositeCallable 
    extends Callable 
{
    
    /** TODO: rename this to something more user-centered.  E.g. addRule (?).
     *        requested by Ben Hogan.
     */
	void addCallable( Callable call );

    /**
     * Resets all expected calls and expected matches.
     */
    void reset();
}

--- NEW FILE: Stub.java ---
/*
 * Created on 07-Apr-2003
 */
package com.mockobjects.dynamic;


public abstract class Stub  
	implements Callable 
{
	public boolean matches( ActiveCall call ) {
		return true;
	}

	public void verify() {
	}
}

--- NEW FILE: CallDecorator.java ---
/** Created on Jun 11, 2003 by npryce
 *  Copyright (c) B13media Ltd.
 */
package com.mockobjects.dynamic;


/** The base class for {@link Callable} objects that decorate stubs or 
 *  other {@link Callables} with expectations.  
 *  The default implementation passes calls through to the decorated 
 *  {@link Callable}.
 */
public class CallDecorator 
    implements Callable 
{
    private Callable delegate;
    
    
    public CallDecorator( Callable delegate ) {
        this.delegate = delegate;
    }
    
    public String getDescription() {
        return delegate.getDescription();
    }
    
    public boolean matches( ActiveCall call ) {
        return delegate.matches( call );
    }
    
    public Object call( ActiveCall call ) 
        throws Throwable 
    {       
        return delegate.call( call );
    }

    public void verify() {
        delegate.verify();
    }
    
    // Implemented to aid visualisation in an IDE debugger
    public String toString() {
        return Mock.className(getClass()) + "(" + getDescription() + ")";
    }
}

--- NEW FILE: ArgumentMatcher.java ---
package com.mockobjects.dynamic;

import java.util.List;

import com.mockobjects.constraint.Constraint;


public class ArgumentMatcher 
    extends NameMatcher
{
	private Constraint[] constraints;
	
	public ArgumentMatcher( String methodName, 
                          Constraint[] constraints, 
                          Callable delegate ) 
    {
        super( methodName, delegate );
		this.constraints = (Constraint[])constraints.clone();
	}
    
	public boolean matches( ActiveCall call ) {
        return super.matches(call)
            && constraintsMatch( call.getParameterValues() );
    }
    
    private boolean constraintsMatch( List args ) {
        if( args.size() != constraints.length ) return false;
        
        for( int i = 0; i < args.size(); i++) {
            if( !constraints[i].eval(args.get(i)) ) return false;
        }
        
        return true;
    }
    
	public String getDescription() {
		return DynamicUtil.methodToString( getMethodName(), constraints );
	}
}

--- NEW FILE: ActiveCall.java ---
package com.mockobjects.dynamic;

import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;


/** An object that holds information about a call dispatched to
 *  a Mock object for err... mocking.
 */
public class ActiveCall 
{
    private String name;
    private Class[] parameterTypes;
    private Class returnType;
    private Object[] parameterValues;
    
    public ActiveCall( String name, Class[] parameterTypes,
                       Class returnType, Object[] parameterValues )
    {
        this.name = name;
        this.parameterTypes = (Class[])parameterTypes.clone();
        this.returnType = returnType;
        if( parameterValues == null ) {
            this.parameterValues = new Object[0];
        } else {
            this.parameterValues = (Object[])parameterValues.clone();
        }
    }
    
    public ActiveCall( Method method, Object[] parameterValues ) {
        this( method.getName(), method.getParameterTypes(),
              method.getReturnType(), parameterValues );
    }
    
    public String getName() {
        return name;
    }
    
    public List getParameterTypes() {
        return Collections.unmodifiableList(Arrays.asList(parameterTypes));
    }
    
    public List getParameterValues() {
        return Collections.unmodifiableList(Arrays.asList(parameterValues));
    }
    
    public Class getReturnType() {
        return returnType;
    }
    
    public String toString() {
        return DynamicUtil.methodToString( name, parameterValues );
    }
    
    public boolean equals( Object o ) {
        if( o instanceof ActiveCall ) {
            return this.equals((ActiveCall)o);
        } else {
            return false;
        }
    }
    
    public int hashCode() {
        return name.hashCode() ^
               arrayHashCode(parameterTypes) ^
               returnType.hashCode() ^
               arrayHashCode(parameterValues);
    }
    
    private int arrayHashCode( Object[] array ) {
        int hashCode = 0;
        for( int i = 0; i < array.length; i++ ) {
            hashCode ^= array[i].hashCode();
        }
        return hashCode;
    }
    
    public boolean equals( ActiveCall call ) {
        return call != null 
            && name.equals(call.name)
            && Arrays.equals( parameterTypes, call.parameterTypes )
            && returnType.equals( call.returnType )
            && Arrays.equals( parameterValues, call.parameterValues );
    }
    
    boolean isCheckingEqualityOnProxy() {
        return name.equals("equals")
            && parameterValues.length == 1
            && Proxy.isProxyClass(parameterValues[0].getClass());
    }
    
    boolean isMockNameGetter() {
        return name.equals("getMockName")
            && parameterValues.length == 0;
    }
}

--- NEW FILE: CallCollectionBuilder.java ---
// WARNING: DO NOT EDIT
// This file was automatically generated by the Boxer (floats like a butterfly, strings like a bee)
// Generated on Thu Jun 19 14:37:31 BST 2003

package com.mockobjects.dynamic;

public class CallCollectionBuilder extends com.mockobjects.dynamic.BaseCallCollectionBuilder {
    public CallCollectionBuilder(com.mockobjects.dynamic.CallFactory arg0, com.mockobjects.dynamic.CompositeCallable arg1) {
        super(arg0, arg1);
    }

    public CallCollectionBuilder(com.mockobjects.dynamic.CompositeCallable arg0) {
        super(arg0);
    }

    public void expectVoid(java.lang.String arg0, byte arg1) {
        super.expectVoid(arg0, new Byte(arg1));
    }

    public void expectVoid(java.lang.String arg0, char arg1) {
        super.expectVoid(arg0, new Character(arg1));
    }

    public void expectVoid(java.lang.String arg0, long arg1) {
        super.expectVoid(arg0, new Long(arg1));
    }

    public void expectVoid(java.lang.String arg0, double arg1) {
        super.expectVoid(arg0, new Double(arg1));
    }

    public void expectVoid(java.lang.String arg0, int arg1) {
        super.expectVoid(arg0, new Integer(arg1));
    }

    public void expectVoid(java.lang.String arg0, float arg1) {
        super.expectVoid(arg0, new Float(arg1));
    }

    public void expectVoid(java.lang.String arg0, boolean arg1) {
        super.expectVoid(arg0, new Boolean(arg1));
    }

    public void expectVoid(java.lang.String arg0, short arg1) {
        super.expectVoid(arg0, new Short(arg1));
    }

    public void expectAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint[] arg1, byte arg2) {
        super.expectAndReturn(arg0, arg1, new Byte(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint[] arg1, char arg2) {
        super.expectAndReturn(arg0, arg1, new Character(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint[] arg1, long arg2) {
        super.expectAndReturn(arg0, arg1, new Long(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint[] arg1, double arg2) {
        super.expectAndReturn(arg0, arg1, new Double(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint[] arg1, int arg2) {
        super.expectAndReturn(arg0, arg1, new Integer(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint[] arg1, float arg2) {
        super.expectAndReturn(arg0, arg1, new Float(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint[] arg1, boolean arg2) {
        super.expectAndReturn(arg0, arg1, new Boolean(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint[] arg1, short arg2) {
        super.expectAndReturn(arg0, arg1, new Short(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, byte arg1) {
        super.expectAndReturn(arg0, new Byte(arg1));
    }

    public void expectAndReturn(java.lang.String arg0, char arg1) {
        super.expectAndReturn(arg0, new Character(arg1));
    }

    public void expectAndReturn(java.lang.String arg0, long arg1) {
        super.expectAndReturn(arg0, new Long(arg1));
    }

    public void expectAndReturn(java.lang.String arg0, double arg1) {
        super.expectAndReturn(arg0, new Double(arg1));
    }

    public void expectAndReturn(java.lang.String arg0, int arg1) {
        super.expectAndReturn(arg0, new Integer(arg1));
    }

    public void expectAndReturn(java.lang.String arg0, float arg1) {
        super.expectAndReturn(arg0, new Float(arg1));
    }

    public void expectAndReturn(java.lang.String arg0, boolean arg1) {
        super.expectAndReturn(arg0, new Boolean(arg1));
    }

    public void expectAndReturn(java.lang.String arg0, short arg1) {
        super.expectAndReturn(arg0, new Short(arg1));
    }

    public void expectAndReturn(java.lang.String arg0, byte arg1, byte arg2) {
        super.expectAndReturn(arg0, new Byte(arg1), new Byte(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, byte arg1, char arg2) {
        super.expectAndReturn(arg0, new Byte(arg1), new Character(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, byte arg1, long arg2) {
        super.expectAndReturn(arg0, new Byte(arg1), new Long(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, byte arg1, double arg2) {
        super.expectAndReturn(arg0, new Byte(arg1), new Double(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, byte arg1, int arg2) {
        super.expectAndReturn(arg0, new Byte(arg1), new Integer(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, byte arg1, float arg2) {
        super.expectAndReturn(arg0, new Byte(arg1), new Float(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, byte arg1, boolean arg2) {
        super.expectAndReturn(arg0, new Byte(arg1), new Boolean(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, byte arg1, short arg2) {
        super.expectAndReturn(arg0, new Byte(arg1), new Short(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, char arg1, byte arg2) {
        super.expectAndReturn(arg0, new Character(arg1), new Byte(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, char arg1, char arg2) {
        super.expectAndReturn(arg0, new Character(arg1), new Character(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, char arg1, long arg2) {
        super.expectAndReturn(arg0, new Character(arg1), new Long(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, char arg1, double arg2) {
        super.expectAndReturn(arg0, new Character(arg1), new Double(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, char arg1, int arg2) {
        super.expectAndReturn(arg0, new Character(arg1), new Integer(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, char arg1, float arg2) {
        super.expectAndReturn(arg0, new Character(arg1), new Float(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, char arg1, boolean arg2) {
        super.expectAndReturn(arg0, new Character(arg1), new Boolean(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, char arg1, short arg2) {
        super.expectAndReturn(arg0, new Character(arg1), new Short(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, long arg1, byte arg2) {
        super.expectAndReturn(arg0, new Long(arg1), new Byte(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, long arg1, char arg2) {
        super.expectAndReturn(arg0, new Long(arg1), new Character(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, long arg1, long arg2) {
        super.expectAndReturn(arg0, new Long(arg1), new Long(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, long arg1, double arg2) {
        super.expectAndReturn(arg0, new Long(arg1), new Double(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, long arg1, int arg2) {
        super.expectAndReturn(arg0, new Long(arg1), new Integer(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, long arg1, float arg2) {
        super.expectAndReturn(arg0, new Long(arg1), new Float(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, long arg1, boolean arg2) {
        super.expectAndReturn(arg0, new Long(arg1), new Boolean(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, long arg1, short arg2) {
        super.expectAndReturn(arg0, new Long(arg1), new Short(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, double arg1, byte arg2) {
        super.expectAndReturn(arg0, new Double(arg1), new Byte(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, double arg1, char arg2) {
        super.expectAndReturn(arg0, new Double(arg1), new Character(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, double arg1, long arg2) {
        super.expectAndReturn(arg0, new Double(arg1), new Long(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, double arg1, double arg2) {
        super.expectAndReturn(arg0, new Double(arg1), new Double(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, double arg1, int arg2) {
        super.expectAndReturn(arg0, new Double(arg1), new Integer(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, double arg1, float arg2) {
        super.expectAndReturn(arg0, new Double(arg1), new Float(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, double arg1, boolean arg2) {
        super.expectAndReturn(arg0, new Double(arg1), new Boolean(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, double arg1, short arg2) {
        super.expectAndReturn(arg0, new Double(arg1), new Short(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, int arg1, byte arg2) {
        super.expectAndReturn(arg0, new Integer(arg1), new Byte(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, int arg1, char arg2) {
        super.expectAndReturn(arg0, new Integer(arg1), new Character(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, int arg1, long arg2) {
        super.expectAndReturn(arg0, new Integer(arg1), new Long(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, int arg1, double arg2) {
        super.expectAndReturn(arg0, new Integer(arg1), new Double(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, int arg1, int arg2) {
        super.expectAndReturn(arg0, new Integer(arg1), new Integer(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, int arg1, float arg2) {
        super.expectAndReturn(arg0, new Integer(arg1), new Float(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, int arg1, boolean arg2) {
        super.expectAndReturn(arg0, new Integer(arg1), new Boolean(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, int arg1, short arg2) {
        super.expectAndReturn(arg0, new Integer(arg1), new Short(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, float arg1, byte arg2) {
        super.expectAndReturn(arg0, new Float(arg1), new Byte(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, float arg1, char arg2) {
        super.expectAndReturn(arg0, new Float(arg1), new Character(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, float arg1, long arg2) {
        super.expectAndReturn(arg0, new Float(arg1), new Long(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, float arg1, double arg2) {
        super.expectAndReturn(arg0, new Float(arg1), new Double(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, float arg1, int arg2) {
        super.expectAndReturn(arg0, new Float(arg1), new Integer(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, float arg1, float arg2) {
        super.expectAndReturn(arg0, new Float(arg1), new Float(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, float arg1, boolean arg2) {
        super.expectAndReturn(arg0, new Float(arg1), new Boolean(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, float arg1, short arg2) {
        super.expectAndReturn(arg0, new Float(arg1), new Short(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, boolean arg1, byte arg2) {
        super.expectAndReturn(arg0, new Boolean(arg1), new Byte(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, boolean arg1, char arg2) {
        super.expectAndReturn(arg0, new Boolean(arg1), new Character(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, boolean arg1, long arg2) {
        super.expectAndReturn(arg0, new Boolean(arg1), new Long(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, boolean arg1, double arg2) {
        super.expectAndReturn(arg0, new Boolean(arg1), new Double(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, boolean arg1, int arg2) {
        super.expectAndReturn(arg0, new Boolean(arg1), new Integer(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, boolean arg1, float arg2) {
        super.expectAndReturn(arg0, new Boolean(arg1), new Float(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, boolean arg1, boolean arg2) {
        super.expectAndReturn(arg0, new Boolean(arg1), new Boolean(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, boolean arg1, short arg2) {
        super.expectAndReturn(arg0, new Boolean(arg1), new Short(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, short arg1, byte arg2) {
        super.expectAndReturn(arg0, new Short(arg1), new Byte(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, short arg1, char arg2) {
        super.expectAndReturn(arg0, new Short(arg1), new Character(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, short arg1, long arg2) {
        super.expectAndReturn(arg0, new Short(arg1), new Long(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, short arg1, double arg2) {
        super.expectAndReturn(arg0, new Short(arg1), new Double(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, short arg1, int arg2) {
        super.expectAndReturn(arg0, new Short(arg1), new Integer(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, short arg1, float arg2) {
        super.expectAndReturn(arg0, new Short(arg1), new Float(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, short arg1, boolean arg2) {
        super.expectAndReturn(arg0, new Short(arg1), new Boolean(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, short arg1, short arg2) {
        super.expectAndReturn(arg0, new Short(arg1), new Short(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint arg1, byte arg2) {
        super.expectAndReturn(arg0, arg1, new Byte(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint arg1, char arg2) {
        super.expectAndReturn(arg0, arg1, new Character(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint arg1, long arg2) {
        super.expectAndReturn(arg0, arg1, new Long(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint arg1, double arg2) {
        super.expectAndReturn(arg0, arg1, new Double(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint arg1, int arg2) {
        super.expectAndReturn(arg0, arg1, new Integer(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint arg1, float arg2) {
        super.expectAndReturn(arg0, arg1, new Float(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint arg1, boolean arg2) {
        super.expectAndReturn(arg0, arg1, new Boolean(arg2));
    }

    public void expectAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint arg1, short arg2) {
        super.expectAndReturn(arg0, arg1, new Short(arg2));
    }

    public void expectAndThrow(java.lang.String arg0, byte arg1, java.lang.Throwable arg2) {
        super.expectAndThrow(arg0, new Byte(arg1), arg2);
    }

    public void expectAndThrow(java.lang.String arg0, char arg1, java.lang.Throwable arg2) {
        super.expectAndThrow(arg0, new Character(arg1), arg2);
    }

    public void expectAndThrow(java.lang.String arg0, long arg1, java.lang.Throwable arg2) {
        super.expectAndThrow(arg0, new Long(arg1), arg2);
    }

    public void expectAndThrow(java.lang.String arg0, double arg1, java.lang.Throwable arg2) {
        super.expectAndThrow(arg0, new Double(arg1), arg2);
    }

    public void expectAndThrow(java.lang.String arg0, int arg1, java.lang.Throwable arg2) {
        super.expectAndThrow(arg0, new Integer(arg1), arg2);
    }

    public void expectAndThrow(java.lang.String arg0, float arg1, java.lang.Throwable arg2) {
        super.expectAndThrow(arg0, new Float(arg1), arg2);
    }

    public void expectAndThrow(java.lang.String arg0, boolean arg1, java.lang.Throwable arg2) {
        super.expectAndThrow(arg0, new Boolean(arg1), arg2);
    }

    public void expectAndThrow(java.lang.String arg0, short arg1, java.lang.Throwable arg2) {
        super.expectAndThrow(arg0, new Short(arg1), arg2);
    }

    public void matchAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint[] arg1, byte arg2) {
        super.matchAndReturn(arg0, arg1, new Byte(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint[] arg1, char arg2) {
        super.matchAndReturn(arg0, arg1, new Character(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint[] arg1, long arg2) {
        super.matchAndReturn(arg0, arg1, new Long(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint[] arg1, double arg2) {
        super.matchAndReturn(arg0, arg1, new Double(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint[] arg1, int arg2) {
        super.matchAndReturn(arg0, arg1, new Integer(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint[] arg1, float arg2) {
        super.matchAndReturn(arg0, arg1, new Float(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint[] arg1, boolean arg2) {
        super.matchAndReturn(arg0, arg1, new Boolean(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint[] arg1, short arg2) {
        super.matchAndReturn(arg0, arg1, new Short(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, byte arg1) {
        super.matchAndReturn(arg0, new Byte(arg1));
    }

    public void matchAndReturn(java.lang.String arg0, char arg1) {
        super.matchAndReturn(arg0, new Character(arg1));
    }

    public void matchAndReturn(java.lang.String arg0, long arg1) {
        super.matchAndReturn(arg0, new Long(arg1));
    }

    public void matchAndReturn(java.lang.String arg0, double arg1) {
        super.matchAndReturn(arg0, new Double(arg1));
    }

    public void matchAndReturn(java.lang.String arg0, int arg1) {
        super.matchAndReturn(arg0, new Integer(arg1));
    }

    public void matchAndReturn(java.lang.String arg0, float arg1) {
        super.matchAndReturn(arg0, new Float(arg1));
    }

    public void matchAndReturn(java.lang.String arg0, boolean arg1) {
        super.matchAndReturn(arg0, new Boolean(arg1));
    }

    public void matchAndReturn(java.lang.String arg0, short arg1) {
        super.matchAndReturn(arg0, new Short(arg1));
    }

    public void matchAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint arg1, byte arg2) {
        super.matchAndReturn(arg0, arg1, new Byte(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint arg1, char arg2) {
        super.matchAndReturn(arg0, arg1, new Character(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint arg1, long arg2) {
        super.matchAndReturn(arg0, arg1, new Long(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint arg1, double arg2) {
        super.matchAndReturn(arg0, arg1, new Double(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint arg1, int arg2) {
        super.matchAndReturn(arg0, arg1, new Integer(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint arg1, float arg2) {
        super.matchAndReturn(arg0, arg1, new Float(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint arg1, boolean arg2) {
        super.matchAndReturn(arg0, arg1, new Boolean(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, com.mockobjects.constraint.Constraint arg1, short arg2) {
        super.matchAndReturn(arg0, arg1, new Short(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, byte arg1, byte arg2) {
        super.matchAndReturn(arg0, new Byte(arg1), new Byte(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, byte arg1, char arg2) {
        super.matchAndReturn(arg0, new Byte(arg1), new Character(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, byte arg1, long arg2) {
        super.matchAndReturn(arg0, new Byte(arg1), new Long(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, byte arg1, double arg2) {
        super.matchAndReturn(arg0, new Byte(arg1), new Double(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, byte arg1, int arg2) {
        super.matchAndReturn(arg0, new Byte(arg1), new Integer(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, byte arg1, float arg2) {
        super.matchAndReturn(arg0, new Byte(arg1), new Float(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, byte arg1, boolean arg2) {
        super.matchAndReturn(arg0, new Byte(arg1), new Boolean(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, byte arg1, short arg2) {
        super.matchAndReturn(arg0, new Byte(arg1), new Short(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, char arg1, byte arg2) {
        super.matchAndReturn(arg0, new Character(arg1), new Byte(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, char arg1, char arg2) {
        super.matchAndReturn(arg0, new Character(arg1), new Character(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, char arg1, long arg2) {
        super.matchAndReturn(arg0, new Character(arg1), new Long(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, char arg1, double arg2) {
        super.matchAndReturn(arg0, new Character(arg1), new Double(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, char arg1, int arg2) {
        super.matchAndReturn(arg0, new Character(arg1), new Integer(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, char arg1, float arg2) {
        super.matchAndReturn(arg0, new Character(arg1), new Float(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, char arg1, boolean arg2) {
        super.matchAndReturn(arg0, new Character(arg1), new Boolean(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, char arg1, short arg2) {
        super.matchAndReturn(arg0, new Character(arg1), new Short(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, long arg1, byte arg2) {
        super.matchAndReturn(arg0, new Long(arg1), new Byte(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, long arg1, char arg2) {
        super.matchAndReturn(arg0, new Long(arg1), new Character(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, long arg1, long arg2) {
        super.matchAndReturn(arg0, new Long(arg1), new Long(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, long arg1, double arg2) {
        super.matchAndReturn(arg0, new Long(arg1), new Double(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, long arg1, int arg2) {
        super.matchAndReturn(arg0, new Long(arg1), new Integer(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, long arg1, float arg2) {
        super.matchAndReturn(arg0, new Long(arg1), new Float(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, long arg1, boolean arg2) {
        super.matchAndReturn(arg0, new Long(arg1), new Boolean(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, long arg1, short arg2) {
        super.matchAndReturn(arg0, new Long(arg1), new Short(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, double arg1, byte arg2) {
        super.matchAndReturn(arg0, new Double(arg1), new Byte(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, double arg1, char arg2) {
        super.matchAndReturn(arg0, new Double(arg1), new Character(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, double arg1, long arg2) {
        super.matchAndReturn(arg0, new Double(arg1), new Long(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, double arg1, double arg2) {
        super.matchAndReturn(arg0, new Double(arg1), new Double(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, double arg1, int arg2) {
        super.matchAndReturn(arg0, new Double(arg1), new Integer(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, double arg1, float arg2) {
        super.matchAndReturn(arg0, new Double(arg1), new Float(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, double arg1, boolean arg2) {
        super.matchAndReturn(arg0, new Double(arg1), new Boolean(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, double arg1, short arg2) {
        super.matchAndReturn(arg0, new Double(arg1), new Short(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, int arg1, byte arg2) {
        super.matchAndReturn(arg0, new Integer(arg1), new Byte(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, int arg1, char arg2) {
        super.matchAndReturn(arg0, new Integer(arg1), new Character(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, int arg1, long arg2) {
        super.matchAndReturn(arg0, new Integer(arg1), new Long(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, int arg1, double arg2) {
        super.matchAndReturn(arg0, new Integer(arg1), new Double(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, int arg1, int arg2) {
        super.matchAndReturn(arg0, new Integer(arg1), new Integer(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, int arg1, float arg2) {
        super.matchAndReturn(arg0, new Integer(arg1), new Float(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, int arg1, boolean arg2) {
        super.matchAndReturn(arg0, new Integer(arg1), new Boolean(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, int arg1, short arg2) {
        super.matchAndReturn(arg0, new Integer(arg1), new Short(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, float arg1, byte arg2) {
        super.matchAndReturn(arg0, new Float(arg1), new Byte(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, float arg1, char arg2) {
        super.matchAndReturn(arg0, new Float(arg1), new Character(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, float arg1, long arg2) {
        super.matchAndReturn(arg0, new Float(arg1), new Long(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, float arg1, double arg2) {
        super.matchAndReturn(arg0, new Float(arg1), new Double(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, float arg1, int arg2) {
        super.matchAndReturn(arg0, new Float(arg1), new Integer(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, float arg1, float arg2) {
        super.matchAndReturn(arg0, new Float(arg1), new Float(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, float arg1, boolean arg2) {
        super.matchAndReturn(arg0, new Float(arg1), new Boolean(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, float arg1, short arg2) {
        super.matchAndReturn(arg0, new Float(arg1), new Short(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, boolean arg1, byte arg2) {
        super.matchAndReturn(arg0, new Boolean(arg1), new Byte(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, boolean arg1, char arg2) {
        super.matchAndReturn(arg0, new Boolean(arg1), new Character(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, boolean arg1, long arg2) {
        super.matchAndReturn(arg0, new Boolean(arg1), new Long(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, boolean arg1, double arg2) {
        super.matchAndReturn(arg0, new Boolean(arg1), new Double(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, boolean arg1, int arg2) {
        super.matchAndReturn(arg0, new Boolean(arg1), new Integer(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, boolean arg1, float arg2) {
        super.matchAndReturn(arg0, new Boolean(arg1), new Float(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, boolean arg1, boolean arg2) {
        super.matchAndReturn(arg0, new Boolean(arg1), new Boolean(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, boolean arg1, short arg2) {
        super.matchAndReturn(arg0, new Boolean(arg1), new Short(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, short arg1, byte arg2) {
        super.matchAndReturn(arg0, new Short(arg1), new Byte(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, short arg1, char arg2) {
        super.matchAndReturn(arg0, new Short(arg1), new Character(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, short arg1, long arg2) {
        super.matchAndReturn(arg0, new Short(arg1), new Long(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, short arg1, double arg2) {
        super.matchAndReturn(arg0, new Short(arg1), new Double(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, short arg1, int arg2) {
        super.matchAndReturn(arg0, new Short(arg1), new Integer(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, short arg1, float arg2) {
        super.matchAndReturn(arg0, new Short(arg1), new Float(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, short arg1, boolean arg2) {
        super.matchAndReturn(arg0, new Short(arg1), new Boolean(arg2));
    }

    public void matchAndReturn(java.lang.String arg0, short arg1, short arg2) {
        super.matchAndReturn(arg0, new Short(arg1), new Short(arg2));
    }

    public void matchAndThrow(java.lang.String arg0, byte arg1, java.lang.Throwable arg2) {
        super.matchAndThrow(arg0, new Byte(arg1), arg2);
    }

    public void matchAndThrow(java.lang.String arg0, char arg1, java.lang.Throwable arg2) {
        super.matchAndThrow(arg0, new Character(arg1), arg2);
    }

    public void matchAndThrow(java.lang.String arg0, long arg1, java.lang.Throwable arg2) {
        super.matchAndThrow(arg0, new Long(arg1), arg2);
    }

    public void matchAndThrow(java.lang.String arg0, double arg1, java.lang.Throwable arg2) {
        super.matchAndThrow(arg0, new Double(arg1), arg2);
    }

    public void matchAndThrow(java.lang.String arg0, int arg1, java.lang.Throwable arg2) {
        super.matchAndThrow(arg0, new Integer(arg1), arg2);
    }

    public void matchAndThrow(java.lang.String arg0, float arg1, java.lang.Throwable arg2) {
        super.matchAndThrow(arg0, new Float(arg1), arg2);
    }

    public void matchAndThrow(java.lang.String arg0, boolean arg1, java.lang.Throwable arg2) {
        super.matchAndThrow(arg0, new Boolean(arg1), arg2);
    }

    public void matchAndThrow(java.lang.String arg0, short arg1, java.lang.Throwable arg2) {
        super.matchAndThrow(arg0, new Short(arg1), arg2);
    }
}

Index: C.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/com/mockobjects/dynamic/C.java,v
retrieving revision 1.3
retrieving revision 1.3.2.1
diff -u -r1.3 -r1.3.2.1
--- C.java	1 Jun 2003 11:40:45 -0000	1.3
+++ C.java	21 Jun 2003 14:01:07 -0000	1.3.2.1
@@ -19,8 +19,7 @@
     public static final Constraint IS_ZERO = eq(new Integer(0));
     public static final Constraint IS_NOT_ZERO = not(IS_ZERO);
     
-	public static final ConstraintMatcher NO_ARGS = new FullConstraintMatcher(new Constraint[0]);
-    public static final ConstraintMatcher ANY_ARGS = new AnyConstraintMatcher();
+	public static final Constraint[] NO_ARGS = new Constraint[0];
     
     public static Constraint same( Object o ) {
         return new IsSame(o);
@@ -30,17 +29,17 @@
         return new IsEqual(o);
     }
     	
-	public static ConstraintMatcher eq( Object arg0, Object arg1 ) {
+	public static Constraint[] eq( Object arg0, Object arg1 ) {
 		return args(eq(arg0), eq(arg1));
 	}
     
-	public static ConstraintMatcher eq( Object arg0, Object arg1, Object arg2 ) {
+	public static Constraint[] eq( Object arg0, Object arg1, Object arg2 ) {
 		return args(eq(arg0), eq(arg1), eq(arg2));
 	}
 
-	public static ConstraintMatcher eq( Object arg0, Object arg1, Object arg2, Object arg3 ) {
-		return args(eq(arg0), eq(arg1), eq(arg2), eq(arg3));
-	}
+    public static Constraint[] eq( Object arg0, Object arg1, Object arg2, Object arg3 ) {
+        return args(eq(arg0), eq(arg1), eq(arg2), eq(arg3));
+    }
 
     public static Constraint eq( int n ) {
         return new IsEqual( new Integer(n) );
@@ -107,32 +106,39 @@
     /*  Helper methods for succinctly constructing Constraint arrays
      */
 
-    public static ConstraintMatcher args() {
+    public static Constraint[] args() {
         return NO_ARGS;
     }
-
-    public static ConstraintMatcher args(Constraint p) {
-        return new FullConstraintMatcher(new Constraint[]{p});
+    
+    public static Constraint[] args(Constraint p) {
+        return new Constraint[]{ p };
     }
-
-    public static ConstraintMatcher args(Constraint p1, Constraint p2) {
-        return new FullConstraintMatcher(new Constraint[]{p1, p2});
+    
+    public static Constraint[] args(Constraint p1, Constraint p2) {
+        return new Constraint[]{ p1, p2 };
     }
 
-    public static ConstraintMatcher args(Constraint p1, Constraint p2, Constraint p3) {
-        return new FullConstraintMatcher(new Constraint[]{p1, p2, p3});
+    public static Constraint[] args( Constraint p1, 
+                                     Constraint p2, 
+                                     Constraint p3 ) 
+    {
+        return new Constraint[]{p1, p2, p3};
+    }
+    
+    public static Constraint[] args( Constraint p1, 
+                                     Constraint p2, 
+                                     Constraint p3,
+                                     Constraint p4 ) 
+    {
+        return new Constraint[]{p1, p2, p3, p4};
     }
-
-	public static ConstraintMatcher args(Constraint p1, Constraint p2, Constraint p3, Constraint p4) {
-		return new FullConstraintMatcher(new Constraint[]{p1, p2, p3, p4});
-	}
     
-	public static ConstraintMatcher anyArgs( int argCount) {
+	public static Constraint[] anyArgs( int argCount ) {
 		Constraint[] constraints = new Constraint[argCount];
 		for (int i = 0; i < constraints.length; i++) {		
 			constraints[i] = new IsAnything();
 		}
 		
-		return new FullConstraintMatcher(constraints); 
+		return constraints; 
 	 }
 }

Index: Callable.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/com/mockobjects/dynamic/Callable.java,v
retrieving revision 1.3
retrieving revision 1.3.2.1
diff -u -r1.3 -r1.3.2.1
--- Callable.java	12 Jun 2003 22:45:13 -0000	1.3
+++ Callable.java	21 Jun 2003 14:01:07 -0000	1.3.2.1
@@ -1,9 +1,12 @@
 package com.mockobjects.dynamic;
 
-import com.mockobjects.*;
+import com.mockobjects.Verifiable;
 
-public interface Callable extends Verifiable {
+public interface Callable extends Verifiable 
+{
 	String getDescription();
-	Object call( String methodName, Object[] args ) throws Throwable;
-	boolean matches(String methodName, Object[] args);
+    
+	boolean matches( ActiveCall call );
+
+    Object call( ActiveCall call ) throws Throwable;
 }

Index: ThrowStub.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/com/mockobjects/dynamic/ThrowStub.java,v
retrieving revision 1.3
retrieving revision 1.3.2.1
diff -u -r1.3 -r1.3.2.1
--- ThrowStub.java	12 Jun 2003 22:45:13 -0000	1.3
+++ ThrowStub.java	21 Jun 2003 14:01:07 -0000	1.3.2.1
@@ -7,7 +7,7 @@
  * @author dev
  */
 public class ThrowStub 
-	extends CallStub
+	extends Stub
 {
 	private Throwable throwable;
 	
@@ -15,7 +15,7 @@
 		this.throwable = throwable;
 	}
 	
-	public Object call(String methodName, Object[] args) throws Throwable {
+	public Object call( ActiveCall call ) throws Throwable {
 		throw throwable;
 	}
 	

Index: CallCollection.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/com/mockobjects/dynamic/CallCollection.java,v
retrieving revision 1.3
retrieving revision 1.3.2.1
diff -u -r1.3 -r1.3.2.1
--- CallCollection.java	8 Jun 2003 21:48:24 -0000	1.3
+++ CallCollection.java	21 Jun 2003 14:01:07 -0000	1.3.2.1
@@ -2,18 +2,20 @@
 
 import junit.framework.AssertionFailedError;
 
-abstract public class CallCollection {
 
-    protected AssertionFailedError createUnexpectedCallError(String methodName, Object[] args) {
-            
+abstract public class CallCollection
+    implements CompositeCallable
+{
+    protected 
+    AssertionFailedError createUnexpectedCallError( ActiveCall call ) { 
         StringBuffer buf = new StringBuffer();
         buf.append("Unexpected call: ");
-        buf.append(DynamicUtil.methodToString(methodName, args));
+        buf.append( DynamicUtil.methodToString( 
+            call.getName(), call.getParameterValues().toArray()) );
         buf.append("\n");
         buf.append("Expected ");
         buf.append(getDescription());
+        
         return new AssertionFailedError(buf.toString());
     }
-
-    abstract protected String getDescription();
 }

Index: ReturnStub.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/com/mockobjects/dynamic/ReturnStub.java,v
retrieving revision 1.3
retrieving revision 1.3.2.1
diff -u -r1.3 -r1.3.2.1
--- ReturnStub.java	12 Jun 2003 22:45:14 -0000	1.3
+++ ReturnStub.java	21 Jun 2003 14:01:07 -0000	1.3.2.1
@@ -7,7 +7,7 @@
  * @author dev
  */
 public class ReturnStub 
-	extends CallStub 
+	extends Stub 
 {
 	private Object result;
 	
@@ -15,7 +15,7 @@
 		this.result = result;
 	}
 
-	public Object call(String methodName, Object[] args) throws Throwable {
+	public Object call( ActiveCall call ) throws Throwable {
 		return result;
 	}
 	

Index: VoidStub.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/com/mockobjects/dynamic/VoidStub.java,v
retrieving revision 1.3
retrieving revision 1.3.2.1
diff -u -r1.3 -r1.3.2.1
--- VoidStub.java	12 Jun 2003 22:45:11 -0000	1.3
+++ VoidStub.java	21 Jun 2003 14:01:07 -0000	1.3.2.1
@@ -4,13 +4,13 @@
 package com.mockobjects.dynamic;
 
 
-public class VoidStub extends CallStub {
+public class VoidStub extends Stub {
 
 	public String getDescription() {
 		return "returns <void>";
 	}
 	
-	public Object call(String methodName, Object[] args) throws Throwable {
+	public Object call( ActiveCall call ) throws Throwable {
 		return null;
 	}
 

Index: DefaultCallFactory.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/com/mockobjects/dynamic/DefaultCallFactory.java,v
retrieving revision 1.5
retrieving revision 1.5.2.1
diff -u -r1.5 -r1.5.2.1
--- DefaultCallFactory.java	20 May 2003 00:05:24 -0000	1.5
+++ DefaultCallFactory.java	21 Jun 2003 14:01:07 -0000	1.5.2.1
@@ -1,5 +1,7 @@
 package com.mockobjects.dynamic;
 
+import com.mockobjects.constraint.Constraint;
+
 public class DefaultCallFactory implements CallFactory {
 
 	public Callable createReturnStub(Object result) {
@@ -10,16 +12,30 @@
 		return new ThrowStub(exception);
 	}
 
-	public Callable createCallExpectation(Callable call) {
+	public Callable createCallOnceExpectation(Callable call) {
 		return new CallOnceExpectation(call);
 	}
 
-	public Callable createCallSignature(String methodName, ConstraintMatcher constraints, Callable call) {
-		return new CallSignature( methodName, constraints, call );
+	public Callable createArgumentMatcher( String methodName, 
+                                         Constraint[] constraints, 
+                                         Callable call ) 
+    {
+		return new ArgumentMatcher( methodName, constraints, call );
 	}
 
 	public Callable createVoidStub() {
 		return new VoidStub();
 	}
 
+    public CompositeCallable createCallSelection() {
+        return new CallSelection();
+    }
+
+    public CompositeCallable createCallSequence() {
+        return new CallSequence();
+    }
+    
+    public CallCollectionBuilder createCallCollectionBuilder(CompositeCallable collection) {
+        return new CallCollectionBuilder( this, collection );
+    }
 }

Index: CallOnceExpectation.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/com/mockobjects/dynamic/CallOnceExpectation.java,v
retrieving revision 1.2
retrieving revision 1.2.2.1
diff -u -r1.2 -r1.2.2.1
--- CallOnceExpectation.java	12 Jun 2003 22:45:13 -0000	1.2
+++ CallOnceExpectation.java	21 Jun 2003 14:01:07 -0000	1.2.2.1
@@ -1,38 +1,35 @@
 package com.mockobjects.dynamic;
 
-import junit.framework.*;
+import junit.framework.AssertionFailedError;
 
-public class CallOnceExpectation implements Callable {
-	private Callable delegate;
+public class CallOnceExpectation 
+    extends CallDecorator 
+{
 	private boolean wasCalled = false;
 	
 	public CallOnceExpectation( Callable delegate ) {
-		this.delegate = delegate;
+		super(delegate);
 	}
 	
 	public String getDescription() {
-		return delegate.getDescription() + " [" + (wasCalled ? "" : "not ") + "called]";	
+		return super.getDescription() + " [" + (wasCalled ? "" : "not ") + "called]";	
 	}
 	
-	public Object call(String methodName, Object[] args) throws Throwable {
+	public Object call( ActiveCall call ) throws Throwable {
 		wasCalled = true;
-		return delegate.call( methodName, args );
+		return super.call( call );
 	}
 	
-	public boolean matches(String methodName, Object[] args) {
-		return (!wasCalled) && delegate.matches( methodName, args );
+	public boolean matches( ActiveCall call ) {
+		return (!wasCalled) && super.matches( call );
 	}
 
 	public void verify() {
 		if( !wasCalled ) {
-			throw new AssertionFailedError( delegate.getDescription() + " was expected but not called" );
+			throw new AssertionFailedError( 
+                super.getDescription() + " was expected but not called" );
 		}
 		
-		delegate.verify();
-	}
-	
-	//	Implemented to aid visualisation in an IDE debugger
-	public String toString() {
-		return Mock.className(this.getClass()) + "(" + this.getDescription() + ")";
+		super.verify();
 	}
 }

Index: CallSequence.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/com/mockobjects/dynamic/CallSequence.java,v
retrieving revision 1.6
retrieving revision 1.6.2.1
diff -u -r1.6 -r1.6.2.1
--- CallSequence.java	12 Jun 2003 22:45:12 -0000	1.6
+++ CallSequence.java	21 Jun 2003 14:01:07 -0000	1.6.2.1
@@ -5,33 +5,37 @@
 
 import junit.framework.AssertionFailedError;
 
-public class CallSequence extends CallCollection implements Callable, CallableAddable {
-	
+public class CallSequence extends CallCollection 
+{
 	private ArrayList expectedCalls = new ArrayList();
-	private CallBag matchedCalls = new CallBag();
 	int callIndex = 0;
 	
-    public void reset()
-    {
-        this.expectedCalls.clear();
-        this.matchedCalls.reset();        
+    public void reset() {
+        expectedCalls.clear();
+        callIndex = 0;
     }
     
-	public Object call(String methodName, Object[] args) throws Throwable {
-		if (expectedCalls.size() == 0) throw new AssertionFailedError("no methods defined on mock, received: " + DynamicUtil.methodToString(methodName, args));
-		if (callIndex == expectedCalls.size()) throw new AssertionFailedError("mock called too many times, received: " + DynamicUtil.methodToString(methodName, args));
+	public Object call( ActiveCall call ) throws Throwable {
+		if (expectedCalls.size() == 0) {
+            throw new AssertionFailedError(
+                "no methods defined on mock, received: " + call );
+        }
+		if (callIndex == expectedCalls.size()) {
+            throw new AssertionFailedError(
+                "mock called too many times, received: " + call );
+        }
 		
-		Callable nextCall = (Callable)expectedCalls.get(callIndex++);
-		if (nextCall.matches(methodName, args))
-			return nextCall.call(methodName, args);
-			
-		try {
-			return matchedCalls.call(methodName, args);...
 
[truncated message content]