Update of /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic In directory sc8-pr-cvs1:/tmp/cvs-serv26046/core/test/mockobjects/dynamic Modified Files: Tag: DynamicMockExperiment MockTest.java MockCallableAddable.java CallBagTest.java CallSequenceTest.java Log Message: expectAndReturn has a higher precendence than matchAndReturn. This was previously unclear and could give strange results. this can be used to provide default method return values which can then be overridden in specific tests where there needs to be a precise expectation. AddableCallable interface has seperate addExpect and addMatch methods which open the door to simpler testing and less reliance on the DefaultCallFactory (this hasn't been implemented) Index: MockTest.java =================================================================== RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockTest.java,v retrieving revision 1.8.2.8 retrieving revision 1.8.2.9 diff -u -r1.8.2.8 -r1.8.2.9 --- MockTest.java 16 Apr 2003 22:48:21 -0000 1.8.2.8 +++ MockTest.java 17 Apr 2003 16:17:25 -0000 1.8.2.9 @@ -57,7 +57,7 @@ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch); mockCallFactory.setupCreateExpectedCall(mockExpectedCall); - mockCallableAddable.addExpectedAdd(mockExpectedCall); + mockCallableAddable.addExpectedAddExpect(mockExpectedCall); mock.expect(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS); @@ -73,7 +73,7 @@ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch); mockCallFactory.setupCreateExpectedCall(mockExpectedCall); - mockCallableAddable.addExpectedAdd(mockExpectedCall); + mockCallableAddable.addExpectedAddExpect(mockExpectedCall); mock.expectAndReturn(METHOD_NOARGANDRETURN_NAME, METHOD_NOARGANDRETURN_RESULT); @@ -89,7 +89,7 @@ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch); mockCallFactory.setupCreateExpectedCall(mockExpectedCall); - mockCallableAddable.addExpectedAdd(mockExpectedCall); + mockCallableAddable.addExpectedAddExpect(mockExpectedCall); mock.expectAndThrow(METHOD_NOARGANDRETURN_NAME, METHOD_EXCEPTION); @@ -105,7 +105,7 @@ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch); mockCallFactory.setupCreateExpectedCall(mockExpectedCall); - mockCallableAddable.addExpectedAdd(mockExpectedCall); + mockCallableAddable.addExpectedAddExpect(mockExpectedCall); mock.expectAndThrow(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_EXCEPTION); @@ -121,7 +121,7 @@ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch); mockCallFactory.setupCreateExpectedCall(mockExpectedCall); - mockCallableAddable.addExpectedAdd(mockExpectedCall); + mockCallableAddable.addExpectedAddExpect(mockExpectedCall); mock.expect(METHOD_NOARG_NAME); @@ -137,7 +137,7 @@ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch); mockCallFactory.setupCreateExpectedCall(mockExpectedCall); - mockCallableAddable.addExpectedAdd(mockExpectedCall); + mockCallableAddable.addExpectedAddExpect(mockExpectedCall); mock.expect(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0]); @@ -153,8 +153,8 @@ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch); mockCallFactory.setupCreateExpectedCall(mockExpectedCall); - mockCallableAddable.addExpectedAdd(mockExpectedCall); - mockCallableAddable.setupCallReturn(METHOD_TWOARG_RESULT); + mockCallableAddable.addExpectedAddExpect(mockExpectedCall); + mockCallableAddable.setupCall(METHOD_TWOARG_RESULT); mock.expectAndReturn(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_TWOARG_RESULT); @@ -170,8 +170,8 @@ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch); mockCallFactory.setupCreateExpectedCall(mockExpectedCall); - mockCallableAddable.addExpectedAdd(mockExpectedCall); - mockCallableAddable.setupCallReturn(METHOD_TWOARG_RESULT); + mockCallableAddable.addExpectedAddExpect(mockExpectedCall); + mockCallableAddable.setupCall(METHOD_TWOARG_RESULT); mock.expectAndThrow(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION); @@ -187,8 +187,8 @@ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch); mockCallFactory.setupCreateExpectedCall(mockExpectedCall); - mockCallableAddable.addExpectedAdd(mockExpectedCall); - mockCallableAddable.setupCallReturn(METHOD_ONEARG_RESULT); + mockCallableAddable.addExpectedAddExpect(mockExpectedCall); + mockCallableAddable.setupCall(METHOD_ONEARG_RESULT); mock.expectAndReturn(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_ONEARG_RESULT); @@ -202,8 +202,8 @@ mockCallFactory.addExpectedCreateCallMatch(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockReturnStub); mockCallFactory.setupCreateCallMatch(mockCallMatch); - mockCallableAddable.addExpectedAdd(mockCallMatch); - mockCallableAddable.setupCallReturn(METHOD_TWOARG_RESULT); + mockCallableAddable.addExpectedAddMatch(mockCallMatch); + mockCallableAddable.setupCall(METHOD_TWOARG_RESULT); mock.matchAndReturn(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_TWOARG_RESULT); @@ -217,8 +217,8 @@ mockCallFactory.addExpectedCreateCallMatch(METHOD_NOARG_NAME, C.NO_ARGS, mockThrowStub); mockCallFactory.setupCreateCallMatch(mockCallMatch); - mockCallableAddable.addExpectedAdd(mockCallMatch); - mockCallableAddable.setupCallReturn(METHOD_NOARGANDRETURN_RESULT); + mockCallableAddable.addExpectedAddMatch(mockCallMatch); + mockCallableAddable.setupCall(METHOD_NOARGANDRETURN_RESULT); mock.matchAndThrow(METHOD_NOARG_NAME, METHOD_EXCEPTION); @@ -232,8 +232,8 @@ mockCallFactory.addExpectedCreateCallMatch(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub); mockCallFactory.setupCreateCallMatch(mockCallMatch); - mockCallableAddable.addExpectedAdd(mockCallMatch); - mockCallableAddable.setupCallReturn(METHOD_ONEARG_RESULT); + mockCallableAddable.addExpectedAddMatch(mockCallMatch); + mockCallableAddable.setupCall(METHOD_ONEARG_RESULT); mock.matchAndThrow(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_EXCEPTION); @@ -247,8 +247,8 @@ mockCallFactory.addExpectedCreateCallMatch(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockThrowStub); mockCallFactory.setupCreateCallMatch(mockCallMatch); - mockCallableAddable.addExpectedAdd(mockCallMatch); - mockCallableAddable.setupCallReturn(METHOD_TWOARG_RESULT); + mockCallableAddable.addExpectedAddMatch(mockCallMatch); + mockCallableAddable.setupCall(METHOD_TWOARG_RESULT); mock.matchAndThrow(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION); @@ -262,8 +262,8 @@ mockCallFactory.addExpectedCreateCallMatch(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub); mockCallFactory.setupCreateCallMatch(mockCallMatch); - mockCallableAddable.addExpectedAdd(mockCallMatch); - mockCallableAddable.setupCallReturn(METHOD_ONEARG_RESULT); + mockCallableAddable.addExpectedAddMatch(mockCallMatch); + mockCallableAddable.setupCall(METHOD_ONEARG_RESULT); mock.matchAndReturn(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_ONEARG_RESULT); @@ -277,8 +277,8 @@ mockCallFactory.addExpectedCreateCallMatch(METHOD_NOARG_NAME, C.NO_ARGS, mockReturnStub); mockCallFactory.setupCreateCallMatch(mockCallMatch); - mockCallableAddable.addExpectedAdd(mockCallMatch); - mockCallableAddable.setupCallReturn(METHOD_ONEARG_RESULT); + mockCallableAddable.addExpectedAddMatch(mockCallMatch); + mockCallableAddable.setupCall(METHOD_ONEARG_RESULT); mock.matchAndReturn(METHOD_NOARG_NAME, METHOD_NOARGANDRETURN_RESULT); @@ -290,7 +290,7 @@ throws Throwable { final String originalMessage = "original message"; - mockCallableAddable.setupCallThrow(new AssertionFailedError(originalMessage)); + mockCallableAddable.setupCall(new AssertionFailedError(originalMessage)); try { proxy.noArgMethodVoid(); @@ -308,14 +308,14 @@ throws Throwable { final String result = "configured result"; - mockCallableAddable.setupCallReturn(result); + mockCallableAddable.setupCall(result); assertSame("result is returned by mock", result, proxy.oneArgMethod(METHOD_TWOARG_ARGS[0])); } public void testMockProxySendsAllArgument() throws Throwable { - mockCallableAddable.setExpectedCall(mock, METHOD_TWOARG_NAME, METHOD_TWOARG_ARGS); - mockCallableAddable.setupCallReturn("result ignored"); + mockCallableAddable.addExpectedCall(mock, METHOD_TWOARG_NAME, METHOD_TWOARG_ARGS); + mockCallableAddable.setupCall("result ignored"); proxy.twoArgMethod(METHOD_TWOARG_ARGS[0], METHOD_TWOARG_ARGS[1]); @@ -324,8 +324,8 @@ public void testMockProxySendsEmptyArrayWhenNoArguments() throws Exception { - mockCallableAddable.setExpectedCall(mock, METHOD_NOARG_NAME, METHOD_NOARG_ARGS); - mockCallableAddable.setupCallReturn("result ignored"); + mockCallableAddable.addExpectedCall(mock, METHOD_NOARG_NAME, METHOD_NOARG_ARGS); + mockCallableAddable.setupCall("result ignored"); proxy.noArgMethodVoid(); @@ -337,7 +337,7 @@ throws Throwable { final Throwable throwable = new DummyThrowable(); - mockCallableAddable.setupCallReturn(new ThrowStub(throwable)); + mockCallableAddable.setupCall(new ThrowStub(throwable)); try { proxy.noArgMethodVoid(); @@ -367,7 +367,7 @@ CallStub ret = new ReturnStub(new Boolean(IGNORED_RESULT)); mockCallFactory.setupCreateReturnStub(ret); mockCallFactory.setupCreateCallMatch(new CallMatch("call",C.anyArgs(1),ret)); - mockCallableAddable.setupCallReturn(new Boolean(false)); + mockCallableAddable.setupCall(new Boolean(false)); mock.matchAndReturn("call", C.anyArgs(1), IGNORED_RESULT); assertFalse("Should handle proxy inequality by calling through", proxy.equals("not a proxy")); Index: MockCallableAddable.java =================================================================== RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/Attic/MockCallableAddable.java,v retrieving revision 1.1.2.1 retrieving revision 1.1.2.2 diff -u -r1.1.2.1 -r1.1.2.2 --- MockCallableAddable.java 14 Apr 2003 08:46:29 -0000 1.1.2.1 +++ MockCallableAddable.java 17 Apr 2003 16:17:26 -0000 1.1.2.2 @@ -1,38 +1,143 @@ package test.mockobjects.dynamic; - import com.mockobjects.*; -import com.mockobjects.dynamic.CallableAddable; + import com.mockobjects.dynamic.Callable; +import com.mockobjects.dynamic.CallableAddable; +import com.mockobjects.dynamic.Mock; + +//Mock modified for []args +public class MockCallableAddable extends MockObject implements CallableAddable { + private ExpectationCounter myAddMatchCalls = new ExpectationCounter("com.mockobjects.dynamic.CallableAddable AddMatchCalls"); + private ExpectationList myAddMatchParameter0Values = new ExpectationList("com.mockobjects.dynamic.CallableAddable AddMatchParameter0Values"); + private ExpectationCounter myAddExpectCalls = new ExpectationCounter("com.mockobjects.dynamic.CallableAddable AddExpectCalls"); + private ExpectationList myAddExpectParameter0Values = new ExpectationList("com.mockobjects.dynamic.CallableAddable AddExpectParameter0Values"); + private ExpectationCounter myMatchesCalls = new ExpectationCounter("com.mockobjects.dynamic.CallableAddable MatchesCalls"); + private ReturnValues myActualMatchesReturnValues = new ReturnValues(true); + private ExpectationList myMatchesParameter0Values = new ExpectationList("com.mockobjects.dynamic.CallableAddable MatchesParameter0Values"); + private ExpectationList myMatchesParameter1Values = new ExpectationList("com.mockobjects.dynamic.CallableAddable MatchesParameter1Values"); + private ExpectationCounter myGetDescriptionCalls = new ExpectationCounter("com.mockobjects.dynamic.CallableAddable GetDescriptionCalls"); + private ReturnValues myActualGetDescriptionReturnValues = new ReturnValues(true); + private ExpectationCounter myCallCalls = new ExpectationCounter("com.mockobjects.dynamic.CallableAddable CallCalls"); + private ReturnValues myActualCallReturnValues = new ReturnValues(true); + private ExpectationList myCallParameter0Values = new ExpectationList("com.mockobjects.dynamic.CallableAddable CallParameter0Values"); + private ExpectationList myCallParameter1Values = new ExpectationList("com.mockobjects.dynamic.CallableAddable CallParameter1Values"); + private ExpectationList myCallParameter2Values = new ExpectationList("com.mockobjects.dynamic.CallableAddable CallParameter2Values"); + private ExpectationCounter myVerifyCalls = new ExpectationCounter("com.mockobjects.dynamic.CallableAddable VerifyCalls"); + + public void setExpectedAddMatchCalls(int calls) { + myAddMatchCalls.setExpected(calls); + } + + public void addExpectedAddMatch(Callable arg0) { + myAddMatchParameter0Values.addExpected(arg0); + } + + public void addMatch(Callable arg0) { + myAddMatchCalls.inc(); + myAddMatchParameter0Values.addActual(arg0); + } + + public void setExpectedAddExpectCalls(int calls) { + myAddExpectCalls.setExpected(calls); + } + + public void addExpectedAddExpect(Callable arg0) { + myAddExpectParameter0Values.addExpected(arg0); + } + + public void addExpect(Callable arg0) { + myAddExpectCalls.inc(); + myAddExpectParameter0Values.addActual(arg0); + } + + public void setExpectedMatchesCalls(int calls) { + myMatchesCalls.setExpected(calls); + } + + public void addExpectedMatches(String arg0, Object[] arg1) { + myMatchesParameter0Values.addExpected(arg0); + myMatchesParameter1Values.addExpected(arg1); + } + + public boolean matches(String arg0, Object[] arg1) { + myMatchesCalls.inc(); + myMatchesParameter0Values.addActual(arg0); + myMatchesParameter1Values.addActual(arg1); + + Object nextReturnValue = myActualMatchesReturnValues.getNext(); + + return ((Boolean) nextReturnValue).booleanValue(); + } + + public void setupMatches(boolean arg) { + myActualMatchesReturnValues.add(new Boolean(arg)); + } + + public void setExpectedGetDescriptionCalls(int calls) { + myGetDescriptionCalls.setExpected(calls); + } + + public String getDescription() { + myGetDescriptionCalls.inc(); + + Object nextReturnValue = myActualGetDescriptionReturnValues.getNext(); + + return (String) nextReturnValue; + } + + public void setupGetDescription(String arg) { + myActualGetDescriptionReturnValues.add(arg); + } + + public void setExpectedCallCalls(int calls) { + myCallCalls.setExpected(calls); + } + + public void addExpectedCall(Mock arg0, String arg1, Object[] arg2) { + myCallParameter0Values.addExpected(arg0); + myCallParameter1Values.addExpected(arg1); + myCallParameter2Values.addExpectedMany(arg2); + } + + public Object call(Mock arg0, String arg1, Object[] arg2) + throws Throwable { + myCallCalls.inc(); + myCallParameter0Values.addActual(arg0); + myCallParameter1Values.addActual(arg1); + myCallParameter2Values.addActualMany(arg2); -public class MockCallableAddable extends MockCallable implements CallableAddable{ - private ExpectationCounter myAddCalls = new ExpectationCounter("MockCallableAddable.add(Callable)"); - private ReturnValues myActualAddReturnValues = new VoidReturnValues("MockCallableAddable.add(Callable)", true); - private ExpectationList myAddParameter0Values = new ExpectationList("MockCallableAddable.add(Callable) com.mockobjects.dynamic.Callable"); + Object nextReturnValue = myActualCallReturnValues.getNext(); - public void setExpectedAddCalls(int calls){ - myAddCalls.setExpected(calls); + return (Object) nextReturnValue; } - public void addExpectedAdd(Callable arg0){ - myAddParameter0Values.addExpected(arg0); + public void setupCall(Object arg) { + myActualCallReturnValues.add(arg); } - public void add(Callable arg0){ - myAddCalls.inc(); - myAddParameter0Values.addActual(arg0); - Object nextReturnValue = myActualAddReturnValues.getNext(); - if (nextReturnValue instanceof ExceptionalReturnValue && ((ExceptionalReturnValue)nextReturnValue).getException() instanceof RuntimeException) - throw (RuntimeException)((ExceptionalReturnValue)nextReturnValue).getException(); + public void setExpectedVerifyCalls(int calls) { + myVerifyCalls.setExpected(calls); } - public void setupExceptionAdd(Throwable arg){ - myActualAddReturnValues.add(new ExceptionalReturnValue(arg)); + /** @deprected use verifyExpectations as this is a mockmock */ + public void verify() { + myVerifyCalls.inc(); } - public void verifyExpectations(){ - super.verifyExpectations(); - myAddCalls.verify(); - myAddParameter0Values.verify(); + public void verifyExpectations() { + myAddMatchCalls.verify(); + myAddMatchParameter0Values.verify(); + myAddExpectCalls.verify(); + myAddExpectParameter0Values.verify(); + myMatchesCalls.verify(); + myMatchesParameter0Values.verify(); + myMatchesParameter1Values.verify(); + myGetDescriptionCalls.verify(); + myCallCalls.verify(); + myCallParameter0Values.verify(); + myCallParameter1Values.verify(); + myCallParameter2Values.verify(); + myVerifyCalls.verify(); } } Index: CallBagTest.java =================================================================== RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/Attic/CallBagTest.java,v retrieving revision 1.1.2.1 retrieving revision 1.1.2.2 diff -u -r1.1.2.1 -r1.1.2.2 --- CallBagTest.java 16 Apr 2003 22:21:06 -0000 1.1.2.1 +++ CallBagTest.java 17 Apr 2003 16:17:27 -0000 1.1.2.2 @@ -55,8 +55,8 @@ methodB.setExpectedCallCount(0); - callSet.add(methodA); - callSet.add(methodB); + callSet.addExpect(methodA); + callSet.addExpect(methodB); assertSame("expected result from method A", METHOD_A_RESULT, callSet.call(unusedMock, METHOD_A_NAME, METHOD_A_ARGS)); @@ -64,6 +64,18 @@ methodA.verifyExpectations(); methodB.verifyExpectations(); } + + 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")); + + callSet.addMatch(methodAMatch); + callSet.addExpect(new ExpectedCall(anotherMethodAMatch)); + + assertSame("expected result from method B, as expect has precendence over match", "result2", + callSet.call(unusedMock, METHOD_A_NAME, METHOD_A_ARGS)); + } public void testCallPassedToContainedElementsOtherOrder() throws Throwable { @@ -76,8 +88,8 @@ methodB.setExpectedMatches(METHOD_B_NAME, METHOD_B_ARGS); methodB.setupMatchesReturn(true); - callSet.add(methodA); - callSet.add(methodB); + callSet.addExpect(methodA); + callSet.addExpect(methodB); assertSame("expected result from method B", METHOD_B_RESULT, callSet.call(unusedMock, METHOD_B_NAME, METHOD_B_ARGS)); @@ -92,7 +104,7 @@ mockCallable.setupCallReturn(result); mockCallable.setupMatchesReturn(true); - callSet.add(mockCallable); + callSet.addExpect(mockCallable); assertSame("result is returned by mock", result, callSet.call(unusedMock, "method", new Object[0])); } @@ -104,7 +116,7 @@ mockCallable.setupMatchesReturn(true); mockCallable.setupCallThrow(throwable); - callSet.add(mockCallable); + callSet.addExpect(mockCallable); try { callSet.call(unusedMock, "hello", new String[0]); @@ -130,8 +142,8 @@ methodB.setExpectedCallCount(0); methodB.setupGetDescription("***methodB-description****"); - callSet.add(methodA); - callSet.add(methodB); + callSet.addExpect(methodA); + callSet.addExpect(methodB); try { callSet.call(unusedMock, methodCName, methodCArgs); @@ -154,8 +166,8 @@ methodA.setExpectedVerifyCalls(1); methodB.setExpectedVerifyCalls(1); - callSet.add(methodA); - callSet.add(methodB); + callSet.addExpect(methodA); + callSet.addExpect(methodB); callSet.verify(); methodA.verifyExpectations(); @@ -166,7 +178,7 @@ throws Exception { methodA.setExpectedVerifyCalls(1); methodA.setupVerifyThrow(new AssertionFailedError("verify failed")); - callSet.add(methodA); + callSet.addExpect(methodA); try { callSet.verify(); Index: CallSequenceTest.java =================================================================== RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/Attic/CallSequenceTest.java,v retrieving revision 1.5.2.3 retrieving revision 1.5.2.4 diff -u -r1.5.2.3 -r1.5.2.4 --- CallSequenceTest.java 16 Apr 2003 22:48:21 -0000 1.5.2.3 +++ CallSequenceTest.java 17 Apr 2003 16:17:27 -0000 1.5.2.4 @@ -6,8 +6,12 @@ import com.mockobjects.constraint.Constraint; import com.mockobjects.dynamic.C; +import com.mockobjects.dynamic.CallMatch; import com.mockobjects.dynamic.CallSequence; +import com.mockobjects.dynamic.Callable; +import com.mockobjects.dynamic.ExpectedCall; import com.mockobjects.dynamic.Mock; +import com.mockobjects.dynamic.ReturnStub; import com.mockobjects.util.AssertMo; @@ -40,7 +44,7 @@ mockCallable.setupMatchesReturn(true); mockCallable.setupCallThrow(throwable); - callSequence.add(mockCallable); + callSequence.addExpect(mockCallable); try { callSequence.call(unusedMock, "hello", new String[0]); @@ -64,7 +68,7 @@ public void testCallFailsWithTooManyCalls() throws Throwable { mockCallable.setupMatchesReturn(true); mockCallable.setupCallReturn(METHOD_A_RESULT); - callSequence.add(mockCallable); + callSequence.addExpect(mockCallable); callSequence.call(unusedMock, "willdefinitelyMatch", new Object[0]); try { @@ -86,8 +90,8 @@ methodB.setExpectedCallCount(0); - callSequence.add(methodA); - callSequence.add(methodB); + callSequence.addExpect(methodA); + callSequence.addExpect(methodB); assertSame("expected result from method A", METHOD_A_RESULT, callSequence.call(unusedMock, METHOD_A_NAME, METHOD_A_ARGS)); @@ -102,8 +106,8 @@ methodA.setupGetDescription("***methodA-description****"); methodB.setupGetDescription("***methodB-description****"); - callSequence.add(methodA); - callSequence.add(methodB); + callSequence.addExpect(methodA); + callSequence.addExpect(methodB); try { assertSame("expected result from method B", METHOD_B_RESULT, callSequence.call(unusedMock, METHOD_B_NAME, METHOD_B_ARGS)); @@ -130,7 +134,7 @@ mockCallable.setupCallReturn(result); mockCallable.setupMatchesReturn(true); - callSequence.add(mockCallable); + callSequence.addExpect(mockCallable); assertSame("result is returned by mock", result, callSequence.call(unusedMock, "method", new Object[0])); } @@ -152,8 +156,8 @@ methodB.setExpectedCallCount(0); methodB.setupGetDescription("***methodB-description****"); - callSequence.add(methodA); - callSequence.add(methodB); + callSequence.addExpect(methodA); + callSequence.addExpect(methodB); try { callSequence.call(unusedMock, methodCName, methodCArgs); @@ -176,8 +180,8 @@ methodA.setExpectedVerifyCalls(1); methodB.setExpectedVerifyCalls(1); - callSequence.add(methodA); - callSequence.add(methodB); + callSequence.addExpect(methodA); + callSequence.addExpect(methodB); callSequence.verify(); methodA.verifyExpectations(); @@ -188,7 +192,7 @@ throws Exception { methodA.setExpectedVerifyCalls(1); methodA.setupVerifyThrow(new AssertionFailedError("verify failed")); - callSequence.add(methodA); + callSequence.addExpect(methodA); try { callSequence.verify(); @@ -199,5 +203,17 @@ } fail("Should have got a failure for contained element failing"); + } + + 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")); + + callSequence.addMatch(methodAMatch); + callSequence.addExpect(new ExpectedCall(anotherMethodAMatch)); + + assertSame("expected result from method B, as expect has precendence over match", "result2", + callSequence.call(unusedMock, METHOD_A_NAME, METHOD_A_ARGS)); } } |