[MO-java-dev] CVS: mockobjects-java/src/core/test/mockobjects/dynamic NameMatcherTest.java,NONE,1.1.2.1 CallDecoratorTest.java,NONE,1.1.2.1 ActiveCallTest.java,NONE,1.1.2.1 ArgumentMatcherTest.java,NONE,1.1.2.1 CallSelectionTest.java,NONE,1.1.2.1 CallCollectionBuilderTest.java,NONE,1.1.2.1 MockCompositeCallable.java,NONE,1.1.2.1 StubTest.java,1.3,1.3.2.1 MockConstraint.java,1.2,1.2.2.1 DynamicUtilTest.java,1.2,1.2.2.1 CallOnceExpectationTest.java,1.2,1.2.2.1 MockCallable.java,1.3,1.3.2.1 CallSequenceTest.java,1.9,1.9.2.1 MockCallFactory.java,1.4,1.4.2.1 CTest.java,1.2,1.2.2.1 MockTest.java,1.12,1.12.2.1 CallMatchTest.java,1.4,NONE ConstraintMatcherTest.java,1.2,NONE CallBagTest.java,1.5,NONE MockCallableAddable.java,1.3,NONE MockConstraintMatcher.java,1.2,NONE

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

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

Modified Files:
      Tag: Nat_reworks_dynamics_from_0_09
	StubTest.java MockConstraint.java DynamicUtilTest.java 
	CallOnceExpectationTest.java MockCallable.java 
	CallSequenceTest.java MockCallFactory.java CTest.java 
	MockTest.java 
Added Files:
      Tag: Nat_reworks_dynamics_from_0_09
	NameMatcherTest.java CallDecoratorTest.java 
	ActiveCallTest.java ArgumentMatcherTest.java 
	CallSelectionTest.java CallCollectionBuilderTest.java 
	MockCompositeCallable.java 
Removed Files:
      Tag: Nat_reworks_dynamics_from_0_09
	CallMatchTest.java ConstraintMatcherTest.java CallBagTest.java 
	MockCallableAddable.java MockConstraintMatcher.java 
Log Message:
Branched and added Nat's latest reworking of the dynamic libraries

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

import junit.framework.TestCase;

import com.mockobjects.dynamic.ActiveCall;
import com.mockobjects.dynamic.NameMatcher;


public class NameMatcherTest 
    extends TestCase 
{
    private final String METHOD_NAME = "methodName";
    private final Object[] ARGS = { "arg1", "arg2" };
    private final MockCallable delegate = new MockCallable();
    
    private final ActiveCall CALL = new ActiveCall( 
        METHOD_NAME, 
        new Class[] { String.class, String.class },
        String.class,
        ARGS );


    private final NameMatcher callName = new NameMatcher( METHOD_NAME, delegate );
    
    public NameMatcherTest(String name) {
        super(name);
    }
    
    public void testReturnsMethodNameAsDescription() {
        assertEquals( "expected method name as description",
                      METHOD_NAME, callName.getDescription() );
    }
    
    public void testReturnsMethodNameFromGetMethodName() {
        assertEquals( "expected method name",
                      METHOD_NAME, callName.getMethodName() );
    }
    
    public void testPassesMatchToDelegateIfMethodHasTheSameName() {
        delegate.setExpectedMatches( CALL );
        delegate.setupMatchesReturn(true);
        
        callName.matches( CALL );
        
        delegate.verifyExpectations();
    }
    
    public void testReturnsMatchResultFromDelegateIfMethodHasTheSameName() {
        delegate.setExpectedMatches( CALL );
        delegate.setupMatchesReturn(true);
        assertTrue( "expected matches to return true",
                     callName.matches( CALL ) );
        delegate.verifyExpectations();


        delegate.setExpectedMatches( CALL );
        delegate.setupMatchesReturn(false);
        assertFalse( "expected matches to return false",
                     callName.matches( CALL ) );
        delegate.verifyExpectations();
    }

    public void testMatchFailsIfMethodNameIsDifferent() {
        final ActiveCall OTHER_CALL = new ActiveCall( 
            "other_" + METHOD_NAME, 
            new Class[] { String.class, String.class },
            String.class,
            ARGS );

        delegate.setExpectedMatchesCount(0);
        
        assertFalse( "expected matches to return false with other method name",
                     callName.matches( OTHER_CALL ) );
                     
        delegate.verifyExpectations();
    }
    
    public void testMatchesAnyMethodWithTheGivenNameWhateverTheArguments() {
        delegate.setupMatchesReturn(true);
        
        final ActiveCall CALL0 = new ActiveCall(
            METHOD_NAME, 
            new Class[0],
            String.class,
            new Object[0] );
        assertTrue( "expected matches to return true",
                     callName.matches(CALL0) );

        final ActiveCall CALL1 = new ActiveCall(
            METHOD_NAME, 
            new Class[] { String.class },
            String.class,
            new Object[]{"arg1"} );
        assertTrue( "expected matches to return true",
                     callName.matches(CALL1) );
        
        final ActiveCall CALL2 = new ActiveCall(
            METHOD_NAME, 
            new Class[] { String.class, String.class },
            String.class,
            new Object[]{"arg1","arg2"} );
        assertTrue( "expected matches to return true",
                     callName.matches(CALL2) );
                                       
        final ActiveCall CALL3 = new ActiveCall(
            METHOD_NAME, 
            new Class[] { String.class, String.class, String.class },
            String.class,
            new Object[]{"arg1","arg2","arg3"} );
        assertTrue( "expected matches to return true",
                     callName.matches(CALL3) );
    }
}

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

import junit.framework.TestCase;

import com.mockobjects.dynamic.ActiveCall;
import com.mockobjects.dynamic.CallDecorator;


public class CallDecoratorTest
    extends TestCase 
{
    private static final Object[] METHOD_ARGS = { "arg1", "arg2" };
    private static final String METHOD_NAME = "methodName";
    
    private static final ActiveCall CALL = new ActiveCall(
        METHOD_NAME, new Class[] { String.class, String.class }, String.class,
        METHOD_ARGS );
    
    MockCallable mockCallable = new MockCallable();
    CallDecorator callDecorator = new CallDecorator(mockCallable);
    
    
    public CallDecoratorTest(String name) {
        super(name);
    }

    public void testPropagatesCallArgumentsToDecorated()
        throws Throwable 
    {
        final Object result = "result";

        mockCallable.setExpectedCall(CALL);
        mockCallable.setupCallReturn(result);

        callDecorator.call(CALL);

        mockCallable.verifyExpectations();
    }

    public void testPropagatesResultFromDecorated()
        throws Throwable 
    {
        final Object result = "result";

        mockCallable.setExpectedCall(CALL);
        mockCallable.setupCallReturn(result);
        
        Object actual_result = callDecorator.call(CALL);
        
        assertSame( "result should be propagated back from decorated",
                    result, actual_result );
        
        mockCallable.verifyExpectations();
    }

    public void testPropagatesExceptionsFromDecorated()
        throws Throwable 
    {
        final Throwable thrown = new Throwable("thrown");
        
        mockCallable.setExpectedCall(CALL);
        mockCallable.setupCallThrow(thrown);
        
        try {
            callDecorator.call(CALL);
            fail("expected exception to be thrown");
        }
        catch( Throwable t ) {
            assertSame( "exception should be propagated back from decorated",
                        thrown, t );
        }
        
        mockCallable.verifyExpectations();
    }

    public void testPropagatesVerifyToDecorated() {
        mockCallable.setExpectedVerifyCalls(1);
        
        callDecorator.verify();
        
        mockCallable.verifyExpectations();
    }


    public void testPropagatesMatchesArgumentsToDecorated()
        throws Throwable 
    {
        mockCallable.setExpectedMatches(CALL);
        mockCallable.setupMatchesReturn(true);

        callDecorator.matches(CALL);
                    
        mockCallable.verifyExpectations();
    }

    public void testPropagatesMatchesSuccessFromDecorated()
        throws Throwable 
    {
        mockCallable.setupMatchesReturn(true);

        assertTrue( "matches should return true", 
                    callDecorator.matches(CALL) );
                    
        mockCallable.verifyExpectations();
    }

    public void testPropagatesMatchesFailureFromDecorated() 
        throws Throwable 
    {
        mockCallable.setupMatchesReturn(false);

        assertFalse( "matches should return false", 
                      callDecorator.matches(CALL) );
                    
        mockCallable.verifyExpectations();
    }
}

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

