Menu
▾
▴
[MO-java-dev] CVS: mockobjects-java/src/core/test/mockobjects/dynamic MockCallableFactory.java,NONE,1.1 MockTest.java,1.16,1.17 MockCallableCollection.java,1.3,1.4
|
From: Tim M. <ma...@us...> - 2003-07-07 02:24:29
|
Update of /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic
In directory sc8-pr-cvs1:/tmp/cvs-serv6994/core/test/mockobjects/dynamic
Modified Files:
MockTest.java MockCallableCollection.java
Added Files:
MockCallableFactory.java
Log Message:
Composition of DynamicMock step - 5
MockTests now substantially cleaned up
--- NEW FILE: MockCallableFactory.java ---
package test.mockobjects.dynamic;
import com.mockobjects.*;
import com.mockobjects.dynamic.CallableFactory;
import com.mockobjects.dynamic.Callable;
import com.mockobjects.dynamic.ConstraintMatcher;
public class MockCallableFactory implements CallableFactory{
private ExpectationCounter myCreateCallExpectationCalls = new ExpectationCounter("MockCallableFactory.createCallExpectation(Callable)");
private ReturnValues myActualCreateCallExpectationReturnValues = new ReturnValues("MockCallableFactory.createCallExpectation(Callable)", true);
private ExpectationList myCreateCallExpectationParameter0Values = new ExpectationList("MockCallableFactory.createCallExpectation(Callable) com.mockobjects.dynamic.Callable");
private ExpectationCounter myCreateReturnCallableCalls = new ExpectationCounter("MockCallableFactory.createReturnCallable(String, ConstraintMatcher, Object)");
private ReturnValues myActualCreateReturnCallableReturnValues = new ReturnValues("MockCallableFactory.createReturnCallable(String, ConstraintMatcher, Object)", true);
private ExpectationList myCreateReturnCallableParameter0Values = new ExpectationList("MockCallableFactory.createReturnCallable(String, ConstraintMatcher, Object) java.lang.String");
private ExpectationList myCreateReturnCallableParameter1Values = new ExpectationList("MockCallableFactory.createReturnCallable(String, ConstraintMatcher, Object) com.mockobjects.dynamic.ConstraintMatcher");
private ExpectationList myCreateReturnCallableParameter2Values = new ExpectationList("MockCallableFactory.createReturnCallable(String, ConstraintMatcher, Object) java.lang.Object");
private ExpectationCounter myCreateThrowableCallableCalls = new ExpectationCounter("MockCallableFactory.createThrowableCallable(String, ConstraintMatcher, Throwable)");
private ReturnValues myActualCreateThrowableCallableReturnValues = new ReturnValues("MockCallableFactory.createThrowableCallable(String, ConstraintMatcher, Throwable)", true);
private ExpectationList myCreateThrowableCallableParameter0Values = new ExpectationList("MockCallableFactory.createThrowableCallable(String, ConstraintMatcher, Throwable) java.lang.String");
private ExpectationList myCreateThrowableCallableParameter1Values = new ExpectationList("MockCallableFactory.createThrowableCallable(String, ConstraintMatcher, Throwable) com.mockobjects.dynamic.ConstraintMatcher");
private ExpectationList myCreateThrowableCallableParameter2Values = new ExpectationList("MockCallableFactory.createThrowableCallable(String, ConstraintMatcher, Throwable) java.lang.Throwable");
private ExpectationCounter myCreateVoidCallableCalls = new ExpectationCounter("MockCallableFactory.createVoidCallable(String, ConstraintMatcher)");
private ReturnValues myActualCreateVoidCallableReturnValues = new ReturnValues("MockCallableFactory.createVoidCallable(String, ConstraintMatcher)", true);
private ExpectationList myCreateVoidCallableParameter0Values = new ExpectationList("MockCallableFactory.createVoidCallable(String, ConstraintMatcher) java.lang.String");
private ExpectationList myCreateVoidCallableParameter1Values = new ExpectationList("MockCallableFactory.createVoidCallable(String, ConstraintMatcher) com.mockobjects.dynamic.ConstraintMatcher");
public void setExpectedCreateCallExpectationCalls(int calls){
myCreateCallExpectationCalls.setExpected(calls);
}
public void addExpectedCreateCallExpectation(Callable arg0){
myCreateCallExpectationParameter0Values.addExpected(arg0);
}
public Callable createCallExpectation(Callable arg0){
myCreateCallExpectationCalls.inc();
myCreateCallExpectationParameter0Values.addActual(arg0);
Object nextReturnValue = myActualCreateCallExpectationReturnValues.getNext();
if (nextReturnValue instanceof ExceptionalReturnValue && ((ExceptionalReturnValue)nextReturnValue).getException() instanceof RuntimeException)
throw (RuntimeException)((ExceptionalReturnValue)nextReturnValue).getException();
return (Callable) nextReturnValue;
}
public void setupExceptionCreateCallExpectation(Throwable arg){
myActualCreateCallExpectationReturnValues.add(new ExceptionalReturnValue(arg));
}
public void setupCreateCallExpectation(Callable arg){
myActualCreateCallExpectationReturnValues.add(arg);
}
public void setExpectedCreateReturnCallableCalls(int calls){
myCreateReturnCallableCalls.setExpected(calls);
}
public void addExpectedCreateReturnCallable(String arg0, ConstraintMatcher arg1, Object arg2){
myCreateReturnCallableParameter0Values.addExpected(arg0);
myCreateReturnCallableParameter1Values.addExpected(arg1);
myCreateReturnCallableParameter2Values.addExpected(arg2);
}
public Callable createReturnCallable(String arg0, ConstraintMatcher arg1, Object arg2){
myCreateReturnCallableCalls.inc();
myCreateReturnCallableParameter0Values.addActual(arg0);
myCreateReturnCallableParameter1Values.addActual(arg1);
myCreateReturnCallableParameter2Values.addActual(arg2);
Object nextReturnValue = myActualCreateReturnCallableReturnValues.getNext();
if (nextReturnValue instanceof ExceptionalReturnValue && ((ExceptionalReturnValue)nextReturnValue).getException() instanceof RuntimeException)
throw (RuntimeException)((ExceptionalReturnValue)nextReturnValue).getException();
return (Callable) nextReturnValue;
}
public void setupExceptionCreateReturnCallable(Throwable arg){
myActualCreateReturnCallableReturnValues.add(new ExceptionalReturnValue(arg));
}
public void setupCreateReturnCallable(Callable arg){
myActualCreateReturnCallableReturnValues.add(arg);
}
public void setExpectedCreateThrowableCallableCalls(int calls){
myCreateThrowableCallableCalls.setExpected(calls);
}
public void addExpectedCreateThrowableCallable(String arg0, ConstraintMatcher arg1, Throwable arg2){
myCreateThrowableCallableParameter0Values.addExpected(arg0);
myCreateThrowableCallableParameter1Values.addExpected(arg1);
myCreateThrowableCallableParameter2Values.addExpected(arg2);
}
public Callable createThrowableCallable(String arg0, ConstraintMatcher arg1, Throwable arg2){
myCreateThrowableCallableCalls.inc();
myCreateThrowableCallableParameter0Values.addActual(arg0);
myCreateThrowableCallableParameter1Values.addActual(arg1);
myCreateThrowableCallableParameter2Values.addActual(arg2);
Object nextReturnValue = myActualCreateThrowableCallableReturnValues.getNext();
if (nextReturnValue instanceof ExceptionalReturnValue && ((ExceptionalReturnValue)nextReturnValue).getException() instanceof RuntimeException)
throw (RuntimeException)((ExceptionalReturnValue)nextReturnValue).getException();
return (Callable) nextReturnValue;
}
public void setupExceptionCreateThrowableCallable(Throwable arg){
myActualCreateThrowableCallableReturnValues.add(new ExceptionalReturnValue(arg));
}
public void setupCreateThrowableCallable(Callable arg){
myActualCreateThrowableCallableReturnValues.add(arg);
}
public void setExpectedCreateVoidCallableCalls(int calls){
myCreateVoidCallableCalls.setExpected(calls);
}
public void addExpectedCreateVoidCallable(String arg0, ConstraintMatcher arg1){
myCreateVoidCallableParameter0Values.addExpected(arg0);
myCreateVoidCallableParameter1Values.addExpected(arg1);
}
public Callable createVoidCallable(String arg0, ConstraintMatcher arg1){
myCreateVoidCallableCalls.inc();
myCreateVoidCallableParameter0Values.addActual(arg0);
myCreateVoidCallableParameter1Values.addActual(arg1);
Object nextReturnValue = myActualCreateVoidCallableReturnValues.getNext();
if (nextReturnValue instanceof ExceptionalReturnValue && ((ExceptionalReturnValue)nextReturnValue).getException() instanceof RuntimeException)
throw (RuntimeException)((ExceptionalReturnValue)nextReturnValue).getException();
return (Callable) nextReturnValue;
}
public void setupExceptionCreateVoidCallable(Throwable arg){
myActualCreateVoidCallableReturnValues.add(new ExceptionalReturnValue(arg));
}
public void setupCreateVoidCallable(Callable arg){
myActualCreateVoidCallableReturnValues.add(arg);
}
public void verify(){
myCreateCallExpectationCalls.verify();
myCreateCallExpectationParameter0Values.verify();
myCreateReturnCallableCalls.verify();
myCreateReturnCallableParameter0Values.verify();
myCreateReturnCallableParameter1Values.verify();
myCreateReturnCallableParameter2Values.verify();
myCreateThrowableCallableCalls.verify();
myCreateThrowableCallableParameter0Values.verify();
//
myCreateThrowableCallableParameter1Values.verify();
myCreateThrowableCallableParameter2Values.verify();
myCreateVoidCallableCalls.verify();
myCreateVoidCallableParameter0Values.verify();
myCreateVoidCallableParameter1Values.verify();
}
}
Index: MockTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockTest.java,v
retrieving revision 1.16
retrieving revision 1.17
diff -u -r1.16 -r1.17
--- MockTest.java 7 Jul 2003 00:19:33 -0000 1.16
+++ MockTest.java 7 Jul 2003 02:24:26 -0000 1.17
@@ -1,9 +1,6 @@
-/*
- * Created on 04-Apr-2003
- */
package test.mockobjects.dynamic;
-import com.mockobjects.constraint.*;
+import com.mockobjects.constraint.Constraint;
import com.mockobjects.constraint.IsEqual;
import com.mockobjects.dynamic.*;
import com.mockobjects.util.*;
@@ -13,348 +10,241 @@
public class MockTest extends TestCase {
private static final String MOCK_NAME = "Test mock";
- 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 ConstraintMatcher METHOD_ONEARG_CONSTRAINTS = C.args(C.eq("oneP1"));
- final String[] METHOD_TWOARG_ARGS = new String[] { "twoP1", "twoP2" };
final ConstraintMatcher METHOD_TWOARG_CONSTRAINTS = C.args(C.eq("twoP1"), C.eq("twoP2"));
+
private DummyInterface proxy;
private Mock mock;
- private MockCallFactory mockCallFactory = new MockCallFactory();
- 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 MockCallableFactory mockCallableFactory = new MockCallableFactory();
+
private MockCallableCollection mockCallables = new MockCallableCollection();
+ private MockCallable mockCall = new MockCallable("call match");
public MockTest(String name) throws Exception {
super(name);
}
public void setUp() {
- mock = new Mock(mockCallFactory, mockCallables, DummyInterface.class, MOCK_NAME);
+ mock = new Mock(mockCallableFactory, mockCallables, DummyInterface.class, MOCK_NAME);
try {
proxy = (DummyInterface)mock.proxy();
} catch (ClassCastException ex) {
fail("proxy is not of expected interface type");
}
-
- mockCallFactory.setupCreateReturnStub(mockReturnStub);
- mockCallFactory.setupCreateVoidStub(mockVoidStub);
- mockCallFactory.setupCreateThrowStub(mockThrowStub);
+
+ mockCallableFactory.setupCreateCallExpectation(mockCall);
}
public void testExpectManyAndVoid() throws Throwable {
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
-
- mockCallFactory.setExpectedCreateVoidStubCalls(1);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockVoidStub);
- mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
-
- mockCallables.expectedCallables.addExpected(mockExpectedCall);
-
- mock.expect(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS);
-
+ mockCallableFactory.addExpectedCreateVoidCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS);
+ mockCallableFactory.setupCreateVoidCallable(mockCall);
+ mockCallableFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallables.addExpectedExpect(mockCall);
+
+ mock.expect(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS);
+
Verifier.verifyObject(this);
- mockCallables.verifyExpectations();
}
public void testExpectNoneAndReturn() throws Throwable {
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
-
- mockCallFactory.createReturnStub.setExpected(METHOD_NOARGANDRETURN_RESULT);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARGANDRETURN_NAME, C.NO_ARGS, mockReturnStub);
- mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
+ mockCallableFactory.addExpectedCreateReturnCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS, DummyInterface.METHOD_NOARG_RESULT);
+ mockCallableFactory.setupCreateReturnCallable(mockCall);
+ mockCallableFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallables.addExpectedExpect(mockCall);
+
+ mock.expectAndReturn(DummyInterface.METHOD_NOARG_NAME, DummyInterface.METHOD_NOARG_RESULT);
- mockCallables.expectedCallables.addExpected(mockExpectedCall);
-
- mock.expectAndReturn(METHOD_NOARGANDRETURN_NAME, METHOD_NOARGANDRETURN_RESULT);
-
Verifier.verifyObject(this);
- mockCallables.verifyExpectations();
}
public void testExpectNoneAndThrow() throws Throwable {
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
-
- mockCallFactory.createThrowStub.setExpected(METHOD_EXCEPTION);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARGANDRETURN_NAME, C.NO_ARGS, mockThrowStub);
- mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
+ mockCallableFactory.addExpectedCreateThrowableCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS, METHOD_EXCEPTION);
+ mockCallableFactory.setupCreateThrowableCallable(mockCall);
+ mockCallableFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallables.addExpectedExpect(mockCall);
- mockCallables.expectedCallables.addExpected(mockExpectedCall);
-
- mock.expectAndThrow(METHOD_NOARGANDRETURN_NAME, METHOD_EXCEPTION);
+ mock.expectAndThrow(DummyInterface.METHOD_NOARG_NAME, METHOD_EXCEPTION);
Verifier.verifyObject(this);
- mockCallables.verifyExpectations();
}
public void testExpectOneAndThrow() throws Throwable {
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
-
- mockCallFactory.createThrowStub.setExpected(METHOD_EXCEPTION);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub);
- mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
+ mockCallableFactory.addExpectedCreateThrowableCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, METHOD_EXCEPTION);
+ mockCallableFactory.setupCreateThrowableCallable(mockCall);
+ mockCallableFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallables.addExpectedExpect(mockCall);
- mockCallables.expectedCallables.addExpected(mockExpectedCall);
-
- mock.expectAndThrow(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_EXCEPTION);
+ mock.expectAndThrow(DummyInterface.METHOD_ONEARG_NAME, DummyInterface.METHOD_ONEARG_ARGS[0], METHOD_EXCEPTION);
Verifier.verifyObject(this);
- mockCallables.verifyExpectations();
}
public void testExpectNoneAndVoid() throws Throwable {
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
-
- mockCallFactory.setExpectedCreateVoidStubCalls(1);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARG_NAME, C.NO_ARGS, mockVoidStub);
- mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
-
- mockCallables.expectedCallables.addExpected(mockExpectedCall);
+ mockCallableFactory.addExpectedCreateVoidCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS);
+ mockCallableFactory.setupCreateVoidCallable(mockCall);
+ mockCallableFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallables.addExpectedExpect(mockCall);
- mock.expect(METHOD_NOARG_NAME);
+ mock.expect(DummyInterface.METHOD_NOARG_NAME);
Verifier.verifyObject(this);
- mockCallables.verifyExpectations();
}
public void testExpectOneAndVoid() throws Throwable {
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
-
- mockCallFactory.setExpectedCreateVoidStubCalls(1);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
- mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
-
- mockCallables.expectedCallables.addExpected(mockExpectedCall);
-
- mock.expect(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0]);
-
- Verifier.verifyObject(this);
- mockCallables.verifyExpectations();
- }
+ mockCallableFactory.addExpectedCreateVoidCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS);
+ mockCallableFactory.setupCreateVoidCallable(mockCall);
+ mockCallableFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallables.addExpectedExpect(mockCall);
- public void testExpectWithConstraint() throws Throwable {
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
-
- mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
- mockCallables.expectedCallables.addExpected(mockExpectedCall);
-
- mock.expect(METHOD_ONEARG_NAME, new IsEqual(METHOD_ONEARG_ARGS[0]));
-
- Verifier.verifyObject(this);
- mockCallables.verifyExpectations();
- }
+ mock.expect(DummyInterface.METHOD_ONEARG_NAME, DummyInterface.METHOD_ONEARG_ARGS[0]);
- public void testExpectWithConstraintArray() throws Throwable {
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
-
- mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
- mockCallables.expectedCallables.addExpected(mockExpectedCall);
-
- mock.expect(METHOD_ONEARG_NAME, new Constraint[] { new IsEqual(METHOD_ONEARG_ARGS[0])});
-
Verifier.verifyObject(this);
- mockCallables.verifyExpectations();
}
-
-
+
public void testExpectManyAndReturn() throws Throwable {
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
-
- mockCallFactory.createReturnStub.setExpected(METHOD_TWOARG_RESULT);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockReturnStub);
- mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
-
- mockCallables.expectedCallables.addExpected(mockExpectedCall);
- mockCallables.setupCall(METHOD_TWOARG_RESULT);
-
- mock.expectAndReturn(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_TWOARG_RESULT);
+ mockCallableFactory.addExpectedCreateReturnCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, DummyInterface.METHOD_TWOARG_RESULT);
+ mockCallableFactory.setupCreateReturnCallable(mockCall);
+ mockCallableFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallables.addExpectedExpect(mockCall);
+
+ mock.expectAndReturn(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, DummyInterface.METHOD_TWOARG_RESULT);
Verifier.verifyObject(this);
- mockCallables.verifyExpectations();
}
public void testExpectManyAndThrow() throws Throwable {
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
-
- mockCallFactory.createThrowStub.setExpected(METHOD_EXCEPTION);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockThrowStub);
- mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
+ mockCallableFactory.addExpectedCreateThrowableCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION);
+ mockCallableFactory.setupCreateThrowableCallable(mockCall);
+ mockCallableFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallables.addExpectedExpect(mockCall);
- mockCallables.expectedCallables.addExpected(mockExpectedCall);
- mockCallables.setupCall(METHOD_TWOARG_RESULT);
-
- mock.expectAndThrow(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION);
+ mock.expectAndThrow(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION);
Verifier.verifyObject(this);
- mockCallables.verifyExpectations();
}
public void testExpectOneAndReturn() throws Throwable {
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
-
- mockCallFactory.createReturnStub.setExpected(METHOD_ONEARG_RESULT);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub);
- mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
-
- mockCallables.expectedCallables.addExpected(mockExpectedCall);
- mockCallables.setupCall(METHOD_ONEARG_RESULT);
-
- mock.expectAndReturn(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_ONEARG_RESULT);
+ mockCallableFactory.addExpectedCreateReturnCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, DummyInterface.METHOD_ONEARG_RESULT);
+ mockCallableFactory.setupCreateReturnCallable(mockCall);
+ mockCallableFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallables.addExpectedExpect(mockCall);
+
+ mock.expectAndReturn(DummyInterface.METHOD_ONEARG_NAME, DummyInterface.METHOD_ONEARG_ARGS[0], DummyInterface.METHOD_ONEARG_RESULT);
Verifier.verifyObject(this);
- mockCallables.verifyExpectations();
}
public void testMatchNoneAndVoid() throws Throwable {
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallables.setupCall(METHOD_NOARGANDRETURN_RESULT);
-
- mockCallFactory.setExpectedCreateVoidStubCalls(1);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARG_NAME, C.NO_ARGS, mockVoidStub);
+ mockCallableFactory.addExpectedCreateVoidCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS);
+ mockCallableFactory.setupCreateVoidCallable(mockCall);
+ mockCallables.addExpectedMatch(mockCall);
- mockCallables.matchedCallables.addExpected(mockCallMatch);
-
- mock.match(METHOD_NOARG_NAME);
+ mock.match(DummyInterface.METHOD_NOARG_NAME);
Verifier.verifyObject(this);
- mockCallables.verifyExpectations();
}
public void testMatchNoneAndReturn() throws Throwable {
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallables.setupCall(METHOD_ONEARG_RESULT);
-
- mockCallFactory.createReturnStub.setExpected(METHOD_NOARGANDRETURN_RESULT);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARG_NAME, C.NO_ARGS, mockReturnStub);
-
- mockCallables.matchedCallables.addExpected(mockCallMatch);
-
- mock.matchAndReturn(METHOD_NOARG_NAME, METHOD_NOARGANDRETURN_RESULT);
-
+ mockCallableFactory.addExpectedCreateReturnCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS, DummyInterface.METHOD_NOARG_RESULT);
+ mockCallableFactory.setupCreateReturnCallable(mockCall);
+ mockCallables.addExpectedMatch(mockCall);
+
+ mock.matchAndReturn(DummyInterface.METHOD_NOARG_NAME, DummyInterface.METHOD_NOARG_RESULT);
+
Verifier.verifyObject(this);
- mockCallables.verifyExpectations();
}
public void testMatchNoneAndThrow() throws Throwable {
- mockCallFactory.setupCreateThrowStub(mockThrowStub);
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
-
- mockCallFactory.createThrowStub.setExpected(METHOD_EXCEPTION);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARG_NAME, C.NO_ARGS, mockThrowStub);
+ mockCallableFactory.addExpectedCreateThrowableCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS, METHOD_EXCEPTION);
+ mockCallableFactory.setupCreateThrowableCallable(mockCall);
+ mockCallables.addExpectedMatch(mockCall);
- mockCallables.matchedCallables.addExpected(mockCallMatch);
- mockCallables.setupCall(METHOD_NOARGANDRETURN_RESULT);
-
- mock.matchAndThrow(METHOD_NOARG_NAME, METHOD_EXCEPTION);
+ mock.matchAndThrow(DummyInterface.METHOD_NOARG_NAME, METHOD_EXCEPTION);
Verifier.verifyObject(this);
- mockCallables.verifyExpectations();
}
public void testMatchOneAndVoid() throws Throwable {
- mockCallFactory.setExpectedCreateVoidStubCalls(1);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
- mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
-
- mockCallables.matchedCallables.addExpected(mockCallMatch);
-
- mock.match(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0]);
-
+ mockCallableFactory.addExpectedCreateVoidCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS);
+ mockCallableFactory.setupCreateVoidCallable(mockCall);
+ mockCallables.addExpectedMatch(mockCall);
+
+ mock.match(DummyInterface.METHOD_ONEARG_NAME, DummyInterface.METHOD_ONEARG_ARGS[0]);
+
Verifier.verifyObject(this);
- mockCallables.verifyExpectations();
}
public void testMatchOneAndReturn() throws Throwable {
- mockCallFactory.createReturnStub.setExpected(METHOD_ONEARG_RESULT);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub);
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
-
- mockCallables.matchedCallables.addExpected(mockCallMatch);
- mockCallables.setupCall(METHOD_ONEARG_RESULT);
-
- mock.matchAndReturn(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_ONEARG_RESULT);
+ mockCallableFactory.addExpectedCreateReturnCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, DummyInterface.METHOD_ONEARG_RESULT);
+ mockCallableFactory.setupCreateReturnCallable(mockCall);
+ mockCallables.addExpectedMatch(mockCall);
+
+ mock.matchAndReturn(DummyInterface.METHOD_ONEARG_NAME, DummyInterface.METHOD_ONEARG_ARGS[0], DummyInterface.METHOD_ONEARG_RESULT);
Verifier.verifyObject(this);
- mockCallables.verifyExpectations();
}
public void testMatchOneAndThrow() throws Throwable {
- mockCallFactory.createThrowStub.setExpected(METHOD_EXCEPTION);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub);
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
-
- mockCallables.matchedCallables.addExpected(mockCallMatch);
- mockCallables.setupCall(METHOD_ONEARG_RESULT);
+ mockCallableFactory.addExpectedCreateThrowableCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, METHOD_EXCEPTION);
+ mockCallableFactory.setupCreateThrowableCallable(mockCall);
+ mockCallables.addExpectedMatch(mockCall);
- mock.matchAndThrow(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_EXCEPTION);
+ mock.matchAndThrow(DummyInterface.METHOD_ONEARG_NAME, DummyInterface.METHOD_ONEARG_ARGS[0], METHOD_EXCEPTION);
Verifier.verifyObject(this);
- mockCallables.verifyExpectations();
}
public void testMatchManyAndVoid() throws Throwable {
- mockCallFactory.setExpectedCreateVoidStubCalls(1);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockVoidStub);
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
- mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
-
- mockCallables.matchedCallables.addExpected(mockCallMatch);
-
- mock.match(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS);
-
+ mockCallableFactory.addExpectedCreateVoidCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS);
+ mockCallableFactory.setupCreateVoidCallable(mockCall);
+ mockCallables.addExpectedMatch(mockCall);
+
+ mock.match(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS);
+
Verifier.verifyObject(this);
- mockCallables.verifyExpectations();
}
public void testMatchManyAndReturn() throws Throwable {
- mockCallFactory.createReturnStub.setExpected(METHOD_TWOARG_RESULT);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockReturnStub);
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
-
- mockCallables.matchedCallables.addExpected(mockCallMatch);
- mockCallables.setupCall(METHOD_TWOARG_RESULT);
-
- mock.matchAndReturn(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_TWOARG_RESULT);
+ mockCallableFactory.addExpectedCreateReturnCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, DummyInterface.METHOD_TWOARG_RESULT);
+ mockCallableFactory.setupCreateReturnCallable(mockCall);
+ mockCallables.addExpectedMatch(mockCall);
+
+ mock.matchAndReturn(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, DummyInterface.METHOD_TWOARG_RESULT);
Verifier.verifyObject(this);
- mockCallables.verifyExpectations();
}
public void testMatchManyAndThrow() throws Throwable {
- mockCallFactory.createThrowStub.setExpected(METHOD_EXCEPTION);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockThrowStub);
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
+ mockCallableFactory.addExpectedCreateThrowableCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION);
+ mockCallableFactory.setupCreateThrowableCallable(mockCall);
+ mockCallables.addExpectedMatch(mockCall);
+
+ mock.matchAndThrow(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION);
- mockCallables.matchedCallables.addExpected(mockCallMatch);
- mockCallables.setupCall(METHOD_TWOARG_RESULT);
+ Verifier.verifyObject(this);
+ }
+
+ public void testExpectWithConstraint() throws Throwable {
+ mockCallableFactory.addExpectedCreateVoidCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS);
+ mockCallableFactory.setupCreateVoidCallable(mockCall);
+ mockCallableFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallables.addExpectedExpect(mockCall);
+
+ mock.expect(DummyInterface.METHOD_ONEARG_NAME, new IsEqual(DummyInterface.METHOD_ONEARG_ARGS[0]));
- mock.matchAndThrow(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION);
+ Verifier.verifyObject(this);
+ }
+
+ public void testExpectWithConstraintArray() throws Throwable {
+ mockCallableFactory.addExpectedCreateVoidCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS);
+ mockCallableFactory.setupCreateVoidCallable(mockCall);
+ mockCallableFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallables.addExpectedExpect(mockCall);
+
+ mock.expect(DummyInterface.METHOD_ONEARG_NAME, new Constraint[] { new IsEqual(DummyInterface.METHOD_ONEARG_ARGS[0])});
Verifier.verifyObject(this);
mockCallables.verifyExpectations();
Index: MockCallableCollection.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockCallableCollection.java,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- MockCallableCollection.java 7 Jul 2003 00:19:33 -0000 1.3
+++ MockCallableCollection.java 7 Jul 2003 02:24:26 -0000 1.4
@@ -33,11 +33,19 @@
public void addMatch(Callable callable) {
matchedCallables.addActual(callable);
}
+
+ public void addExpectedMatch(Callable callable) {
+ matchedCallables.addExpected(callable);
+ }
public void addExpect(Callable callable) {
expectedCallables.addActual(callable);
}
+ public void addExpectedExpect(Callable callable) {
+ expectedCallables.addExpected(callable);
+ }
+
public void setExpectedMatchesCalls(int calls) {
myMatchesCalls.setExpected(calls);
}
|
