[MO-java-dev] CVS: mockobjects-java/src/core/test/mockobjects/dynamic MockCallMocker.java,NONE,1.1.2.1 DummyThrowable.java,NONE,1.1.2.1 MockConstraint.java,NONE,1.1.2.1 DummyInterface.java,NONE,1.1.2.1 ExpectedCallTest.java,NONE,1.1.2.1 StubTest.java,NONE,1.1.2.1 MockTest.java,1.8.2.1,1.8.2.2 CallSetTest.java,1.1.2.1,1.1.2.2 TestInterface.java,1.1.2.1,NONE TestThrowable.java,1.1.2.1,NONE SingleCallTest.java,1.1.2.1,NONE TestConstraint.java,1.1.2.1,NONE

[Tim M. <ma...@us...>]

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

Modified Files:
      Tag: DynamicMockExperiment
	MockTest.java CallSetTest.java 
Added Files:
      Tag: DynamicMockExperiment
	MockCallMocker.java DummyThrowable.java MockConstraint.java 
	DummyInterface.java ExpectedCallTest.java StubTest.java 
Removed Files:
      Tag: DynamicMockExperiment
	TestInterface.java TestThrowable.java SingleCallTest.java 
	TestConstraint.java 
Log Message:
Refactored class hierarchy:
   - call actions can be stubbed
   - stubs can be decorated with expectations
   - calls can be grouped in a CallSet (set/bag)
   - a mock object inherits from CallSet

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

import junit.framework.*;

import com.mockobjects.*;
import com.mockobjects.dynamic.CallMocker;
import com.mockobjects.dynamic.Mock;
import com.mockobjects.util.*;

public class MockCallMocker implements CallMocker {
	
	private ExpectationCounter callCount = new ExpectationCounter("call.count");
	private ExpectationValue callMock = new ExpectationValue("call.mock");
	private ExpectationValue callMethodName = new ExpectationValue("call.methodName");
	private ExpectationList callArgs = new ExpectationList("call.args");
	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 ReturnValue matchesResult = new ReturnValue("matches.return");
	
	private ExpectationCounter verifyCount = new ExpectationCounter("verify.count");
	private AssertionFailedError verifyError = null;
	
	private ReturnValue toStringResult = new ReturnValue("toString.return");
	
	
	public void setExpectedCallCount( int count ) {
		callCount.setExpected(count);	
	}
	
	public void setExpectedCall( Mock mock, String methodName, Object[] args ) {
		callMock.setExpected(mock);
		callMethodName.setExpected(methodName);
		callArgs.addExpectedMany(args);
	}
	
	public void setupCallReturn( Object result ) {
		callResult.setValue(result);
	}
	
	public void setupCallThrow( Throwable thrown ) {
		callThrow = thrown;
	}
	
	public Object call(Mock mock, String methodName, Object[] args) throws Throwable {
		callMock.setActual(mock);
		callMethodName.setActual(methodName);
		callArgs.addActualMany(args);
		callCount.inc();
		
		if( callThrow != null ) {
			throw callThrow;
		} else {
			return callResult.getValue();
		}
	}
	
	public void setExpectedMatches( String methodName, Object[] args ) {
		matchesMethodName.setExpected(methodName);
		matchesArgs.addExpectedMany(args);
	}
	
	public void setupMatchesReturn( boolean result ) {
		matchesResult.setValue(result);
	}
	
	public boolean matches(String methodName, Object[] args) {
		matchesMethodName.setActual(methodName);
		matchesArgs.addActualMany(args);
		return matchesResult.getBooleanValue();
	}

	public void setExpectedVerifyCalls( int count ) {
		verifyCount.setExpected(count);
	}

	public void setupVerifyThrow( AssertionFailedError err ) {
		verifyError = err;
	}
	
	/** @deprecated to avoid calling verify instead of verifyExpectations
	 */
	public void verify() {
		verifyCount.inc();
		if( verifyError != null ) throw verifyError;
	}
	
	/** We have to rename 'verify' because we want to mock the behaviour of the
	 *  verify method itself.
	 */
	public void verifyExpectations() {
		Verifier.verifyObject(this);
	}
	