import java.lang.reflect.Method;
import java.util.Arrays;

import junit.framework.TestCase;

import com.mockobjects.dynamic.ActiveCall;

public class ActiveCallTest 
    extends TestCase 
{
    public String exampleMethod( int number, boolean flag ) {
        return "hello, world";
    }
    
    final String METHOD_NAME = "exampleMethod";
    final Class[] ARG_TYPES = { int.class, boolean.class };
    final Class RETURN_TYPE = String.class;
    final Object[] ARG_VALUES = { new Integer(0), Boolean.TRUE };
    
    
    public ActiveCallTest(String name) {
        super(name);
    }
    
    public void testCanBeConstructedWithExplicitCallDetails() {
        ActiveCall call = new ActiveCall( METHOD_NAME, ARG_TYPES,
                                          RETURN_TYPE, ARG_VALUES );
        
        assertEquals( "name", METHOD_NAME, call.getName() );
        assertEquals( "parameter types", 
                      Arrays.asList(ARG_TYPES), call.getParameterTypes() );
        assertEquals( "return type", 
                      RETURN_TYPE, call.getReturnType() );
        assertEquals( "argument values",
                      Arrays.asList(ARG_VALUES), call.getParameterValues() );
    }
    
    public void testCanBeConstructedFromAMethodObject() throws Exception {
        Method method = getClass().getMethod( METHOD_NAME, ARG_TYPES );
        
        ActiveCall call = new ActiveCall( method, ARG_VALUES );
        
        assertEquals( "name", method.getName(), call.getName() );
        assertEquals( "parameter types", 
                      Arrays.asList(method.getParameterTypes()), 
                      call.getParameterTypes() );
        assertEquals( "return type", 
                      method.getReturnType(), call.getReturnType() );
        assertEquals( "argument values",
                      Arrays.asList(ARG_VALUES), call.getParameterValues() );
    }
    
    public void testConstructorInterpretsNullParameterValueArrayAsZeroArguments() {
        ActiveCall call = new ActiveCall( METHOD_NAME, new Class[0],
                                          RETURN_TYPE, null );
        
        assertEquals( "expected no parameters values",
                      0, call.getParameterValues().size() );
    }
    
    public void testTestsForEqualityOnMethodSignatureAndArguments() {
        ActiveCall call1 = new ActiveCall( 
            METHOD_NAME, (Class[])ARG_TYPES.clone(), RETURN_TYPE,
            (Object[])ARG_VALUES.clone() );
        ActiveCall call2 = new ActiveCall( 
            METHOD_NAME, (Class[])ARG_TYPES.clone(), RETURN_TYPE,
            (Object[])ARG_VALUES.clone() );
        ActiveCall differentName = new ActiveCall( 
            "other" + METHOD_NAME, (Class[])ARG_TYPES.clone(), RETURN_TYPE,
            (Object[])ARG_VALUES.clone() );
        ActiveCall differentReturnType = new ActiveCall( 
            "other" + METHOD_NAME, (Class[])ARG_TYPES.clone(), int.class,
            (Object[])ARG_VALUES.clone() );
        ActiveCall differentArgTypes = new ActiveCall( 
            "other" + METHOD_NAME, new Class[]{double.class}, RETURN_TYPE,
            (Object[])ARG_VALUES.clone() );
        ActiveCall differentArgValues = new ActiveCall( 
            "other" + METHOD_NAME, (Class[])ARG_TYPES.clone(), RETURN_TYPE,
            new Object[] { new Integer(1), Boolean.FALSE } );
            
        assertTrue( "should be equal to itself", call1.equals(call1) );
        assertTrue( "identical calls should be equal", call1.equals(call2) );
        
        assertFalse( "should not be equal to object that is not an ActiveCall",
                     call1.equals(new Object()) );
        assertFalse( "should not be equal to null", call1.equals(null) );
        assertFalse( "should not be equal if different name",
                     call1.equals(differentName) );
        assertFalse( "should not be equal if different parameter types",
                     call1.equals(differentArgTypes) );
        assertFalse( "should not be equal if different return type",
                     call1.equals(differentReturnType) );
        assertFalse( "should not be equal if different argumentValues",
                     call1.equals(differentArgValues) );
    }
    
    public void testFollowsEqualsHashcodeProtocol() {
        ActiveCall call1 = new ActiveCall( 
            METHOD_NAME, (Class[])ARG_TYPES.clone(), RETURN_TYPE,
            (Object[])ARG_VALUES.clone() );
        ActiveCall call2 = new ActiveCall( 
            METHOD_NAME, (Class[])ARG_TYPES.clone(), RETURN_TYPE,
            (Object[])ARG_VALUES.clone() );
        
        assertEquals( "should have equal hash codes",
                      call1.hashCode(), call2.hashCode() );        
    }
}

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

import junit.framework.TestCase;

import com.mockobjects.constraint.Constraint;
import com.mockobjects.dynamic.ActiveCall;
import com.mockobjects.dynamic.ArgumentMatcher;


