[MO-java-dev] CVS: mockobjects-java/src/core/test/mockobjects/dynamic CallBagTest.java,1.6,1.7

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

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

Modified Files:
	CallBagTest.java 
Log Message:
renamed callSet variable to callBag

Index: CallBagTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/CallBagTest.java,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -r1.6 -r1.7
--- CallBagTest.java	5 Jul 2003 15:15:54 -0000	1.6
+++ CallBagTest.java	5 Jul 2003 16:34:14 -0000	1.7
@@ -19,7 +19,7 @@
 	final String[] METHOD_B_ARGS = new String[] { "b1", "b2" };
 	final ActiveCall METHOD_B_CALL = new ActiveCall(METHOD_B_NAME, METHOD_B_ARGS);
 	
-	private CallBag callSet = new CallBag();
+	private CallBag callBag = new CallBag();
 	
 	private MockCallable methodA = new MockCallable("method a");
 	private MockCallable methodB = new MockCallable("method b");
@@ -32,7 +32,7 @@
 
 	public void testCallFailsOnEmptySet() throws Throwable {
 		try {
-			callSet.call(new ActiveCall("missingMethod", new Object[0]));
+			callBag.call(new ActiveCall("missingMethod", new Object[0]));
 		} catch (AssertionFailedError ex) {
 			AssertMo.assertIncludes("reports empty set in error message", "no methods", ex.getMessage());
 
@@ -44,16 +44,16 @@
 
 	public void testCallPassedToContainedElements() throws Throwable {
 		methodA.setExpectedMatches(METHOD_A_NAME, METHOD_A_ARGS);
-		methodA.setupMatchesReturn(true);
+		methodA.setupAlwaysMatchActiveCall(true);
 		methodA.activeCall.setExpected(METHOD_A_CALL);
 		methodA.setupCallReturn(METHOD_A_RESULT);
 
 		methodB.activeCall.setExpectNothing();
 
-		callSet.addExpect(methodA);
-		callSet.addExpect(methodB);
+		callBag.addExpect(methodA);
+		callBag.addExpect(methodB);
 
-		assertSame("expected result from method A", METHOD_A_RESULT, callSet.call(METHOD_A_CALL));
+		assertSame("expected result from method A", METHOD_A_RESULT, callBag.call(METHOD_A_CALL));
 
 		methodA.verifyExpectations();
 		methodB.verifyExpectations();
@@ -64,29 +64,29 @@
 		Callable methodASignature = new CallSignature(METHOD_A_NAME,METHOD_A_CONSTRAINTS, new ReturnStub("result1"));
 		Callable anotherMethodASignature = new CallSignature(METHOD_A_NAME,METHOD_A_CONSTRAINTS, new ReturnStub("result2"));
 	
-		callSet.addMatch(methodASignature);
-		callSet.addExpect(new CallOnceExpectation(anotherMethodASignature));
+		callBag.addMatch(methodASignature);
+		callBag.addExpect(new CallOnceExpectation(anotherMethodASignature));
 
 		assertSame("expected result from method B, as  expect has precendence over match", "result2",
-			callSet.call(METHOD_A_CALL));
+			callBag.call(METHOD_A_CALL));
 	}
 
 	public void testCallPassedToContainedElementsOtherOrder()
 		throws Throwable {
 		methodA.setExpectedMatches(METHOD_B_NAME, METHOD_B_ARGS);
-		methodA.setupMatchesReturn(false);
+		methodA.setupAlwaysMatchActiveCall(false);
 		methodA.activeCall.setExpectNothing();
 		methodB.activeCall.setExpected(METHOD_B_CALL);
 
 		methodB.setupCallReturn(METHOD_B_RESULT);
 		methodB.setExpectedMatches(METHOD_B_NAME, METHOD_B_ARGS);
-		methodB.setupMatchesReturn(true);
+		methodB.setupAlwaysMatchActiveCall(true);
 
-		callSet.addExpect(methodA);
-		callSet.addExpect(methodB);
+		callBag.addExpect(methodA);
+		callBag.addExpect(methodB);
 
 		assertSame("expected result from method B", METHOD_B_RESULT,
-		    callSet.call(METHOD_B_CALL));
+		    callBag.call(METHOD_B_CALL));
 
 		methodA.verifyExpectations();
 		methodB.verifyExpectations();
@@ -96,31 +96,31 @@
 		final String result = "result";
 
 		mockCallable.setupCallReturn(result);
-		mockCallable.setupMatchesReturn(true);
+		mockCallable.setupAlwaysMatchActiveCall(true);
 		
-		callSet.addExpect(mockCallable);
+		callBag.addExpect(mockCallable);
 
-		assertSame("result is returned by mock", result, callSet.call(new ActiveCall("method", new Object[0])));
+		assertSame("result is returned by mock", result, callBag.call(new ActiveCall("method", new Object[0])));
 	}
 
 	public void testCallableThrowableThrown()
 		throws Throwable {
 		final Throwable throwable = new DummyThrowable();
 
-		mockCallable.setupMatchesReturn(true);
+		mockCallable.setupAlwaysMatchActiveCall(true);
 		mockCallable.setupCallThrow(throwable);
 		
-		callSet.addExpect(mockCallable);
+		callBag.addExpect(mockCallable);
 
 		try {
-			callSet.call(new ActiveCall("hello", new String[0]));
+			callBag.call(new ActiveCall("anyMethod", new String[0]));
 		} catch (Throwable ex) {
-			assertSame("exception is caught by mock", throwable, ex);
+			assertSame("exception was thrown by mock", throwable, ex);
 		}
 	}
 
 	public void testEmptySetVerifies() throws Exception {
-		callSet.verify();
+		callBag.verify();
 	}
 
 	public void testFailureIfNoElementMatches() throws Throwable {
@@ -129,19 +129,19 @@
 		final ActiveCall methodCCall = new ActiveCall(methodCName, methodCArgs);
 
 		methodA.setExpectedMatches(methodCName, methodCArgs);
-		methodA.setupMatchesReturn(false);
+		methodA.setupAlwaysMatchActiveCall(false);
 		methodA.activeCall.setExpectNothing();
 		methodA.setupGetDescription("***methodA-description****");
 		methodB.activeCall.setExpected(methodCCall);
-		methodB.setupMatchesReturn(false);
+		methodB.setupAlwaysMatchActiveCall(false);
 		methodB.activeCall.setExpectNothing();
 		methodB.setupGetDescription("***methodB-description****");
 
-		callSet.addExpect(methodA);
-		callSet.addExpect(methodB);
+		callBag.addExpect(methodA);
+		callBag.addExpect(methodB);
 
 		try {
-			callSet.call(methodCCall);
+			callBag.call(methodCCall);
 		} 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());
@@ -161,9 +161,9 @@
 		methodA.setExpectedVerifyCalls(1);
 		methodB.setExpectedVerifyCalls(1);
 
-		callSet.addExpect(methodA);
-		callSet.addExpect(methodB);
-		callSet.verify();
+		callBag.addExpect(methodA);
+		callBag.addExpect(methodB);
+		callBag.verify();
 
 		methodA.verifyExpectations();
 		methodB.verifyExpectations();
@@ -173,10 +173,10 @@
 		throws Exception {
 		methodA.setExpectedVerifyCalls(1);
 		methodA.setupVerifyThrow(new AssertionFailedError("verify failed"));
-		callSet.addExpect(methodA);
+		callBag.addExpect(methodA);
 
 		try {
-			callSet.verify();
+			callBag.verify();
 		} catch (AssertionFailedError ex) {
 			methodA.verifyExpectations();