	public void setupGetDescription( String result ) {
		toStringResult.setValue(result);
	}
	
	public String getDescription() {
		return (String)toStringResult.getValue();
	}
}

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

/**
 * @author dev
 */
public class DummyThrowable extends Throwable {

	public DummyThrowable() {
		super();
	}

	public DummyThrowable(String message) {
		super(message);
	}

	public DummyThrowable(String message, Throwable cause) {
		super(message, cause);
	}

	public DummyThrowable(Throwable cause) {
		super(cause);
	}

}

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

import junit.framework.*;

import com.mockobjects.*;
import com.mockobjects.constraint.*;

/**
 * @author dev
 */
public class MockConstraint extends Assert implements Constraint, Verifiable {
	private String description;
	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;
	}
	
	public boolean eval( Object o ) {
		assertSame( "should be expected argument", expectedArg, o );
		wasChecked = true;
		return result;
	}
	
	public void verify() {
		assertTrue( description + " should have been checked", wasChecked );
	}
}

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

/**
 * @author dev
 */
public interface DummyInterface {
	public String aMethod( String arg1, String arg2 ) throws Throwable;
	
	public void aMethodWithNoArguments();
}

--- NEW FILE: ExpectedCallTest.java ---
/*
 * Created on 04-Apr-2003
 *
 * To change this generated comment go to 
 * Window>Preferences>Java>Code Generation>Code and Comments
 */
package test.mockobjects.dynamic;

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

import junit.framework.*;

public class ExpectedCallTest extends TestCase {

	final String methodName = "methodName";
	Mock mock = new Mock(DummyInterface.class,"mock");
	ExpectedCall call;
	
	public ExpectedCallTest(String name) {
		super(name);
	}
	
	public void testCallArgumentsArePropagatedToDecorated() throws Throwable {
		final Object[] arguments = new Object[0];
		final String result = "result";
		
		MockCallMocker mockDecorated = new MockCallMocker();
		mockDecorated.setExpectedCall( mock, methodName, arguments );
		mockDecorated.setupCallReturn( result );
		
		ExpectedCall call = new ExpectedCall( methodName, new Constraint[0], mockDecorated );
		
		call.call(mock, methodName, arguments);
		
		mockDecorated.verifyExpectations();
	}
	
	public void testUncalledCallDoesNotVerify() {
		ExpectedCall call = new ExpectedCall(methodName, C.args(), new ReturnStub("ignored") );
		
		try {
			call.verify();
		}
		catch( AssertionFailedError ex ) {
			AssertMo.assertIncludes("should include call name", methodName, ex.getMessage() );
			return;
		}
		fail("expected verify to fail");
	}
	
	public void testSuccessfulCallVerifies() throws Throwable {
		ExpectedCall call = new ExpectedCall("methodName", C.args(), new ReturnStub("ignored") );
		
		call.call( mock, "methodName", new Object[0] );
		call.verify();		
	}
	
	public void testMultipleCallsSucceed() throws Throwable {
		ExpectedCall call = new ExpectedCall(methodName, C.args(), new ReturnStub("ignored") );
		
		call.call( mock, methodName, new Object[0] );
		call.call( mock, methodName, new Object[0] );
	}
	
	public void testArgumentsCheckedAgainstConstraints() throws Throwable {
		String[] args = { "arg1", "arg2", "arg3" };
		MockConstraint[] constraints = {
			new MockConstraint( "constraint1", args[0], true ),
			new MockConstraint( "constraint2", args[1], true ),
			new MockConstraint( "constraint3", args[2], true )
		};
		ExpectedCall call = new ExpectedCall( methodName, (Constraint[])constraints, new ReturnStub("ignored") );
		
		call.call( mock, methodName, args );
		
		for( int i = 0; i < constraints.length; i++ ) {
			constraints[i].verify();
		}
	}
	