public class ArgumentMatcherTest
    extends TestCase 
{
    private final String METHOD_NAME = "methodName";
    private final MockCallable mockCallable = new MockCallable();
    

    public ArgumentMatcherTest(String name) {
        super(name);
    }

    // Note: CallSignature extends CallDecorator (indirectly) and only
    //       overrides the matches method.  Therefore the only tests that
    //       need to be written are those that exercise the matches method.
    //       All other tests have been removed from this test class.
    //                                                               --Nat.  
    
    public void setUp() {
        mockCallable.setupMatchesReturn(true);
    }
    
    public void testDoesNotMatchDifferentName() 
        throws Throwable 
    {
        final ActiveCall call = new ActiveCall(
            "otherName", new Class[0], void.class, null );
        
        ArgumentMatcher callSignature = 
            new ArgumentMatcher( METHOD_NAME, new Constraint[0], mockCallable );
        
        assertFalse( "call should not match",  callSignature.matches(call) );
                     
        mockCallable.verifyExpectations();
    }
    
    public void testDoesNotMatchWhenTooManyArguments() throws Throwable {
        String[] args = { "arg1", "arg2" };
        ActiveCall call = new ActiveCall(
            METHOD_NAME, new Class[]{String.class,String.class}, void.class,
            args );
        Constraint[] constraints = { 
            new MockConstraint("constraint1", args[0], true) 
        };
        
        ArgumentMatcher callSignature = 
            new ArgumentMatcher( METHOD_NAME, constraints, mockCallable );
        
        assertFalse( "should not match if too many arguments", 
                     callSignature.matches(call) );
    }
    
    public void testDoesNotMatchWhenTooFewArguments() 
        throws Throwable 
    {
        String[] args = { "arg1" };
        ActiveCall call = new ActiveCall(
            METHOD_NAME, new Class[]{String.class}, void.class, args );
        Constraint[] constraints = { 
            new MockConstraint("constraint1", args[0], true), 
            new MockConstraint("constraint2", args[0], true) 
        };
        
        ArgumentMatcher callSignature = 
            new ArgumentMatcher( METHOD_NAME, constraints, mockCallable );
        
        assertFalse( "should not match if too few arguments", 
                     callSignature.matches(call) );
    }
    
    public void testDoesNotMatchWhenConstraintIsViolated() 
        throws Throwable 
    {
        String[] args = { "argA", "argB", "argC" };
        ActiveCall call = new ActiveCall(
            METHOD_NAME, new Class[]{String.class,String.class,String.class},
            void.class, args );
        Constraint[] constraints = {
            new MockConstraint("constraintA", args[0], true), 
            new MockConstraint("constraintB", args[1], false),
            new MockConstraint("constraintC", args[2], true)
        };

        ArgumentMatcher callSignature = 
            new ArgumentMatcher( METHOD_NAME, constraints, mockCallable );

        assertFalse( "should not match if constraint is violated", 
                     callSignature.matches(call) );
    }

    public void testDoesNotMatchWithNoArgumentsAndCalleeHasArguments()
        throws Throwable 
    {
        String[] args = new String[] { "arg1", "arg2" };
        ActiveCall call = new ActiveCall(
            METHOD_NAME, new Class[]{String.class,String.class}, void.class,
            args );
        Constraint[] constraints = new MockConstraint[0];

        ArgumentMatcher callSignature = 
            new ArgumentMatcher( METHOD_NAME, constraints, mockCallable );

        assertFalse( "should not match", 
                     callSignature.matches(call) );
    }

    public void testMatchesWithNoArguments() 
        throws Throwable 
    {
        String[] args = new String[0];
        ActiveCall call = new ActiveCall(
            METHOD_NAME, new Class[0], void.class, args );
        Constraint[] constraints = new MockConstraint[0];

        ArgumentMatcher callSignature = 
            new ArgumentMatcher( METHOD_NAME, constraints, mockCallable );
        
        assertTrue( "should match", 
                    callSignature.matches(call) );
    }

    public void testMatchesWhenConstraintsPass()
        throws Throwable 
    {
        String[] args = { "argA", "argB", "argC" };
        ActiveCall call = new ActiveCall(
            METHOD_NAME, new Class[]{ String.class, String.class, String.class },
            void.class, args );
        
        MockConstraint constraintA = 
            new MockConstraint("constraintA", args[0], true);
        MockConstraint constraintB = 
            new MockConstraint("constraintB", args[1], true);
        MockConstraint constraintC = 
            new MockConstraint("constraintC", args[2], true);
        Constraint[] constraints = { 
            constraintA, constraintB, constraintC 
        };

        ArgumentMatcher callSignature = 
            new ArgumentMatcher( METHOD_NAME, constraints, mockCallable );
        
        assertTrue( "should match", 
                    callSignature.matches(call) );
        
        constraintA.verify();
        constraintB.verify();
        constraintC.verify();
    }
    
    public void testChecksThatDelegateMatchesWhenConstraintsMatch()
        throws Throwable
    {
        String[] args = { "argA", "argB", "argC" };
        ActiveCall call = new ActiveCall(
            METHOD_NAME, new Class[]{ String.class, String.class, String.class },
            void.class, args );
        
        MockConstraint constraintA = 
            new MockConstraint("constraintA", args[0], true);
        MockConstraint constraintB = 
            new MockConstraint("constraintB", args[1], true);
        MockConstraint constraintC = 
            new MockConstraint("constraintC", args[2], true);
        Constraint[] constraints = { 
            constraintA, constraintB, constraintC 
        };

        mockCallable.setExpectedMatches(call);
        mockCallable.setupMatchesReturn(false);
        
        ArgumentMatcher callSignature = 
            new ArgumentMatcher( METHOD_NAME, constraints, mockCallable );
        
        assertFalse( "should not match", callSignature.matches(call) );
        
        mockCallable.verifyExpectations();   
    }
}

--- NEW FILE: CallSelectionTest.java ---
package test.mockobjects.dynamic;

import junit.framework.AssertionFailedError;
import junit.framework.TestCase;

import com.mockobjects.constraint.Constraint;
import com.mockobjects.dynamic.*;
import com.mockobjects.util.AssertMo;

