Menu
▾
▴
[MO-java-dev] CVS: mockobjects-java/src/core/test/mockobjects/dynamic MockTest.java,1.9,1.10 CallBagTest.java,1.2,1.3 MockCallFactory.java,1.2,1.3 CallSequenceTest.java,1.6,1.7 CallMatchTest.java,1.2,1.3
Update of /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic
In directory sc8-pr-cvs1:/tmp/cvs-serv25099/core/test/mockobjects/dynamic
Modified Files:
MockTest.java CallBagTest.java MockCallFactory.java
CallSequenceTest.java CallMatchTest.java
Log Message:
Renamed internal class CallMatch to CallSignature - to avoid
confusion with MatchAndReturn
Index: MockTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockTest.java,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -r1.9 -r1.10
--- MockTest.java 18 May 2003 20:59:39 -0000 1.9
+++ MockTest.java 19 May 2003 23:37:49 -0000 1.10
@@ -53,8 +53,8 @@
public void testExpectManyAndVoid() throws Throwable {
mockCallFactory.setExpectedCreateVoidStubCalls(1);
mockCallFactory.setupCreateVoidStub(mockVoidStub);
- mockCallFactory.addExpectedCreateCallMatch(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockVoidStub);
- mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockVoidStub);
+ mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
@@ -69,8 +69,8 @@
public void testExpectNoneAndReturn() throws Throwable {
mockCallFactory.addExpectedCreateReturnStub(METHOD_NOARGANDRETURN_RESULT);
mockCallFactory.setupCreateReturnStub(mockReturnStub);
- mockCallFactory.addExpectedCreateCallMatch(METHOD_NOARGANDRETURN_NAME, C.NO_ARGS, mockReturnStub);
- mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARGANDRETURN_NAME, C.NO_ARGS, mockReturnStub);
+ mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
@@ -85,8 +85,8 @@
public void testExpectNoneAndThrow() throws Throwable {
mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
mockCallFactory.setupCreateThrowStub(mockThrowStub);
- mockCallFactory.addExpectedCreateCallMatch(METHOD_NOARGANDRETURN_NAME, C.NO_ARGS, mockThrowStub);
- mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARGANDRETURN_NAME, C.NO_ARGS, mockThrowStub);
+ mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
@@ -101,8 +101,8 @@
public void testExpectOneAndThrow() throws Throwable {
mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
mockCallFactory.setupCreateThrowStub(mockThrowStub);
- mockCallFactory.addExpectedCreateCallMatch(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub);
- mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub);
+ mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
@@ -117,8 +117,8 @@
public void testExpectNoneAndVoid() throws Throwable {
mockCallFactory.setExpectedCreateVoidStubCalls(1);
mockCallFactory.setupCreateVoidStub(mockVoidStub);
- mockCallFactory.addExpectedCreateCallMatch(METHOD_NOARG_NAME, C.NO_ARGS, mockVoidStub);
- mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARG_NAME, C.NO_ARGS, mockVoidStub);
+ mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
@@ -133,8 +133,8 @@
public void testExpectOneAndVoid() throws Throwable {
mockCallFactory.setExpectedCreateVoidStubCalls(1);
mockCallFactory.setupCreateVoidStub(mockVoidStub);
- mockCallFactory.addExpectedCreateCallMatch(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
- mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
+ mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
@@ -148,8 +148,8 @@
public void testExpectWithConstraint() throws Throwable {
mockCallFactory.setupCreateVoidStub(mockVoidStub);
- mockCallFactory.addExpectedCreateCallMatch(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
- mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
+ mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
@@ -162,8 +162,8 @@
public void testExpectWithConstraintArray() throws Throwable {
mockCallFactory.setupCreateVoidStub(mockVoidStub);
- mockCallFactory.addExpectedCreateCallMatch(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
- mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
+ mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
@@ -178,8 +178,8 @@
public void testExpectManyAndReturn() throws Throwable {
mockCallFactory.addExpectedCreateReturnStub(METHOD_TWOARG_RESULT);
mockCallFactory.setupCreateReturnStub(mockReturnStub);
- mockCallFactory.addExpectedCreateCallMatch(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockReturnStub);
- mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockReturnStub);
+ mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
@@ -195,8 +195,8 @@
public void testExpectManyAndThrow() throws Throwable {
mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
mockCallFactory.setupCreateThrowStub(mockThrowStub);
- mockCallFactory.addExpectedCreateCallMatch(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockThrowStub);
- mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockThrowStub);
+ mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
@@ -212,8 +212,8 @@
public void testExpectOneAndReturn() throws Throwable {
mockCallFactory.addExpectedCreateReturnStub(METHOD_ONEARG_RESULT);
mockCallFactory.setupCreateReturnStub(mockReturnStub);
- mockCallFactory.addExpectedCreateCallMatch(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub);
- mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub);
+ mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
@@ -229,8 +229,8 @@
public void testMatchManyAndReturn() throws Throwable {
mockCallFactory.addExpectedCreateReturnStub(METHOD_TWOARG_RESULT);
mockCallFactory.setupCreateReturnStub(mockReturnStub);
- mockCallFactory.addExpectedCreateCallMatch(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockReturnStub);
- mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockReturnStub);
+ mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallableAddable.addExpectedAddMatch(mockCallMatch);
mockCallableAddable.setupCall(METHOD_TWOARG_RESULT);
@@ -244,8 +244,8 @@
public void testMatchNoneAndThrow() throws Throwable {
mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
mockCallFactory.setupCreateThrowStub(mockThrowStub);
- mockCallFactory.addExpectedCreateCallMatch(METHOD_NOARG_NAME, C.NO_ARGS, mockThrowStub);
- mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARG_NAME, C.NO_ARGS, mockThrowStub);
+ mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallableAddable.addExpectedAddMatch(mockCallMatch);
mockCallableAddable.setupCall(METHOD_NOARGANDRETURN_RESULT);
@@ -259,8 +259,8 @@
public void testMatchOneAndThrow() throws Throwable {
mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
mockCallFactory.setupCreateThrowStub(mockThrowStub);
- mockCallFactory.addExpectedCreateCallMatch(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub);
- mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub);
+ mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallableAddable.addExpectedAddMatch(mockCallMatch);
mockCallableAddable.setupCall(METHOD_ONEARG_RESULT);
@@ -274,8 +274,8 @@
public void testMatchManyAndThrow() throws Throwable {
mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
mockCallFactory.setupCreateThrowStub(mockThrowStub);
- mockCallFactory.addExpectedCreateCallMatch(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockThrowStub);
- mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockThrowStub);
+ mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallableAddable.addExpectedAddMatch(mockCallMatch);
mockCallableAddable.setupCall(METHOD_TWOARG_RESULT);
@@ -289,8 +289,8 @@
public void testMatchOneAndReturn() throws Throwable {
mockCallFactory.addExpectedCreateReturnStub(METHOD_ONEARG_RESULT);
mockCallFactory.setupCreateReturnStub(mockReturnStub);
- mockCallFactory.addExpectedCreateCallMatch(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub);
- mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub);
+ mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallableAddable.addExpectedAddMatch(mockCallMatch);
mockCallableAddable.setupCall(METHOD_ONEARG_RESULT);
@@ -304,8 +304,8 @@
public void testMatchNoneAndReturn() throws Throwable {
mockCallFactory.addExpectedCreateReturnStub(METHOD_NOARGANDRETURN_RESULT);
mockCallFactory.setupCreateReturnStub(mockReturnStub);
- mockCallFactory.addExpectedCreateCallMatch(METHOD_NOARG_NAME, C.NO_ARGS, mockReturnStub);
- mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARG_NAME, C.NO_ARGS, mockReturnStub);
+ mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallableAddable.addExpectedAddMatch(mockCallMatch);
mockCallableAddable.setupCall(METHOD_ONEARG_RESULT);
@@ -396,7 +396,7 @@
boolean IGNORED_RESULT = true;
CallStub ret = new ReturnStub(new Boolean(IGNORED_RESULT));
mockCallFactory.setupCreateReturnStub(ret);
- mockCallFactory.setupCreateCallMatch(new CallMatch("call",C.anyArgs(1),ret));
+ mockCallFactory.setupCreateCallSignature(new CallSignature("call",C.anyArgs(1),ret));
mockCallableAddable.setupCall(new Boolean(false));
mock.matchAndReturn("call", C.anyArgs(1), IGNORED_RESULT);
Index: CallBagTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/CallBagTest.java,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- CallBagTest.java 18 May 2003 20:59:38 -0000 1.2
+++ CallBagTest.java 19 May 2003 23:37:49 -0000 1.3
@@ -59,11 +59,11 @@
public void testExpectOverridesMatch() throws Throwable {
- Callable methodAMatch = new CallMatch(METHOD_A_NAME,METHOD_A_CONSTRAINTS, new ReturnStub("result1"));
- Callable anotherMethodAMatch = new CallMatch(METHOD_A_NAME,METHOD_A_CONSTRAINTS, new ReturnStub("result2"));
+ 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(methodAMatch);
- callSet.addExpect(new ExpectedCall(anotherMethodAMatch));
+ callSet.addMatch(methodASignature);
+ callSet.addExpect(new ExpectedCall(anotherMethodASignature));
assertSame("expected result from method B, as expect has precendence over match", "result2",
callSet.call(unusedMock, METHOD_A_NAME, METHOD_A_ARGS));
Index: MockCallFactory.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockCallFactory.java,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- MockCallFactory.java 18 May 2003 20:59:38 -0000 1.2
+++ MockCallFactory.java 19 May 2003 23:37:49 -0000 1.3
@@ -17,11 +17,11 @@
private ExpectationCounter myCreateExpectedCallCalls = new ExpectationCounter("MockCallFactory.createExpectedCall(Callable)");
private ReturnValues myActualCreateExpectedCallReturnValues = new ReturnValues("MockCallFactory.createExpectedCall(Callable)", true);
private ExpectationList myCreateExpectedCallParameter0Values = new ExpectationList("MockCallFactory.createExpectedCall(Callable) com.mockobjects.dynamic.Callable");
- private ExpectationCounter myCreateCallMatchCalls = new ExpectationCounter("MockCallFactory.createCallMatch(String, ConstraintMatcher, Callable)");
- private ReturnValues myActualCreateCallMatchReturnValues = new ReturnValues("MockCallFactory.createCallMatch(String, ConstraintMatcher, Callable)", true);
- private ExpectationList myCreateCallMatchParameter0Values = new ExpectationList("MockCallFactory.createCallMatch(String, ConstraintMatcher, Callable) java.lang.String");
- private ExpectationList myCreateCallMatchParameter1Values = new ExpectationList("MockCallFactory.createCallMatch(String, ConstraintMatcher, Callable) com.mockobjects.dynamic.ConstraintMatcher");
- private ExpectationList myCreateCallMatchParameter2Values = new ExpectationList("MockCallFactory.createCallMatch(String, ConstraintMatcher, Callable) com.mockobjects.dynamic.Callable");
+ private ExpectationCounter myCreateCallSignatureCalls = new ExpectationCounter("MockCallFactory.createCallMatch(String, ConstraintMatcher, Callable)");
+ private ReturnValues myActualCreateCallSignatureReturnValues = new ReturnValues("MockCallFactory.createCallMatch(String, ConstraintMatcher, Callable)", true);
+ private ExpectationList myCreateCallSignatureParameter0Values = new ExpectationList("MockCallFactory.createCallMatch(String, ConstraintMatcher, Callable) java.lang.String");
+ private ExpectationList myCreateCallSignatureParameter1Values = new ExpectationList("MockCallFactory.createCallMatch(String, ConstraintMatcher, Callable) com.mockobjects.dynamic.ConstraintMatcher");
+ private ExpectationList myCreateCallSignatureParameter2Values = new ExpectationList("MockCallFactory.createCallMatch(String, ConstraintMatcher, Callable) com.mockobjects.dynamic.Callable");
public void setExpectedCreateReturnStubCalls(int calls){
myCreateReturnStubCalls.setExpected(calls);
@@ -118,33 +118,33 @@
myActualCreateExpectedCallReturnValues.add(arg);
}
- public void setExpectedCreateCallMatchCalls(int calls){
- myCreateCallMatchCalls.setExpected(calls);
+ public void setExpectedCreateCallSignatureCalls(int calls){
+ myCreateCallSignatureCalls.setExpected(calls);
}
- public void addExpectedCreateCallMatch(String arg0, ConstraintMatcher arg1, Callable arg2){
- myCreateCallMatchParameter0Values.addExpected(arg0);
- myCreateCallMatchParameter1Values.addExpectedMany(arg1.getConstraints());
- myCreateCallMatchParameter2Values.addExpected(arg2);
- }
-
- public Callable createCallMatch(String arg0, ConstraintMatcher arg1, Callable arg2){
- myCreateCallMatchCalls.inc();
- myCreateCallMatchParameter0Values.addActual(arg0);
- myCreateCallMatchParameter1Values.addActualMany(arg1.getConstraints());
- myCreateCallMatchParameter2Values.addActual(arg2);
- Object nextReturnValue = myActualCreateCallMatchReturnValues.getNext();
+ public void addExpectedCreateCallSignature(String arg0, ConstraintMatcher arg1, Callable arg2){
+ myCreateCallSignatureParameter0Values.addExpected(arg0);
+ myCreateCallSignatureParameter1Values.addExpectedMany(arg1.getConstraints());
+ myCreateCallSignatureParameter2Values.addExpected(arg2);
+ }
+
+ public Callable createCallSignature(String arg0, ConstraintMatcher arg1, Callable arg2){
+ myCreateCallSignatureCalls.inc();
+ myCreateCallSignatureParameter0Values.addActual(arg0);
+ myCreateCallSignatureParameter1Values.addActualMany(arg1.getConstraints());
+ myCreateCallSignatureParameter2Values.addActual(arg2);
+ Object nextReturnValue = myActualCreateCallSignatureReturnValues.getNext();
if (nextReturnValue instanceof ExceptionalReturnValue && ((ExceptionalReturnValue)nextReturnValue).getException() instanceof RuntimeException)
throw (RuntimeException)((ExceptionalReturnValue)nextReturnValue).getException();
return (Callable) nextReturnValue;
}
- public void setupExceptionCreateCallMatch(Throwable arg){
- myActualCreateCallMatchReturnValues.add(new ExceptionalReturnValue(arg));
+ public void setupExceptionCreateCallSignature(Throwable arg){
+ myActualCreateCallSignatureReturnValues.add(new ExceptionalReturnValue(arg));
}
- public void setupCreateCallMatch(Callable arg){
- myActualCreateCallMatchReturnValues.add(arg);
+ public void setupCreateCallSignature(Callable arg){
+ myActualCreateCallSignatureReturnValues.add(arg);
}
public void verify(){
@@ -155,9 +155,9 @@
myCreateVoidStubCalls.verify();
myCreateExpectedCallCalls.verify();
myCreateExpectedCallParameter0Values.verify();
- myCreateCallMatchCalls.verify();
- myCreateCallMatchParameter0Values.verify();
- myCreateCallMatchParameter1Values.verify();
- myCreateCallMatchParameter2Values.verify();
+ myCreateCallSignatureCalls.verify();
+ myCreateCallSignatureParameter0Values.verify();
+ myCreateCallSignatureParameter1Values.verify();
+ myCreateCallSignatureParameter2Values.verify();
}
}
Index: CallSequenceTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/CallSequenceTest.java,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -r1.6 -r1.7
--- CallSequenceTest.java 18 May 2003 20:59:38 -0000 1.6
+++ CallSequenceTest.java 19 May 2003 23:37:49 -0000 1.7
@@ -5,7 +5,7 @@
import com.mockobjects.dynamic.*;
import com.mockobjects.dynamic.C;
-import com.mockobjects.dynamic.CallMatch;
+import com.mockobjects.dynamic.CallSignature;
import com.mockobjects.dynamic.CallSequence;
import com.mockobjects.dynamic.Callable;
import com.mockobjects.dynamic.ExpectedCall;
@@ -206,11 +206,11 @@
public void testExpectOverridesMatch() throws Throwable {
- Callable methodAMatch = new CallMatch(METHOD_A_NAME,METHOD_A_CONSTRAINTS, new ReturnStub("result1"));
- Callable anotherMethodAMatch = new CallMatch(METHOD_A_NAME,METHOD_A_CONSTRAINTS, new ReturnStub("result2"));
+ 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"));
- callSequence.addMatch(methodAMatch);
- callSequence.addExpect(new ExpectedCall(anotherMethodAMatch));
+ callSequence.addMatch(methodASignature);
+ callSequence.addExpect(new ExpectedCall(anotherMethodASignature));
assertSame("expected result from method B, as expect has precendence over match", "result2",
callSequence.call(unusedMock, METHOD_A_NAME, METHOD_A_ARGS));
Index: CallMatchTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/CallMatchTest.java,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- CallMatchTest.java 18 May 2003 20:59:38 -0000 1.2
+++ CallMatchTest.java 19 May 2003 23:37:49 -0000 1.3
@@ -14,7 +14,7 @@
Mock mock = new Mock(DummyInterface.class, "mock");
MockCallable mockCallable = new MockCallable();
MockConstraintMatcher mockConstraintMatcher = new MockConstraintMatcher();
- CallMatch callMatch = new CallMatch(METHOD_NAME, mockConstraintMatcher, mockCallable);
+ CallSignature callSignature = new CallSignature(METHOD_NAME, mockConstraintMatcher, mockCallable);
public CallMatchTest(String name) {
super(name);
@@ -28,7 +28,7 @@
mockCallable.setExpectedCall(mock, METHOD_NAME, arguments);
mockCallable.setupCallReturn(result);
- callMatch.call(mock, METHOD_NAME, arguments);
+ callSignature.call(mock, METHOD_NAME, arguments);
mockCallable.verifyExpectations();
}
@@ -36,7 +36,7 @@
public void testUncalledCallVerifies() {
mockCallable.setExpectedVerifyCalls(1);
- callMatch.verify();
+ callSignature.verify();
mockCallable.verifyExpectations();
}
@@ -45,8 +45,8 @@
mockCallable.setExpectedVerifyCalls(1);
mockCallable.setupCallReturn("result");
- callMatch.call(mock, "methodName", IGNORED_ARGS);
- callMatch.verify();
+ callSignature.call(mock, "methodName", IGNORED_ARGS);
+ callSignature.verify();
mockCallable.verifyExpectations();
}
@@ -54,8 +54,8 @@
public void testMultipleCallsSucceed() throws Throwable {
mockCallable.setupCallReturn("result");
- callMatch.call(mock, METHOD_NAME, IGNORED_ARGS);
- callMatch.call(mock, METHOD_NAME, IGNORED_ARGS);
+ callSignature.call(mock, METHOD_NAME, IGNORED_ARGS);
+ callSignature.call(mock, METHOD_NAME, IGNORED_ARGS);
mockCallable.verifyExpectations();
}
@@ -65,7 +65,7 @@
}
public void testCallDoesNotMatchWhenWrongName() throws Throwable {
- assertFalse("call does not match", callMatch.matches("anotherName", IGNORED_ARGS));
+ assertFalse("call does not match", callSignature.matches("anotherName", IGNORED_ARGS));
mockCallable.verifyExpectations();
}
@@ -75,10 +75,10 @@
mockConstraintMatcher.setupMatches(true);
- callMatch.call(mock, METHOD_NAME, IGNORED_ARGS);
- assertTrue("matches after first call", callMatch.matches(METHOD_NAME, IGNORED_ARGS));
- callMatch.call(mock, METHOD_NAME, IGNORED_ARGS);
- assertTrue("matches after further calls", callMatch.matches(METHOD_NAME, IGNORED_ARGS));
+ callSignature.call(mock, METHOD_NAME, IGNORED_ARGS);
+ assertTrue("matches after first call", callSignature.matches(METHOD_NAME, IGNORED_ARGS));
+ callSignature.call(mock, METHOD_NAME, IGNORED_ARGS);
+ assertTrue("matches after further calls", callSignature.matches(METHOD_NAME, IGNORED_ARGS));
mockCallable.verifyExpectations();
}
@@ -90,13 +90,13 @@
mockConstraintMatcher.addExpectedMatches(args);
mockConstraintMatcher.setupMatches(true);
- assertTrue("matches delegated to constraint matcher", callMatch.matches(METHOD_NAME, args));
+ assertTrue("matches delegated to constraint matcher", callSignature.matches(METHOD_NAME, args));
mockConstraintMatcher.verify();
}
public void testMatchesFailure() throws Throwable {
mockConstraintMatcher.setupMatches(false);
- assertFalse("Should not match if constraint matcher doesn't", callMatch.matches(METHOD_NAME, IGNORED_ARGS));
+ assertFalse("Should not match if constraint matcher doesn't", callSignature.matches(METHOD_NAME, IGNORED_ARGS));
}
}
|