	public void testWrongNumberOfArguments() throws Throwable {
		String[] args = { "arg1", "arg2" };
		MockConstraint[] constraints = {
			new MockConstraint( "constraint1", args[0], true ),
			new MockConstraint( "constraint2", args[1], true ),
			new MockConstraint( "constraint3", args[1], true )
		};
		
		ExpectedCall call = new ExpectedCall( methodName, (Constraint[])constraints, new ReturnStub("ignored") );

		boolean passed = true;
		try {
			call.call( mock, methodName, args );
			passed = false;
		} catch (AssertionFailedError ex) {
			AssertMo.assertIncludes("Should show expected number of arguments", 
									Integer.toString(constraints.length), ex.getMessage());
			AssertMo.assertIncludes("Should show actual number of arguments", 
									Integer.toString(args.length), ex.getMessage());
			AssertMo.assertIncludes("Should include the method name",
									methodName, ex.getMessage());	
		}
		
		assertTrue("Should fail is call doesn't give an exception", passed);
	}
	
	public void testConstraintFailure() throws Throwable {
		String[] args = { "argA", "argB", "argC" };
		MockConstraint[] constraints = {
			new MockConstraint( "constraintA", args[0], true ),
			new MockConstraint( "constraintB", args[1], false ),
			new MockConstraint( "constraintC", args[2], true )
		};
		
		ExpectedCall call = new ExpectedCall( methodName, (Constraint[])constraints, new ReturnStub("ignored") );

		boolean passed = true;
		try {
			call.call( mock, methodName, args );
			passed = false;
		} catch (AssertionFailedError ex) {
			AssertMo.assertIncludes("Should include the method name",
									methodName, ex.getMessage());
			AssertMo.assertIncludes("Should show index of failed argument",
									"1", ex.getMessage() );
			AssertMo.assertIncludes("Should show expected arguments", 
									AssertMo.join(constraints), ex.getMessage());
			AssertMo.assertIncludes("Should show actual arguments",
									AssertMo.join(args), ex.getMessage());
		}
		
		assertTrue("Should fail is call doesn't give an exception", passed);
	}

	
	public void testCallMatchesArguments() throws Throwable {
		String[] args = { "arg1", "arg2", "arg3" };
		MockConstraint[] constraints = {
			new MockConstraint( "constraint1", args[0], true ),
			new MockConstraint( "constraint2", args[1], true ),
			new MockConstraint( "constraint3", args[2], true )
		};
		ExpectedCall call = new ExpectedCall( methodName, (Constraint[])constraints, new ReturnStub("ignored") );
		
		assertTrue( "call matches", call.matches( methodName, args) );
	}
	
	public void testCallDoesNotMatchWhenWrongName() throws Throwable {
		ExpectedCall call = new ExpectedCall( methodName, new Constraint[0], new ReturnStub("ignored") );
		assertFalse( "call does not match", call.matches( "anotherName", new Object[0]) );
	}
	
	public void testCallDoesNotMatchWhenWrongNumberOfArguments() throws Throwable {
		String[] args = { "arg1", "arg2" };
		MockConstraint[] constraints = {
			new MockConstraint( "constraint1", args[0], true ),
			new MockConstraint( "constraint2", args[1], true ),
			new MockConstraint( "constraint3", args[1], true )
		};
		
		ExpectedCall call = new ExpectedCall( methodName, (Constraint[])constraints, new ReturnStub("ignored") );

		assertFalse( "call does not match", call.matches( methodName, args) );
	}
	
	public void testCallDoesNotMatchWhenConstraintIsViolated() throws Throwable {
		String[] args = { "argA", "argB", "argC" };
		MockConstraint[] constraints = {
			new MockConstraint( "constraintA", args[0], true ),
			new MockConstraint( "constraintB", args[1], false ),
			new MockConstraint( "constraintC", args[2], true )
		};
		
		ExpectedCall call = new ExpectedCall( methodName, (Constraint[])constraints, new ReturnStub("ignored") );

		assertFalse( "call does not match", call.matches( methodName, args) );
	}

	public void testMatchesAfterCalls() throws Throwable {
		ExpectedCall call = new ExpectedCall(methodName, C.args(), new ReturnStub("ignored") );
		
		call.call( mock, methodName, new Object[0] );
		assertTrue( "matches after first call", call.matches( methodName, new Object[0]) );
		call.call( mock, methodName, new Object[0] );
		assertTrue( "matches after further calls", call.matches( methodName, new Object[0]) );
	}
}

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

