Menu
▾
▴
[MO-java-dev] CVS: mockobjects-java/src/core/test/mockobjects/dynamic MockCallableAddable.java,NONE,1.1.2.1 MockTest.java,1.8.2.4,1.8.2.5 DummyInterface.java,1.1.2.2,1.1.2.3 CallSetTest.java,1.1.2.6,1.1.2.7
Update of /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic
In directory sc8-pr-cvs1:/tmp/cvs-serv14578/src/core/test/mockobjects/dynamic
Modified Files:
Tag: DynamicMockExperiment
MockTest.java DummyInterface.java CallSetTest.java
Added Files:
Tag: DynamicMockExperiment
MockCallableAddable.java
Log Message:
Made CallSet a composite of Mock (with CallableAddable interface)
made tests that were tricky much simpler, and first step to
CallList
--- NEW FILE: MockCallableAddable.java ---
package test.mockobjects.dynamic;
import com.mockobjects.*;
import com.mockobjects.dynamic.CallableAddable;
import com.mockobjects.dynamic.Callable;
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");
public void setExpectedAddCalls(int calls){
myAddCalls.setExpected(calls);
}
public void addExpectedAdd(Callable arg0){
myAddParameter0Values.addExpected(arg0);
}
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 setupExceptionAdd(Throwable arg){
myActualAddReturnValues.add(new ExceptionalReturnValue(arg));
}
public void verifyExpectations(){
super.verifyExpectations();
myAddCalls.verify();
myAddParameter0Values.verify();
}
}
Index: MockTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockTest.java,v
retrieving revision 1.8.2.4
retrieving revision 1.8.2.5
diff -u -r1.8.2.4 -r1.8.2.5
--- MockTest.java 11 Apr 2003 13:21:16 -0000 1.8.2.4
+++ MockTest.java 14 Apr 2003 08:46:28 -0000 1.8.2.5
@@ -3,119 +3,249 @@
*/
package test.mockobjects.dynamic;
+import com.mockobjects.constraint.Constraint;
import com.mockobjects.dynamic.*;
import com.mockobjects.util.*;
import junit.framework.*;
-/**
- * @author dev
- */
-public class MockTest extends TestCase {
- private Mock aMock;
- private DummyInterface proxy;
+public class MockTest extends TestCase {
private static final String MOCK_NAME = "Test mock";
-
- public MockTest(String name) {
+ final String METHOD_NOARG_NAME = "noArgMethodVoid";
+ final String METHOD_ONEARG_NAME = "oneArgMethod";
+ final String METHOD_ONEARG_RESULT = "resultOArgs";
+ final String METHOD_TWOARG_NAME = "twoArgMethod";
+ final String METHOD_TWOARG_RESULT = "resultTwoArgs";
+ final Throwable METHOD_EXCEPTION = new DummyThrowable("Configured test throwable");
+ final Object[] METHOD_NOARG_ARGS = new Object[0];
+ final String[] METHOD_ONEARG_ARGS = new String[] { "oneP1" };
+ final Constraint[] METHOD_ONEARG_CONSTRAINTS = C.args(C.eq("oneP1"));
+ final String[] METHOD_TWOARG_ARGS = new String[] { "twoP1", "twoP2" };
+ final Constraint[] METHOD_TWOARG_CONSTRAINTS = C.args(C.eq("twoP1"), C.eq("twoP2"));
+ private DummyInterface proxy;
+ private Mock mock;
+ private MockCallFactory mockCallFactory = new MockCallFactory();
+ private MockCallable mockCallMatch = new MockCallable();
+ private MockCallable mockExpectedCall = new MockCallable();
+ private MockCallable mockReturnStub = new MockCallable();
+ private MockCallable mockThrowStub = new MockCallable();
+ private MockCallable mockVoidStub = new MockCallable();
+ private MockCallableAddable mockCallableAddable = new MockCallableAddable();
+
+ public MockTest(String name) throws Exception {
super(name);
}
-
+
public void setUp() {
- aMock = new Mock( DummyInterface.class, MOCK_NAME );
+ mock = new Mock(mockCallFactory, mockCallableAddable, DummyInterface.class, MOCK_NAME);
+
try {
- proxy = (DummyInterface)aMock.proxy();
- }
- catch( ClassCastException ex ) {
+ proxy = (DummyInterface)mock.proxy();
+ } catch (ClassCastException ex) {
fail("proxy is not of expected interface type");
}
}
-
- public void testNewMockVerifies() throws Exception {
- aMock.verify();
+
+ public void testExpect() throws Throwable {
+ mockCallFactory.setExpectedCreateVoidStubCalls(1);
+ mockCallFactory.setupCreateVoidStub(mockVoidStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockVoidStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
+ mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
+
+ mockCallableAddable.addExpectedAdd(mockExpectedCall);
+
+ mock.expect(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
}
- public void testMockNameFromClass() throws Exception {
- assertEquals( "mockString", Mock.mockNameFromClass(String.class) );
+ public void testExpectOne() throws Throwable {
+ mockCallFactory.setExpectedCreateVoidStubCalls(1);
+ mockCallFactory.setupCreateVoidStub(mockVoidStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
+ mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
+
+ mockCallableAddable.addExpectedAdd(mockExpectedCall);
+
+ mock.expect(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0]);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
}
-
- public void testMockToStringContainsName() {
- AssertMo.assertIncludes( "result of toString() should include name",
- MOCK_NAME, aMock.toString() );
+
+ public void testExpectAndReturn() throws Throwable {
+ mockCallFactory.addExpectedCreateReturnStub(METHOD_TWOARG_RESULT);
+ mockCallFactory.setupCreateReturnStub(mockReturnStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockReturnStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
+ mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
+
+ mockCallableAddable.addExpectedAdd(mockExpectedCall);
+ mockCallableAddable.setupCallReturn(METHOD_TWOARG_RESULT);
+
+ mock.expectAndReturn(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_TWOARG_RESULT);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
}
-
- public void testCallMockerReceivesArgumentsFromProxy() throws Throwable {
- final String methodName = "aMethod";
- final String[] expectedArgs = { "hello", "world" };
- final String[] receivedArgs = new String[2];
-
- MockCallable mockMethod = new MockCallable();
- mockMethod.setExpectedMatches( methodName, expectedArgs );
- mockMethod.setupMatchesReturn(true);
- mockMethod.setExpectedCall( aMock, methodName, expectedArgs );
- mockMethod.setupCallReturn( "result ignored" );
-
- aMock.add( mockMethod );
-
- proxy.aMethod( expectedArgs[0], expectedArgs[1] );
-
- mockMethod.verifyExpectations();
+
+ public void testExpectAndThrow() throws Throwable {
+ mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
+ mockCallFactory.setupCreateThrowStub(mockThrowStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockThrowStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
+ mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
+
+ mockCallableAddable.addExpectedAdd(mockExpectedCall);
+ mockCallableAddable.setupCallReturn(METHOD_TWOARG_RESULT);
+
+ mock.expectAndThrow(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
}
-
- public void testCallMockerReceivesEmptyArrayWhenNoArguments() throws Exception {
- final String methodName = "aMethodWithNoArguments";
- final Object[] expectedArgs = {};
-
- MockCallable mockMethod = new MockCallable();
- mockMethod.setExpectedMatches( methodName, expectedArgs );
- mockMethod.setupMatchesReturn(true);
- mockMethod.setExpectedCall( aMock, methodName, expectedArgs );
- mockMethod.setupCallReturn( "result ignored" );
-
- aMock.add( mockMethod );
-
- proxy.aMethodWithNoArguments();
-
- mockMethod.verifyExpectations();
+
+ public void testExpectOneAndReturn() throws Throwable {
+ mockCallFactory.addExpectedCreateReturnStub(METHOD_ONEARG_RESULT);
+ mockCallFactory.setupCreateReturnStub(mockReturnStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
+ mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
+
+ mockCallableAddable.addExpectedAdd(mockExpectedCall);
+ mockCallableAddable.setupCallReturn(METHOD_ONEARG_RESULT);
+
+ mock.expectAndReturn(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_ONEARG_RESULT);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
}
-
- public void testCallMockerResultReturnedByProxy() throws Throwable {
- final String result = "result";
-
- aMock.add( new ReturnStub(result) );
-
- assertSame( "result is returned by mock",
- result, proxy.aMethod( "hello", "world" ) );
+
+ public void testMatchAndReturn() throws Throwable {
+ mockCallFactory.addExpectedCreateReturnStub(METHOD_TWOARG_RESULT);
+ mockCallFactory.setupCreateReturnStub(mockReturnStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockReturnStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+
+ mockCallableAddable.addExpectedAdd(mockCallMatch);
+ mockCallableAddable.setupCallReturn(METHOD_TWOARG_RESULT);
+
+ mock.matchAndReturn(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_TWOARG_RESULT);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
}
- public void testCallMockerThrowableThrownThroughProxy() throws Throwable {
- final Throwable throwable = new DummyThrowable();
-
- aMock.add( new ThrowStub(throwable) );
-
- try {
- proxy.aMethod( "hello", "world" );
- }
- catch( Throwable ex ) {
- assertSame( "exception is caught by mock",
- throwable, ex );
- }
+ public void testMatchAndThrow() throws Throwable {
+ mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
+ mockCallFactory.setupCreateThrowStub(mockThrowStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockThrowStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+
+ mockCallableAddable.addExpectedAdd(mockCallMatch);
+ mockCallableAddable.setupCallReturn(METHOD_TWOARG_RESULT);
+
+ mock.matchAndThrow(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
}
-
- public void testCallMockerAnnotatesAssertionFailedErrors() throws Throwable {
+
+ public void testMatchOneAndReturn() throws Throwable {
+ mockCallFactory.addExpectedCreateReturnStub(METHOD_ONEARG_RESULT);
+ mockCallFactory.setupCreateReturnStub(mockReturnStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+
+ mockCallableAddable.addExpectedAdd(mockCallMatch);
+ mockCallableAddable.setupCallReturn(METHOD_ONEARG_RESULT);
+
+ mock.matchAndReturn(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_ONEARG_RESULT);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testMockAnnotatesAssertionFailedErrors()
+ throws Throwable {
final String originalMessage = "original message";
final AssertionFailedError error = new AssertionFailedError(originalMessage);
-
- aMock.add( new ThrowStub(error) );
-
+
+ mockCallableAddable.setupCallThrow(new AssertionFailedError(originalMessage));
+
+ try {
+ proxy.noArgMethodVoid();
+ } catch (AssertionFailedError err) {
+ AssertMo.assertIncludes("should contain original message", originalMessage, err.getMessage());
+ AssertMo.assertIncludes("should contain mock name", MOCK_NAME, err.getMessage());
+ }
+ }
+
+ public void testMockNameFromClass() throws Exception {
+ assertEquals("mockString", Mock.mockNameFromClass(String.class));
+ }
+
+ public void testMockProxyReturnsConfiguredResult()
+ throws Throwable {
+ final String result = "configured result";
+
+ mockCallableAddable.setupCallReturn(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");
+
+ //mock.invoke(unusedProxy, METHOD_A_METHOD, METHOD_A_ARGS);
+ proxy.twoArgMethod(METHOD_TWOARG_ARGS[0], METHOD_TWOARG_ARGS[1]);
+
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testMockProxySendsEmptyArrayWhenNoArguments()
+ throws Exception {
+ mockCallableAddable.setExpectedCall(mock, METHOD_NOARG_NAME, METHOD_NOARG_ARGS);
+ mockCallableAddable.setupCallReturn("result ignored");
+
+ proxy.noArgMethodVoid();
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testMockProxyThrowsConfiguredExceptions()
+ throws Throwable {
+ final Throwable throwable = new DummyThrowable();
+
+ mockCallableAddable.setupCallReturn(new ThrowStub(throwable));
+
try {
- proxy.aMethod( "hello", "world" );
+ proxy.noArgMethodVoid();
+ } catch (Throwable ex) {
+ assertSame("exception is caught by mock", throwable, ex);
}
- catch( AssertionFailedError err ) {
- AssertMo.assertIncludes( "should contain original message",
- originalMessage, err.getMessage() );
- AssertMo.assertIncludes( "should contain mock name",
- MOCK_NAME, err.getMessage() );
- }
+ }
+
+ public void testMockToStringContainsName() {
+ AssertMo.assertIncludes("result of toString() should include name", MOCK_NAME, mock.toString());
+ }
+
+ public void testMockVerifies() throws Exception {
+ mockCallableAddable.setExpectedVerifyCalls(1);
+
+ mock.verify();
+
+ mockCallableAddable.verifyExpectations();
}
}
Index: DummyInterface.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/Attic/DummyInterface.java,v
retrieving revision 1.1.2.2
retrieving revision 1.1.2.3
diff -u -r1.1.2.2 -r1.1.2.3
--- DummyInterface.java 10 Apr 2003 21:26:36 -0000 1.1.2.2
+++ DummyInterface.java 14 Apr 2003 08:46:29 -0000 1.1.2.3
@@ -7,8 +7,8 @@
* @author dev
*/
public interface DummyInterface {
- public String aMethod( String arg1, String arg2 ) throws Throwable;
- public String oneArgMethod( Object o);
+ public String twoArgMethod( String arg1, String arg2 ) throws Throwable;
+ public String oneArgMethod( String arg1);
- public void aMethodWithNoArguments();
+ public void noArgMethodVoid();
}
Index: CallSetTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/Attic/CallSetTest.java,v
retrieving revision 1.1.2.6
retrieving revision 1.1.2.7
diff -u -r1.1.2.6 -r1.1.2.7
--- CallSetTest.java 11 Apr 2003 15:38:21 -0000 1.1.2.6
+++ CallSetTest.java 14 Apr 2003 08:46:29 -0000 1.1.2.7
@@ -9,287 +9,178 @@
import junit.framework.*;
+
/**
* @author dev
*/
public class CallSetTest extends TestCase {
- private MockCallFactory mockCallFactory = new MockCallFactory();
- private CallSet callSet = new CallSet(mockCallFactory);
- private MockCallable mockReturnStub = new MockCallable();
- private MockCallable mockCallMatch = new MockCallable();
- private MockCallable mockExpectedCall = new MockCallable();
- private MockCallable mockThrowStub = new MockCallable();
- private MockCallable mockVoidStub = new MockCallable();
-
- private Mock unusedMock = null;
- private MockCallable methodA = new MockCallable();
- private MockCallable methodB = new MockCallable();
final String METHOD_A_NAME = "methodA";
- final String[] METHOD_A_ARGS = new String[] { "a1", "a2" };
- final Constraint[] METHOD_A_CONSTRAINTS = C.args( C.eq("a1"), C.eq("a2") );
final String METHOD_A_RESULT = "resultA";
- final Throwable METHOD_A_EXCEPTION = new DummyThrowable("Configured test throwable");
-
final String METHOD_B_NAME = "methodB";
- final String[] METHOD_B_ARGS = new String[] { "b1", "b2" };
final String METHOD_B_RESULT = "resultB";
-
-
- public CallSetTest(String name) {
- super(name);
- }
-
- public void testEmptySetVerifies() throws Exception {
- callSet.verify();
- }
-
- public void testVerifyFailsIfContainedElementDoesNotVerify() throws Exception {
- methodA.setExpectedVerifyCalls(1);
- methodA.setupVerifyThrow( new AssertionFailedError("verify failed") );
- callSet.add( methodA );
-
- try {
- callSet.verify();
- } catch (AssertionFailedError ex) {
- methodA.verifyExpectations();
- return;
- }
- fail("Should have got a failure for contained element failing");
- }
-
- public void testVerifiesIfAllContainedElementsVerify() throws Throwable {
- methodA.setExpectedVerifyCalls(1);
- methodB.setExpectedVerifyCalls(1);
-
- callSet.add( methodA );
- callSet.add( methodB );
- callSet.verify();
-
- methodA.verifyExpectations();
- methodB.verifyExpectations();
- }
+ private static final String MOCK_NAME = "Test mock";
- public void testExpect() throws Throwable{
- mockExpectedCall.setupMatchesReturn(true);
- mockExpectedCall.setupCallReturn(METHOD_A_RESULT);
-
- mockCallFactory.setExpectedCreateVoidStubCalls(1);
- mockCallFactory.setupCreateVoidStub( mockVoidStub );
- mockCallFactory.addExpectedCreateCallMatch( METHOD_A_NAME, METHOD_A_CONSTRAINTS, mockVoidStub );
- mockCallFactory.setupCreateCallMatch( mockCallMatch );
- mockCallFactory.addExpectedCreateExpectedCall( mockCallMatch );
- mockCallFactory.setupCreateExpectedCall( mockExpectedCall );
-
- callSet.expect( METHOD_A_NAME, METHOD_A_CONSTRAINTS );
-
- assertSame( "should be result of calling expected call",
- METHOD_A_RESULT, callSet.call( unusedMock, METHOD_A_NAME, METHOD_A_ARGS ) );
-
- Verifier.verifyObject(this);
- }
-
- public void testExpectAndReturn() throws Throwable{
- mockExpectedCall.setupMatchesReturn(true);
- mockExpectedCall.setupCallReturn(METHOD_A_RESULT);
-
- mockCallFactory.addExpectedCreateReturnStub( METHOD_A_RESULT );
- mockCallFactory.setupCreateReturnStub( mockReturnStub );
- mockCallFactory.addExpectedCreateCallMatch( METHOD_A_NAME, METHOD_A_CONSTRAINTS, mockReturnStub );
- mockCallFactory.setupCreateCallMatch( mockCallMatch );
- mockCallFactory.addExpectedCreateExpectedCall( mockCallMatch );
- mockCallFactory.setupCreateExpectedCall( mockExpectedCall );
-
- callSet.expectAndReturn( METHOD_A_NAME, METHOD_A_CONSTRAINTS, METHOD_A_RESULT );
-
- assertSame( "should be result of calling expected call",
- METHOD_A_RESULT, callSet.call( unusedMock, METHOD_A_NAME, METHOD_A_ARGS ) );
-
- Verifier.verifyObject(this);
- }
-
- public void testMatchAndReturn() throws Throwable{
- mockCallMatch.setupMatchesReturn(true);
- mockCallMatch.setupCallReturn(METHOD_A_RESULT);
-
- mockCallFactory.addExpectedCreateReturnStub( METHOD_A_RESULT );
- mockCallFactory.setupCreateReturnStub( mockReturnStub );
- mockCallFactory.addExpectedCreateCallMatch( METHOD_A_NAME, METHOD_A_CONSTRAINTS, mockReturnStub );
- mockCallFactory.setupCreateCallMatch( mockCallMatch );
-
- callSet.matchAndReturn( METHOD_A_NAME, METHOD_A_CONSTRAINTS, METHOD_A_RESULT );
-
- assertSame( "should be result of calling expected call",
- METHOD_A_RESULT, callSet.call( unusedMock, METHOD_A_NAME, METHOD_A_ARGS ) );
-
- Verifier.verifyObject(this);
- }
+ final Throwable METHOD_A_EXCEPTION = new DummyThrowable("Configured test throwable");
+ final String[] METHOD_A_ARGS = new String[] { "a1", "a2" };
+ final Constraint[] METHOD_A_CONSTRAINTS = C.args(C.eq("a1"), C.eq("a2"));
+ final String[] METHOD_B_ARGS = new String[] { "b1", "b2" };
+ private CallSet callSet = new CallSet();
+ private Mock unusedMock = null;
- public void testMatchOneAndReturn() throws Throwable{
- final String PARAMETER = "One Arg Method";
- mockCallMatch.setupMatchesReturn(true);
- mockCallMatch.setupCallReturn(METHOD_A_RESULT);
-
- mockCallFactory.addExpectedCreateReturnStub( METHOD_A_RESULT );
- mockCallFactory.setupCreateReturnStub( mockReturnStub );
- mockCallFactory.addExpectedCreateCallMatch( "oneArgMethod", C.args(C.eq(PARAMETER)), mockReturnStub );
- mockCallFactory.setupCreateCallMatch( mockCallMatch );
-
- callSet.matchAndReturn( "oneArgMethod", PARAMETER, METHOD_A_RESULT );
-
- assertSame( "should be result of calling expected call",
- METHOD_A_RESULT, callSet.call( unusedMock, "oneArgMethod", new Object[] {PARAMETER}) );
-
- Verifier.verifyObject(this);
- }
+ private MockCallable methodA = new MockCallable();
+ private MockCallable methodB = new MockCallable();
+ private MockCallable mockCallable = new MockCallable();
+// private MockCallable mockExpectedCall = new MockCallable();
+// private MockCallable mockReturnStub = new MockCallable();
+// private MockCallable mockThrowStub = new MockCallable();
+// private MockCallable mockVoidStub = new MockCallable();
- public void testExpectOneAndReturn() throws Throwable{
- final String PARAMETER = "One Arg Method";
- mockExpectedCall.setupMatchesReturn(true);
- mockExpectedCall.setupCallReturn(METHOD_A_RESULT);
-
- mockCallFactory.addExpectedCreateReturnStub( METHOD_A_RESULT );
- mockCallFactory.setupCreateReturnStub( mockReturnStub );
- mockCallFactory.addExpectedCreateCallMatch( "oneArgMethod", C.args(C.eq(PARAMETER)), mockReturnStub );
- mockCallFactory.setupCreateCallMatch( mockCallMatch );
- mockCallFactory.addExpectedCreateExpectedCall( mockCallMatch );
- mockCallFactory.setupCreateExpectedCall( mockExpectedCall );
-
- callSet.expectAndReturn( "oneArgMethod", PARAMETER, METHOD_A_RESULT );
-
- assertSame( "should be result of calling expected call",
- METHOD_A_RESULT, callSet.call( unusedMock, "oneArgMethod", new Object[] {PARAMETER}) );
-
- Verifier.verifyObject(this);
- }
- public void testExpectAndThrow() throws Throwable{
- mockExpectedCall.setupMatchesReturn(true);
- mockExpectedCall.setupCallThrow(METHOD_A_EXCEPTION);
-
- mockCallFactory.addExpectedCreateThrowStub(METHOD_A_EXCEPTION);
- mockCallFactory.setupCreateThrowStub( mockThrowStub );
- mockCallFactory.addExpectedCreateCallMatch( METHOD_A_NAME, METHOD_A_CONSTRAINTS, mockThrowStub );
- mockCallFactory.setupCreateCallMatch( mockCallMatch );
- mockCallFactory.addExpectedCreateExpectedCall( mockCallMatch );
- mockCallFactory.setupCreateExpectedCall( mockExpectedCall );
-
- callSet.expectAndThrow( METHOD_A_NAME, METHOD_A_CONSTRAINTS, METHOD_A_EXCEPTION );
-
- try {
- callSet.call( unusedMock, METHOD_A_NAME, METHOD_A_ARGS );
- } catch (DummyThrowable ex) {
- Verifier.verifyObject(this);
- return;
- }
-
- fail("Should have thrown configured exception");
+ public CallSetTest(String name) {
+ super(name);
}
-
- public void testMatchAndThrow() throws Throwable{
- mockCallMatch.setupMatchesReturn(true);
- mockCallMatch.setupCallThrow(METHOD_A_EXCEPTION);
-
- mockCallFactory.addExpectedCreateThrowStub(METHOD_A_EXCEPTION);
- mockCallFactory.setupCreateThrowStub( mockThrowStub );
- mockCallFactory.addExpectedCreateCallMatch( METHOD_A_NAME, METHOD_A_CONSTRAINTS, mockThrowStub );
- mockCallFactory.setupCreateCallMatch( mockCallMatch );
-
- callSet.matchAndThrow( METHOD_A_NAME, METHOD_A_CONSTRAINTS, METHOD_A_EXCEPTION );
-
+
+ public void testCallFailsOnEmptySet() throws Throwable {
try {
- callSet.call( unusedMock, METHOD_A_NAME, METHOD_A_ARGS );
- } catch (DummyThrowable ex) {
- Verifier.verifyObject(this);
+ callSet.call(unusedMock, "missingMethod", new Object[0]);
+ } catch (AssertionFailedError ex) {
+ AssertMo.assertIncludes("reports empty set in error message", "no methods", ex.getMessage());
+
return;
}
-
- fail("Should have thrown configured exception");
+
+ fail("Should fail for a missing item");
}
-
+
public void testCallPassedToContainedElements() throws Throwable {
- methodA.setExpectedMatches( METHOD_A_NAME, METHOD_A_ARGS );
+ methodA.setExpectedMatches(METHOD_A_NAME, METHOD_A_ARGS);
methodA.setupMatchesReturn(true);
- methodA.setExpectedCall( unusedMock, METHOD_A_NAME, METHOD_A_ARGS );
+ methodA.setExpectedCall(unusedMock, METHOD_A_NAME, METHOD_A_ARGS);
methodA.setupCallReturn(METHOD_A_RESULT);
- methodB.setExpectedCallCount( 0 );
-
- callSet.add( methodA );
- callSet.add( methodB );
-
- assertSame( "expected result from method A",
- METHOD_A_RESULT, callSet.call( unusedMock, METHOD_A_NAME, METHOD_A_ARGS ) );
-
+ methodB.setExpectedCallCount(0);
+
+ callSet.add(methodA);
+ callSet.add(methodB);
+
+ assertSame("expected result from method A", METHOD_A_RESULT,
+ callSet.call(unusedMock, METHOD_A_NAME, METHOD_A_ARGS));
+
methodA.verifyExpectations();
methodB.verifyExpectations();
}
- public void testCallPassedToContainedElementsOtherOrder() throws Throwable {
- methodA.setExpectedMatches( METHOD_B_NAME, METHOD_B_ARGS );
+ public void testCallPassedToContainedElementsOtherOrder()
+ throws Throwable {
+ methodA.setExpectedMatches(METHOD_B_NAME, METHOD_B_ARGS);
methodA.setupMatchesReturn(false);
- methodA.setExpectedCallCount( 0 );
- methodB.setExpectedCall( unusedMock, METHOD_B_NAME, METHOD_B_ARGS );
-
+ methodA.setExpectedCallCount(0);
+ methodB.setExpectedCall(unusedMock, METHOD_B_NAME, METHOD_B_ARGS);
+
methodB.setupCallReturn(METHOD_B_RESULT);
- methodB.setExpectedMatches( METHOD_B_NAME, METHOD_B_ARGS );
+ methodB.setExpectedMatches(METHOD_B_NAME, METHOD_B_ARGS);
methodB.setupMatchesReturn(true);
-
- callSet.add( methodA );
- callSet.add( methodB );
-
- assertSame( "expected result from method B",
- METHOD_B_RESULT, callSet.call( unusedMock, METHOD_B_NAME, METHOD_B_ARGS ) );
-
+
+ callSet.add(methodA);
+ callSet.add(methodB);
+
+ assertSame("expected result from method B", METHOD_B_RESULT,
+ callSet.call(unusedMock, METHOD_B_NAME, METHOD_B_ARGS));
+
methodA.verifyExpectations();
methodB.verifyExpectations();
}
-
+
+ public void testConfiguredResultReturned() throws Throwable {
+ final String result = "result";
+
+ mockCallable.setupCallReturn(result);
+ mockCallable.setupMatchesReturn(true);
+
+ callSet.add(mockCallable);
+
+ assertSame("result is returned by mock", result, callSet.call(unusedMock, "method", new Object[0]));
+ }
+
+ public void testCallableThrowableThrown()
+ throws Throwable {
+ final Throwable throwable = new DummyThrowable();
+
+ mockCallable.setupMatchesReturn(true);
+ mockCallable.setupCallThrow(throwable);
+
+ callSet.add(mockCallable);
+
+ try {
+ callSet.call(unusedMock, "hello", new String[0]);
+ } catch (Throwable ex) {
+ assertSame("exception is caught by mock", throwable, ex);
+ }
+ }
+
+ public void testEmptySetVerifies() throws Exception {
+ callSet.verify();
+ }
+
public void testFailureIfNoElementMatches() throws Throwable {
final String methodCName = "methodC";
final String[] methodCArgs = { "c1", "c2" };
-
- methodA.setExpectedMatches( methodCName, methodCArgs );
+
+ methodA.setExpectedMatches(methodCName, methodCArgs);
methodA.setupMatchesReturn(false);
- methodA.setExpectedCallCount( 0 );
+ methodA.setExpectedCallCount(0);
methodA.setupGetDescription("***methodA-description****");
- methodB.setExpectedCall( unusedMock, methodCName, methodCArgs );
+ methodB.setExpectedCall(unusedMock, methodCName, methodCArgs);
methodB.setupMatchesReturn(false);
- methodB.setExpectedCallCount( 0 );
+ methodB.setExpectedCallCount(0);
methodB.setupGetDescription("***methodB-description****");
-
- callSet.add( methodA );
- callSet.add( methodB );
-
+
+ callSet.add(methodA);
+ callSet.add(methodB);
+
try {
- callSet.call( unusedMock, methodCName, methodCArgs );
+ callSet.call(unusedMock, methodCName, methodCArgs);
} 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() );
+ 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 testCallFailsOnEmptySet() throws Throwable {
+ public void testVerifiesIfAllContainedElementsVerify()
+ throws Throwable {
+ methodA.setExpectedVerifyCalls(1);
+ methodB.setExpectedVerifyCalls(1);
+
+ callSet.add(methodA);
+ callSet.add(methodB);
+ callSet.verify();
+
+ methodA.verifyExpectations();
+ methodB.verifyExpectations();
+ }
+
+ public void testVerifyFailsIfContainedElementDoesNotVerify()
+ throws Exception {
+ methodA.setExpectedVerifyCalls(1);
+ methodA.setupVerifyThrow(new AssertionFailedError("verify failed"));
+ callSet.add(methodA);
+
try {
- callSet.call( unusedMock, "methodC", new Object[] { "arg1", "arg2" } );
+ callSet.verify();
} catch (AssertionFailedError ex) {
- AssertMo.assertIncludes( "reports empty set in error message",
- "no methods", ex.getMessage() );
+ methodA.verifyExpectations();
+
return;
}
-
- fail("Should fail for a missing item");
- }
+ fail("Should have got a failure for contained element failing");
+ }
}
|