public class CallSelectionTest 
    extends TestCase 
{
	final String METHOD_A_NAME = "methodA";
	final String METHOD_A_RESULT = "resultA";
    final Throwable METHOD_A_EXCEPTION = 
        new DummyThrowable("Configured test throwable");
    final String[] METHOD_A_ARGS = new String[] { "a1", "a2" };
    final Constraint[] METHOD_A_CONSTRAINTS = C.args(C.eq("a1"), C.eq("a2"));
    final ActiveCall CALL_A = new ActiveCall(
        METHOD_A_NAME, new Class[]{String.class,String.class}, String.class,
        METHOD_A_ARGS );
        
	final String METHOD_B_NAME = "methodB";
	final String METHOD_B_RESULT = "resultB";
	final String[] METHOD_B_ARGS = new String[] { "b1", "b2" };
    final ActiveCall CALL_B = new ActiveCall(
        METHOD_B_NAME, new Class[]{String.class,String.class}, String.class,
        METHOD_B_ARGS );
    
    final String METHOD_C_NAME = "methodC";
    final String[] METHOD_C_ARGS = { "c1", "c2" };
    final ActiveCall CALL_C = new ActiveCall(
        METHOD_C_NAME, new Class[]{String.class,String.class}, Void.class,
        METHOD_C_ARGS );
    
	private CallSelection callSelection = new CallSelection();
	
	private MockCallable methodA = new MockCallable();
	private MockCallable methodB = new MockCallable();
	private MockCallable mockCallable = new MockCallable();
	

	public CallSelectionTest(String name) {
		super(name);
	}

	public void testCallFailsOnEmptySet() throws Throwable {
		try {
			callSelection.call(CALL_A);
		} catch (AssertionFailedError ex) {
			AssertMo.assertIncludes( "reports empty set in error message", 
                                     "no methods", ex.getMessage());

			return;
		}

		fail("Should fail for a missing item");
	}

	public void testCallPassedToContainedElementsInReverseOrderOfAddition() 
        throws Throwable 
    {
		methodA.setExpectedMatches(CALL_A);
		methodA.setupMatchesReturn(true);
		methodA.setExpectedCall(CALL_A);
		methodA.setupCallReturn(METHOD_A_RESULT);
        
        methodB.setExpectedMatches(CALL_A);
        methodB.setupMatchesReturn(false);

        callSelection.addCallable(methodA);
		callSelection.addCallable(methodB);

		assertSame("expected result from method A", METHOD_A_RESULT,
		    callSelection.call(CALL_A));
        
		methodA.verifyExpectations();
		methodB.verifyExpectations();
	}
	
	public void testMatchedCallStopsSearch()
		throws Throwable 
    {
        methodA.setExpectedCallCount(0);
        
		methodB.setExpectedMatches(CALL_B);
		methodB.setupMatchesReturn(true);
        methodB.setExpectedCall(CALL_B);
        methodB.setupCallReturn(METHOD_B_RESULT);
        
		callSelection.addCallable(methodA);
		callSelection.addCallable(methodB);

		assertSame( "expected result from method B", 
                    METHOD_B_RESULT, callSelection.call(CALL_B));

		methodA.verifyExpectations();
		methodB.verifyExpectations();
	}

    public void testExpectationsOverrideEarlierMatchingExpectations() 
        throws Throwable 
    {
        Callable methodASignature = 
            new ArgumentMatcher( METHOD_A_NAME, METHOD_A_CONSTRAINTS, 
                                 new ReturnStub("result1"));
        Callable anotherMethodASignature = 
            new ArgumentMatcher( METHOD_A_NAME, METHOD_A_CONSTRAINTS, 
                                 new ReturnStub("result2"));
    
        callSelection.addCallable(methodASignature);
        callSelection.addCallable(new CallOnceExpectation(anotherMethodASignature));

        assertSame( "expected result from method A", 
                    "result2",
                    callSelection.call(CALL_A));
        
        callSelection.verify();
    }

	public void testConfiguredResultReturned() throws Throwable {
		mockCallable.setupCallReturn(METHOD_A_RESULT);
		mockCallable.setupMatchesReturn(true);
		
		callSelection.addCallable(mockCallable);

		assertSame( "result is returned by mock", 
                    METHOD_A_RESULT, callSelection.call(CALL_A));
	}

	public void testCallableThrowableThrown()
		throws Throwable 
    {
		mockCallable.setupMatchesReturn(true);
		mockCallable.setupCallThrow(METHOD_A_EXCEPTION);
		
		callSelection.addCallable(mockCallable);

		try {
			callSelection.call(CALL_A);
		} catch (Throwable ex) {
			assertSame("exception is caught by mock", METHOD_A_EXCEPTION, ex);
		}
	}

	public void testEmptySetVerifies() throws Exception {
		callSelection.verify();
	}

	public void testReportsFailureIfNoElementMatches() throws Throwable {
		methodA.setExpectedMatches(CALL_C);
		methodA.setupMatchesReturn(false);
		methodA.setExpectedCallCount(0);
		methodA.setupGetDescription("***methodA-description****");
		methodB.setExpectedCall(CALL_C);
		methodB.setupMatchesReturn(false);
		methodB.setExpectedCallCount(0);
		methodB.setupGetDescription("***methodB-description****");

		callSelection.addCallable(methodA);
		callSelection.addCallable(methodB);

		try {
			callSelection.call(CALL_C);
		} catch (AssertionFailedError ex) {
			AssertMo.assertIncludes("method name is in error message", "methodC", ex.getMessage());
			AssertMo.assertIncludes("argument is in error message (1)", METHOD_C_ARGS[0], ex.getMessage());
			AssertMo.assertIncludes("argument is in error message (2)", METHOD_C_ARGS[1], ex.getMessage());

			AssertMo.assertIncludes("shows set contents (A)", methodA.getDescription(), ex.getMessage());
			AssertMo.assertIncludes("shows set contents (B)", methodB.getDescription(), ex.getMessage());

			return;
		}

		fail("Should fail for a missing item");
	}

	public void testVerifiesIfAllContainedElementsVerify()
		throws Throwable {
		methodA.setExpectedVerifyCalls(1);
		methodB.setExpectedVerifyCalls(1);

		callSelection.addCallable(methodA);
		callSelection.addCallable(methodB);
		callSelection.verify();

		methodA.verifyExpectations();
		methodB.verifyExpectations();
	}

	public void testVerifyFailsIfContainedElementDoesNotVerify()
		throws Exception 
    {
		methodA.setExpectedVerifyCalls(1);
		methodA.setupVerifyThrow(new AssertionFailedError("verify failed"));
		callSelection.addCallable(methodA);

		try {
			callSelection.verify();
		} catch (AssertionFailedError ex) {
			methodA.verifyExpectations();

			return;
		}

		fail("Should have got a failure for contained element failing");
	}
    
    public void testDoesNotMatchIfEmpty() {
        assertTrue( "empty selection does not match",
                    !callSelection.matches(CALL_A) );
    }
    
    public void testPassesMatchesParametersToAllElements() {
        callSelection.addCallable( methodA );
        callSelection.addCallable( methodB );
        
        methodA.setExpectedMatches(CALL_A);
        methodA.setupMatchesReturn(true);
        methodB.setExpectedMatches(CALL_A);
        methodA.setupMatchesReturn(true);
        
        assertTrue( "should match", callSelection.matches(CALL_A) );
        
        callSelection.verify();
    }    
    
    public void testMatchesIfAnyExpectedElementMatches() {
        callSelection.addCallable( methodA );
        callSelection.addCallable( methodB );
        
        methodA.setupMatchesReturn(true);
        methodB.setupMatchesReturn(false);
        assertTrue( "should match methodA", callSelection.matches(CALL_A) );
        
        methodA.setupMatchesReturn(false);
        methodB.setupMatchesReturn(true);
        assertTrue( "should match methodB", callSelection.matches(CALL_B) );
    }
    
    public void testDoesNotMatchIfNoElementsMatch() {
        callSelection.addCallable( methodA );
        callSelection.addCallable( methodB );
        
        methodA.setExpectedMatches(CALL_C);
        methodA.setupMatchesReturn(false);
        methodB.setExpectedMatches(CALL_C);
        methodB.setupMatchesReturn(false);
        
        assertFalse( "no method should match", callSelection.matches(CALL_C) );
    }
}

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

import junit.framework.TestCase;

import com.mockobjects.constraint.Constraint;
import com.mockobjects.constraint.IsEqual;
import com.mockobjects.dynamic.C;
import com.mockobjects.dynamic.CallCollectionBuilder;
import com.mockobjects.util.Verifier;


