Menu
▾
▴
[MO-java-dev] CVS: mockobjects-java/src/core/test/mockobjects/dynamic MockCallableCollection.java,NONE,1.1 CallSignatureTest.java,NONE,1.1 MockCallFactory.java,1.4,1.5 MockTest.java,1.14,1.15 CallMatchTest.java,1.6,NONE MockCallableAddable.java,1.4,NONE
|
From: Steve F. <sm...@us...> - 2003-07-06 02:31:39
|
Update of /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic
In directory sc8-pr-cvs1:/tmp/cvs-serv6790/src/core/test/mockobjects/dynamic
Modified Files:
MockCallFactory.java MockTest.java
Added Files:
MockCallableCollection.java CallSignatureTest.java
Removed Files:
CallMatchTest.java MockCallableAddable.java
Log Message:
General tidy up
Renaming Call types to Callable
Collapsed CallableFactory interface
--- NEW FILE: MockCallableCollection.java ---
package test.mockobjects.dynamic;
import com.mockobjects.ExpectationCounter;
import com.mockobjects.ExpectationList;
import com.mockobjects.MockObject;
import com.mockobjects.ReturnValues;
import com.mockobjects.dynamic.ActiveCall;
import com.mockobjects.dynamic.Callable;
import com.mockobjects.dynamic.CallableCollection;
import com.mockobjects.util.NotImplementedException;
import com.mockobjects.util.Verifier;
//Mock modified for []args
public class MockCallableCollection extends MockObject implements CallableCollection {
public ExpectationList matchedCallables = new ExpectationList("CallableAddable matchedCallables");
public ExpectationList expectedCallables = new ExpectationList("CallableAddable expectedCallables");
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 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 void reset() {
throw new NotImplementedException();
}
public void addMatch(Callable callable) {
matchedCallables.addActual(callable);
}
public void addExpect(Callable callable) {
expectedCallables.addActual(callable);
}
public void setExpectedMatchesCalls(int calls) {
myMatchesCalls.setExpected(calls);
}
public void addExpectedMatches(String arg0, Object[] arg1) {
myMatchesParameter0Values.addExpected(arg0);
myMatchesParameter1Values.addExpected(arg1);
}
public boolean matches(ActiveCall call) {
myMatchesCalls.inc();
myMatchesParameter0Values.addActual(call.getMethodName());
myMatchesParameter1Values.addActual(call.args);
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(String methodName, Object[] args) {
myCallMethodNames.addExpected(methodName);
myCallArguments.addExpectedMany(args);
}
public Object call(ActiveCall call)
throws Throwable {
myCallCalls.inc();
myCallMethodNames.addActual(call.getMethodName());
myCallArguments.addActualMany(call.args);
Object nextReturnValue = myActualCallReturnValues.getNext();
return (Object) nextReturnValue;
}
public void setupCall(Object arg) {
myActualCallReturnValues.add(arg);
}
public void setExpectedVerifyCalls(int calls) {
myVerifyCalls.setExpected(calls);
}
/** @deprected use verifyExpectations as this is a mockmock */
public void verify() {
myVerifyCalls.inc();
}
public void verifyExpectations() {
Verifier.verifyObject(this);
}
}
--- NEW FILE: CallSignatureTest.java ---
/*
* Created on 04-Apr-2003
*/
package test.mockobjects.dynamic;
import junit.framework.TestCase;
import com.mockobjects.dynamic.*;
public class CallSignatureTest extends TestCase {
final String METHOD_NAME = "methodName";
final Object[] IGNORED_ARGS = new Object[0];
final ActiveCall CALL = new ActiveCall(METHOD_NAME, IGNORED_ARGS);
Mock mock = new Mock(DummyInterface.class, "mock");
MockCallable mockCallable = new MockCallable("mock callable");
MockConstraintMatcher mockConstraintMatcher = new MockConstraintMatcher();
CallSignature callSignature = new CallSignature(METHOD_NAME, mockConstraintMatcher, mockCallable);
public CallSignatureTest(String name) {
super(name);
}
public void testCallArgumentsArePropagatedToDecorated()
throws Throwable {
final String result = "result";
mockCallable.activeCall.setExpected(CALL);
mockCallable.setupCallReturn(result);
callSignature.call(CALL);
mockCallable.verifyExpectations();
}
public void testUncalledCallVerifies() {
mockCallable.setExpectedVerifyCalls(1);
callSignature.verify();
mockCallable.verifyExpectations();
}
public void testCallSuccessVerifies() throws Throwable {
mockCallable.setExpectedVerifyCalls(1);
mockCallable.setupCallReturn("result");
callSignature.call(CALL);
callSignature.verify();
mockCallable.verifyExpectations();
}
public void testMultipleCallsSucceed() throws Throwable {
mockCallable.setupCallReturn("result");
callSignature.call(CALL);
callSignature.call(CALL);
mockCallable.verifyExpectations();
}
public void testCallFailure() throws Throwable {
// na
}
public void testCallDoesNotMatchWhenWrongName() throws Throwable {
assertFalse("call does not match", callSignature.matches(new ActiveCall("anotherName", IGNORED_ARGS)));
mockCallable.verifyExpectations();
}
public void testMatchesAfterCalls() throws Throwable {
mockCallable.setupCallReturn("result");
mockCallable.setupAlwaysMatchActiveCall(true);
mockConstraintMatcher.setupMatches(true);
callSignature.call(CALL);
assertTrue("matches after first call", callSignature.matches( CALL ));
callSignature.call(CALL);
assertTrue("matches after further calls", callSignature.matches( CALL ));
mockCallable.verifyExpectations();
}
public void testMatchesDelegatesToContraintMatcher()
throws Throwable {
final String[] args = new String[] { "a1", "a2" };
mockConstraintMatcher.addExpectedMatches(args);
mockConstraintMatcher.setupMatches(true);
assertTrue("matches delegated to constraint matcher", callSignature.matches(new ActiveCall(METHOD_NAME, args)));
mockConstraintMatcher.verify();
}
public void testMatchesFailure() throws Throwable {
mockConstraintMatcher.setupMatches(false);
assertFalse("Should not match if constraint matcher doesn't", callSignature.matches(CALL));
}
}
Index: MockCallFactory.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockCallFactory.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- MockCallFactory.java 19 May 2003 23:56:23 -0000 1.4
+++ MockCallFactory.java 6 Jul 2003 02:31:37 -0000 1.5
@@ -1,17 +1,16 @@
package test.mockobjects.dynamic;
import com.mockobjects.*;
-import com.mockobjects.dynamic.CallFactory;
+import com.mockobjects.dynamic.CallableFactory;
import com.mockobjects.dynamic.Callable;
import com.mockobjects.dynamic.ConstraintMatcher;
+import com.mockobjects.util.Verifier;
-public class MockCallFactory implements CallFactory{
- private ExpectationCounter myCreateReturnStubCalls = new ExpectationCounter("MockCallFactory.createReturnStub(Object)");
+public class MockCallFactory implements CallableFactory{
private ReturnValues myActualCreateReturnStubReturnValues = new ReturnValues("MockCallFactory.createReturnStub(Object)", true);
- private ExpectationList myCreateReturnStubParameter0Values = new ExpectationList("MockCallFactory.createReturnStub(Object) java.lang.Object");
- private ExpectationCounter myCreateThrowStubCalls = new ExpectationCounter("MockCallFactory.createThrowStub(Throwable)");
+ public ExpectationValue createReturnStub = new ExpectationValue("createReturnStub");
private ReturnValues myActualCreateThrowStubReturnValues = new ReturnValues("MockCallFactory.createThrowStub(Throwable)", true);
- private ExpectationList myCreateThrowStubParameter0Values = new ExpectationList("MockCallFactory.createThrowStub(Throwable) java.lang.Throwable");
+ public ExpectationValue createThrowStub = new ExpectationValue("createThrowStub");
private ExpectationCounter myCreateVoidStubCalls = new ExpectationCounter("MockCallFactory.createVoidStub()");
private ReturnValues myActualCreateVoidStubReturnValues = new ReturnValues("MockCallFactory.createVoidStub()", true);
private ExpectationCounter myCreateCallExpectationCalls = new ExpectationCounter("MockCallFactory.createCallExpectation(Callable)");
@@ -23,42 +22,20 @@
private ExpectationList myCreateCallSignatureParameter1Values = new ExpectationList("MockCallFactory.createCallMatch(String, ConstraintMatcher, Callable) com.mockobjects.dynamic.ConstraintMatcher");
private ExpectationList myCreateCallSignatureParameter2Values = new ExpectationList("MockCallFactory.createCallMatch(String, ConstraintMatcher, Callable) com.mockobjects.dynamic.Callable");
- public void setExpectedCreateReturnStubCalls(int calls){
- myCreateReturnStubCalls.setExpected(calls);
- }
-
- public void addExpectedCreateReturnStub(Object arg0){
- myCreateReturnStubParameter0Values.addExpected(arg0);
- }
-
- public Callable createReturnStub(Object arg0){
- myCreateReturnStubCalls.inc();
- myCreateReturnStubParameter0Values.addActual(arg0);
+ private Callable createReturnStub(Object arg0){
+ createReturnStub.setActual(arg0);
Object nextReturnValue = myActualCreateReturnStubReturnValues.getNext();
if (nextReturnValue instanceof ExceptionalReturnValue && ((ExceptionalReturnValue)nextReturnValue).getException() instanceof RuntimeException)
throw (RuntimeException)((ExceptionalReturnValue)nextReturnValue).getException();
return (Callable) nextReturnValue;
}
- public void setupExceptionCreateReturnStub(Throwable arg){
- myActualCreateReturnStubReturnValues.add(new ExceptionalReturnValue(arg));
- }
-
public void setupCreateReturnStub(Callable arg){
myActualCreateReturnStubReturnValues.add(arg);
}
- public void setExpectedCreateThrowStubCalls(int calls){
- myCreateThrowStubCalls.setExpected(calls);
- }
-
- public void addExpectedCreateThrowStub(Throwable arg0){
- myCreateThrowStubParameter0Values.addExpected(arg0);
- }
-
- public Callable createThrowStub(Throwable arg0){
- myCreateThrowStubCalls.inc();
- myCreateThrowStubParameter0Values.addActual(arg0);
+ private Callable createThrowStub(Throwable arg0){
+ createThrowStub.setActual(arg0);
Object nextReturnValue = myActualCreateThrowStubReturnValues.getNext();
if (nextReturnValue instanceof ExceptionalReturnValue && ((ExceptionalReturnValue)nextReturnValue).getException() instanceof RuntimeException)
throw (RuntimeException)((ExceptionalReturnValue)nextReturnValue).getException();
@@ -77,7 +54,7 @@
myCreateVoidStubCalls.setExpected(calls);
}
- public Callable createVoidStub(){
+ private Callable createVoidStub(){
myCreateVoidStubCalls.inc();
Object nextReturnValue = myActualCreateVoidStubReturnValues.getNext();
if (nextReturnValue instanceof ExceptionalReturnValue && ((ExceptionalReturnValue)nextReturnValue).getException() instanceof RuntimeException)
@@ -128,7 +105,7 @@
myCreateCallSignatureParameter2Values.addExpected(arg2);
}
- public Callable createCallSignature(String arg0, ConstraintMatcher arg1, Callable arg2){
+ private Callable createCallSignature(String arg0, ConstraintMatcher arg1, Callable arg2){
myCreateCallSignatureCalls.inc();
myCreateCallSignatureParameter0Values.addActual(arg0);
myCreateCallSignatureParameter1Values.addActualMany(arg1.getConstraints());
@@ -147,17 +124,20 @@
myActualCreateCallSignatureReturnValues.add(arg);
}
+ public Callable createReturnCallable(String methodName, ConstraintMatcher constraints, Object result) {
+ return createCallSignature(methodName, constraints, createReturnStub(result));
+ }
+
+
+ public Callable createThrowableCallable(String methodName, ConstraintMatcher constraints, Throwable throwable) {
+ return createCallSignature(methodName, constraints, createThrowStub(throwable));
+ }
+
+ public Callable createVoidCallable(String methodName, ConstraintMatcher constraints) {
+ return createCallSignature(methodName, constraints, createVoidStub());
+ }
+
public void verify(){
- myCreateReturnStubCalls.verify();
- myCreateReturnStubParameter0Values.verify();
- myCreateThrowStubCalls.verify();
- myCreateThrowStubParameter0Values.verify();
- myCreateVoidStubCalls.verify();
- myCreateCallExpectationCalls.verify();
- myCreateCallExpectationParameter0Values.verify();
- myCreateCallSignatureCalls.verify();
- myCreateCallSignatureParameter0Values.verify();
- myCreateCallSignatureParameter1Values.verify();
- myCreateCallSignatureParameter2Values.verify();
+ Verifier.verifyObject(this);
}
}
Index: MockTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockTest.java,v
retrieving revision 1.14
retrieving revision 1.15
diff -u -r1.14 -r1.15
--- MockTest.java 5 Jul 2003 15:15:54 -0000 1.14
+++ MockTest.java 6 Jul 2003 02:31:37 -0000 1.15
@@ -34,340 +34,337 @@
private MockCallable mockReturnStub = new MockCallable("return stub");
private MockCallable mockThrowStub = new MockCallable("throw stub");
private MockCallable mockVoidStub = new MockCallable("void stub");
- private MockCallableAddable mockCallableAddable = new MockCallableAddable();
+ private MockCallableCollection mockCallables = new MockCallableCollection();
public MockTest(String name) throws Exception {
super(name);
}
public void setUp() {
- mock = new Mock(mockCallFactory, mockCallableAddable, DummyInterface.class, MOCK_NAME);
+ mock = new Mock(mockCallFactory, mockCallables, DummyInterface.class, MOCK_NAME);
try {
proxy = (DummyInterface)mock.proxy();
} catch (ClassCastException ex) {
fail("proxy is not of expected interface type");
}
+
+ mockCallFactory.setupCreateReturnStub(mockReturnStub);
+ mockCallFactory.setupCreateVoidStub(mockVoidStub);
+ mockCallFactory.setupCreateThrowStub(mockThrowStub);
}
public void testExpectManyAndVoid() throws Throwable {
+ mockCallFactory.setupCreateCallSignature(mockCallMatch);
+ mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
+
mockCallFactory.setExpectedCreateVoidStubCalls(1);
- mockCallFactory.setupCreateVoidStub(mockVoidStub);
mockCallFactory.addExpectedCreateCallSignature(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockVoidStub);
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
- mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
- mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
+ mockCallables.expectedCallables.addExpected(mockExpectedCall);
mock.expect(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testExpectNoneAndReturn() throws Throwable {
- mockCallFactory.addExpectedCreateReturnStub(METHOD_NOARGANDRETURN_RESULT);
- mockCallFactory.setupCreateReturnStub(mockReturnStub);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARGANDRETURN_NAME, C.NO_ARGS, mockReturnStub);
mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
- mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
+ mockCallFactory.createReturnStub.setExpected(METHOD_NOARGANDRETURN_RESULT);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARGANDRETURN_NAME, C.NO_ARGS, mockReturnStub);
+ mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
+
+ mockCallables.expectedCallables.addExpected(mockExpectedCall);
mock.expectAndReturn(METHOD_NOARGANDRETURN_NAME, METHOD_NOARGANDRETURN_RESULT);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testExpectNoneAndThrow() throws Throwable {
- mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
- mockCallFactory.setupCreateThrowStub(mockThrowStub);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARGANDRETURN_NAME, C.NO_ARGS, mockThrowStub);
mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
- mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
+ mockCallFactory.createThrowStub.setExpected(METHOD_EXCEPTION);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARGANDRETURN_NAME, C.NO_ARGS, mockThrowStub);
+ mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
+
+ mockCallables.expectedCallables.addExpected(mockExpectedCall);
mock.expectAndThrow(METHOD_NOARGANDRETURN_NAME, METHOD_EXCEPTION);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testExpectOneAndThrow() throws Throwable {
- mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
- mockCallFactory.setupCreateThrowStub(mockThrowStub);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub);
mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
- mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
+ mockCallFactory.createThrowStub.setExpected(METHOD_EXCEPTION);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub);
+ mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
+
+ mockCallables.expectedCallables.addExpected(mockExpectedCall);
mock.expectAndThrow(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_EXCEPTION);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testExpectNoneAndVoid() throws Throwable {
+ mockCallFactory.setupCreateCallSignature(mockCallMatch);
+ mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
+
mockCallFactory.setExpectedCreateVoidStubCalls(1);
- mockCallFactory.setupCreateVoidStub(mockVoidStub);
mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARG_NAME, C.NO_ARGS, mockVoidStub);
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
- mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
- mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
+ mockCallables.expectedCallables.addExpected(mockExpectedCall);
mock.expect(METHOD_NOARG_NAME);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testExpectOneAndVoid() throws Throwable {
+ mockCallFactory.setupCreateCallSignature(mockCallMatch);
+ mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
+
mockCallFactory.setExpectedCreateVoidStubCalls(1);
- mockCallFactory.setupCreateVoidStub(mockVoidStub);
mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
- mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
- mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
+ mockCallables.expectedCallables.addExpected(mockExpectedCall);
mock.expect(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0]);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testExpectWithConstraint() throws Throwable {
- mockCallFactory.setupCreateVoidStub(mockVoidStub);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
- mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
+ mockCallables.expectedCallables.addExpected(mockExpectedCall);
mock.expect(METHOD_ONEARG_NAME, new IsEqual(METHOD_ONEARG_ARGS[0]));
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testExpectWithConstraintArray() throws Throwable {
- mockCallFactory.setupCreateVoidStub(mockVoidStub);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
- mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
+ mockCallables.expectedCallables.addExpected(mockExpectedCall);
mock.expect(METHOD_ONEARG_NAME, new Constraint[] { new IsEqual(METHOD_ONEARG_ARGS[0])});
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testExpectManyAndReturn() throws Throwable {
- mockCallFactory.addExpectedCreateReturnStub(METHOD_TWOARG_RESULT);
- mockCallFactory.setupCreateReturnStub(mockReturnStub);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockReturnStub);
mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
- mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
- mockCallableAddable.setupCall(METHOD_TWOARG_RESULT);
+ mockCallFactory.createReturnStub.setExpected(METHOD_TWOARG_RESULT);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockReturnStub);
+ mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
+
+ mockCallables.expectedCallables.addExpected(mockExpectedCall);
+ mockCallables.setupCall(METHOD_TWOARG_RESULT);
mock.expectAndReturn(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_TWOARG_RESULT);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testExpectManyAndThrow() throws Throwable {
- mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
- mockCallFactory.setupCreateThrowStub(mockThrowStub);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockThrowStub);
mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
- mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
- mockCallableAddable.setupCall(METHOD_TWOARG_RESULT);
+ mockCallFactory.createThrowStub.setExpected(METHOD_EXCEPTION);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockThrowStub);
+ mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
+
+ mockCallables.expectedCallables.addExpected(mockExpectedCall);
+ mockCallables.setupCall(METHOD_TWOARG_RESULT);
mock.expectAndThrow(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testExpectOneAndReturn() throws Throwable {
- mockCallFactory.addExpectedCreateReturnStub(METHOD_ONEARG_RESULT);
- mockCallFactory.setupCreateReturnStub(mockReturnStub);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub);
mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
- mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
- mockCallableAddable.setupCall(METHOD_ONEARG_RESULT);
+ mockCallFactory.createReturnStub.setExpected(METHOD_ONEARG_RESULT);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub);
+ mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
+
+ mockCallables.expectedCallables.addExpected(mockExpectedCall);
+ mockCallables.setupCall(METHOD_ONEARG_RESULT);
mock.expectAndReturn(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_ONEARG_RESULT);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testMatchNoneAndVoid() throws Throwable {
+ mockCallFactory.setupCreateCallSignature(mockCallMatch);
+ mockCallables.setupCall(METHOD_NOARGANDRETURN_RESULT);
+
mockCallFactory.setExpectedCreateVoidStubCalls(1);
- mockCallFactory.setupCreateVoidStub(mockVoidStub);
mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARG_NAME, C.NO_ARGS, mockVoidStub);
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallableAddable.addExpectedAddMatch(mockCallMatch);
- mockCallableAddable.setupCall(METHOD_NOARGANDRETURN_RESULT);
+ mockCallables.matchedCallables.addExpected(mockCallMatch);
mock.match(METHOD_NOARG_NAME);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testMatchNoneAndReturn() throws Throwable {
- mockCallFactory.addExpectedCreateReturnStub(METHOD_NOARGANDRETURN_RESULT);
- mockCallFactory.setupCreateReturnStub(mockReturnStub);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARG_NAME, C.NO_ARGS, mockReturnStub);
mockCallFactory.setupCreateCallSignature(mockCallMatch);
+ mockCallables.setupCall(METHOD_ONEARG_RESULT);
+
+ mockCallFactory.createReturnStub.setExpected(METHOD_NOARGANDRETURN_RESULT);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARG_NAME, C.NO_ARGS, mockReturnStub);
- mockCallableAddable.addExpectedAddMatch(mockCallMatch);
- mockCallableAddable.setupCall(METHOD_ONEARG_RESULT);
+ mockCallables.matchedCallables.addExpected(mockCallMatch);
mock.matchAndReturn(METHOD_NOARG_NAME, METHOD_NOARGANDRETURN_RESULT);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testMatchNoneAndThrow() throws Throwable {
- mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
mockCallFactory.setupCreateThrowStub(mockThrowStub);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARG_NAME, C.NO_ARGS, mockThrowStub);
mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallableAddable.addExpectedAddMatch(mockCallMatch);
- mockCallableAddable.setupCall(METHOD_NOARGANDRETURN_RESULT);
+ mockCallFactory.createThrowStub.setExpected(METHOD_EXCEPTION);
+ mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARG_NAME, C.NO_ARGS, mockThrowStub);
+
+ mockCallables.matchedCallables.addExpected(mockCallMatch);
+ mockCallables.setupCall(METHOD_NOARGANDRETURN_RESULT);
mock.matchAndThrow(METHOD_NOARG_NAME, METHOD_EXCEPTION);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testMatchOneAndVoid() throws Throwable {
mockCallFactory.setExpectedCreateVoidStubCalls(1);
- mockCallFactory.setupCreateVoidStub(mockVoidStub);
mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
- mockCallableAddable.addExpectedAddMatch(mockCallMatch);
+ mockCallables.matchedCallables.addExpected(mockCallMatch);
mock.match(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0]);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testMatchOneAndReturn() throws Throwable {
- mockCallFactory.addExpectedCreateReturnStub(METHOD_ONEARG_RESULT);
- mockCallFactory.setupCreateReturnStub(mockReturnStub);
+ mockCallFactory.createReturnStub.setExpected(METHOD_ONEARG_RESULT);
mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub);
mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallableAddable.addExpectedAddMatch(mockCallMatch);
- mockCallableAddable.setupCall(METHOD_ONEARG_RESULT);
+ mockCallables.matchedCallables.addExpected(mockCallMatch);
+ mockCallables.setupCall(METHOD_ONEARG_RESULT);
mock.matchAndReturn(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_ONEARG_RESULT);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testMatchOneAndThrow() throws Throwable {
- mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
- mockCallFactory.setupCreateThrowStub(mockThrowStub);
+ mockCallFactory.createThrowStub.setExpected(METHOD_EXCEPTION);
mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub);
mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallableAddable.addExpectedAddMatch(mockCallMatch);
- mockCallableAddable.setupCall(METHOD_ONEARG_RESULT);
+ mockCallables.matchedCallables.addExpected(mockCallMatch);
+ mockCallables.setupCall(METHOD_ONEARG_RESULT);
mock.matchAndThrow(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_EXCEPTION);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testMatchManyAndVoid() throws Throwable {
mockCallFactory.setExpectedCreateVoidStubCalls(1);
- mockCallFactory.setupCreateVoidStub(mockVoidStub);
mockCallFactory.addExpectedCreateCallSignature(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockVoidStub);
mockCallFactory.setupCreateCallSignature(mockCallMatch);
mockCallFactory.addExpectedCreateCallExpectation(mockCallMatch);
mockCallFactory.setupCreateCallExpectation(mockExpectedCall);
- mockCallableAddable.addExpectedAddMatch(mockCallMatch);
+ mockCallables.matchedCallables.addExpected(mockCallMatch);
mock.match(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testMatchManyAndReturn() throws Throwable {
- mockCallFactory.addExpectedCreateReturnStub(METHOD_TWOARG_RESULT);
- mockCallFactory.setupCreateReturnStub(mockReturnStub);
+ mockCallFactory.createReturnStub.setExpected(METHOD_TWOARG_RESULT);
mockCallFactory.addExpectedCreateCallSignature(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockReturnStub);
mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallableAddable.addExpectedAddMatch(mockCallMatch);
- mockCallableAddable.setupCall(METHOD_TWOARG_RESULT);
+ mockCallables.matchedCallables.addExpected(mockCallMatch);
+ mockCallables.setupCall(METHOD_TWOARG_RESULT);
mock.matchAndReturn(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_TWOARG_RESULT);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testMatchManyAndThrow() throws Throwable {
- mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
- mockCallFactory.setupCreateThrowStub(mockThrowStub);
+ mockCallFactory.createThrowStub.setExpected(METHOD_EXCEPTION);
mockCallFactory.addExpectedCreateCallSignature(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockThrowStub);
mockCallFactory.setupCreateCallSignature(mockCallMatch);
- mockCallableAddable.addExpectedAddMatch(mockCallMatch);
- mockCallableAddable.setupCall(METHOD_TWOARG_RESULT);
+ mockCallables.matchedCallables.addExpected(mockCallMatch);
+ mockCallables.setupCall(METHOD_TWOARG_RESULT);
mock.matchAndThrow(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testMockAnnotatesAssertionFailedErrors()
throws Throwable {
final String originalMessage = "original message";
- mockCallableAddable.setupCall(new AssertionFailedError(originalMessage));
+ mockCallables.setupCall(new AssertionFailedError(originalMessage));
try {
proxy.noArgMethodVoid();
@@ -385,36 +382,36 @@
throws Throwable {
final String result = "configured result";
- mockCallableAddable.setupCall(result);
+ mockCallables.setupCall(result);
assertSame("result is returned by mock", result, proxy.oneArgMethod(METHOD_TWOARG_ARGS[0]));
}
public void testMockProxySendsAllArgument() throws Throwable {
- mockCallableAddable.addExpectedCall(METHOD_TWOARG_NAME, METHOD_TWOARG_ARGS);
- mockCallableAddable.setupCall("result ignored");
+ mockCallables.addExpectedCall(METHOD_TWOARG_NAME, METHOD_TWOARG_ARGS);
+ mockCallables.setupCall("result ignored");
proxy.twoArgMethod(METHOD_TWOARG_ARGS[0], METHOD_TWOARG_ARGS[1]);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testMockProxySendsEmptyArrayWhenNoArguments()
throws Exception {
- mockCallableAddable.addExpectedCall(METHOD_NOARG_NAME, METHOD_NOARG_ARGS);
- mockCallableAddable.setupCall("result ignored");
+ mockCallables.addExpectedCall(METHOD_NOARG_NAME, METHOD_NOARG_ARGS);
+ mockCallables.setupCall("result ignored");
proxy.noArgMethodVoid();
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testMockProxyThrowsConfiguredExceptions()
throws Throwable {
final Throwable throwable = new DummyThrowable();
- mockCallableAddable.setupCall(new ThrowStub(throwable));
+ mockCallables.setupCall(new ThrowStub(throwable));
try {
proxy.noArgMethodVoid();
@@ -428,11 +425,11 @@
}
public void testMockVerifies() throws Exception {
- mockCallableAddable.setExpectedVerifyCalls(1);
+ mockCallables.setExpectedVerifyCalls(1);
mock.verify();
- mockCallableAddable.verifyExpectations();
+ mockCallables.verifyExpectations();
}
public void testProxyEquality() throws Exception {
@@ -444,7 +441,7 @@
CallStub ret = new ReturnStub(new Boolean(IGNORED_RESULT));
mockCallFactory.setupCreateReturnStub(ret);
mockCallFactory.setupCreateCallSignature(new CallSignature("call",C.anyArgs(1),ret));
- mockCallableAddable.setupCall(new Boolean(false));
+ mockCallables.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"));
--- CallMatchTest.java DELETED ---
--- MockCallableAddable.java DELETED ---
|
