Menu
▾
▴
[MO-java-dev] CVS: mockobjects-java/src/core/test/mockobjects/dynamic CallOnceExpectationTest.java,1.2,1.3 StubTest.java,1.3,1.4 MockTest.java,1.13,1.14 CallBagTest.java,1.5,1.6 CallMatchTest.java,1.4,1.5 MockCallableAddable.java,1.3,1.4 CallSequenceTest.java,1.9,1.10 MockCallable.java,1.3,1.4
|
From: Steve F. <sm...@us...> - 2003-07-05 15:15:57
|
Update of /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic
In directory sc8-pr-cvs1:/tmp/cvs-serv21732/src/core/test/mockobjects/dynamic
Modified Files:
CallOnceExpectationTest.java StubTest.java MockTest.java
CallBagTest.java CallMatchTest.java MockCallableAddable.java
CallSequenceTest.java MockCallable.java
Log Message:
Refactored methoName and arguments to ActiveCall object.
Index: CallOnceExpectationTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/CallOnceExpectationTest.java,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- CallOnceExpectationTest.java 12 Jun 2003 22:45:16 -0000 1.2
+++ CallOnceExpectationTest.java 5 Jul 2003 15:15:54 -0000 1.3
@@ -10,11 +10,13 @@
final String RESULT = "result!";
final String METHOD_NAME = "methodName";
- final Object[] ARGS = { "arg1", "arg2" };
+ final Object[] ARGS = { "arg1", "arg2" };
+ final ActiveCall CALL = new ActiveCall(METHOD_NAME, ARGS) ;
+
final String DECORATED_DESCRIPTION = DynamicUtil.methodToString( METHOD_NAME, ARGS );
Mock ignoredMock = null;
- MockCallable mockCallable = new MockCallable();
+ MockCallable mockCallable = new MockCallable("mock callable");
CallOnceExpectation call = new CallOnceExpectation( mockCallable );
public CallOnceExpectationTest(String name) {
@@ -49,7 +51,7 @@
mockCallable.setupCallReturn( RESULT );
mockCallable.setExpectedVerifyCalls(1);
- call.call( METHOD_NAME, ARGS );
+ call.call( CALL );
call.verify();
mockCallable.verifyExpectations();
@@ -58,15 +60,15 @@
public void testMatchesDelegated() throws Throwable {
mockCallable.setExpectedMatches( METHOD_NAME, ARGS );
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.activeCall.setExpected(CALL);
mockCallable.setupCallReturn(RESULT);
- call.call( METHOD_NAME, ARGS );
+ call.call( CALL );
mockCallable.verifyExpectations();
}
@@ -75,16 +77,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 +97,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: StubTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/StubTest.java,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- StubTest.java 12 Jun 2003 22:45:16 -0000 1.3
+++ StubTest.java 5 Jul 2003 15:15:54 -0000 1.4
@@ -3,39 +3,31 @@
*/
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;
-/**
- * @author dev
- */
public class StubTest extends TestCase {
public StubTest(String name) {
super(name);
}
+ ActiveCall stubCall = new ActiveCall("ignoredName", new Object[0]);
+
public void testReturnStub() throws Throwable {
- final String result = "result";
-
- ReturnStub stub = new ReturnStub(result);
- String ignoredMethodName = "methodName";
- Object[] ignoredArgs = new Object[0];
+ final String RESULT = "result";
- assertSame( "Should be the same result object",
- result, stub.call( ignoredMethodName, ignoredArgs ) );
+ assertSame( "Should be the same result object", RESULT, new ReturnStub(RESULT).call( stubCall) );
}
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 );
+ new ThrowStub(throwable).call( stubCall );
}
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.13
retrieving revision 1.14
diff -u -r1.13 -r1.14
--- MockTest.java 2 Jul 2003 03:46:18 -0000 1.13
+++ MockTest.java 5 Jul 2003 15:15:54 -0000 1.14
@@ -29,11 +29,11 @@
private DummyInterface proxy;
private Mock mock;
private MockCallFactory mockCallFactory = new MockCallFactory();
- private MockCallable mockCallMatch = new MockCallable();
- private MockCallable mockExpectedCall = new MockCallable();
- private MockCallable mockReturnStub = new MockCallable();
- private MockCallable mockThrowStub = new MockCallable();
- private MockCallable mockVoidStub = new MockCallable();
+ private MockCallable mockCallMatch = new MockCallable("call match");
+ private MockCallable mockExpectedCall = new MockCallable("expected call");
+ private MockCallable mockReturnStub = new MockCallable("return stub");
+ private MockCallable mockThrowStub = new MockCallable("throw stub");
+ private MockCallable mockVoidStub = new MockCallable("void stub");
private MockCallableAddable mockCallableAddable = new MockCallableAddable();
public MockTest(String name) throws Exception {
Index: CallBagTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/CallBagTest.java,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -r1.5 -r1.6
--- CallBagTest.java 12 Jun 2003 22:45:16 -0000 1.5
+++ CallBagTest.java 5 Jul 2003 15:15:54 -0000 1.6
@@ -13,14 +13,17 @@
final Throwable METHOD_A_EXCEPTION = new DummyThrowable("Configured test throwable");
final String[] METHOD_A_ARGS = new String[] { "a1", "a2" };
+ final ActiveCall METHOD_A_CALL = new ActiveCall(METHOD_A_NAME, METHOD_A_ARGS);
+
final ConstraintMatcher METHOD_A_CONSTRAINTS = C.args(C.eq("a1"), C.eq("a2"));
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 Mock unusedMock = null;
- private MockCallable methodA = new MockCallable();
- private MockCallable methodB = new MockCallable();
- private MockCallable mockCallable = new MockCallable();
+ private MockCallable methodA = new MockCallable("method a");
+ private MockCallable methodB = new MockCallable("method b");
+ private MockCallable mockCallable = new MockCallable("mock callable");
public CallBagTest(String name) {
@@ -29,7 +32,7 @@
public void testCallFailsOnEmptySet() throws Throwable {
try {
- callSet.call("missingMethod", new Object[0]);
+ callSet.call(new ActiveCall("missingMethod", new Object[0]));
} catch (AssertionFailedError ex) {
AssertMo.assertIncludes("reports empty set in error message", "no methods", ex.getMessage());
@@ -42,16 +45,15 @@
public void testCallPassedToContainedElements() throws Throwable {
methodA.setExpectedMatches(METHOD_A_NAME, METHOD_A_ARGS);
methodA.setupMatchesReturn(true);
- methodA.setExpectedCall(unusedMock, METHOD_A_NAME, METHOD_A_ARGS);
+ methodA.activeCall.setExpected(METHOD_A_CALL);
methodA.setupCallReturn(METHOD_A_RESULT);
- methodB.setExpectedCallCount(0);
+ methodB.activeCall.setExpectNothing();
callSet.addExpect(methodA);
callSet.addExpect(methodB);
- assertSame("expected result from method A", METHOD_A_RESULT,
- callSet.call(METHOD_A_NAME, METHOD_A_ARGS));
+ assertSame("expected result from method A", METHOD_A_RESULT, callSet.call(METHOD_A_CALL));
methodA.verifyExpectations();
methodB.verifyExpectations();
@@ -66,15 +68,15 @@
callSet.addExpect(new CallOnceExpectation(anotherMethodASignature));
assertSame("expected result from method B, as expect has precendence over match", "result2",
- callSet.call(METHOD_A_NAME, METHOD_A_ARGS));
+ callSet.call(METHOD_A_CALL));
}
public void testCallPassedToContainedElementsOtherOrder()
throws Throwable {
methodA.setExpectedMatches(METHOD_B_NAME, METHOD_B_ARGS);
methodA.setupMatchesReturn(false);
- methodA.setExpectedCallCount(0);
- methodB.setExpectedCall(unusedMock, METHOD_B_NAME, METHOD_B_ARGS);
+ methodA.activeCall.setExpectNothing();
+ methodB.activeCall.setExpected(METHOD_B_CALL);
methodB.setupCallReturn(METHOD_B_RESULT);
methodB.setExpectedMatches(METHOD_B_NAME, METHOD_B_ARGS);
@@ -84,7 +86,7 @@
callSet.addExpect(methodB);
assertSame("expected result from method B", METHOD_B_RESULT,
- callSet.call(METHOD_B_NAME, METHOD_B_ARGS));
+ callSet.call(METHOD_B_CALL));
methodA.verifyExpectations();
methodB.verifyExpectations();
@@ -98,7 +100,7 @@
callSet.addExpect(mockCallable);
- assertSame("result is returned by mock", result, callSet.call("method", new Object[0]));
+ assertSame("result is returned by mock", result, callSet.call(new ActiveCall("method", new Object[0])));
}
public void testCallableThrowableThrown()
@@ -111,7 +113,7 @@
callSet.addExpect(mockCallable);
try {
- callSet.call("hello", new String[0]);
+ callSet.call(new ActiveCall("hello", new String[0]));
} catch (Throwable ex) {
assertSame("exception is caught by mock", throwable, ex);
}
@@ -124,21 +126,22 @@
public void testFailureIfNoElementMatches() throws Throwable {
final String methodCName = "methodC";
final String[] methodCArgs = { "c1", "c2" };
+ final ActiveCall methodCCall = new ActiveCall(methodCName, methodCArgs);
methodA.setExpectedMatches(methodCName, methodCArgs);
methodA.setupMatchesReturn(false);
- methodA.setExpectedCallCount(0);
+ methodA.activeCall.setExpectNothing();
methodA.setupGetDescription("***methodA-description****");
- methodB.setExpectedCall(unusedMock, methodCName, methodCArgs);
+ methodB.activeCall.setExpected(methodCCall);
methodB.setupMatchesReturn(false);
- methodB.setExpectedCallCount(0);
+ methodB.activeCall.setExpectNothing();
methodB.setupGetDescription("***methodB-description****");
callSet.addExpect(methodA);
callSet.addExpect(methodB);
try {
- callSet.call(methodCName, methodCArgs);
+ callSet.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());
Index: CallMatchTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/CallMatchTest.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- CallMatchTest.java 12 Jun 2003 22:45:15 -0000 1.4
+++ CallMatchTest.java 5 Jul 2003 15:15:54 -0000 1.5
@@ -9,10 +9,12 @@
public class CallMatchTest extends TestCase {
- private static final Object[] IGNORED_ARGS = new Object[0];
final String METHOD_NAME = "methodName";
+ final Object[] IGNORED_ARGS = new Object[0];
+ final ActiveCall CALL = new ActiveCall(METHOD_NAME, IGNORED_ARGS);
+
Mock mock = new Mock(DummyInterface.class, "mock");
- MockCallable mockCallable = new MockCallable();
+ MockCallable mockCallable = new MockCallable("mock callable");
MockConstraintMatcher mockConstraintMatcher = new MockConstraintMatcher();
CallSignature callSignature = new CallSignature(METHOD_NAME, mockConstraintMatcher, mockCallable);
@@ -22,13 +24,12 @@
public void testCallArgumentsArePropagatedToDecorated()
throws Throwable {
- final Object[] arguments = IGNORED_ARGS;
final String result = "result";
- mockCallable.setExpectedCall(mock, METHOD_NAME, arguments);
+ mockCallable.activeCall.setExpected(CALL);
mockCallable.setupCallReturn(result);
- callSignature.call(METHOD_NAME, arguments);
+ callSignature.call(CALL);
mockCallable.verifyExpectations();
}
@@ -45,7 +46,7 @@
mockCallable.setExpectedVerifyCalls(1);
mockCallable.setupCallReturn("result");
- callSignature.call("methodName", IGNORED_ARGS);
+ callSignature.call(CALL);
callSignature.verify();
mockCallable.verifyExpectations();
@@ -54,8 +55,8 @@
public void testMultipleCallsSucceed() throws Throwable {
mockCallable.setupCallReturn("result");
- callSignature.call(METHOD_NAME, IGNORED_ARGS);
- callSignature.call(METHOD_NAME, IGNORED_ARGS);
+ callSignature.call(CALL);
+ callSignature.call(CALL);
mockCallable.verifyExpectations();
}
@@ -65,7 +66,7 @@
}
public void testCallDoesNotMatchWhenWrongName() throws Throwable {
- assertFalse("call does not match", callSignature.matches("anotherName", IGNORED_ARGS));
+ assertFalse("call does not match", callSignature.matches(new ActiveCall("anotherName", IGNORED_ARGS)));
mockCallable.verifyExpectations();
}
@@ -75,10 +76,10 @@
mockConstraintMatcher.setupMatches(true);
- callSignature.call(METHOD_NAME, IGNORED_ARGS);
- assertTrue("matches after first call", callSignature.matches(METHOD_NAME, IGNORED_ARGS));
- callSignature.call(METHOD_NAME, IGNORED_ARGS);
- assertTrue("matches after further calls", callSignature.matches(METHOD_NAME, IGNORED_ARGS));
+ callSignature.call(CALL);
+ assertTrue("matches after first call", callSignature.matches( CALL ));
+ callSignature.call(CALL);
+ assertTrue("matches after further calls", callSignature.matches( CALL ));
mockCallable.verifyExpectations();
}
@@ -90,13 +91,13 @@
mockConstraintMatcher.addExpectedMatches(args);
mockConstraintMatcher.setupMatches(true);
- assertTrue("matches delegated to constraint matcher", callSignature.matches(METHOD_NAME, args));
+ assertTrue("matches delegated to constraint matcher", callSignature.matches(new ActiveCall(METHOD_NAME, args)));
mockConstraintMatcher.verify();
}
public void testMatchesFailure() throws Throwable {
mockConstraintMatcher.setupMatches(false);
- assertFalse("Should not match if constraint matcher doesn't", callSignature.matches(METHOD_NAME, IGNORED_ARGS));
+ assertFalse("Should not match if constraint matcher doesn't", callSignature.matches(CALL));
}
}
Index: MockCallableAddable.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockCallableAddable.java,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- MockCallableAddable.java 12 Jun 2003 22:45:15 -0000 1.3
+++ MockCallableAddable.java 5 Jul 2003 15:15:54 -0000 1.4
@@ -4,6 +4,7 @@
import com.mockobjects.ExpectationList;
import com.mockobjects.MockObject;
import com.mockobjects.ReturnValues;
+import com.mockobjects.dynamic.ActiveCall;
import com.mockobjects.dynamic.Callable;
import com.mockobjects.dynamic.CallableAddable;
import com.mockobjects.util.NotImplementedException;
@@ -65,10 +66,10 @@
myMatchesParameter1Values.addExpected(arg1);
}
- public boolean matches(String arg0, Object[] arg1) {
+ public boolean matches(ActiveCall call) {
myMatchesCalls.inc();
- myMatchesParameter0Values.addActual(arg0);
- myMatchesParameter1Values.addActual(arg1);
+ myMatchesParameter0Values.addActual(call.getMethodName());
+ myMatchesParameter1Values.addActual(call.args);
Object nextReturnValue = myActualMatchesReturnValues.getNext();
@@ -104,11 +105,11 @@
myCallArguments.addExpectedMany(args);
}
- public Object call(String methodName, Object[] args)
+ public Object call(ActiveCall call)
throws Throwable {
myCallCalls.inc();
- myCallMethodNames.addActual(methodName);
- myCallArguments.addActualMany(args);
+ myCallMethodNames.addActual(call.getMethodName());
+ myCallArguments.addActualMany(call.args);
Object nextReturnValue = myActualCallReturnValues.getNext();
Index: CallSequenceTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/CallSequenceTest.java,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -r1.9 -r1.10
--- CallSequenceTest.java 12 Jun 2003 22:45:16 -0000 1.9
+++ CallSequenceTest.java 5 Jul 2003 15:15:54 -0000 1.10
@@ -9,7 +9,6 @@
import com.mockobjects.dynamic.CallSequence;
import com.mockobjects.dynamic.Callable;
import com.mockobjects.dynamic.CallOnceExpectation;
-import com.mockobjects.dynamic.Mock;
import com.mockobjects.dynamic.ReturnStub;
import com.mockobjects.util.AssertMo;
@@ -25,13 +24,16 @@
final String METHOD_B_RESULT = "resultB";
final Throwable METHOD_A_EXCEPTION = new DummyThrowable("Configured test throwable");
final String[] METHOD_A_ARGS = new String[] { "a1", "a2" };
+ final ActiveCall METHOD_A_CALL = new ActiveCall(METHOD_A_NAME, METHOD_A_ARGS);
+
final ConstraintMatcher METHOD_A_CONSTRAINTS = C.args(C.eq("a1"), C.eq("a2"));
final String[] METHOD_B_ARGS = new String[] { "b1", "b2" };
+ final ActiveCall METHOD_B_CALL = new ActiveCall(METHOD_B_NAME, METHOD_B_ARGS);
+
private CallSequence callSequence = new CallSequence();
- private Mock unusedMock = null;
- private MockCallable methodA = new MockCallable();
- private MockCallable methodB = new MockCallable();
- private MockCallable mockCallable = new MockCallable();
+ private MockCallable methodA = new MockCallable("method a");
+ private MockCallable methodB = new MockCallable("method b");
+ private MockCallable mockCallable = new MockCallable("mock callable");
public CallSequenceTest(String name) {
super(name);
@@ -46,7 +48,7 @@
callSequence.addExpect(mockCallable);
try {
- callSequence.call("hello", new String[0]);
+ callSequence.call(new ActiveCall("hello", new String[0]));
} catch (Throwable ex) {
assertSame("exception is caught by mock", throwable, ex);
}
@@ -54,7 +56,7 @@
public void testCallFailsOnEmptyList() throws Throwable {
try {
- callSequence.call("missingMethod", new Object[0]);
+ callSequence.call(new ActiveCall("missingMethod", new Object[0]));
} catch (AssertionFailedError ex) {
AssertMo.assertIncludes("reports empty set in error message", "no methods", ex.getMessage());
@@ -68,10 +70,10 @@
mockCallable.setupMatchesReturn(true);
mockCallable.setupCallReturn(METHOD_A_RESULT);
callSequence.addExpect(mockCallable);
- callSequence.call("willdefinitelyMatch", new Object[0]);
+ callSequence.call(new ActiveCall("willdefinitelyMatch", new Object[0]));
try {
- callSequence.call("oneMethodTooMany", new Object[0]);
+ callSequence.call(new ActiveCall("oneMethodTooMany", new Object[0]));
} catch (AssertionFailedError ex) {
AssertMo.assertIncludes("reports one method call too many", "too many", ex.getMessage());
@@ -84,15 +86,15 @@
public void testCallPassedToContainedElements() throws Throwable {
methodA.setExpectedMatches(METHOD_A_NAME, METHOD_A_ARGS);
methodA.setupMatchesReturn(true);
- methodA.setExpectedCall(unusedMock, METHOD_A_NAME, METHOD_A_ARGS);
+ methodA.activeCall.setExpected(METHOD_A_CALL);
methodA.setupCallReturn(METHOD_A_RESULT);
- methodB.setExpectedCallCount(0);
+ methodB.activeCall.setExpectNothing();
callSequence.addExpect(methodA);
callSequence.addExpect(methodB);
- assertSame("expected result from method A", METHOD_A_RESULT, callSequence.call(METHOD_A_NAME, METHOD_A_ARGS));
+ assertSame("expected result from method A", METHOD_A_RESULT, callSequence.call(METHOD_A_CALL));
methodA.verifyExpectations();
methodB.verifyExpectations();
@@ -109,7 +111,7 @@
callSequence.addExpect(methodB);
try {
- assertSame("expected result from method B", METHOD_B_RESULT, callSequence.call(METHOD_B_NAME, METHOD_B_ARGS));
+ assertSame("expected result from method B", METHOD_B_RESULT, callSequence.call(METHOD_B_CALL));
} catch (AssertionFailedError ex) {
String message = ex.getMessage();
AssertMo.assertIncludes("Should have expected error message", "Unexpected call: methodB", message);
@@ -135,7 +137,7 @@
callSequence.addExpect(mockCallable);
- assertSame("result is returned by mock", result, callSequence.call("method", new Object[0]));
+ assertSame("result is returned by mock", result, callSequence.call(new ActiveCall("method", new Object[0])));
}
public void testEmptySetVerifies() throws Exception {
@@ -145,21 +147,22 @@
public void testFailureIfNoElementMatches() throws Throwable {
final String methodCName = "methodC";
final String[] methodCArgs = { "c1", "c2" };
-
+ final ActiveCall methodCCall = new ActiveCall(methodCName, methodCArgs);
+
methodA.setExpectedMatches(methodCName, methodCArgs);
methodA.setupMatchesReturn(false);
- methodA.setExpectedCallCount(0);
+ methodA.activeCall.setExpectNothing();
methodA.setupGetDescription("***methodA-description****");
- methodB.setExpectedCall(unusedMock, methodCName, methodCArgs);
+ methodB.activeCall.setExpected(methodCCall);
methodB.setupMatchesReturn(false);
- methodB.setExpectedCallCount(0);
+ methodB.activeCall.setExpectNothing();
methodB.setupGetDescription("***methodB-description****");
callSequence.addExpect(methodA);
callSequence.addExpect(methodB);
try {
- callSequence.call(methodCName, methodCArgs);
+ callSequence.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());
@@ -213,6 +216,6 @@
callSequence.addExpect(new CallOnceExpectation(anotherMethodASignature));
assertSame("expected result from method B, as expect has precendence over match", "result2",
- callSequence.call(METHOD_A_NAME, METHOD_A_ARGS));
+ callSequence.call(METHOD_A_CALL));
}
}
Index: MockCallable.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockCallable.java,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- MockCallable.java 12 Jun 2003 22:45:16 -0000 1.3
+++ MockCallable.java 5 Jul 2003 15:15:54 -0000 1.4
@@ -1,17 +1,21 @@
package test.mockobjects.dynamic;
-import junit.framework.*;
+import junit.framework.AssertionFailedError;
-import com.mockobjects.*;
+import com.mockobjects.ExpectationCounter;
+import com.mockobjects.ExpectationList;
+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");
+ final public String name;
+
+ public ExpectationValue activeCall = new ExpectationValue("call") ;
+
private ReturnValue callResult = new ReturnValue("call.return");
private Throwable callThrow = null;
@@ -25,14 +29,8 @@
private ReturnValue toStringResult = new ReturnValue("toString.return");
-
- public void setExpectedCallCount( int count ) {
- callCount.setExpected(count);
- }
-
- public void setExpectedCall( Mock mock, String methodName, Object[] args ) {
- callMethodName.setExpected(methodName);
- callArgs.addExpectedMany(args);
+ public MockCallable(String name) {
+ this.name = name;
}
public void setupCallReturn( Object result ) {
@@ -43,11 +41,9 @@
callThrow = thrown;
}
- public Object call(String methodName, Object[] args) throws Throwable {
- callMethodName.setActual(methodName);
- callArgs.addActualMany(args);
- callCount.inc();
-
+ public Object call(ActiveCall anActiveCall) throws Throwable {
+ activeCall.setActual(anActiveCall);
+
if( callThrow != null ) {
throw callThrow;
} else {
@@ -68,9 +64,9 @@
matchesResult.setValue(result);
}
- public boolean matches(String methodName, Object[] args) {
- matchesMethodName.setActual(methodName);
- matchesArgs.addActualMany(args);
+ public boolean matches(ActiveCall call) {
+ matchesMethodName.setActual(call.getMethodName());
+ matchesArgs.addActualMany(call.args);
matchesCount.inc();
return matchesResult.getBooleanValue();
}
@@ -103,5 +99,9 @@
public String getDescription() {
return (String)toStringResult.getValue();
+ }
+
+ public String toString() {
+ return "MockCallable " + name;
}
}
|