public class CallCollectionBuilderTest
    extends TestCase
{
	final String METHOD_NOARG_NAME = "noArgMethodVoid";
	final String METHOD_NOARGANDRETURN_NAME = "noArgMethod";
	final String METHOD_NOARGANDRETURN_RESULT = "resultNoArgs";
	final String METHOD_ONEARG_NAME = "oneArgMethod";
	final String METHOD_ONEARG_RESULT = "result1Args";
	final String METHOD_TWOARG_NAME = "twoArgMethod";
	final String METHOD_TWOARG_RESULT = "resultTwoArgs";
	final Throwable METHOD_EXCEPTION = 
        new DummyThrowable("Configured test throwable");
	final Object[] METHOD_NOARG_ARGS = new Object[0];
	final String[] METHOD_ONEARG_ARGS = new String[] { "oneP1" };
	final Constraint[] METHOD_ONEARG_CONSTRAINTS = C.args(C.eq("oneP1"));
	final String[] METHOD_TWOARG_ARGS = new String[] { "twoP1", "twoP2" };
	final Constraint[] METHOD_TWOARG_CONSTRAINTS = 
        C.args(C.eq("twoP1"), C.eq("twoP2"));
    
	private MockCallFactory mockCallFactory = new MockCallFactory();
    private MockCallable mockCallable = new MockCallable();
	private MockCallable mockArgumentMatcher = new MockCallable();
	private MockCallable mockCallOnceExpectation = new MockCallable();
	private MockCallable mockReturnStub = new MockCallable();
	private MockCallable mockThrowStub = new MockCallable();
	private MockCallable mockVoidStub = new MockCallable();
	private MockCompositeCallable mockCompositeCallable = 
        new MockCompositeCallable();
    
    private CallCollectionBuilder builder;
    
	
    public CallCollectionBuilderTest(String name) throws Exception {
		super(name);
	}
    
	public void setUp() {
		builder = new CallCollectionBuilder( mockCallFactory, 
                                             mockCompositeCallable );
	}

    public void testAddsCallablesToComposite()
        throws Throwable
    {
        mockCompositeCallable.addExpectedAddCallableValues( mockCallable );
        
        builder.addCallable( mockCallable );
        
        mockCompositeCallable.verifyExpectations();
    }
    
    public void testBuildsDecoratorToWrapExpectedCallableObject()
        throws Throwable
    {
        mockCallFactory.addExpectedCreateArgumentMatcherValues(
            METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, 
            mockCallable );
        mockCallFactory.setupCreateArgumentMatcher( mockArgumentMatcher );
        
        mockCallFactory.addExpectedCreateCallOnceExpectationValues(
            mockArgumentMatcher );
        mockCallFactory.setupCreateCallOnceExpectation( mockCallOnceExpectation );
        
        mockCompositeCallable.addExpectedAddCallableValues(mockCallOnceExpectation);
        
        builder.expect( METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS,
                        mockCallable );
        
        mockCallFactory.verify();
        mockCompositeCallable.verifyExpectations();
    }
    
	public void testBuildsDecoratorsForExpectVoidWithConstraintArray() 
        throws Throwable 
    {
		mockCallFactory.setExpectedCreateVoidStubCalls(1);
		mockCallFactory.setupCreateVoidStub(mockVoidStub);
		mockCallFactory.addExpectedCreateArgumentMatcherValues( 
            METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockVoidStub );
		mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
		mockCallFactory.addExpectedCreateCallOnceExpectationValues(
            mockArgumentMatcher );
		mockCallFactory.setupCreateCallOnceExpectation(
            mockCallOnceExpectation);
        
		mockCompositeCallable.addExpectedAddCallableValues(
            mockCallOnceExpectation);
        
		builder.expectVoid(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS);
        
		Verifier.verifyObject(this);
		mockCompositeCallable.verifyExpectations();
	}
	
	public void testBuildsDecoratorsForExpectAndReturnWithNoArguments() 
        throws Throwable 
    {
		mockCallFactory.addExpectedCreateReturnStubValues(
            METHOD_NOARGANDRETURN_RESULT);
		mockCallFactory.setupCreateReturnStub(mockReturnStub);
		mockCallFactory.addExpectedCreateArgumentMatcherValues(
            METHOD_NOARGANDRETURN_NAME, C.NO_ARGS, mockReturnStub);
		mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
		mockCallFactory.addExpectedCreateCallOnceExpectationValues(
            mockArgumentMatcher );
		mockCallFactory.setupCreateCallOnceExpectation(
            mockCallOnceExpectation );

		mockCompositeCallable.addExpectedAddCallableValues(
            mockCallOnceExpectation );

		builder.expectAndReturn( METHOD_NOARGANDRETURN_NAME, 
                                 METHOD_NOARGANDRETURN_RESULT );

		Verifier.verifyObject(this);
		mockCompositeCallable.verifyExpectations();
	}	
	
	public void testBuildsDecoratorsForExpectAndThrowWithNoArguments() 
        throws Throwable 
    {
		mockCallFactory.addExpectedCreateThrowStubValues(
            METHOD_EXCEPTION );
		mockCallFactory.setupCreateThrowStub(mockThrowStub);
		mockCallFactory.addExpectedCreateArgumentMatcherValues(
            METHOD_NOARGANDRETURN_NAME, C.NO_ARGS, mockThrowStub );
		mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
		mockCallFactory.addExpectedCreateCallOnceExpectationValues(
            mockArgumentMatcher);
		mockCallFactory.setupCreateCallOnceExpectation(
            mockCallOnceExpectation );

		mockCompositeCallable.addExpectedAddCallableValues(
            mockCallOnceExpectation );

		builder.expectAndThrow(METHOD_NOARGANDRETURN_NAME, METHOD_EXCEPTION);

		Verifier.verifyObject(this);
		mockCompositeCallable.verifyExpectations();
	}	
	
	public void testBuildsDecoratorsForExpectAndThrowWithOneArgument() 
        throws Throwable 
    {
		mockCallFactory.addExpectedCreateThrowStubValues(METHOD_EXCEPTION);
		mockCallFactory.setupCreateThrowStub(mockThrowStub);
		mockCallFactory.addExpectedCreateArgumentMatcherValues(
            METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub );
		mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
		mockCallFactory.addExpectedCreateCallOnceExpectationValues(
            mockArgumentMatcher);
		mockCallFactory.setupCreateCallOnceExpectation(
            mockCallOnceExpectation );
        
		mockCompositeCallable.addExpectedAddCallableValues(
            mockCallOnceExpectation );
        
		builder.expectAndThrow(
            METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_EXCEPTION);
        
		Verifier.verifyObject(this);
		mockCompositeCallable.verifyExpectations();
	}	
	
	public void testBuildsDecoratorsForExpectVoidWithNoArguments() 
        throws Throwable 
    {
		mockCallFactory.setExpectedCreateVoidStubCalls(1);
		mockCallFactory.setupCreateVoidStub(mockVoidStub);
		mockCallFactory.addExpectedCreateArgumentMatcherValues(
            METHOD_NOARG_NAME, C.NO_ARGS, mockVoidStub );
		mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
		mockCallFactory.addExpectedCreateCallOnceExpectationValues(
            mockArgumentMatcher );
		mockCallFactory.setupCreateCallOnceExpectation(mockCallOnceExpectation);
	
		mockCompositeCallable.addExpectedAddCallableValues(mockCallOnceExpectation);
	
		builder.expectVoid( METHOD_NOARG_NAME );
	
		Verifier.verifyObject(this);
		mockCompositeCallable.verifyExpectations();
	}
	
 	public void testBuildsDecoratorsForExpectVoidWithOneArgument() 
        throws Throwable 
    {
		mockCallFactory.setExpectedCreateVoidStubCalls(1);
		mockCallFactory.setupCreateVoidStub(mockVoidStub);
		mockCallFactory.addExpectedCreateArgumentMatcherValues(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
		mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
		mockCallFactory.addExpectedCreateCallOnceExpectationValues(mockArgumentMatcher);
		mockCallFactory.setupCreateCallOnceExpectation(mockCallOnceExpectation);

		mockCompositeCallable.addExpectedAddCallableValues(mockCallOnceExpectation);

		builder.expectVoid(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0]);

		Verifier.verifyObject(this);
		mockCompositeCallable.verifyExpectations();
	}
	
	public void testBuildsDecoratorsForExpectVoidWithOneConstraint() 
        throws Throwable 
    {
		mockCallFactory.setupCreateVoidStub(mockVoidStub);
		mockCallFactory.addExpectedCreateArgumentMatcherValues(
            METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub );
		mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
		mockCallFactory.setupCreateCallOnceExpectation(
            mockCallOnceExpectation );

		mockCompositeCallable.addExpectedAddCallableValues(
            mockCallOnceExpectation );

		builder.expectVoid(
            METHOD_ONEARG_NAME, 
            new IsEqual(METHOD_ONEARG_ARGS[0]) );

		Verifier.verifyObject(this);
		mockCompositeCallable.verifyExpectations();
	}
	
	public void testBuildsDecoratorsForExpectAndReturnWithManyConstraints() 
        throws Throwable 
    {
		mockCallFactory.addExpectedCreateReturnStubValues(
            METHOD_TWOARG_RESULT );
		mockCallFactory.setupCreateReturnStub(mockReturnStub);
		mockCallFactory.addExpectedCreateArgumentMatcherValues(
            METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockReturnStub);
		mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
		mockCallFactory.addExpectedCreateCallOnceExpectationValues(
            mockArgumentMatcher);
		mockCallFactory.setupCreateCallOnceExpectation(
            mockCallOnceExpectation);

		mockCompositeCallable.addExpectedAddCallableValues(
            mockCallOnceExpectation);

		builder.expectAndReturn( METHOD_TWOARG_NAME, 
                                 METHOD_TWOARG_CONSTRAINTS, 
                                 METHOD_TWOARG_RESULT);

		Verifier.verifyObject(this);
		mockCompositeCallable.verifyExpectations();
	}

	public void testBuildsDecoratorsForExpectAndThrowWithManyConstraints() 
        throws Throwable 
    {
		mockCallFactory.addExpectedCreateThrowStubValues(METHOD_EXCEPTION);
		mockCallFactory.setupCreateThrowStub(mockThrowStub);
		mockCallFactory.addExpectedCreateArgumentMatcherValues(
            METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockThrowStub );
		mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
		mockCallFactory.addExpectedCreateCallOnceExpectationValues(
            mockArgumentMatcher);
		mockCallFactory.setupCreateCallOnceExpectation(
            mockCallOnceExpectation);

		mockCompositeCallable.addExpectedAddCallableValues(
            mockCallOnceExpectation);
		mockCompositeCallable.setupCallReturn(METHOD_TWOARG_RESULT);

		builder.expectAndThrow( METHOD_TWOARG_NAME, 
                                METHOD_TWOARG_CONSTRAINTS,
                                METHOD_EXCEPTION );

		Verifier.verifyObject(this);
		mockCompositeCallable.verifyExpectations();
	}

	public void testBuildsDecoratorsForExpectAndReturnWithOneArgument() 
        throws Throwable 
    {
		mockCallFactory.addExpectedCreateReturnStubValues(
            METHOD_ONEARG_RESULT );
		mockCallFactory.setupCreateReturnStub(mockReturnStub);
		mockCallFactory.addExpectedCreateArgumentMatcherValues(
            METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub );
		mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
		mockCallFactory.addExpectedCreateCallOnceExpectationValues(
            mockArgumentMatcher );
		mockCallFactory.setupCreateCallOnceExpectation(
            mockCallOnceExpectation );
        
		mockCompositeCallable.addExpectedAddCallableValues(
            mockCallOnceExpectation );
		mockCompositeCallable.setupCallReturn(METHOD_ONEARG_RESULT);

		builder.expectAndReturn( METHOD_ONEARG_NAME, 
                                 METHOD_ONEARG_ARGS[0], 
                                 METHOD_ONEARG_RESULT );

		Verifier.verifyObject(this);
		mockCompositeCallable.verifyExpectations();
	}

    public void testBuildsDecoratorsForExpectAndReturnWithOneConstraint() 
        throws Throwable 
    {
        mockCallFactory.addExpectedCreateReturnStubValues(
            METHOD_ONEARG_RESULT );
        mockCallFactory.setupCreateReturnStub(mockReturnStub);
        mockCallFactory.addExpectedCreateArgumentMatcherValues(
            METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub );
        mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
        mockCallFactory.addExpectedCreateCallOnceExpectationValues(
            mockArgumentMatcher );
        mockCallFactory.setupCreateCallOnceExpectation(
            mockCallOnceExpectation );
        
        mockCompositeCallable.addExpectedAddCallableValues(
            mockCallOnceExpectation );
        mockCompositeCallable.setupCallReturn(METHOD_ONEARG_RESULT);

        builder.expectAndReturn( METHOD_ONEARG_NAME, 
                                 METHOD_ONEARG_CONSTRAINTS[0], 
                                 METHOD_ONEARG_RESULT );
        
        Verifier.verifyObject(this);
        mockCompositeCallable.verifyExpectations();
    }

    public void testBuildsDecoratorsForExpectAndThrowWithOneConstraint() 
        throws Throwable 
    {
        mockCallFactory.addExpectedCreateReturnStubValues(
            METHOD_ONEARG_RESULT );
        mockCallFactory.setupCreateThrowStub(mockThrowStub);
        mockCallFactory.addExpectedCreateArgumentMatcherValues(
            METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub );
        mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
        mockCallFactory.addExpectedCreateCallOnceExpectationValues(
            mockArgumentMatcher );
        mockCallFactory.setupCreateCallOnceExpectation(
            mockCallOnceExpectation );
        
        mockCompositeCallable.addExpectedAddCallableValues(
            mockCallOnceExpectation );

        builder.expectAndThrow( METHOD_ONEARG_NAME, 
                                METHOD_ONEARG_CONSTRAINTS[0], 
                                METHOD_EXCEPTION );
        
        Verifier.verifyObject(this);
        mockCompositeCallable.verifyExpectations();
    }

	public void testBuildsDecoratorsForMatchAndReturnWithManyConstraints() 
        throws Throwable 
    {
		mockCallFactory.addExpectedCreateReturnStubValues(
            METHOD_TWOARG_RESULT );
		mockCallFactory.setupCreateReturnStub(mockReturnStub);
		mockCallFactory.addExpectedCreateArgumentMatcherValues(
            METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockReturnStub);
		mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);

		mockCompositeCallable.addExpectedAddCallableValues(
            mockArgumentMatcher);

		builder.matchAndReturn( METHOD_TWOARG_NAME, 
                                METHOD_TWOARG_CONSTRAINTS, 
                                METHOD_TWOARG_RESULT);

		Verifier.verifyObject(this);
		mockCompositeCallable.verifyExpectations();
	}

	public void testBuildsDecoratorsForMatchAndThrowWithNoArguments() 
        throws Throwable 
    {
		mockCallFactory.addExpectedCreateThrowStubValues(METHOD_EXCEPTION);
		mockCallFactory.setupCreateThrowStub(mockThrowStub);
		mockCallFactory.addExpectedCreateArgumentMatcherValues(METHOD_NOARG_NAME, C.NO_ARGS, mockThrowStub);
		mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);

		mockCompositeCallable.addExpectedAddCallableValues(
            mockArgumentMatcher);

		builder.matchAndThrow(METHOD_NOARG_NAME, METHOD_EXCEPTION);

		Verifier.verifyObject(this);
		mockCompositeCallable.verifyExpectations();
	}
	
	public void testBuildsDecoratorsForMatchAndThrowWithOneArgument() 
        throws Throwable 
    {
		mockCallFactory.addExpectedCreateThrowStubValues(METHOD_EXCEPTION);
		mockCallFactory.setupCreateThrowStub(mockThrowStub);
		mockCallFactory.addExpectedCreateArgumentMatcherValues(
            METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub);
		mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);

		mockCompositeCallable.addExpectedAddCallableValues(
            mockArgumentMatcher);

		builder.matchAndThrow( METHOD_ONEARG_NAME, 
                               METHOD_ONEARG_ARGS[0], 
                               METHOD_EXCEPTION);

		Verifier.verifyObject(this);
		mockCompositeCallable.verifyExpectations();
	}
    
	public void testBuildsDecoratorsForMatchAndThrowWithManyArguments() 
        throws Throwable 
    {
		mockCallFactory.addExpectedCreateThrowStubValues(METHOD_EXCEPTION);
		mockCallFactory.setupCreateThrowStub(mockThrowStub);
		mockCallFactory.addExpectedCreateArgumentMatcherValues(
            METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockThrowStub);
		mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);

		mockCompositeCallable.addExpectedAddCallableValues(
            mockArgumentMatcher);

		builder.matchAndThrow( METHOD_TWOARG_NAME, 
                               METHOD_TWOARG_CONSTRAINTS, 
                               METHOD_EXCEPTION );

		Verifier.verifyObject(this);
		mockCompositeCallable.verifyExpectations();
	}

	public void testBuildsDecoratorsForMatchAndReturnWithOneArgument() 
        throws Throwable 
    {
		mockCallFactory.addExpectedCreateReturnStubValues(
            METHOD_ONEARG_RESULT);
		mockCallFactory.setupCreateReturnStub(mockReturnStub);
		mockCallFactory.addExpectedCreateArgumentMatcherValues(
            METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub);
		mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);

		mockCompositeCallable.addExpectedAddCallableValues(
            mockArgumentMatcher );

		builder.matchAndReturn( METHOD_ONEARG_NAME, 
                                METHOD_ONEARG_ARGS[0], 
                                METHOD_ONEARG_RESULT );

		Verifier.verifyObject(this);
		mockCompositeCallable.verifyExpectations();
	}
	
	public void testBuildsDecoratorsForMatchAndReturnWithNoArguments() 
        throws Throwable 
    {
		mockCallFactory.addExpectedCreateReturnStubValues(
            METHOD_NOARGANDRETURN_RESULT);
		mockCallFactory.setupCreateReturnStub(mockReturnStub);
		mockCallFactory.addExpectedCreateArgumentMatcherValues(
            METHOD_NOARG_NAME, C.NO_ARGS, mockReturnStub);
		mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);

		mockCompositeCallable.addExpectedAddCallableValues(
            mockArgumentMatcher);

		builder.matchAndReturn( METHOD_NOARG_NAME, 
                                METHOD_NOARGANDRETURN_RESULT);

		Verifier.verifyObject(this);
		mockCompositeCallable.verifyExpectations();
	}
    
    public void testBuildsCallSequenceAndWrapsItWithACallCollectionBuilder() {
        final CallCollectionBuilder expectedSequenceBuilder =
            new CallCollectionBuilder( mockCallFactory, 
                                       mockCompositeCallable );
        
        mockCallFactory.setupCreateCallSequence( mockCompositeCallable ); 
        mockCallFactory.addExpectedCreateCallCollectionBuilderValues( 
            mockCompositeCallable );
        mockCallFactory.setupCreateCallCollectionBuilder( 
            expectedSequenceBuilder );
        
        CallCollectionBuilder returnedSequenceBuilder = 
            builder.newCallSequence();
        
        assertSame( "expected same builder for new sequence",
                    expectedSequenceBuilder, returnedSequenceBuilder );
        
        mockCallFactory.verify();
    }
    
    public void testBuildsCallSelectionAndWrapsItWithACallCollectionBuilder() {
        final CallCollectionBuilder expectedSelectionBuilder =
            new CallCollectionBuilder( mockCallFactory, 
                                       mockCompositeCallable );
        
        mockCallFactory.setupCreateCallSelection( mockCompositeCallable ); 
        mockCallFactory.addExpectedCreateCallCollectionBuilderValues( 
            mockCompositeCallable );
        mockCallFactory.setupCreateCallCollectionBuilder( 
            expectedSelectionBuilder );
        
        CallCollectionBuilder returnedSelectionBuilder = 
            builder.newCallSelection();
        
        assertSame( "expected same builder for new selection",
                    expectedSelectionBuilder, returnedSelectionBuilder );
        
        mockCallFactory.verify();
    }
}