import com.mockobjects.dynamic.*;

import junit.framework.*;

/**
 * @author dev
 */
public class StubTest extends TestCase {

	public StubTest(String name) {
		super(name);
	}
	
	public void testReturnStub() throws Throwable {
		final String result = "result";
		
		ReturnStub stub = new ReturnStub(result);
		String ignoredMethodName = "methodName";
		Mock ignoredMock = null;
		Object[] ignoredArgs = new Object[0];
		
		assertSame( "Should be the same result object",
					result, stub.call( ignoredMock, ignoredMethodName, ignoredArgs ) );
	}

	public void testThrowStub() {
		final Throwable throwable = new DummyThrowable();
		
		ThrowStub stub = new ThrowStub(throwable);
		String ignoredMethodName = "methodName";
		Mock ignoredMock = null;
		Object[] ignoredArgs = new Object[0];
		
		try {
			stub.call( ignoredMock, ignoredMethodName, ignoredArgs );
		}
		catch( Throwable t ) {
			assertSame( "Should be the same throwable", throwable, t );
		}
	}
}

Index: MockTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockTest.java,v
retrieving revision 1.8.2.1
retrieving revision 1.8.2.2
diff -u -r1.8.2.1 -r1.8.2.2
--- MockTest.java	4 Apr 2003 16:47:39 -0000	1.8.2.1
+++ MockTest.java	7 Apr 2003 14:26:57 -0000	1.8.2.2
@@ -1,8 +1,5 @@
 /*
  * Created on 04-Apr-2003
- *
- * To change this generated comment go to 
- * Window>Preferences>Java>Code Generation>Code and Comments
  */
 package test.mockobjects.dynamic;
 
