Menu
▾
▴
mockobjects-java-dev
|
From: Steve F. <sm...@us...> - 2003-10-01 16:05:17
|
Update of /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic
In directory sc8-pr-cvs1:/tmp/cvs-serv13114/src/core/test/mockobjects/dynamic
Modified Files:
MockTest.java
Log Message:
Index: MockTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockTest.java,v
retrieving revision 1.20
retrieving revision 1.21
diff -u -r1.20 -r1.21
--- MockTest.java 23 Sep 2003 23:04:33 -0000 1.20
+++ MockTest.java 1 Oct 2003 16:05:12 -0000 1.21
@@ -5,9 +5,10 @@
import com.mockobjects.constraint.Constraint;
import com.mockobjects.constraint.IsEqual;
-import com.mockobjects.dynamic.C;
-import com.mockobjects.dynamic.ConstraintMatcher;
-import com.mockobjects.dynamic.Mock;
+import com.mockobjects.dynamic.*;
+import com.mockobjects.util.*;
+
+import junit.framework.*;
public class MockTest extends TestCase {
@@ -17,10 +18,11 @@
final ConstraintMatcher METHOD_ONEARG_CONSTRAINTS = C.args(C.eq("oneP1"));
final ConstraintMatcher METHOD_TWOARG_CONSTRAINTS = C.args(C.eq("twoP1"), C.eq("twoP2"));
- private MockInvokableFactory mockCallableFactory = new MockInvokableFactory();
- private MockInvocationDispatcher mockDispatcher = new MockInvocationDispatcher();
- private MockInvokable mockInvokable = new MockInvokable();
+ private MockCallableFactory mockCallableFactory = new MockCallableFactory();
+ private MockCallableCollection mockCallables = new MockCallableCollection();
+ private MockCallable mockCall = new MockCallable("call match");
+ private DummyInterface proxy;
private Mock mock;
public MockTest(String name) throws Exception {
@@ -28,227 +30,220 @@
}
public void setUp() {
- mock = new Mock(mockCallableFactory, mockDispatcher, DummyInterface.class, MOCK_NAME);
- mockCallableFactory.createCallExpectationResult = mockInvokable;
+ mock = new Mock(mockCallableFactory, mockCallables, DummyInterface.class, MOCK_NAME);
+ proxy = (DummyInterface)mock.proxy();
+ mockCallableFactory.setupCreateCallExpectation(mockCall);
}
public void testExpectManyAndVoid() throws Throwable {
- mockCallableFactory.createVoidCallableResult = mockInvokable;
-
- mockCallableFactory.expectCreateVoidCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS);
- mockCallableFactory.createCallExpectation.setExpected(mockInvokable);
-
- mockDispatcher.addInvokable.setExpected(mockInvokable);
+ 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);
- verifyThis();
+ Verifier.verifyObject(this);
}
- private void verifyThis() {
- mockCallableFactory.verify();
- mockDispatcher.verifyExpectations();
- mockInvokable.verifyExpectations();
- }
-
- public void testExpectNoneAndReturn() throws Throwable {
- mockCallableFactory.expectCreateReturnCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS, DummyInterface.METHOD_NOARG_RESULT);
- mockCallableFactory.createReturnCallableResult = mockInvokable;
- mockCallableFactory.createCallExpectation.setExpected(mockInvokable);
- mockDispatcher.addInvokable.setExpected(mockInvokable);
+ public void testExpectNoneAndReturn() throws Throwable {
+ 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);
- verifyThis();
+ Verifier.verifyObject(this);
}
public void testExpectNoneAndThrow() throws Throwable {
- mockCallableFactory.expectCreateThrowableCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS, METHOD_EXCEPTION);
- mockCallableFactory.createThrowableCallableResult = mockInvokable;
- mockCallableFactory.createCallExpectation.setExpected(mockInvokable);
- mockDispatcher.addInvokable.setExpected(mockInvokable);
+ mockCallableFactory.addExpectedCreateThrowableCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS, METHOD_EXCEPTION);
+ mockCallableFactory.setupCreateThrowableCallable(mockCall);
+ mockCallableFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallables.addExpectedExpect(mockCall);
mock.expectAndThrow(DummyInterface.METHOD_NOARG_NAME, METHOD_EXCEPTION);
- verifyThis();
+ Verifier.verifyObject(this);
}
public void testExpectOneAndThrow() throws Throwable {
- mockCallableFactory.expectCreateThrowableCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, METHOD_EXCEPTION);
- mockCallableFactory.createThrowableCallableResult = mockInvokable;
- mockCallableFactory.createCallExpectation.setExpected(mockInvokable);
- mockDispatcher.addInvokable.setExpected(mockInvokable);
+ mockCallableFactory.addExpectedCreateThrowableCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, METHOD_EXCEPTION);
+ mockCallableFactory.setupCreateThrowableCallable(mockCall);
+ mockCallableFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallables.addExpectedExpect(mockCall);
mock.expectAndThrow(DummyInterface.METHOD_ONEARG_NAME, DummyInterface.METHOD_ONEARG_ARGS[0], METHOD_EXCEPTION);
- verifyThis();
+ Verifier.verifyObject(this);
}
public void testExpectNoneAndVoid() throws Throwable {
- mockCallableFactory.expectCreateVoidCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS);
- mockCallableFactory.createVoidCallableResult = mockInvokable;
- mockCallableFactory.createCallExpectation.setExpected(mockInvokable);
- mockDispatcher.addInvokable.setExpected(mockInvokable);
+ mockCallableFactory.addExpectedCreateVoidCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS);
+ mockCallableFactory.setupCreateVoidCallable(mockCall);
+ mockCallableFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallables.addExpectedExpect(mockCall);
mock.expect(DummyInterface.METHOD_NOARG_NAME);
- verifyThis();
+ Verifier.verifyObject(this);
}
public void testExpectOneAndVoid() throws Throwable {
- mockCallableFactory.expectCreateVoidCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS);
- mockCallableFactory.createVoidCallableResult = mockInvokable;
- mockCallableFactory.createCallExpectation.setExpected(mockInvokable);
- mockDispatcher.addInvokable.setExpected(mockInvokable);
+ mockCallableFactory.addExpectedCreateVoidCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS);
+ mockCallableFactory.setupCreateVoidCallable(mockCall);
+ mockCallableFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallables.addExpectedExpect(mockCall);
mock.expect(DummyInterface.METHOD_ONEARG_NAME, DummyInterface.METHOD_ONEARG_ARGS[0]);
- verifyThis();
+ Verifier.verifyObject(this);
}
public void testExpectManyAndReturn() throws Throwable {
- mockCallableFactory.expectCreateReturnCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, DummyInterface.METHOD_TWOARG_RESULT);
- mockCallableFactory.createReturnCallableResult = mockInvokable;
- mockCallableFactory.createCallExpectation.setExpected(mockInvokable);
- mockDispatcher.addInvokable.setExpected(mockInvokable);
+ 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);
- verifyThis();
+ Verifier.verifyObject(this);
}
public void testExpectManyAndThrow() throws Throwable {
- mockCallableFactory.expectCreateThrowableCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION);
- mockCallableFactory.createThrowableCallableResult = mockInvokable;
- mockCallableFactory.createCallExpectation.setExpected(mockInvokable);
- mockDispatcher.addInvokable.setExpected(mockInvokable);
+ mockCallableFactory.addExpectedCreateThrowableCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION);
+ mockCallableFactory.setupCreateThrowableCallable(mockCall);
+ mockCallableFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallables.addExpectedExpect(mockCall);
mock.expectAndThrow(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION);
- verifyThis();
+ Verifier.verifyObject(this);
}
public void testExpectOneAndReturn() throws Throwable {
- mockCallableFactory.expectCreateReturnCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, DummyInterface.METHOD_ONEARG_RESULT);
- mockCallableFactory.createReturnCallableResult = mockInvokable;
- mockCallableFactory.createCallExpectation.setExpected(mockInvokable);
- mockDispatcher.addInvokable.setExpected(mockInvokable);
+ 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);
- verifyThis();
+ Verifier.verifyObject(this);
}
public void testMatchNoneAndVoid() throws Throwable {
- mockCallableFactory.expectCreateVoidCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS);
- mockCallableFactory.createVoidCallableResult = mockInvokable;
- mockDispatcher.addInvokable.setExpected(mockInvokable);
+ mockCallableFactory.addExpectedCreateVoidCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS);
+ mockCallableFactory.setupCreateVoidCallable(mockCall);
+ mockCallables.addExpectedMatch(mockCall);
mock.match(DummyInterface.METHOD_NOARG_NAME);
- verifyThis();
+ Verifier.verifyObject(this);
}
public void testMatchNoneAndReturn() throws Throwable {
- mockCallableFactory.expectCreateReturnCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS, DummyInterface.METHOD_NOARG_RESULT);
- mockCallableFactory.createReturnCallableResult = mockInvokable;
- mockDispatcher.addInvokable.setExpected(mockInvokable);
+ 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);
- verifyThis();
+ Verifier.verifyObject(this);
}
public void testMatchNoneAndThrow() throws Throwable {
- mockCallableFactory.expectCreateThrowableCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS, METHOD_EXCEPTION);
- mockCallableFactory.createThrowableCallableResult = mockInvokable;
- mockDispatcher.addInvokable.setExpected(mockInvokable);
+ mockCallableFactory.addExpectedCreateThrowableCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS, METHOD_EXCEPTION);
+ mockCallableFactory.setupCreateThrowableCallable(mockCall);
+ mockCallables.addExpectedMatch(mockCall);
mock.matchAndThrow(DummyInterface.METHOD_NOARG_NAME, METHOD_EXCEPTION);
- verifyThis();
+ Verifier.verifyObject(this);
}
public void testMatchOneAndVoid() throws Throwable {
- mockCallableFactory.expectCreateVoidCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS);
- mockCallableFactory.createVoidCallableResult = mockInvokable;
- mockDispatcher.addInvokable.setExpected(mockInvokable);
+ 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]);
- verifyThis();
+ Verifier.verifyObject(this);
}
public void testMatchOneAndReturn() throws Throwable {
- mockCallableFactory.expectCreateReturnCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, DummyInterface.METHOD_ONEARG_RESULT);
- mockCallableFactory.createReturnCallableResult = mockInvokable;
- mockDispatcher.addInvokable.setExpected(mockInvokable);
+ 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);
- verifyThis();
+ Verifier.verifyObject(this);
}
public void testMatchOneAndThrow() throws Throwable {
- mockCallableFactory.expectCreateThrowableCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, METHOD_EXCEPTION);
- mockCallableFactory.createThrowableCallableResult = mockInvokable;
- mockDispatcher.addInvokable.setExpected(mockInvokable);
+ mockCallableFactory.addExpectedCreateThrowableCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, METHOD_EXCEPTION);
+ mockCallableFactory.setupCreateThrowableCallable(mockCall);
+ mockCallables.addExpectedMatch(mockCall);
mock.matchAndThrow(DummyInterface.METHOD_ONEARG_NAME, DummyInterface.METHOD_ONEARG_ARGS[0], METHOD_EXCEPTION);
- verifyThis();
+ Verifier.verifyObject(this);
}
public void testMatchManyAndVoid() throws Throwable {
- mockCallableFactory.expectCreateVoidCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS);
- mockCallableFactory.createVoidCallableResult = mockInvokable;
- mockDispatcher.addInvokable.setExpected(mockInvokable);
+ mockCallableFactory.addExpectedCreateVoidCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS);
+ mockCallableFactory.setupCreateVoidCallable(mockCall);
+ mockCallables.addExpectedMatch(mockCall);
mock.match(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS);
- verifyThis();
+ Verifier.verifyObject(this);
}
public void testMatchManyAndReturn() throws Throwable {
- mockCallableFactory.expectCreateReturnCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, DummyInterface.METHOD_TWOARG_RESULT);
- mockCallableFactory.createReturnCallableResult = mockInvokable;
- mockDispatcher.addInvokable.setExpected(mockInvokable);
+ 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);
- verifyThis();
+ Verifier.verifyObject(this);
}
public void testMatchManyAndThrow() throws Throwable {
- mockCallableFactory.expectCreateThrowableCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION);
- mockCallableFactory.createThrowableCallableResult = mockInvokable;
- mockDispatcher.addInvokable.setExpected(mockInvokable);
+ 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);
- verifyThis();
+ Verifier.verifyObject(this);
}
public void testExpectWithConstraint() throws Throwable {
- mockCallableFactory.expectCreateVoidCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS);
- mockCallableFactory.createVoidCallableResult = mockInvokable;
- mockCallableFactory.createCallExpectation.setExpected(mockInvokable);
- mockDispatcher.addInvokable.setExpected(mockInvokable);
+ 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]));
- verifyThis();
+ Verifier.verifyObject(this);
}
public void testExpectWithConstraintArray() throws Throwable {
- mockCallableFactory.expectCreateVoidCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS);
- mockCallableFactory.createVoidCallableResult = mockInvokable;
- mockCallableFactory.createCallExpectation.setExpected(mockInvokable);
- mockDispatcher.addInvokable.setExpected(mockInvokable);
+ 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])});
- verifyThis();
- mockDispatcher.verifyExpectations();
+ Verifier.verifyObject(this);
+ mockCallables.verifyExpectations();
}
}
|
×
Want the latest updates on software, tech news, and AI?
Get latest updates about software, tech news, and AI from SourceForge directly in your inbox once a month.
Thanks for helping keep SourceForge clean.
X