--- NEW FILE: MockCompositeCallable.java ---
package test.mockobjects.dynamic;

import com.mockobjects.ExceptionalReturnValue;
import com.mockobjects.ExpectationCounter;
import com.mockobjects.ExpectationList;
import com.mockobjects.VoidReturnValues;
import com.mockobjects.ReturnValues;
import com.mockobjects.dynamic.Callable;
import com.mockobjects.dynamic.CompositeCallable;

public class MockCompositeCallable 
  extends MockCallable
  implements CompositeCallable
{
   private ExpectationCounter myAddCallableCalls = new ExpectationCounter("com.mockobjects.dynamic.CompositeCallable AddCallableCalls");
   private ReturnValues myActualAddCallableReturnValues = new VoidReturnValues(false);
   private ExpectationList myAddCallableParameter0Values = new ExpectationList("com.mockobjects.dynamic.CompositeCallable com.mockobjects.dynamic.Callable");
   private ExpectationCounter myResetCalls = new ExpectationCounter("com.mockobjects.dynamic.CompositeCallable ResetCalls");
   private ReturnValues myActualResetReturnValues = new VoidReturnValues(false);
   public void setExpectedAddCallableCalls(int calls){
      myAddCallableCalls.setExpected(calls);
   }
   public void addExpectedAddCallableValues(Callable arg0){
      myAddCallableParameter0Values.addExpected(arg0);
   }
   public void addCallable(Callable arg0){
      myAddCallableCalls.inc();
      myAddCallableParameter0Values.addActual(arg0);
      Object nextReturnValue = myActualAddCallableReturnValues.getNext();
      if (nextReturnValue instanceof ExceptionalReturnValue && ((ExceptionalReturnValue)nextReturnValue).getException() instanceof RuntimeException)
          throw (RuntimeException)((ExceptionalReturnValue)nextReturnValue).getException();
   }
   public void setupExceptionAddCallable(Throwable arg){
      myActualAddCallableReturnValues.add(new ExceptionalReturnValue(arg));
   }
   public void setExpectedResetCalls(int calls){
      myResetCalls.setExpected(calls);
   }
   public void reset(){
      myResetCalls.inc();
      Object nextReturnValue = myActualResetReturnValues.getNext();
      if (nextReturnValue instanceof ExceptionalReturnValue && ((ExceptionalReturnValue)nextReturnValue).getException() instanceof RuntimeException)
          throw (RuntimeException)((ExceptionalReturnValue)nextReturnValue).getException();
   }
   public void setupExceptionReset(Throwable arg){
      myActualResetReturnValues.add(new ExceptionalReturnValue(arg));
   }
}