@@ -13,14 +10,11 @@
 
 /**
  * @author dev
- *
- * To change this generated comment go to 
- * Window>Preferences>Java>Code Generation>Code and Comments
  */
 public class MockTest extends TestCase {
 
 	private Mock aMock;
-	private TestInterface proxy;
+	private DummyInterface proxy;
 	private static final String MOCK_NAME = "Test mock";
 	
 	public MockTest(String name) {
@@ -28,9 +22,9 @@
 	}
 	
 	public void setUp() {
-		aMock = new Mock( TestInterface.class, MOCK_NAME );
+		aMock = new Mock( DummyInterface.class, MOCK_NAME );
 		try {
-			proxy = (TestInterface)aMock.proxy();
+			proxy = (DummyInterface)aMock.proxy();
 		}
 		catch( ClassCastException ex ) {
 			fail("proxy is not of expected interface type");
@@ -42,120 +36,62 @@
 	}
 	
 	public void testMockNameFromClass() throws Exception {
-		assertEquals( "mock-String", Mock.mockNameFromClass(String.class) );
+		assertEquals( "mockString", Mock.mockNameFromClass(String.class) );
 	}
 	
-	public void testVerifyFailsIfExpectedCallNotCalled() throws Throwable {
-		aMock.expect( new CallMocker() {
-			public void verify() { throw new AssertionFailedError("example error"); }
-			public boolean matches(String methodName, Object[] args) {
-							return false;
-						}
-			public Object call(Mock mock, String methodName, Object[] args) {
-				return null;
-			}
-		} );
-		
-		try {
-			aMock.verify();
-		}
-		catch( AssertionFailedError ex ) {
-			AssertMo.assertIncludes( "mock name should be in exception message", 
-									 MOCK_NAME, ex.getMessage() );
-			return;
-		}
-		fail("verify should have failed");
-	}
-
-	public void testVerifiesIfExpectedCallIsCalled() throws Throwable {
-		aMock.expect( new CallMocker() {
-			public void verify() {}
-			public boolean matches(String methodName, Object[] args) {
-							return false;
-						}
-
-			public Object call(Mock mock, String methodName, Object[] args) {
-				return null;
-			}
-		} );
-		
-		proxy.aMethod( "hello", "world" );		
-		aMock.verify();
+	public void testMockToStringContainsName() {
+		AssertMo.assertIncludes( "result of toString() should include name",
+								 MOCK_NAME, aMock.toString() );
 	}
-
+	
 	public void testCallMockerReceivesArgumentsFromProxy() throws Throwable {
+		final String methodName = "aMethod";
 		final String[] expectedArgs = { "hello", "world" };
 		final String[] receivedArgs = new String[2];
 		
-		aMock.expect( new CallMocker() {
-			public void verify() {}
-			public boolean matches(String methodName, Object[] args) {
-							return false;
-						}
-
-			public Object call(Mock mock, String methodName, Object[] args) {
-				assertEquals( "should be expected number of args", expectedArgs.length, args.length );
-				System.arraycopy( args, 0, receivedArgs, 0, args.length );
-				return null;
-			}
-		} );
+		MockCallMocker mockMethod = new MockCallMocker();
+		mockMethod.setExpectedMatches( methodName, expectedArgs );
+		mockMethod.setupMatchesReturn(true);
+		mockMethod.setExpectedCall( aMock, methodName, expectedArgs );
+		mockMethod.setupCallReturn( "result ignored" );
+		
+		aMock.expect( mockMethod );
 				
 		proxy.aMethod( expectedArgs[0], expectedArgs[1] );
-		for( int i = 0; i < expectedArgs.length; i++ ) {
-			assertSame( "arg " + (i+1), expectedArgs[i], receivedArgs[i] );
-		}
+		
+		mockMethod.verifyExpectations();
 	}
 	
 	public void testCallMockerReceivesEmptyArrayWhenNoArguments() throws Exception {
-		aMock.expect( new CallMocker() {
-			public void verify() {}
-			public boolean matches(String methodName, Object[] args) {
-							return false;
-						}
-			public Object call( Mock mock, String methodName, Object[] args ) {
-				assertNotNull( "Arg array should not be null", args );
-				assertEquals( "Arg array should have zero length", 0, args.length );
-				return null;
-			}
-		} );
+		final String methodName = "aMethodWithNoArguments";
+		final Object[] expectedArgs = {};
+		
+		MockCallMocker mockMethod = new MockCallMocker();
+		mockMethod.setExpectedMatches( methodName, expectedArgs );
+		mockMethod.setupMatchesReturn(true);
+		mockMethod.setExpectedCall( aMock, methodName, expectedArgs );
+		mockMethod.setupCallReturn( "result ignored" );
 		
+		aMock.expect( mockMethod );
+
 		proxy.aMethodWithNoArguments();
+		
+		mockMethod.verifyExpectations();
 	}
 	
 	public void testCallMockerResultReturnedByProxy() throws Throwable {
 		final String result = "result";
 		
-		aMock.expect( new CallMocker() {
-			public void verify() {}
-
-			public Object call(Mock mock, String methodName, Object[] args) {
-				return result;
-			}
-
-			public boolean matches(String methodName, Object[] args) {
-				return false;
-			}
-		} );
+		aMock.expect( new ReturnStub(result) );
 		
 		assertSame( "result is returned by mock", 
 					result, proxy.aMethod( "hello", "world" ) );		
 	}
 
 	public void testCallMockerThrowableThrownThroughProxy() throws Throwable {
-		final Throwable throwable = new TestThrowable();
+		final Throwable throwable = new DummyThrowable();
 		
-		aMock.expect( new CallMocker() {
-			public void verify() {}
-			public boolean matches(String methodName, Object[] args) {
-							return false;
-						}
-
-			public Object call(Mock mock, String methodName, Object[] args) 
-				throws Throwable 
-			{
-				throw throwable;
-			}
-		} );
+		aMock.expect( new ThrowStub(throwable) );
 		
 		try {
 			proxy.aMethod( "hello", "world" );
@@ -170,18 +106,7 @@
 		final String originalMessage = "original message";
 		final AssertionFailedError error = new AssertionFailedError(originalMessage);
 		
-		aMock.expect( new CallMocker() {
-			public void verify() {}
-			public boolean matches(String methodName, Object[] args) {
-							return false;
-						}
-
-			public Object call(Mock mock, String methodName, Object[] args) 
-				throws Throwable 
-			{
-				throw error;
-			}
-		} );
+		aMock.expect( new ThrowStub(error) );
 		
 		try {
 			proxy.aMethod( "hello", "world" );
@@ -193,30 +118,4 @@
 									 MOCK_NAME, err.getMessage() );
 		}		
 	}
-	
-	public void testMockDispatchesCallToMatchingCallMocker() throws Throwable {
-		final String[] expectedArgs = { "hello", "world" };
-		final String[] receivedArgs = new String[2];
-		
-		aMock.expect( new CallMocker() {
-			public void verify() {}
-			public boolean matches(String methodName, Object[] args) {
-							return false;
-						}
-
-			public Object call(Mock mock, String methodName, Object[] args) {
-				assertEquals( "should be expected number of args", expectedArgs.length, args.length );
-				System.arraycopy( args, 0, receivedArgs, 0, args.length );
-				return null;
-			}
-		} );
-				
-		proxy.aMethod( expectedArgs[0], expectedArgs[1] );
-		
-		for( int i = 0; i < expectedArgs.length; i++ ) {
-			assertSame( "arg " + (i+1), expectedArgs[i], receivedArgs[i] );
-		}
-	}
-	
-
 }

Index: CallSetTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/Attic/CallSetTest.java,v
retrieving revision 1.1.2.1
retrieving revision 1.1.2.2
diff -u -r1.1.2.1 -r1.1.2.2
--- CallSetTest.java	4 Apr 2003 16:47:40 -0000	1.1.2.1
+++ CallSetTest.java	7 Apr 2003 14:27:01 -0000	1.1.2.2
@@ -4,6 +4,7 @@
 package test.mockobjects.dynamic;
 
 import com.mockobjects.dynamic.*;
+import com.mockobjects.util.*;
 
 import junit.framework.*;
 
@@ -13,39 +14,135 @@
 public class CallSetTest extends TestCase {
 	private CallSet callSet = new CallSet();
 	private Mock unusedMock = null;
+	private MockCallMocker methodA = new MockCallMocker();
+	private MockCallMocker methodB = new MockCallMocker();
+	final String methodAName = "methodA";
+	final String[] methodAArgs = new String[] { "a1", "a2" };
+	final String methodAResult = "resultA";
+		
+	final String methodBName = "methodB";
+	final String[] methodBArgs = new String[] { "b1", "b2" };
+	final String methodBResult = "resultB";
+		
 		
 	public CallSetTest(String name) {
 		super(name);
 	}
-
+	
 	public void testEmptySetVerifies() throws Exception {
 		callSet.verify();
 	}
 	
-	public void testSingleItemNotCalledFails() throws Exception {
-		callSet.add(new SingleCall("methodThatWontBeCalled",C.args()));
+	public void testVerifyFailsIfContainedElementDoesNotVerify() throws Exception {
+		methodA.setExpectedVerifyCalls(1);
+		methodA.setupVerifyThrow( new AssertionFailedError("verify failed") );
+		callSet.expect( methodA );
 		
 		try {
 			callSet.verify();
 		} catch (AssertionFailedError ex) {
+			methodA.verifyExpectations();
 			return;
 		}
-		
-		fail("Should have got a failure for a method that wasn't called");
+		fail("Should have got a failure for contained element failing");
 	}
 	
-	public void testSingleItemCalledSuccessfully() throws Throwable {
-		callSet.add(new SingleCall("methodThatWillBeCalled",C.args()));
-		callSet.call( unusedMock, "methodThatWillBeCalled", new Object[0] );
+	public void testVerifiesIfAllContainedElementsVerify() throws Throwable {
+		methodA.setExpectedVerifyCalls(1);
+		methodB.setExpectedVerifyCalls(1);
+		
+		callSet.expect( methodA );
+		callSet.expect( methodB );
 		callSet.verify();
+		
+		methodA.verifyExpectations();
+		methodB.verifyExpectations();
 	}
 	
-	public void testTwoItemsCalledSameOrder() throws Throwable {
-		callSet.add(new SingleCall("methodA",C.args()));
-		callSet.add(new SingleCall("methodB",C.args()));
-		callSet.call( unusedMock, "methodA", new Object[0] );
-		callSet.call( unusedMock, "methodB", new Object[0] );
-		callSet.verify();
+	public void testCallPassedToContainedElements() throws Throwable {
+		methodA.setExpectedMatches( methodAName, methodAArgs );
+		methodA.setupMatchesReturn(true);
+		methodA.setExpectedCall( unusedMock, methodAName, methodAArgs );
+		methodA.setupCallReturn(methodAResult);
+
+		methodB.setExpectedCallCount( 0 );
+		
+		callSet.expect( methodA );
+		callSet.expect( methodB );
+		
+		assertSame( "expected result from method A", 
+		            methodAResult, callSet.call( unusedMock, methodAName, methodAArgs ) );
+					
+		methodA.verifyExpectations();
+		methodB.verifyExpectations();
+	}
+
+	public void testCallPassedToContainedElementsOtherOrder() throws Throwable {
+		methodA.setExpectedMatches( methodBName, methodBArgs );
+		methodA.setupMatchesReturn(false);
+		methodA.setExpectedCallCount( 0 );
+		methodB.setExpectedCall( unusedMock, methodBName, methodBArgs );
+		
+		methodB.setupCallReturn(methodBResult);
+		methodB.setExpectedMatches( methodBName, methodBArgs );
+		methodB.setupMatchesReturn(true);
+		
+		callSet.expect( methodA );
+		callSet.expect( methodB );
+		
+		assertSame( "expected result from method B", 
+					methodBResult, callSet.call( unusedMock, methodBName, methodBArgs ) );
+		
+		methodA.verifyExpectations();
+		methodB.verifyExpectations();
+	}
+	
+	public void testFailureIfNoElementMatches() throws Throwable {
+		final String methodCName = "methodC";
+		final String[] methodCArgs = { "c1", "c2" };
+		
+		methodA.setExpectedMatches( methodCName, methodCArgs );
+		methodA.setupMatchesReturn(false);
+		methodA.setExpectedCallCount( 0 );
+		methodA.setupGetDescription("***methodA-toString****");
+		methodB.setExpectedCall( unusedMock, methodCName, methodCArgs );
+		methodB.setupMatchesReturn(false);
+		methodB.setExpectedCallCount( 0 );
+		methodB.setupGetDescription("***methodB-toString****");
+		
+		callSet.expect( methodA );
+		callSet.expect( methodB );
+		
+		try {
+			callSet.call( unusedMock, methodCName, methodCArgs );
+		} catch (AssertionFailedError ex) {
+			AssertMo.assertIncludes( "method name is in error message",
+									 "methodC", ex.getMessage() );
+			AssertMo.assertIncludes( "argument is in error message (1)", 
+                                     methodCArgs[0], ex.getMessage() );
+			AssertMo.assertIncludes( "argument is in error message (2)", 
+									 methodCArgs[1], ex.getMessage() );
+            
+			AssertMo.assertIncludes( "shows set contents (A)", 
+									 methodA.toString(), ex.getMessage() );
+			AssertMo.assertIncludes( "shows set contents (B)", 
+									 methodB.toString(), ex.getMessage() );
+			return;
+		}
+		
+		fail("Should fail for a missing item");
+	}
+
+	public void testCallFailsOnEmptySet() throws Throwable {
+		try {
+			callSet.call( unusedMock, "methodC", new Object[] { "arg1", "arg2" } );
+		} catch (AssertionFailedError ex) {
+			AssertMo.assertIncludes( "reports empty set in error message", 
+									 "no methods", ex.getMessage() );
+			return;
+		}
+		
+		fail("Should fail for a missing item");
 	}
 
 }

--- TestInterface.java DELETED ---

--- TestThrowable.java DELETED ---

--- SingleCallTest.java DELETED ---

--- TestConstraint.java DELETED ---