Menu
▾
▴
[MO-java-dev] CVS: mockobjects-java/src/core/test/mockobjects/dynamic MockInvocationDispatcher.java,NONE,1.1 MockInvokableFactory.java,NONE,1.1 LIFOInvocationDispatcherTest.java,NONE,1.1 MockTest.java,1.18,1.19 CoreMockTest.java,1.4,1.5 InvocationDispatcherTest.java,1.2,NONE CallBagTest.java,1.12,NONE MockCallFactory.java,1.6,NONE MockCallableCollection.java,1.7,NONE MockCallableFactory.java,1.2,NONE MockCallableList.java,1.2,NONE
|
From: Steve F. <sm...@us...> - 2003-09-11 21:39:06
|
Update of /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic In directory sc8-pr-cvs1:/tmp/cvs-serv7270/src/core/test/mockobjects/dynamic Modified Files: MockTest.java CoreMockTest.java Added Files: MockInvocationDispatcher.java MockInvokableFactory.java LIFOInvocationDispatcherTest.java Removed Files: InvocationDispatcherTest.java CallBagTest.java MockCallFactory.java MockCallableCollection.java MockCallableFactory.java MockCallableList.java Log Message: Changed CoreMock to use InvocationDispatcher instead of CallableCollection, and propagated changes. Removed OrderedMock and other unused types. --- NEW FILE: MockInvocationDispatcher.java --- /* * 11-Sep-2003 * Copyright mockobjects.com */ package test.mockobjects.dynamic; import junit.framework.AssertionFailedError; import com.mockobjects.ExpectationCounter; import com.mockobjects.ExpectationValue; import com.mockobjects.MockObject; import com.mockobjects.dynamic.Invocation; import com.mockobjects.dynamic.InvocationDispatcher; import com.mockobjects.dynamic.Invokable; public class MockInvocationDispatcher extends MockObject implements InvocationDispatcher { public ExpectationValue dispatchInvocation = new ExpectationValue("dispatchInvocation"); public Object dispatchResult; public Throwable dispatchThrowable; public ExpectationValue addInvokable = new ExpectationValue("addInvokable"); public ExpectationCounter clearCalls = new ExpectationCounter("clear calls"); public ExpectationCounter verifyCalls = new ExpectationCounter("verify calls"); public AssertionFailedError verifyFailure; public void add(Invokable invokable) { addInvokable.setActual(invokable); } public void clear() { clearCalls.inc(); } public Object dispatch(Invocation invocation) throws Throwable { dispatchInvocation.setActual(invocation); if (null != dispatchThrowable) { throw dispatchThrowable; } return dispatchResult; } /** * @deprecated Use verifyExpectations to verify this object */ public void verify() { verifyCalls.inc(); if (null != verifyFailure) { throw verifyFailure; } } public void verifyExpectations() { super.verify(); } } --- NEW FILE: MockInvokableFactory.java --- /* * Copyright mockobjects.com 11-Sep-2003 * */ package test.mockobjects.dynamic; import com.mockobjects.ExpectationList; import com.mockobjects.ExpectationValue; import com.mockobjects.MockObject; import com.mockobjects.dynamic.InvokableFactory; import com.mockobjects.dynamic.ConstraintMatcher; import com.mockobjects.dynamic.Invokable; public class MockInvokableFactory extends MockObject implements InvokableFactory { public Invokable createCallExpectationResult; public Invokable createReturnCallableResult; public Invokable createThrowableCallableResult; public Invokable createVoidCallableResult; public ExpectationValue createCallExpectation = new ExpectationValue("createCallExpectation"); public ExpectationList parameters = new ExpectationList("parameters"); public Invokable createCallExpectation(Invokable invokable) { createCallExpectation.setActual(invokable); return createCallExpectationResult; } public void expectCreateReturnCallable( String methodName, ConstraintMatcher constraints, Object result) { parameters.addExpectedMany( new Object[] { "createReturnCallable", methodName, constraints, result }); } public Invokable createReturnCallable( String methodName, ConstraintMatcher constraints, Object result) { parameters.addActualMany( new Object[] { "createReturnCallable", methodName, constraints, result }); return createReturnCallableResult; } public void expectCreateThrowableCallable( String methodName, ConstraintMatcher constraints, Throwable throwable) { parameters.addExpectedMany( new Object[] { "createThrowableCallable", methodName, constraints, throwable }); } public Invokable createThrowableCallable( String methodName, ConstraintMatcher constraints, Throwable throwable) { parameters.addActualMany( new Object[] { "createThrowableCallable", methodName, constraints, throwable }); return createThrowableCallableResult; } public void expectCreateVoidCallable( String methodName, ConstraintMatcher constraints) { parameters.addExpectedMany( new Object[] { "createVoidCallable", methodName, constraints }); } public Invokable createVoidCallable( String methodName, ConstraintMatcher constraints) { parameters.addActualMany( new Object[] { "createVoidCallable", methodName, constraints }); return createVoidCallableResult; } } --- NEW FILE: LIFOInvocationDispatcherTest.java --- /* * Created on 20-Aug-2003 * Copyright mockobjects.com */ package test.mockobjects.dynamic; import java.lang.reflect.Method; import junit.framework.TestCase; import com.mockobjects.dynamic.DynamicMockError; import com.mockobjects.dynamic.Invocation; import com.mockobjects.dynamic.LIFOInvocationDispatcher; public class LIFOInvocationDispatcherTest extends TestCase { private Invocation invocation; private LIFOInvocationDispatcher dispatcher; private MockInvokable invokable1 = new MockInvokable(); private MockInvokable invokable2 = new MockInvokable(); public void setUp() throws NoSuchMethodException { invocation = new Invocation(getDummyMethod(), null); dispatcher = new LIFOInvocationDispatcher(); } public void dummyMethod() {}; public void testInvokeFailsWhenEmpty() throws Throwable { try { dispatcher.dispatch(invocation); } catch( DynamicMockError ex ) { assertSame("should be same invocation", invocation, ex.invocation); return; } fail("expected AssertionFailedError"); } public void testInvokesInvokableThatMatches() throws Throwable { Object result = "invoke result"; invokable1.matchesInvocation.setExpected(invocation); invokable1.matchesResult = true; invokable1.invokeInvocation.setExpected(invocation); invokable1.invokeResult = result; dispatcher.add( invokable1 ); dispatcher.dispatch(invocation); invokable1.verifyExpectations(); } public void testReturnsValueFromInvokable() throws Throwable { Object result = "invoke result"; invokable1.matchesResult = true; invokable1.invokeResult = result; dispatcher.add( invokable1 ); assertSame( "should be same result", result, dispatcher.dispatch(invocation) ); } public void testPropagatesExceptionFromInvokable() throws Throwable { Throwable exception = new Throwable("test throwable"); invokable1.matchesResult = true; invokable1.invokeThrow = exception; dispatcher.add( invokable1 ); try { dispatcher.dispatch(invocation); fail("expected exception"); } catch( Throwable t ) { assertSame( "should be same exception", exception, t ); } } public void testInvokeFailsWhenNoInvokablesMatch() throws Throwable { invokable1.matchesResult = false; invokable2.matchesResult = false; dispatcher.add( invokable1 ); dispatcher.add( invokable2 ); try { dispatcher.dispatch(invocation); } catch( DynamicMockError ex ) { assertSame("should be same invocation", invocation, ex.invocation); return; } fail("expected AssertionFailedError"); } public void testLaterInvokablesOverrideEarlierInvokables() throws Throwable { invokable1.matchesInvocation.setExpectNothing(); invokable1.matchesResult = true; invokable1.invokeInvocation.setExpectNothing(); invokable2.matchesInvocation.setExpected(invocation); invokable2.matchesResult = true; invokable2.invokeInvocation.setExpected(invocation); dispatcher.add( invokable1 ); dispatcher.add( invokable2 ); dispatcher.dispatch( invocation ); verifyInvokables(); } public void testSearchesForMatchInLIFOOrder() throws Throwable { invokable1.matchesInvocation.setExpected(invocation); invokable1.matchesResult = true; invokable1.invokeInvocation.setExpected(invocation); invokable1.invokeResult = "one"; invokable2.matchesInvocation.setExpected(invocation); invokable2.matchesResult = false; invokable2.invokeInvocation.setExpectNothing(); dispatcher.add( invokable1 ); dispatcher.add( invokable2 ); assertEquals("Should be invokable1", "one", dispatcher.dispatch( invocation )); verifyInvokables(); } public void testVerifiesAllInvokables() { invokable1.verifyCalls.setExpected(1); invokable2.verifyCalls.setExpected(1); dispatcher.add( invokable1 ); dispatcher.add( invokable2 ); dispatcher.verify(); verifyInvokables(); } public void testClearRemovesAllInvokables() throws Throwable { invokable1.matchesResult = true; dispatcher.add( invokable1 ); dispatcher.clear(); testInvokeFailsWhenEmpty(); } private Method getDummyMethod() throws NoSuchMethodException { return getClass().getDeclaredMethod("dummyMethod", new Class[0]); } private void verifyInvokables() { invokable1.verifyExpectations(); invokable2.verifyExpectations(); } } Index: MockTest.java =================================================================== RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockTest.java,v retrieving revision 1.18 retrieving revision 1.19 diff -u -r1.18 -r1.19 --- MockTest.java 9 Jul 2003 23:54:20 -0000 1.18 +++ MockTest.java 11 Sep 2003 21:39:01 -0000 1.19 @@ -1,11 +1,12 @@ package test.mockobjects.dynamic; +import junit.framework.TestCase; + import com.mockobjects.constraint.Constraint; import com.mockobjects.constraint.IsEqual; -import com.mockobjects.dynamic.*; -import com.mockobjects.util.*; - -import junit.framework.*; +import com.mockobjects.dynamic.C; +import com.mockobjects.dynamic.ConstraintMatcher; +import com.mockobjects.dynamic.Mock; public class MockTest extends TestCase { @@ -15,11 +16,10 @@ final ConstraintMatcher METHOD_ONEARG_CONSTRAINTS = C.args(C.eq("oneP1")); final ConstraintMatcher METHOD_TWOARG_CONSTRAINTS = C.args(C.eq("twoP1"), C.eq("twoP2")); - private MockCallableFactory mockCallableFactory = new MockCallableFactory(); - private MockCallableCollection mockCallables = new MockCallableCollection(); - private MockCallable mockCall = new MockCallable("call match"); + private MockInvokableFactory mockCallableFactory = new MockInvokableFactory(); + private MockInvocationDispatcher mockDispatcher = new MockInvocationDispatcher(); + private MockInvokable mockInvokable = new MockInvokable(); - private DummyInterface proxy; private Mock mock; public MockTest(String name) throws Exception { @@ -27,220 +27,227 @@ } public void setUp() { - mock = new Mock(mockCallableFactory, mockCallables, DummyInterface.class, MOCK_NAME); - proxy = (DummyInterface)mock.proxy(); - mockCallableFactory.setupCreateCallExpectation(mockCall); + mock = new Mock(mockCallableFactory, mockDispatcher, DummyInterface.class, MOCK_NAME); + mockCallableFactory.createCallExpectationResult = mockInvokable; } public void testExpectManyAndVoid() throws Throwable { - mockCallableFactory.addExpectedCreateVoidCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS); - mockCallableFactory.setupCreateVoidCallable(mockCall); - mockCallableFactory.addExpectedCreateCallExpectation(mockCall); - mockCallables.addExpectedExpect(mockCall); + mockCallableFactory.createVoidCallableResult = mockInvokable; + + mockCallableFactory.expectCreateVoidCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS); + mockCallableFactory.createCallExpectation.setExpected(mockInvokable); + + mockDispatcher.addInvokable.setExpected(mockInvokable); mock.expect(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS); - Verifier.verifyObject(this); + verifyThis(); } - 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); + 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); mock.expectAndReturn(DummyInterface.METHOD_NOARG_NAME, DummyInterface.METHOD_NOARG_RESULT); - Verifier.verifyObject(this); + verifyThis(); } public void testExpectNoneAndThrow() throws Throwable { - mockCallableFactory.addExpectedCreateThrowableCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS, METHOD_EXCEPTION); - mockCallableFactory.setupCreateThrowableCallable(mockCall); - mockCallableFactory.addExpectedCreateCallExpectation(mockCall); - mockCallables.addExpectedExpect(mockCall); + mockCallableFactory.expectCreateThrowableCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS, METHOD_EXCEPTION); + mockCallableFactory.createThrowableCallableResult = mockInvokable; + mockCallableFactory.createCallExpectation.setExpected(mockInvokable); + mockDispatcher.addInvokable.setExpected(mockInvokable); mock.expectAndThrow(DummyInterface.METHOD_NOARG_NAME, METHOD_EXCEPTION); - Verifier.verifyObject(this); + verifyThis(); } public void testExpectOneAndThrow() throws Throwable { - mockCallableFactory.addExpectedCreateThrowableCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, METHOD_EXCEPTION); - mockCallableFactory.setupCreateThrowableCallable(mockCall); - mockCallableFactory.addExpectedCreateCallExpectation(mockCall); - mockCallables.addExpectedExpect(mockCall); + mockCallableFactory.expectCreateThrowableCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, METHOD_EXCEPTION); + mockCallableFactory.createThrowableCallableResult = mockInvokable; + mockCallableFactory.createCallExpectation.setExpected(mockInvokable); + mockDispatcher.addInvokable.setExpected(mockInvokable); mock.expectAndThrow(DummyInterface.METHOD_ONEARG_NAME, DummyInterface.METHOD_ONEARG_ARGS[0], METHOD_EXCEPTION); - Verifier.verifyObject(this); + verifyThis(); } public void testExpectNoneAndVoid() throws Throwable { - mockCallableFactory.addExpectedCreateVoidCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS); - mockCallableFactory.setupCreateVoidCallable(mockCall); - mockCallableFactory.addExpectedCreateCallExpectation(mockCall); - mockCallables.addExpectedExpect(mockCall); + mockCallableFactory.expectCreateVoidCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS); + mockCallableFactory.createVoidCallableResult = mockInvokable; + mockCallableFactory.createCallExpectation.setExpected(mockInvokable); + mockDispatcher.addInvokable.setExpected(mockInvokable); mock.expect(DummyInterface.METHOD_NOARG_NAME); - Verifier.verifyObject(this); + verifyThis(); } public void testExpectOneAndVoid() throws Throwable { - mockCallableFactory.addExpectedCreateVoidCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS); - mockCallableFactory.setupCreateVoidCallable(mockCall); - mockCallableFactory.addExpectedCreateCallExpectation(mockCall); - mockCallables.addExpectedExpect(mockCall); + mockCallableFactory.expectCreateVoidCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS); + mockCallableFactory.createVoidCallableResult = mockInvokable; + mockCallableFactory.createCallExpectation.setExpected(mockInvokable); + mockDispatcher.addInvokable.setExpected(mockInvokable); mock.expect(DummyInterface.METHOD_ONEARG_NAME, DummyInterface.METHOD_ONEARG_ARGS[0]); - Verifier.verifyObject(this); + verifyThis(); } public void testExpectManyAndReturn() throws Throwable { - mockCallableFactory.addExpectedCreateReturnCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, DummyInterface.METHOD_TWOARG_RESULT); - mockCallableFactory.setupCreateReturnCallable(mockCall); - mockCallableFactory.addExpectedCreateCallExpectation(mockCall); - mockCallables.addExpectedExpect(mockCall); + mockCallableFactory.expectCreateReturnCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, DummyInterface.METHOD_TWOARG_RESULT); + mockCallableFactory.createReturnCallableResult = mockInvokable; + mockCallableFactory.createCallExpectation.setExpected(mockInvokable); + mockDispatcher.addInvokable.setExpected(mockInvokable); mock.expectAndReturn(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, DummyInterface.METHOD_TWOARG_RESULT); - Verifier.verifyObject(this); + verifyThis(); } public void testExpectManyAndThrow() throws Throwable { - mockCallableFactory.addExpectedCreateThrowableCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION); - mockCallableFactory.setupCreateThrowableCallable(mockCall); - mockCallableFactory.addExpectedCreateCallExpectation(mockCall); - mockCallables.addExpectedExpect(mockCall); + mockCallableFactory.expectCreateThrowableCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION); + mockCallableFactory.createThrowableCallableResult = mockInvokable; + mockCallableFactory.createCallExpectation.setExpected(mockInvokable); + mockDispatcher.addInvokable.setExpected(mockInvokable); mock.expectAndThrow(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION); - Verifier.verifyObject(this); + verifyThis(); } public void testExpectOneAndReturn() throws Throwable { - mockCallableFactory.addExpectedCreateReturnCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, DummyInterface.METHOD_ONEARG_RESULT); - mockCallableFactory.setupCreateReturnCallable(mockCall); - mockCallableFactory.addExpectedCreateCallExpectation(mockCall); - mockCallables.addExpectedExpect(mockCall); + mockCallableFactory.expectCreateReturnCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, DummyInterface.METHOD_ONEARG_RESULT); + mockCallableFactory.createReturnCallableResult = mockInvokable; + mockCallableFactory.createCallExpectation.setExpected(mockInvokable); + mockDispatcher.addInvokable.setExpected(mockInvokable); mock.expectAndReturn(DummyInterface.METHOD_ONEARG_NAME, DummyInterface.METHOD_ONEARG_ARGS[0], DummyInterface.METHOD_ONEARG_RESULT); - Verifier.verifyObject(this); + verifyThis(); } public void testMatchNoneAndVoid() throws Throwable { - mockCallableFactory.addExpectedCreateVoidCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS); - mockCallableFactory.setupCreateVoidCallable(mockCall); - mockCallables.addExpectedMatch(mockCall); + mockCallableFactory.expectCreateVoidCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS); + mockCallableFactory.createVoidCallableResult = mockInvokable; + mockDispatcher.addInvokable.setExpected(mockInvokable); mock.match(DummyInterface.METHOD_NOARG_NAME); - Verifier.verifyObject(this); + verifyThis(); } public void testMatchNoneAndReturn() throws Throwable { - mockCallableFactory.addExpectedCreateReturnCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS, DummyInterface.METHOD_NOARG_RESULT); - mockCallableFactory.setupCreateReturnCallable(mockCall); - mockCallables.addExpectedMatch(mockCall); + mockCallableFactory.expectCreateReturnCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS, DummyInterface.METHOD_NOARG_RESULT); + mockCallableFactory.createReturnCallableResult = mockInvokable; + mockDispatcher.addInvokable.setExpected(mockInvokable); mock.matchAndReturn(DummyInterface.METHOD_NOARG_NAME, DummyInterface.METHOD_NOARG_RESULT); - Verifier.verifyObject(this); + verifyThis(); } public void testMatchNoneAndThrow() throws Throwable { - mockCallableFactory.addExpectedCreateThrowableCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS, METHOD_EXCEPTION); - mockCallableFactory.setupCreateThrowableCallable(mockCall); - mockCallables.addExpectedMatch(mockCall); + mockCallableFactory.expectCreateThrowableCallable(DummyInterface.METHOD_NOARG_NAME, C.NO_ARGS, METHOD_EXCEPTION); + mockCallableFactory.createThrowableCallableResult = mockInvokable; + mockDispatcher.addInvokable.setExpected(mockInvokable); mock.matchAndThrow(DummyInterface.METHOD_NOARG_NAME, METHOD_EXCEPTION); - Verifier.verifyObject(this); + verifyThis(); } public void testMatchOneAndVoid() throws Throwable { - mockCallableFactory.addExpectedCreateVoidCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS); - mockCallableFactory.setupCreateVoidCallable(mockCall); - mockCallables.addExpectedMatch(mockCall); + mockCallableFactory.expectCreateVoidCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS); + mockCallableFactory.createVoidCallableResult = mockInvokable; + mockDispatcher.addInvokable.setExpected(mockInvokable); mock.match(DummyInterface.METHOD_ONEARG_NAME, DummyInterface.METHOD_ONEARG_ARGS[0]); - Verifier.verifyObject(this); + verifyThis(); } public void testMatchOneAndReturn() throws Throwable { - mockCallableFactory.addExpectedCreateReturnCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, DummyInterface.METHOD_ONEARG_RESULT); - mockCallableFactory.setupCreateReturnCallable(mockCall); - mockCallables.addExpectedMatch(mockCall); + mockCallableFactory.expectCreateReturnCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, DummyInterface.METHOD_ONEARG_RESULT); + mockCallableFactory.createReturnCallableResult = mockInvokable; + mockDispatcher.addInvokable.setExpected(mockInvokable); mock.matchAndReturn(DummyInterface.METHOD_ONEARG_NAME, DummyInterface.METHOD_ONEARG_ARGS[0], DummyInterface.METHOD_ONEARG_RESULT); - Verifier.verifyObject(this); + verifyThis(); } public void testMatchOneAndThrow() throws Throwable { - mockCallableFactory.addExpectedCreateThrowableCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, METHOD_EXCEPTION); - mockCallableFactory.setupCreateThrowableCallable(mockCall); - mockCallables.addExpectedMatch(mockCall); + mockCallableFactory.expectCreateThrowableCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, METHOD_EXCEPTION); + mockCallableFactory.createThrowableCallableResult = mockInvokable; + mockDispatcher.addInvokable.setExpected(mockInvokable); mock.matchAndThrow(DummyInterface.METHOD_ONEARG_NAME, DummyInterface.METHOD_ONEARG_ARGS[0], METHOD_EXCEPTION); - Verifier.verifyObject(this); + verifyThis(); } public void testMatchManyAndVoid() throws Throwable { - mockCallableFactory.addExpectedCreateVoidCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS); - mockCallableFactory.setupCreateVoidCallable(mockCall); - mockCallables.addExpectedMatch(mockCall); + mockCallableFactory.expectCreateVoidCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS); + mockCallableFactory.createVoidCallableResult = mockInvokable; + mockDispatcher.addInvokable.setExpected(mockInvokable); mock.match(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS); - Verifier.verifyObject(this); + verifyThis(); } public void testMatchManyAndReturn() throws Throwable { - mockCallableFactory.addExpectedCreateReturnCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, DummyInterface.METHOD_TWOARG_RESULT); - mockCallableFactory.setupCreateReturnCallable(mockCall); - mockCallables.addExpectedMatch(mockCall); + mockCallableFactory.expectCreateReturnCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, DummyInterface.METHOD_TWOARG_RESULT); + mockCallableFactory.createReturnCallableResult = mockInvokable; + mockDispatcher.addInvokable.setExpected(mockInvokable); mock.matchAndReturn(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, DummyInterface.METHOD_TWOARG_RESULT); - Verifier.verifyObject(this); + verifyThis(); } public void testMatchManyAndThrow() throws Throwable { - mockCallableFactory.addExpectedCreateThrowableCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION); - mockCallableFactory.setupCreateThrowableCallable(mockCall); - mockCallables.addExpectedMatch(mockCall); + mockCallableFactory.expectCreateThrowableCallable(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION); + mockCallableFactory.createThrowableCallableResult = mockInvokable; + mockDispatcher.addInvokable.setExpected(mockInvokable); mock.matchAndThrow(DummyInterface.METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION); - Verifier.verifyObject(this); + verifyThis(); } public void testExpectWithConstraint() throws Throwable { - mockCallableFactory.addExpectedCreateVoidCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS); - mockCallableFactory.setupCreateVoidCallable(mockCall); - mockCallableFactory.addExpectedCreateCallExpectation(mockCall); - mockCallables.addExpectedExpect(mockCall); + mockCallableFactory.expectCreateVoidCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS); + mockCallableFactory.createVoidCallableResult = mockInvokable; + mockCallableFactory.createCallExpectation.setExpected(mockInvokable); + mockDispatcher.addInvokable.setExpected(mockInvokable); mock.expect(DummyInterface.METHOD_ONEARG_NAME, new IsEqual(DummyInterface.METHOD_ONEARG_ARGS[0])); - Verifier.verifyObject(this); + verifyThis(); } public void testExpectWithConstraintArray() throws Throwable { - mockCallableFactory.addExpectedCreateVoidCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS); - mockCallableFactory.setupCreateVoidCallable(mockCall); - mockCallableFactory.addExpectedCreateCallExpectation(mockCall); - mockCallables.addExpectedExpect(mockCall); + mockCallableFactory.expectCreateVoidCallable(DummyInterface.METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS); + mockCallableFactory.createVoidCallableResult = mockInvokable; + mockCallableFactory.createCallExpectation.setExpected(mockInvokable); + mockDispatcher.addInvokable.setExpected(mockInvokable); mock.expect(DummyInterface.METHOD_ONEARG_NAME, new Constraint[] { new IsEqual(DummyInterface.METHOD_ONEARG_ARGS[0])}); - Verifier.verifyObject(this); - mockCallables.verifyExpectations(); + verifyThis(); + mockDispatcher.verifyExpectations(); } } Index: CoreMockTest.java =================================================================== RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/CoreMockTest.java,v retrieving revision 1.4 retrieving revision 1.5 diff -u -r1.4 -r1.5 --- CoreMockTest.java 20 Aug 2003 21:51:27 -0000 1.4 +++ CoreMockTest.java 11 Sep 2003 21:39:01 -0000 1.5 @@ -3,13 +3,13 @@ */ package test.mockobjects.dynamic; +import junit.framework.AssertionFailedError; +import junit.framework.TestCase; + import com.mockobjects.dynamic.CoreMock; import com.mockobjects.dynamic.DynamicUtil; +import com.mockobjects.dynamic.Invocation; import com.mockobjects.util.AssertMo; -import com.mockobjects.util.Verifier; - -import junit.framework.AssertionFailedError; -import junit.framework.TestCase; public class CoreMockTest extends TestCase { @@ -17,15 +17,15 @@ private DummyInterface proxy; private CoreMock coreMock; - private MockCallableCollection mockCallables = new MockCallableCollection(); - private MockCallable mockCallable = new MockCallable("coreMock mockCallable"); + private MockInvocationDispatcher mockDispatcher = new MockInvocationDispatcher(); + private MockInvokable mockInvokable = new MockInvokable(); public CoreMockTest(String name) { super(name); } public void setUp() { - coreMock = new CoreMock(DummyInterface.class, MOCK_NAME, mockCallables); + coreMock = new CoreMock(DummyInterface.class, MOCK_NAME, mockDispatcher); try { proxy = (DummyInterface)coreMock.proxy(); @@ -39,7 +39,7 @@ final String originalMessage = "original message"; Object arg = new AssertionFailedError(originalMessage); - mockCallables.callResult = arg; + mockDispatcher.dispatchResult = arg; try { proxy.noArgVoidMethod(); @@ -52,36 +52,15 @@ public void testProxyReturnsConfiguredResult() throws Throwable { final String RESULT = "configured result"; - mockCallables.callResult = RESULT; + mockDispatcher.dispatchResult = RESULT; assertSame("result is returned by coreMock", RESULT, proxy.oneArgMethod("arg")); } - public void testProxySendsAllArgument() throws Throwable { - mockCallables.addExpectedCall(DummyInterface.METHOD_TWOARG_NAME, DummyInterface.METHOD_TWOARG_ARGS); - - proxy.twoArgMethod(DummyInterface.METHOD_TWOARG_ARGS[0], DummyInterface.METHOD_TWOARG_ARGS[1]); - - // Can't use Verifier as we are verifying "verify" - mockCallables.verifyExpectations(); - } - - public void testProxySendsEmptyArrayWhenNoArguments() throws Throwable { - mockCallables.callResult = "result ignored"; - - mockCallables.addExpectedCall(DummyInterface.METHOD_NOARGVOID_NAME, DummyInterface.METHOD_NOARGVOID_ARGS); - - proxy.noArgVoidMethod(); - - Verifier.verifyObject(this); - // Can't use Verifier as we are verifying "verify" - mockCallables.verifyExpectations(); - } - public void testExceptionsPropagatedThroughProxy() throws Throwable { final Throwable throwable = new DummyThrowable(); - mockCallables.callException = throwable; + mockDispatcher.dispatchThrowable = throwable; try { proxy.noArgVoidMethod(); @@ -93,49 +72,50 @@ } public void testMockVerifies() throws Exception { - mockCallables.setExpectedVerifyCalls(1); + mockDispatcher.verifyCalls.setExpected(1); coreMock.verify(); // Can't use Verifier as we are verifying "verify" - mockCallables.verifyExpectations(); + mockDispatcher.verifyExpectations(); } public void testProxyEquality() throws Exception { - mockCallables.callResult = new Boolean(false); + mockDispatcher.dispatchResult = new Boolean(false); - mockCallables.setExpectedCallCalls(0); + mockDispatcher.dispatchInvocation.setExpectNothing(); assertTrue("Proxy equality is implemented directly", proxy.equals(proxy)); - - Verifier.verifyObject(this); + mockDispatcher.verifyExpectations(); } public void testProxyInequality() throws Exception { - mockCallables.callResult = new Boolean(false); + mockDispatcher.dispatchResult = new Boolean(false); - mockCallables.addExpectedCall("equals", new Object[] {"not a proxy"}); + mockDispatcher.dispatchInvocation.setExpected( + new Invocation("equals", new Class[] { Object.class }, boolean.class, + new Object[] { "not a proxy" })); assertFalse("Should handle proxy inequality by calling through", proxy.equals("not a proxy")); - - Verifier.verifyObject(this); + mockDispatcher.verifyExpectations(); } public void testProxyEqualityWithNull() throws Exception { - mockCallables.callResult = new Boolean(true); - mockCallables.addExpectedCall("equals", new Object[] {null}); + mockDispatcher.dispatchResult = new Boolean(true); + mockDispatcher.dispatchInvocation.setExpected( + new Invocation("equals", new Class[] { Object.class }, boolean.class, + new Object[] { null })); assertTrue("Proxy should handle null equality", proxy.equals(null)); - - Verifier.verifyObject(this); + mockDispatcher.verifyExpectations(); } public void testCallingGetMockNameOnProxyReturnsNameOfUnderlyingMock() { - mockCallables.setExpectedCallCalls(0); + mockDispatcher.dispatchInvocation.setExpectNothing(); assertEquals("proxy.getMockName() returns name of underlying mock", MOCK_NAME, proxy.getMockName()); - Verifier.verifyObject(this); + mockDispatcher.verifyExpectations(); } public void testGeneratesMockNameFromInterfaceNameIfNoNameSpecified() throws Exception { @@ -151,40 +131,33 @@ coreMock.verify(); // should not fail on a proxyToString call } - public void testAddAnExpectation() { - mockCallables.addExpectedExpect(mockCallable); + public void testAddAnInvokable() { + mockDispatcher.addInvokable.setExpected(mockInvokable); - coreMock.expect(mockCallable); + coreMock.expect(mockInvokable); - mockCallables.verifyExpectations(); + mockDispatcher.verifyExpectations(); } - public void testAddAStub() { - mockCallables.addExpectedMatch(mockCallable); - - coreMock.stub(mockCallable); - - mockCallables.verifyExpectations(); - } public void testReset() { - mockCallables.resetCalls.setExpected(1); + mockDispatcher.clearCalls.setExpected(1); coreMock.reset(); - mockCallables.verifyExpectations(); + mockDispatcher.verifyExpectations(); } public void testVerifyFailuresIncludeMockName() { - mockCallables.verifyFailure = new AssertionFailedError("verify failure"); + mockDispatcher.verifyFailure = new AssertionFailedError("verify failure"); - mockCallables.setExpectedVerifyCalls(1); + mockDispatcher.verifyCalls.setExpected(1); try { coreMock.verify(); } catch (AssertionFailedError expected) { AssertMo.assertIncludes("Should include mock name", MOCK_NAME, expected.getMessage()); - mockCallables.verifyExpectations(); + mockDispatcher.verifyExpectations(); return; } fail("Should have thrown exception"); --- InvocationDispatcherTest.java DELETED --- --- CallBagTest.java DELETED --- --- MockCallFactory.java DELETED --- --- MockCallableCollection.java DELETED --- --- MockCallableFactory.java DELETED --- --- MockCallableList.java DELETED --- |