Index: StubTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/StubTest.java,v
retrieving revision 1.3
retrieving revision 1.3.2.1
diff -u -r1.3 -r1.3.2.1
--- StubTest.java	12 Jun 2003 22:45:16 -0000	1.3
+++ StubTest.java	21 Jun 2003 14:01:07 -0000	1.3.2.1
@@ -3,15 +3,20 @@
  */
 package test.mockobjects.dynamic;
 
-import com.mockobjects.dynamic.*;
+import junit.framework.TestCase;
 
-import junit.framework.*;
+import com.mockobjects.dynamic.ActiveCall;
+import com.mockobjects.dynamic.ReturnStub;
+import com.mockobjects.dynamic.ThrowStub;
+import com.mockobjects.dynamic.VoidStub;
 
-/**
- * @author dev
- */
-public class StubTest extends TestCase {
 
+public class StubTest 
+    extends TestCase 
+{
+    static final ActiveCall IGNORED_CALL = null;
+    
+    
 	public StubTest(String name) {
 		super(name);
 	}
@@ -20,25 +25,28 @@
 		final String result = "result";
 		
 		ReturnStub stub = new ReturnStub(result);
-		String ignoredMethodName = "methodName";
-		Object[] ignoredArgs = new Object[0];
 		
-		assertSame( "Should be the same result object",
-					result, stub.call( ignoredMethodName, ignoredArgs ) );
+		assertSame( "should be the same result object",
+					result, stub.call( IGNORED_CALL ) );
 	}
 
+    public void testVoidStub() throws Throwable {
+        VoidStub stub = new VoidStub();
+        
+        assertNull( "should return null",
+                    stub.call( IGNORED_CALL ) );
+    }
+
 	public void testThrowStub() {
 		final Throwable throwable = new DummyThrowable();
 		
 		ThrowStub stub = new ThrowStub(throwable);
-		String ignoredMethodName = "methodName";
-		Object[] ignoredArgs = new Object[0];
 		
 		try {
-			stub.call( ignoredMethodName, ignoredArgs );
+			stub.call( IGNORED_CALL );
 		}
 		catch( Throwable t ) {
-			assertSame( "Should be the same throwable", throwable, t );
+			assertSame( "should be the same throwable", throwable, t );
 		}
 	}
 }

Index: MockConstraint.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockConstraint.java,v
retrieving revision 1.2
retrieving revision 1.2.2.1
diff -u -r1.2 -r1.2.2.1
--- MockConstraint.java	18 May 2003 20:59:39 -0000	1.2
+++ MockConstraint.java	21 Jun 2003 14:01:07 -0000	1.2.2.1
@@ -3,26 +3,28 @@
  */
 package test.mockobjects.dynamic;
 
-import junit.framework.*;
+import junit.framework.Assert;
 
-import com.mockobjects.*;
-import com.mockobjects.constraint.*;
+import com.mockobjects.Verifiable;
+import com.mockobjects.constraint.Constraint;
 
