Menu
▾
▴
[MO-java-dev] CVS: mockobjects-java/src/core/test/mockobjects/dynamic MockCallableCollection.java,1.4,1.5 DummyInterface.java,1.3,1.4 MockTest.java,1.17,1.18 CoreMockTest.java,1.1,1.2 CallBagTest.java,1.9,1.10 TestCallBag.java,1.1,NONE
Update of /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic
In directory sc8-pr-cvs1:/tmp/cvs-serv3011/src/core/test/mockobjects/dynamic
Modified Files:
MockCallableCollection.java DummyInterface.java MockTest.java
CoreMockTest.java CallBagTest.java
Removed Files:
TestCallBag.java
Log Message:
Tidied up Mock and CoreMock
Reworked some of the tests to be more legible and simpler. Also, closer
to mock implementation
Index: MockCallableCollection.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockCallableCollection.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- MockCallableCollection.java 7 Jul 2003 02:24:26 -0000 1.4
+++ MockCallableCollection.java 9 Jul 2003 23:54:20 -0000 1.5
@@ -1,14 +1,11 @@
package test.mockobjects.dynamic;
-import com.mockobjects.ExpectationCounter;
-import com.mockobjects.ExpectationList;
-import com.mockobjects.MockObject;
-import com.mockobjects.ReturnValues;
+import com.mockobjects.*;
import com.mockobjects.dynamic.Invocation;
import com.mockobjects.dynamic.Callable;
import com.mockobjects.dynamic.CallableCollection;
-import com.mockobjects.util.NotImplementedException;
import com.mockobjects.util.Verifier;
+import junit.framework.AssertionFailedError;
//Mock modified for []args
public class MockCallableCollection extends MockObject implements CallableCollection {
@@ -21,13 +18,17 @@
private ExpectationCounter myGetDescriptionCalls = new ExpectationCounter("com.mockobjects.dynamic.CallableAddable GetDescriptionCalls");
private ReturnValues myActualGetDescriptionReturnValues = new ReturnValues("GetDescription", true);
private ExpectationCounter myCallCalls = new ExpectationCounter("com.mockobjects.dynamic.CallableAddable CallCalls");
- private ReturnValues myActualCallReturnValues = new ReturnValues("CallReturn", true);
private ExpectationList myCallMethodNames = new ExpectationList("com.mockobjects.dynamic.CallableAddable methodName");
private ExpectationList myCallArguments = new ExpectationList("com.mockobjects.dynamic.CallableAddable arguments");
private ExpectationCounter myVerifyCalls = new ExpectationCounter("com.mockobjects.dynamic.CallableAddable VerifyCalls");
+ public Object callResult = null;
+ public Throwable callException;
+ public ExpectationCounter resetCalls = new ExpectationCounter("CallableCollection reset calls");
+ public AssertionFailedError verifyFailure;
+
public void reset() {
- throw new NotImplementedException();
+ resetCalls.inc();
}
public void addMatch(Callable callable) {
@@ -94,28 +95,23 @@
myCallArguments.addExpectedMany(args);
}
- public Object call(Invocation invocation)
- throws Throwable {
+ public Object call(Invocation invocation) throws Throwable {
myCallCalls.inc();
myCallMethodNames.addActual(invocation.getMethodName());
myCallArguments.addActualMany(invocation.args);
- Object nextReturnValue = myActualCallReturnValues.getNext();
-
- return (Object) nextReturnValue;
- }
-
- public void setupCall(Object arg) {
- myActualCallReturnValues.add(arg);
+ if (callException != null) throw callException;
+ return callResult;
}
- public void setExpectedVerifyCalls(int calls) {
+ public void setExpectedVerifyCalls(int calls) {
myVerifyCalls.setExpected(calls);
}
- /** @deprected use verifyExpectations as this is a mockmock */
+ /** @deprecated use verifyExpectations as this is a mockmock */
public void verify() {
myVerifyCalls.inc();
+ if (verifyFailure != null) throw verifyFailure;
}
public void verifyExpectations() {
Index: DummyInterface.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/DummyInterface.java,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- DummyInterface.java 7 Jul 2003 00:19:33 -0000 1.3
+++ DummyInterface.java 9 Jul 2003 23:54:20 -0000 1.4
@@ -2,10 +2,11 @@
package test.mockobjects.dynamic;
public interface DummyInterface {
- void noArgVoidMethod();
+ void noArgVoidMethod() throws Throwable;
String noArgMethod();
String oneArgMethod( String arg1);
String twoArgMethod( String arg1, String arg2 ) throws Throwable;
+ String getMockName();
final String METHOD_NOARGVOID_NAME = "noArgVoidMethod";
final Object[] METHOD_NOARGVOID_ARGS = new Object[0];
@@ -21,4 +22,5 @@
final String METHOD_TWOARG_NAME = "twoArgMethod";
final String[] METHOD_TWOARG_ARGS = new String[] { "twoP1", "twoP2" };
final String METHOD_TWOARG_RESULT = "resultTwoArgs";
+
}
Index: MockTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockTest.java,v
retrieving revision 1.17
retrieving revision 1.18
diff -u -r1.17 -r1.18
--- MockTest.java 7 Jul 2003 02:24:26 -0000 1.17
+++ MockTest.java 9 Jul 2003 23:54:20 -0000 1.18
@@ -14,13 +14,13 @@
final Throwable METHOD_EXCEPTION = new DummyThrowable("Configured test throwable");
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 DummyInterface proxy;
private Mock mock;
- 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);
@@ -28,13 +28,7 @@
public void setUp() {
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");
- }
-
+ proxy = (DummyInterface)mock.proxy();
mockCallableFactory.setupCreateCallExpectation(mockCall);
}
Index: CoreMockTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/CoreMockTest.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- CoreMockTest.java 7 Jul 2003 00:19:33 -0000 1.1
+++ CoreMockTest.java 9 Jul 2003 23:54:20 -0000 1.2
@@ -13,67 +13,63 @@
public class CoreMockTest extends TestCase {
- private static final String MOCK_NAME = "Test mock";
+ private static final String MOCK_NAME = "Test coreMock";
private DummyInterface proxy;
- private CoreMock mock;
+ private CoreMock coreMock;
private MockCallableCollection mockCallables = new MockCallableCollection();
- private MockCallable mockCallable = new MockCallable("mockCallable");
-
- public CoreMockTest(String name) {
+ private MockCallable mockCallable = new MockCallable("coreMock mockCallable");
+
+ public CoreMockTest(String name) {
super(name);
}
public void setUp() {
- mock = new CoreMock(DummyInterface.class, MOCK_NAME, mockCallables);
+ coreMock = new CoreMock(DummyInterface.class, MOCK_NAME, mockCallables);
try {
- proxy = (DummyInterface)mock.proxy();
+ proxy = (DummyInterface)coreMock.proxy();
} catch (ClassCastException ex) {
fail("proxy is not of expected interface type");
}
}
- public void testMockAnnotatesAssertionFailedErrors()
+ public void testMockAnnotatesAssertionFailedError()
throws Throwable {
final String originalMessage = "original message";
- mockCallables.setupCall(new AssertionFailedError(originalMessage));
+ Object arg = new AssertionFailedError(originalMessage);
+ mockCallables.callResult = arg;
- try {
+ try {
proxy.noArgVoidMethod();
} catch (AssertionFailedError err) {
AssertMo.assertIncludes("should contain original message", originalMessage, err.getMessage());
- AssertMo.assertIncludes("should contain mock name", MOCK_NAME, err.getMessage());
+ AssertMo.assertIncludes("should contain coreMock name", MOCK_NAME, err.getMessage());
}
}
- public void testMockNameFromClass() throws Exception {
- assertEquals("mockString", CoreMock.mockNameFromClass(String.class));
- }
-
- public void testMockProxyReturnsConfiguredResult() throws Throwable {
- final String result = "configured result";
+ public void testProxyReturnsConfiguredResult() throws Throwable {
+ final String RESULT = "configured result";
- mockCallables.setupCall(result);
+ mockCallables.callResult = RESULT;
- assertSame("result is returned by mock", result, proxy.oneArgMethod("arg"));
+ assertSame("result is returned by coreMock", RESULT, proxy.oneArgMethod("arg"));
}
- public void testMockProxySendsAllArgument() throws Throwable {
- mockCallables.addExpectedCall(DummyInterface.METHOD_TWOARG_NAME, DummyInterface.METHOD_TWOARG_ARGS);
- mockCallables.setupCall("result ignored");
-
+ 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 testMockProxySendsEmptyArrayWhenNoArguments()
- throws Exception {
- mockCallables.addExpectedCall(DummyInterface.METHOD_NOARGVOID_NAME, DummyInterface.METHOD_NOARGVOID_ARGS);
- mockCallables.setupCall("result ignored");
+ public void testProxySendsEmptyArrayWhenNoArguments() throws Throwable {
+ mockCallables.callResult = "result ignored";
+
+ mockCallables.addExpectedCall(DummyInterface.METHOD_NOARGVOID_NAME, DummyInterface.METHOD_NOARGVOID_ARGS);
proxy.noArgVoidMethod();
@@ -82,53 +78,106 @@
mockCallables.verifyExpectations();
}
- public void testMockProxyThrowsConfiguredExceptions() throws Throwable {
+ public void testExceptionsPropagatedThroughProxy() throws Throwable {
final Throwable throwable = new DummyThrowable();
- mockCallable.setupCallThrow(throwable);
- mockCallables.setupCall(mockCallable);
+ mockCallables.callException = throwable;
- try {
+ try {
proxy.noArgVoidMethod();
} catch (Throwable ex) {
- assertSame("exception is caught by mock", throwable, ex);
+ assertSame("exception is caught by coreMock", throwable, ex);
+ return;
}
- }
-
- public void testMockToStringContainsName() {
- AssertMo.assertIncludes("result of toString() should include name", MOCK_NAME, mock.toString());
+ fail("Should have thrown exception");
}
public void testMockVerifies() throws Exception {
mockCallables.setExpectedVerifyCalls(1);
- mock.verify();
+ coreMock.verify();
// Can't use Verifier as we are verifying "verify"
mockCallables.verifyExpectations();
}
public void testProxyEquality() throws Exception {
- mockCallables.setupCall(new Boolean(false));
- mockCallables.setExpectedCallCalls(0);
+ mockCallables.callResult = new Boolean(false);
+
+ mockCallables.setExpectedCallCalls(0);
- assertTrue("Should handle proxy equality without checking expectations", proxy.equals(proxy));
+ assertTrue("Proxy equality is implemented directly", proxy.equals(proxy));
Verifier.verifyObject(this);
}
- public void testProxyInEquality() throws Exception {
- mockCallables.setupCall(new Boolean(false));
- mockCallables.addExpectedCall("equals", new Object[] {"not a proxy"});
+ public void testProxyInequality() throws Exception {
+ mockCallables.callResult = new Boolean(false);
+
+ mockCallables.addExpectedCall("equals", new Object[] {"not a proxy"});
assertFalse("Should handle proxy inequality by calling through", proxy.equals("not a proxy"));
Verifier.verifyObject(this);
}
-
+
+ public void testCallingGetMockNameOnProxyReturnsNameOfUnderlyingMock() {
+ mockCallables.setExpectedCallCalls(0);
+
+ assertEquals("proxy.getMockName() returns name of underlying mock", MOCK_NAME, proxy.getMockName());
+
+ Verifier.verifyObject(this);
+ }
+
+ public void testMockNameFromClass() throws Exception {
+ assertEquals("mockString", CoreMock.mockNameFromClass(String.class));
+ }
+
+ public void testMockToStringContainsName() {
+ AssertMo.assertIncludes("result of toString() should include name", MOCK_NAME, coreMock.toString());
+ }
+
public void testProxyToString() throws Exception {
- assertEquals("Should get a mock name without touching the underlying mock", MOCK_NAME, DynamicUtil.proxyToString(proxy));
- mock.verify(); // should not fail on a proxyToString call
+ assertEquals("Should get a coreMock name without touching the underlying coreMock", MOCK_NAME, DynamicUtil.proxyToString(proxy));
+ coreMock.verify(); // should not fail on a proxyToString call
}
+ public void testAddAnExpectation() {
+ mockCallables.addExpectedExpect(mockCallable);
+
+ coreMock.expect(mockCallable);
+
+ mockCallables.verifyExpectations();
+ }
+
+ public void testAddAStub() {
+ mockCallables.addExpectedMatch(mockCallable);
+
+ coreMock.stub(mockCallable);
+
+ mockCallables.verifyExpectations();
+ }
+
+ public void testReset() {
+ mockCallables.resetCalls.setExpected(1);
+
+ coreMock.reset();
+
+ mockCallables.verifyExpectations();
+ }
+
+ public void testVerifyFailuresIncludeMockName() {
+ mockCallables.verifyFailure = new AssertionFailedError("verify failure");
+
+ mockCallables.setExpectedVerifyCalls(1);
+
+ try {
+ coreMock.verify();
+ } catch (AssertionFailedError expected) {
+ AssertMo.assertIncludes("Should include mock name", MOCK_NAME, expected.getMessage());
+ mockCallables.verifyExpectations();
+ return;
+ }
+ fail("Should have thrown exception");
+ }
}
Index: CallBagTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/CallBagTest.java,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -r1.9 -r1.10
--- CallBagTest.java 9 Jul 2003 02:14:00 -0000 1.9
+++ CallBagTest.java 9 Jul 2003 23:54:20 -0000 1.10
@@ -1,183 +1,152 @@
package test.mockobjects.dynamic;
-import com.mockobjects.dynamic.*;
-import com.mockobjects.util.*;
-
-import junit.framework.*;
-
+import com.mockobjects.dynamic.CallBag;
+import com.mockobjects.dynamic.Invocation;
+import com.mockobjects.util.AssertMo;
+import junit.framework.Assert;
+import junit.framework.AssertionFailedError;
+import junit.framework.TestCase;
+
+/**
+ * Copyright mockobjects.com 09-Jul-2003
+ */
public class CallBagTest extends TestCase {
- final String METHOD_A_NAME = "methodA";
- final String METHOD_A_RESULT = "resultA";
- final String METHOD_B_NAME = "methodB";
- final String METHOD_B_RESULT = "resultB";
-
- final Throwable METHOD_A_EXCEPTION = new DummyThrowable("Configured test throwable");
- final String[] METHOD_A_ARGS = new String[] { "a1", "a2" };
- final Invocation METHOD_A_INVOCATION = new Invocation(METHOD_A_NAME, METHOD_A_ARGS);
-
- final ConstraintMatcher METHOD_A_CONSTRAINTS = C.args(C.eq("a1"), C.eq("a2"));
- final String[] METHOD_B_ARGS = new String[] { "b1", "b2" };
- final Invocation METHOD_B_INVOCATION = new Invocation(METHOD_B_NAME, METHOD_B_ARGS);
-
- private CallBag callBag = new CallBag();
-
- private MockCallable methodA = new MockCallable("method A");
- private MockCallable methodB = new MockCallable("method B");
- private MockCallable mockCallable = new MockCallable("mock callable");
-
-
- public CallBagTest(String name) {
- super(name);
- }
-
- public void testCallFailsOnEmptySet() throws Throwable {
- try {
- callBag.call(new Invocation("missingMethod", new Object[0]));
- } catch (AssertionFailedError ex) {
- AssertMo.assertIncludes("reports empty set in error message", "no methods", ex.getMessage());
-
- return;
- }
-
- fail("Should fail for a missing item");
- }
-
- public void testCallPassedToContainedElements() throws Throwable {
- methodA.matches = true;
- methodA.setupCallReturn(METHOD_A_RESULT);
-
- methodA.setExpectedMatches(METHOD_A_NAME, METHOD_A_ARGS);
- methodA.callInvocation.setExpected(METHOD_A_INVOCATION);
-
- callBag.addExpect(methodB);
- callBag.addExpect(methodA);
-
- assertSame("expected result from method A", METHOD_A_RESULT, callBag.call(METHOD_A_INVOCATION));
-
- methodA.verifyExpectations();
- methodB.verifyExpectations();
- }
-
- public void testExpectOverridesMatch() throws Throwable {
-
- Callable methodASignature = new CallSignature(METHOD_A_NAME,METHOD_A_CONSTRAINTS, new ReturnStub("result1"));
- Callable anotherMethodASignature = new CallSignature(METHOD_A_NAME,METHOD_A_CONSTRAINTS, new ReturnStub("result2"));
-
- callBag.addMatch(methodASignature);
- callBag.addExpect(new CallOnceExpectation(anotherMethodASignature));
-
- assertSame("expected result from method B, as expect has precendence over match", "result2",
- callBag.call(METHOD_A_INVOCATION));
- }
-
- public void testCallPassedToContainedElementsOtherOrder()
- throws Throwable {
- methodA.matches = false;
- methodB.setupCallReturn(METHOD_B_RESULT);
- methodB.matches = true;
-
- methodB.callInvocation.setExpected(METHOD_B_INVOCATION);
- methodB.setExpectedMatches(METHOD_B_NAME, METHOD_B_ARGS);
-
- callBag.addExpect(methodA);
- callBag.addExpect(methodB);
-
- assertSame("expected result from method B", METHOD_B_RESULT,
- callBag.call(METHOD_B_INVOCATION));
-
- methodA.verifyExpectations();
- methodB.verifyExpectations();
- }
-
- public void testConfiguredResultReturned() throws Throwable {
- final String result = "result";
-
- mockCallable.setupCallReturn(result);
- mockCallable.matches = true;
-
- callBag.addExpect(mockCallable);
-
- assertSame("result is returned by mock", result, callBag.call(new Invocation("method", new Object[0])));
- }
-
- public void testCallableThrowableThrown()
- throws Throwable {
- final Throwable throwable = new DummyThrowable();
-
- mockCallable.matches = true;
- mockCallable.setupCallThrow(throwable);
-
- callBag.addExpect(mockCallable);
-
- try {
- callBag.call(new Invocation("anyMethod", new String[0]));
- } catch (Throwable ex) {
- assertSame("exception was thrown by mock", throwable, ex);
- }
- }
-
- public void testEmptySetVerifies() throws Exception {
- callBag.verify();
- }
-
- public void testFailureIfNoElementMatches() throws Throwable {
- final String methodCName = "methodC";
- final String[] methodCArgs = { "c1", "c2" };
- final Invocation methodCInvocation = new Invocation(methodCName, methodCArgs);
-
- methodA.setExpectedMatches(methodCName, methodCArgs);
- methodA.matches = false;
- methodA.callInvocation.setExpectNothing();
- methodB.callInvocation.setExpected(methodCInvocation);
- methodB.matches = false;
- methodB.callInvocation.setExpectNothing();
-
- callBag.addExpect(methodA);
- callBag.addExpect(methodB);
-
- try {
- callBag.call(methodCInvocation);
- } catch (AssertionFailedError ex) {
- AssertMo.assertIncludes("method name is in error message", "methodC", ex.getMessage());
- AssertMo.assertIncludes("argument is in error message (1)", methodCArgs[0], ex.getMessage());
- AssertMo.assertIncludes("argument is in error message (2)", methodCArgs[1], ex.getMessage());
-
- AssertMo.assertIncludes("shows set contents (A)", methodA.getDescription(), ex.getMessage());
- AssertMo.assertIncludes("shows set contents (B)", methodB.getDescription(), ex.getMessage());
-
- return;
- }
-
- fail("Should fail for a missing item");
- }
-
- public void testVerifiesIfAllContainedElementsVerify()
- throws Throwable {
- methodA.setExpectedVerifyCalls(1);
- methodB.setExpectedVerifyCalls(1);
-
- callBag.addExpect(methodA);
- callBag.addExpect(methodB);
- callBag.verify();
-
- methodA.verifyExpectations();
- methodB.verifyExpectations();
- }
-
- public void testVerifyFailsIfContainedElementDoesNotVerify()
- throws Exception {
- methodA.setExpectedVerifyCalls(1);
- methodA.setupVerifyThrow(new AssertionFailedError("verify failed"));
- callBag.addExpect(methodA);
-
- try {
- callBag.verify();
- } catch (AssertionFailedError ex) {
- methodA.verifyExpectations();
-
- return;
- }
-
- fail("Should have got a failure for contained element failing");
- }
+ public CallBagTest(String name) {
+ super(name);
+ }
+
+ private MockCallable mockCallable = new MockCallable("mock callable");
+ private MockCallableList mockExpected = new MockCallableList();
+ private MockCallableList mockStubs = new MockCallableList();
+ private Invocation dummyInvocation = new Invocation("missingMethod", new Object[0]);
+
+ private CallBag callBag = new CallBag(mockExpected, mockStubs);
+
+ public void testAddExpectation() {
+ mockExpected.addedCallables.addExpected(mockCallable);
+ mockStubs.addedCallables.setExpectNothing();
+
+ callBag.addExpect(mockCallable);
+
+ verifyAll();
+ }
+
+ public void testAddStub() {
+ mockExpected.addedCallables.setExpectNothing();
+ mockStubs.addedCallables.addExpected(mockCallable);
+
+ callBag.addMatch(mockCallable);
+
+ verifyAll();
+ }
+
+ public void testResetBothExpectationsAndStubs() {
+ mockExpected.clearCalls.setExpected(1);
+ mockStubs.clearCalls.setExpected(1);
+
+ callBag.reset();
+
+ verifyAll();
+ }
+
+ public void testCallFailsWhenNoExpectationsOrStubs() throws Throwable {
+ mockExpected.lastMatchingCall = null;
+ mockStubs.lastMatchingCall = null;
+ mockExpected.isEmpty = true;
+
+ mockExpected.lastMatchingCallInvocation.setExpected(dummyInvocation);
+ mockStubs.lastMatchingCallInvocation.setExpected(dummyInvocation);
+
+ try {
+ callBag.call(dummyInvocation);
+ } catch (AssertionFailedError ex) {
+ AssertMo.assertIncludes("reports empty list", "no methods", ex.getMessage());
+ verifyAll();
+ return;
+ }
+ fail("Should fail for a missing item");
+ }
+
+ public void testCallReportsMissingMethodWhenNothingMatches() throws Throwable {
+ mockExpected.lastMatchingCall = null;
+ mockStubs.lastMatchingCall = null;
+ mockExpected.applied = mockCallable;
+
+ mockExpected.lastMatchingCallInvocation.setExpected(dummyInvocation);
+ mockStubs.lastMatchingCallInvocation.setExpected(dummyInvocation);
+
+ try {
+ callBag.call(dummyInvocation);
+ } catch (AssertionFailedError ex) {
+ AssertMo.assertIncludes("reports missing method", mockCallable.getDescription(), ex.getMessage());
+ verifyAll();
+ return;
+ }
+ fail("Should fail for a missing item");
+ }
+
+ public void testCallTriesExpectationsBeforeStubs() throws Throwable {
+ mockExpected.lastMatchingCall = mockCallable;
+ mockStubs.lastMatchingCall = null;
+ mockCallable.setupCallReturn("call result");
+
+ mockExpected.lastMatchingCallInvocation.setExpected(dummyInvocation);
+ mockStubs.lastMatchingCallInvocation.setExpectNothing();
+ mockCallable.callInvocation.setExpected(dummyInvocation);
+
+ assertEquals("Call should return", "call result", callBag.call(dummyInvocation));
+
+ verifyAll();
+ }
+
+ public void testCallTriesStubsIfNoExpectations() throws Throwable {
+ mockExpected.lastMatchingCall = null;
+ mockStubs.lastMatchingCall = mockCallable;
+ mockCallable.setupCallReturn("call result");
+
+ mockExpected.lastMatchingCallInvocation.setExpected(dummyInvocation);
+ mockStubs.lastMatchingCallInvocation.setExpected(dummyInvocation);
+ mockCallable.callInvocation.setExpected(dummyInvocation);
+
+ assertEquals("Call should return", "call result", callBag.call(dummyInvocation));
+
+ verifyAll();
+ }
+
+ public void testCallExceptionsArePropagatedUp() {
+ Throwable throwable = new Throwable();
+ mockExpected.lastMatchingCall = mockCallable;
+ mockCallable.setupCallThrow(throwable);
+
+ try {
+ callBag.call(dummyInvocation);
+ } catch (Throwable ex) {
+ Assert.assertEquals("Should have caught throwable", throwable, ex);
+ return;
+ }
+ fail("Should throw throwable");
+ }
+
+ public void testVerifiesOnlyExpectationsNotStubs() {
+ mockExpected.verifyCalls.setExpected(1);
+ mockStubs.verifyCalls.setExpectNothing();
+
+ callBag.verify();
+
+ verifyAll();
+ }
+
+ public void testMatchesNotImplemented() {
+ try {
+ callBag.matches(dummyInvocation);
+ } catch (AssertionFailedError unused) {
+ return;
+ }
+ fail("Should have failed because not implemented");
+ }
+ private void verifyAll() {
+ mockCallable.verifyExpectations();
+ mockExpected.verifyExpectations();
+ mockStubs.verifyExpectations();
+ }
}
--- TestCallBag.java DELETED ---
|