-/**
- * @author dev
- */
-public class MockConstraint extends Assert implements Constraint, Verifiable {
+
+public class MockConstraint 
+    extends Assert 
+    implements Constraint, Verifiable 
+{
 	private String description;
-	private Object expectedArg;		
+	private Object expectedArg;
 	private boolean result;
 	private boolean wasChecked = false;
 	
+    
 	public MockConstraint( String description, Object expectedArg, boolean result ) {
 		this.description = description;
 		this.expectedArg = expectedArg;
 		this.result = result;
 	}
-
+    
 	public String toString() {
 		return description;
 	}

Index: DynamicUtilTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/DynamicUtilTest.java,v
retrieving revision 1.2
retrieving revision 1.2.2.1
diff -u -r1.2 -r1.2.2.1
--- DynamicUtilTest.java	18 May 2003 20:59:39 -0000	1.2
+++ DynamicUtilTest.java	21 Jun 2003 14:01:07 -0000	1.2.2.1
@@ -3,11 +3,11 @@
  */
 package test.mockobjects.dynamic;
 
+import junit.framework.TestCase;
+
 import com.mockobjects.dynamic.DynamicUtil;
 import com.mockobjects.dynamic.Mock;
 import com.mockobjects.util.AssertMo;
-
-import junit.framework.TestCase;
 
 /**
  * @author e2x

Index: CallOnceExpectationTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/CallOnceExpectationTest.java,v
retrieving revision 1.2
retrieving revision 1.2.2.1
diff -u -r1.2 -r1.2.2.1
--- CallOnceExpectationTest.java	12 Jun 2003 22:45:16 -0000	1.2
+++ CallOnceExpectationTest.java	21 Jun 2003 14:01:07 -0000	1.2.2.1
@@ -1,19 +1,25 @@
 package test.mockobjects.dynamic;
 
-import com.mockobjects.dynamic.*;
-import com.mockobjects.util.*;
+import junit.framework.AssertionFailedError;
+import junit.framework.TestCase;
 
-import junit.framework.*;
+import com.mockobjects.dynamic.ActiveCall;
+import com.mockobjects.dynamic.CallOnceExpectation;
+import com.mockobjects.dynamic.DynamicUtil;
+import com.mockobjects.util.AssertMo;
 
 
-public class CallOnceExpectationTest extends TestCase {
-
+public class CallOnceExpectationTest 
+    extends TestCase 
+{
 	final String RESULT = "result!";
 	final String METHOD_NAME = "methodName";
 	final Object[] ARGS = { "arg1", "arg2" }; 
 	final String DECORATED_DESCRIPTION = DynamicUtil.methodToString( METHOD_NAME, ARGS );
-	
-	Mock ignoredMock = null;
+    final ActiveCall CALL = new ActiveCall(
+        METHOD_NAME, new Class[]{String.class,String.class}, String.class,
+        ARGS );
+    
 	MockCallable mockCallable = new MockCallable();
 	CallOnceExpectation call = new CallOnceExpectation( mockCallable );
 	
@@ -49,24 +55,24 @@
 		mockCallable.setupCallReturn( RESULT );
 		mockCallable.setExpectedVerifyCalls(1);
 		
-		call.call( METHOD_NAME, ARGS );
+		call.call( CALL );
 		call.verify();
 		
 		mockCallable.verifyExpectations();
 	}
 	
 	public void testMatchesDelegated() throws Throwable {
-		mockCallable.setExpectedMatches( METHOD_NAME, ARGS );
+		mockCallable.setExpectedMatches(CALL);
 		mockCallable.setupMatchesReturn(true);
-		assertTrue( "returns matches to be true", call.matches( METHOD_NAME, ARGS ) );
+		assertTrue( "returns matches to be true", call.matches(CALL) );
 		mockCallable.verifyExpectations();
 	}
 	
 	public void testCallArgumentsPassedThrough() throws Throwable {
-		mockCallable.setExpectedCall(ignoredMock, METHOD_NAME, ARGS);
+		mockCallable.setExpectedCall(CALL);
 		mockCallable.setupCallReturn(RESULT);
 		
-		call.call( METHOD_NAME, ARGS );
+		call.call( CALL );
 		mockCallable.verifyExpectations();
 	}
 	
@@ -75,16 +81,16 @@
         mockCallable.setupMatchesReturn(true);
         mockCallable.setupCallReturn(RESULT);
         
-        assertTrue( "First time should match", call.matches(METHOD_NAME, ARGS));
-        call.call(METHOD_NAME, ARGS);
-        assertFalse( "Second time should not match", call.matches(METHOD_NAME, ARGS));
+        assertTrue( "First time should match", call.matches(CALL));
+        call.call(CALL);
+        assertFalse( "Second time should not match", call.matches(CALL));
     }
     
 	public void testDecoratedResultPassedThrough() throws Throwable {
 		mockCallable.setupCallReturn(RESULT);
 		
 		assertSame( "should return decorated's result",
-				    RESULT, call.call( METHOD_NAME, ARGS ) );
+				    RESULT, call.call(CALL) );
 		mockCallable.verifyExpectations();
 	}
 
@@ -95,7 +101,7 @@
 		mockCallable.setupCallThrow(exception);
 		
 		try {
-			call.call( METHOD_NAME, ARGS );
+			call.call(CALL);
 			fail("expected decorated's throwable to be thrown");
 		}
 		catch( DummyThrowable ex ) {

Index: MockCallable.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockCallable.java,v
retrieving revision 1.3
retrieving revision 1.3.2.1
diff -u -r1.3 -r1.3.2.1
--- MockCallable.java	12 Jun 2003 22:45:16 -0000	1.3
+++ MockCallable.java	21 Jun 2003 14:01:07 -0000	1.3.2.1
@@ -1,22 +1,22 @@
 package test.mockobjects.dynamic;
 
-import junit.framework.*;
+import junit.framework.AssertionFailedError;
 
-import com.mockobjects.*;
+import com.mockobjects.ExpectationCounter;
+import com.mockobjects.ExpectationValue;
+import com.mockobjects.ReturnValue;
+import com.mockobjects.dynamic.ActiveCall;
 import com.mockobjects.dynamic.Callable;
-import com.mockobjects.dynamic.Mock;
-import com.mockobjects.util.*;
+import com.mockobjects.util.Verifier;
 
 public class MockCallable implements Callable {
 	
 	private ExpectationCounter callCount = new ExpectationCounter("call.count");
-	private ExpectationValue callMethodName = new ExpectationValue("call.methodName");
-	private ExpectationList callArgs = new ExpectationList("call.args");
+	private ExpectationValue callCall = new ExpectationValue("call.call");
 	private ReturnValue callResult = new ReturnValue("call.return");
 	private Throwable callThrow = null;
 	
-	private ExpectationValue matchesMethodName = new ExpectationValue("matches.methodName");
-	private ExpectationList matchesArgs = new ExpectationList("matches.args");
+	private ExpectationValue matchesCall = new ExpectationValue("matches.call");
 	private ReturnValue matchesResult = new ReturnValue("matches.return");
 	private ExpectationCounter matchesCount = new ExpectationCounter("matches.count");
 	
@@ -30,9 +30,8 @@
 		callCount.setExpected(count);	
 	}
 	
-	public void setExpectedCall( Mock mock, String methodName, Object[] args ) {
-		callMethodName.setExpected(methodName);
-		callArgs.addExpectedMany(args);
+	public void setExpectedCall( ActiveCall call ) {
+		callCall.setExpected(call);
 	}
 	
 	public void setupCallReturn( Object result ) {
@@ -43,9 +42,8 @@
 		callThrow = thrown;
 	}
 	
-	public Object call(String methodName, Object[] args) throws Throwable {
-		callMethodName.setActual(methodName);
-		callArgs.addActualMany(args);
+	public Object call( ActiveCall call ) throws Throwable {
+		callCall.setActual(call);
 		callCount.inc();
 		
 		if( callThrow != null ) {
@@ -55,9 +53,8 @@
 		}
 	}
 	
-	public void setExpectedMatches( String methodName, Object[] args ) {
-		matchesMethodName.setExpected(methodName);
-		matchesArgs.addExpectedMany(args);
+	public void setExpectedMatches( ActiveCall call )...
 
[truncated message content]