Menu
▾
▴
mockobjects-java-dev
Update of /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic
In directory sc8-pr-cvs1:/tmp/cvs-serv12659/core/test/mockobjects/dynamic
Modified Files:
Tag: MethodMatcherAlternative
MockTest.java MockCallFactory.java CallSequenceTest.java
Added Files:
Tag: MethodMatcherAlternative
CallFactoryTest.java
Log Message:
Little experiment to do Mocks a different way.
Broken tests - and nothing interesting yet.
--- NEW FILE: CallFactoryTest.java ---
/*
* Created on 06-Jul-2003
*/
package test.mockobjects.dynamic;
import com.mockobjects.dynamic.ActiveCall;
import com.mockobjects.dynamic.C;
import com.mockobjects.dynamic.CallFactory;
import com.mockobjects.dynamic.Callable;
import com.mockobjects.dynamic.DefaultCallFactory;
import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
public class CallFactoryTest extends TestCase {
private final String METHOD_NAME1 = "method1";
private final String METHOD_NAME2 = "method2";
private final Object[] METHOD_ARGS = new Object[0];
private CallFactory myCallFactory = new DefaultCallFactory();
private ActiveCall myMethod1 = new ActiveCall(METHOD_NAME1, METHOD_ARGS);
private ActiveCall myMethod2 = new ActiveCall(METHOD_NAME2, METHOD_ARGS);
public CallFactoryTest(String name) {
super(name);
}
public void testCreateReturnStub() throws Throwable {
Callable methodCall = myCallFactory.createMethodCallWithReturn(METHOD_NAME1, C.NO_ARGS, "result");
assertTrue("Should match method1", methodCall.matches(myMethod1));
assertFalse("Should not match method2", methodCall.matches(myMethod2));
assertEquals("Should get a result", "result", methodCall.call(myMethod1));
}
public void testCreateVoidStub() throws Throwable {
Callable methodCall = myCallFactory.createMethodCallWithVoid(METHOD_NAME1, C.NO_ARGS);
assertTrue("Should match method1", methodCall.matches(myMethod1));
assertFalse("Should not match method2", methodCall.matches(myMethod2));
assertEquals("Should get a void result", null, methodCall.call(myMethod1));
}
public void testCreateMethodCallWithException() throws Throwable {
Callable methodCall = myCallFactory.createMethodCallWithException(METHOD_NAME1, C.NO_ARGS, new RuntimeException("An exception"));
assertTrue("Should match method1", methodCall.matches(myMethod1));
assertFalse("Should not match method2", methodCall.matches(myMethod2));
try {
methodCall.call(myMethod1);
fail("Should get an exception");
} catch(RuntimeException e) {
//pass
}
}
}
Index: MockTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockTest.java,v
retrieving revision 1.14
retrieving revision 1.14.2.1
diff -u -r1.14 -r1.14.2.1
--- MockTest.java 5 Jul 2003 15:15:54 -0000 1.14
+++ MockTest.java 6 Jul 2003 14:21:29 -0000 1.14.2.1
@@ -4,7 +4,6 @@
package test.mockobjects.dynamic;
import com.mockobjects.constraint.*;
-import com.mockobjects.constraint.IsEqual;
import com.mockobjects.dynamic.*;
import com.mockobjects.util.*;
@@ -13,27 +12,33 @@
public class MockTest extends TestCase {
private static final String MOCK_NAME = "Test mock";
+
final String METHOD_NOARG_NAME = "noArgMethodVoid";
- final String METHOD_NOARGANDRETURN_NAME = "noArgMethod";
- final String METHOD_NOARGANDRETURN_RESULT = "resultNoArgs";
+ final int METHOD_NOARG_RESULT = 100;
+
final String METHOD_ONEARG_NAME = "oneArgMethod";
final String METHOD_ONEARG_RESULT = "result1Args";
+
final String METHOD_TWOARG_NAME = "twoArgMethod";
- final String METHOD_TWOARG_RESULT = "resultTwoArgs";
+ final boolean METHOD_TWOARG_RESULT = true;
+
+ final String ONE_PARAM_VALUE = "p1";
+ final int TWO_PARAM_VALUE = 54;
+
+ final Constraint[] ONE_PARAM_CONSTRAINT = C.args(C.eq(ONE_PARAM_VALUE));
+ final Constraint[] TWO_PARAM_CONSTRAINT = C.args(C.eq(ONE_PARAM_VALUE), C.gt(TWO_PARAM_VALUE));
+
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 ConstraintMatcher METHOD_ONEARG_CONSTRAINTS = C.args(C.eq("oneP1"));
+ final Constraint[] METHOD_ONEARG_CONSTRAINTS = C.args(C.eq("oneP1"));
final String[] METHOD_TWOARG_ARGS = new String[] { "twoP1", "twoP2" };
- final ConstraintMatcher METHOD_TWOARG_CONSTRAINTS = C.args(C.eq("twoP1"), C.eq("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("call match");
- private MockCallable mockExpectedCall = new MockCallable("expected call");
- private MockCallable mockReturnStub = new MockCallable("return stub");
- private MockCallable mockThrowStub = new MockCallable("throw stub");
- private MockCallable mockVoidStub = new MockCallable("void stub");
+ private MockCallable mockCall = new MockCallable("call match");
+
private MockCallableAddable mockCallableAddable = new MockCallableAddable();
public MockTest(String name) throws Exception {
@@ -48,319 +53,197 @@
} catch (ClassCastException ex) {
fail("proxy is not of expected interface type");
}
+
+ mockCallFactory.setupCreateCallExpectation(mockCall);
}
public void testExpectManyAndVoid() 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.addExpectedAddExpect(mockExpectedCall);
-
- mock.expect(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS);
-
+ mockCallFactory.addExpectedCreateMethodCallWithVoid(METHOD_TWOARG_NAME, TWO_PARAM_CONSTRAINT);
+ mockCallFactory.setupCreateMethodCallWithVoid(mockCall);
+ mockCallFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallableAddable.addExpectedAddExpect(mockCall);
+
+ mock.expect(METHOD_TWOARG_NAME, TWO_PARAM_CONSTRAINT);
+
Verifier.verifyObject(this);
- mockCallableAddable.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);
-
- mock.expectAndReturn(METHOD_NOARGANDRETURN_NAME, METHOD_NOARGANDRETURN_RESULT);
-
+ mockCallFactory.addExpectedCreateMethodCallWithReturn(METHOD_NOARG_NAME, C.NO_ARGS, new Integer(METHOD_NOARG_RESULT));
+ mockCallFactory.setupCreateMethodCallWithReturn(mockCall);
+ mockCallFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallableAddable.addExpectedAddExpect(mockCall);
+
+ mock.expectAndReturn(METHOD_NOARG_NAME, METHOD_NOARG_RESULT);
+
Verifier.verifyObject(this);
- mockCallableAddable.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);
+ mockCallFactory.addExpectedCreateMethodCallWithException(METHOD_NOARG_NAME, C.NO_ARGS, METHOD_EXCEPTION);
+ mockCallFactory.setupCreateMethodCallWithException(mockCall);
+ mockCallFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallableAddable.addExpectedAddExpect(mockCall);
- mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
-
- mock.expectAndThrow(METHOD_NOARGANDRETURN_NAME, METHOD_EXCEPTION);
+ mock.expectAndThrow(METHOD_NOARG_NAME, METHOD_EXCEPTION);
Verifier.verifyObject(this);
- mockCallableAddable.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);
+ mockCallFactory.addExpectedCreateMethodCallWithException(METHOD_ONEARG_NAME, ONE_PARAM_CONSTRAINT, METHOD_EXCEPTION);
+ mockCallFactory.setupCreateMethodCallWithException(mockCall);
+ mockCallFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallableAddable.addExpectedAddExpect(mockCall);
- mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
-
- mock.expectAndThrow(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_EXCEPTION);
+ mock.expectAndThrow(METHOD_ONEARG_NAME, ONE_PARAM_VALUE, METHOD_EXCEPTION);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
}
public void testExpectNoneAndVoid() throws Throwable {
- 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);
+ mockCallFactory.addExpectedCreateMethodCallWithVoid(METHOD_NOARG_NAME, C.NO_ARGS);
+ mockCallFactory.setupCreateMethodCallWithVoid(mockCall);
+ mockCallFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallableAddable.addExpectedAddExpect(mockCall);
mock.expect(METHOD_NOARG_NAME);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
}
public void testExpectOneAndVoid() 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.addExpectedAddExpect(mockExpectedCall);
-
- mock.expect(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0]);
-
- Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
- }
+ mockCallFactory.addExpectedCreateMethodCallWithVoid(METHOD_ONEARG_NAME, ONE_PARAM_CONSTRAINT);
+ mockCallFactory.setupCreateMethodCallWithVoid(mockCall);
+ mockCallFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallableAddable.addExpectedAddExpect(mockCall);
- 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);
-
- mock.expect(METHOD_ONEARG_NAME, new IsEqual(METHOD_ONEARG_ARGS[0]));
-
- Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
- }
+ mock.expect(METHOD_ONEARG_NAME, ONE_PARAM_VALUE);
- 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);
-
- mock.expect(METHOD_ONEARG_NAME, new Constraint[] { new IsEqual(METHOD_ONEARG_ARGS[0])});
-
Verifier.verifyObject(this);
- mockCallableAddable.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);
-
- mock.expectAndReturn(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_TWOARG_RESULT);
+ mockCallFactory.addExpectedCreateMethodCallWithReturn(METHOD_TWOARG_NAME, TWO_PARAM_CONSTRAINT, new Boolean(METHOD_TWOARG_RESULT));
+ mockCallFactory.setupCreateMethodCallWithReturn(mockCall);
+ mockCallFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallableAddable.addExpectedAddExpect(mockCall);
+
+ mock.expectAndReturn(METHOD_TWOARG_NAME, TWO_PARAM_CONSTRAINT, METHOD_TWOARG_RESULT);
- Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
+ mockCallFactory.verify();
}
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);
+ mockCallFactory.addExpectedCreateMethodCallWithException(METHOD_TWOARG_NAME, TWO_PARAM_CONSTRAINT, METHOD_EXCEPTION);
+ mockCallFactory.setupCreateMethodCallWithException(mockCall);
+ mockCallFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallableAddable.addExpectedAddExpect(mockCall);
- mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
- mockCallableAddable.setupCall(METHOD_TWOARG_RESULT);
-
- mock.expectAndThrow(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION);
+ mock.expectAndThrow(METHOD_TWOARG_NAME, TWO_PARAM_CONSTRAINT, METHOD_EXCEPTION);
Verifier.verifyObject(this);
- mockCallableAddable.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);
-
- mock.expectAndReturn(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_ONEARG_RESULT);
+ mockCallFactory.addExpectedCreateMethodCallWithReturn(METHOD_ONEARG_NAME, ONE_PARAM_CONSTRAINT, METHOD_ONEARG_RESULT);
+ mockCallFactory.setupCreateMethodCallWithReturn(mockCall);
+ mockCallFactory.addExpectedCreateCallExpectation(mockCall);
+ mockCallableAddable.addExpectedAddExpect(mockCall);
+
+ mock.expectAndReturn(METHOD_ONEARG_NAME, ONE_PARAM_VALUE, METHOD_ONEARG_RESULT);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
}
public void testMatchNoneAndVoid() throws Throwable {
- mockCallFactory.setExpectedCreateVoidStubCalls(1);
- mockCallFactory.setupCreateVoidStub(mockVoidStub);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_NOARG_NAME, C.NO_ARGS, mockVoidStub);
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
+ mockCallFactory.addExpectedCreateMethodCallWithVoid(METHOD_NOARG_NAME, C.NO_ARGS);
+ mockCallFactory.setupCreateMethodCallWithVoid(mockCall);
+ mockCallableAddable.addExpectedAddMatch(mockCall);
- mockCallableAddable.addExpectedAddMatch(mockCallMatch);
- mockCallableAddable.setupCall(METHOD_NOARGANDRETURN_RESULT);
-
mock.match(METHOD_NOARG_NAME);
Verifier.verifyObject(this);
- mockCallableAddable.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);
-
- mockCallableAddable.addExpectedAddMatch(mockCallMatch);
- mockCallableAddable.setupCall(METHOD_ONEARG_RESULT);
-
- mock.matchAndReturn(METHOD_NOARG_NAME, METHOD_NOARGANDRETURN_RESULT);
-
+ mockCallFactory.addExpectedCreateMethodCallWithReturn(METHOD_NOARG_NAME, C.NO_ARGS, new Integer(METHOD_NOARG_RESULT));
+ mockCallFactory.setupCreateMethodCallWithReturn(mockCall);
+ mockCallableAddable.addExpectedAddMatch(mockCall);
+
+ mock.matchAndReturn(METHOD_NOARG_NAME, METHOD_NOARG_RESULT);
+
Verifier.verifyObject(this);
- mockCallableAddable.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.addExpectedCreateMethodCallWithException(METHOD_NOARG_NAME, C.NO_ARGS, METHOD_EXCEPTION);
+ mockCallFactory.setupCreateMethodCallWithException(mockCall);
+ mockCallableAddable.addExpectedAddMatch(mockCall);
mock.matchAndThrow(METHOD_NOARG_NAME, METHOD_EXCEPTION);
Verifier.verifyObject(this);
- mockCallableAddable.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);
-
- mock.match(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0]);
-
+ mockCallFactory.addExpectedCreateMethodCallWithVoid(METHOD_ONEARG_NAME, ONE_PARAM_CONSTRAINT);
+ mockCallFactory.setupCreateMethodCallWithVoid(mockCall);
+ mockCallableAddable.addExpectedAddMatch(mockCall);
+
+ mock.match(METHOD_ONEARG_NAME, ONE_PARAM_VALUE);
+
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
}
public void testMatchOneAndReturn() throws Throwable {
- mockCallFactory.addExpectedCreateReturnStub(METHOD_ONEARG_RESULT);
- mockCallFactory.setupCreateReturnStub(mockReturnStub);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub);
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
-
- mockCallableAddable.addExpectedAddMatch(mockCallMatch);
- mockCallableAddable.setupCall(METHOD_ONEARG_RESULT);
-
- mock.matchAndReturn(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_ONEARG_RESULT);
+ mockCallFactory.addExpectedCreateMethodCallWithReturn(METHOD_ONEARG_NAME, ONE_PARAM_CONSTRAINT, METHOD_ONEARG_RESULT);
+ mockCallFactory.setupCreateMethodCallWithReturn(mockCall);
+ mockCallableAddable.addExpectedAddMatch(mockCall);
+
+ mock.matchAndReturn(METHOD_ONEARG_NAME, ONE_PARAM_VALUE, METHOD_ONEARG_RESULT);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
}
public void testMatchOneAndThrow() throws Throwable {
- mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
- mockCallFactory.setupCreateThrowStub(mockThrowStub);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub);
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
+ mockCallFactory.addExpectedCreateMethodCallWithException(METHOD_ONEARG_NAME, ONE_PARAM_CONSTRAINT, METHOD_EXCEPTION);
+ mockCallFactory.setupCreateMethodCallWithException(mockCall);
+ mockCallableAddable.addExpectedAddMatch(mockCall);
- mockCallableAddable.addExpectedAddMatch(mockCallMatch);
- mockCallableAddable.setupCall(METHOD_ONEARG_RESULT);
-
- mock.matchAndThrow(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_EXCEPTION);
+ mock.matchAndThrow(METHOD_ONEARG_NAME, ONE_PARAM_VALUE, METHOD_EXCEPTION);
Verifier.verifyObject(this);
- mockCallableAddable.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);
-
- mock.match(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS);
-
+ mockCallFactory.addExpectedCreateMethodCallWithVoid(METHOD_TWOARG_NAME, TWO_PARAM_CONSTRAINT);
+ mockCallFactory.setupCreateMethodCallWithVoid(mockCall);
+ mockCallableAddable.addExpectedAddMatch(mockCall);
+
+ mock.match(METHOD_TWOARG_NAME, TWO_PARAM_CONSTRAINT);
+
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
}
public void testMatchManyAndReturn() throws Throwable {
- mockCallFactory.addExpectedCreateReturnStub(METHOD_TWOARG_RESULT);
- mockCallFactory.setupCreateReturnStub(mockReturnStub);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockReturnStub);
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
-
- mockCallableAddable.addExpectedAddMatch(mockCallMatch);
- mockCallableAddable.setupCall(METHOD_TWOARG_RESULT);
-
- mock.matchAndReturn(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_TWOARG_RESULT);
+ mockCallFactory.addExpectedCreateMethodCallWithReturn(METHOD_TWOARG_NAME, TWO_PARAM_CONSTRAINT, new Boolean(METHOD_TWOARG_RESULT));
+ mockCallFactory.setupCreateMethodCallWithReturn(mockCall);
+ mockCallableAddable.addExpectedAddMatch(mockCall);
+
+ mock.matchAndReturn(METHOD_TWOARG_NAME, TWO_PARAM_CONSTRAINT, METHOD_TWOARG_RESULT);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
}
public void testMatchManyAndThrow() throws Throwable {
- mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
- mockCallFactory.setupCreateThrowStub(mockThrowStub);
- mockCallFactory.addExpectedCreateCallSignature(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockThrowStub);
- mockCallFactory.setupCreateCallSignature(mockCallMatch);
+ mockCallFactory.addExpectedCreateMethodCallWithException(METHOD_TWOARG_NAME, TWO_PARAM_CONSTRAINT, METHOD_EXCEPTION);
+ mockCallFactory.setupCreateMethodCallWithException(mockCall);
+ mockCallableAddable.addExpectedAddMatch(mockCall);
- mockCallableAddable.addExpectedAddMatch(mockCallMatch);
- mockCallableAddable.setupCall(METHOD_TWOARG_RESULT);
-
- mock.matchAndThrow(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION);
+ mock.matchAndThrow(METHOD_TWOARG_NAME, TWO_PARAM_CONSTRAINT, METHOD_EXCEPTION);
Verifier.verifyObject(this);
- mockCallableAddable.verifyExpectations();
}
public void testMockAnnotatesAssertionFailedErrors()
@@ -440,10 +323,8 @@
}
public void testProxyInEquality() throws Exception {
- boolean IGNORED_RESULT = true;
- CallStub ret = new ReturnStub(new Boolean(IGNORED_RESULT));
- mockCallFactory.setupCreateReturnStub(ret);
- mockCallFactory.setupCreateCallSignature(new CallSignature("call",C.anyArgs(1),ret));
+ int IGNORED_RESULT = -1;
+ mockCallFactory.setupCreateMethodCallWithReturn(new VoidStub());
mockCallableAddable.setupCall(new Boolean(false));
mock.matchAndReturn("call", C.anyArgs(1), IGNORED_RESULT);
Index: MockCallFactory.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockCallFactory.java,v
retrieving revision 1.4
retrieving revision 1.4.4.1
diff -u -r1.4 -r1.4.4.1
--- MockCallFactory.java 19 May 2003 23:56:23 -0000 1.4
+++ MockCallFactory.java 6 Jul 2003 14:21:29 -0000 1.4.4.1
@@ -3,161 +3,150 @@
import com.mockobjects.*;
import com.mockobjects.dynamic.CallFactory;
import com.mockobjects.dynamic.Callable;
-import com.mockobjects.dynamic.ConstraintMatcher;
+import com.mockobjects.constraint.Constraint;
-public class MockCallFactory implements CallFactory{
- private ExpectationCounter myCreateReturnStubCalls = new ExpectationCounter("MockCallFactory.createReturnStub(Object)");
- 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)");
- private ReturnValues myActualCreateThrowStubReturnValues = new ReturnValues("MockCallFactory.createThrowStub(Throwable)", true);
- private ExpectationList myCreateThrowStubParameter0Values = new ExpectationList("MockCallFactory.createThrowStub(Throwable) java.lang.Throwable");
- private ExpectationCounter myCreateVoidStubCalls = new ExpectationCounter("MockCallFactory.createVoidStub()");
- private ReturnValues myActualCreateVoidStubReturnValues = new ReturnValues("MockCallFactory.createVoidStub()", true);
+public class MockCallFactory implements CallFactory, Verifiable {
private ExpectationCounter myCreateCallExpectationCalls = new ExpectationCounter("MockCallFactory.createCallExpectation(Callable)");
private ReturnValues myActualCreateCallExpectationReturnValues = new ReturnValues("MockCallFactory.createCallExpectation(Callable)", true);
private ExpectationList myCreateCallExpectationParameter0Values = new ExpectationList("MockCallFactory.createCallExpectation(Callable) com.mockobjects.dynamic.Callable");
- private ExpectationCounter myCreateCallSignatureCalls = new ExpectationCounter("MockCallFactory.createCallMatch(String, ConstraintMatcher, Callable)");
- private ReturnValues myActualCreateCallSignatureReturnValues = new ReturnValues("MockCallFactory.createCallMatch(String, ConstraintMatcher, Callable)", true);
- private ExpectationList myCreateCallSignatureParameter0Values = new ExpectationList("MockCallFactory.createCallMatch(String, ConstraintMatcher, Callable) java.lang.String");
- 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");
+ private ExpectationCounter myCreateMethodCallWithVoidCalls = new ExpectationCounter("MockCallFactory.createMethodCallWithVoid(String, Constraint[])");
+ private ReturnValues myActualCreateMethodCallWithVoidReturnValues = new ReturnValues("MockCallFactory.createMethodCallWithVoid(String, Constraint[])", true);
+ private ExpectationList myCreateMethodCallWithVoidParameter0Values = new ExpectationList("MockCallFactory.createMethodCallWithVoid(String, Constraint[]) java.lang.String");
+ private ExpectationList myCreateMethodCallWithVoidParameter1Values = new ExpectationList("MockCallFactory.createMethodCallWithVoid(String, Constraint[]) com.mockobjects.constraint.Constraint");
+ private ExpectationCounter myCreateMethodCallWithExceptionCalls = new ExpectationCounter("MockCallFactory.createMethodCallWithException(String, Constraint[], Throwable)");
+ private ReturnValues myActualCreateMethodCallWithExceptionReturnValues = new ReturnValues("MockCallFactory.createMethodCallWithException(String, Constraint[], Throwable)", true);
+ private ExpectationList myCreateMethodCallWithExceptionParameter0Values = new ExpectationList("MockCallFactory.createMethodCallWithException(String, Constraint[], Throwable) java.lang.String");
+ private ExpectationList myCreateMethodCallWithExceptionParameter1Values = new ExpectationList("MockCallFactory.createMethodCallWithException(String, Constraint[], Throwable) com.mockobjects.constraint.Constraint");
+ private ExpectationList myCreateMethodCallWithExceptionParameter2Values = new ExpectationList("MockCallFactory.createMethodCallWithException(String, Constraint[], Throwable) java.lang.Throwable");
+ private ExpectationCounter myCreateMethodCallWithReturnCalls = new ExpectationCounter("MockCallFactory.createMethodCallWithReturn(String, Constraint[], Object)");
+ private ReturnValues myActualCreateMethodCallWithReturnReturnValues = new ReturnValues("MockCallFactory.createMethodCallWithReturn(String, Constraint[], Object)", true);
+ private ExpectationList myCreateMethodCallWithReturnParameter0Values = new ExpectationList("MockCallFactory.createMethodCallWithReturn(String, Constraint[], Object) java.lang.String");
+ private ExpectationList myCreateMethodCallWithReturnParameter1Values = new ExpectationList("MockCallFactory.createMethodCallWithReturn(String, Constraint[], Object) com.mockobjects.constraint.Constraint");
+ private ExpectationList myCreateMethodCallWithReturnParameter2Values = new ExpectationList("MockCallFactory.createMethodCallWithReturn(String, Constraint[], Object) java.lang.Object");
- public void setExpectedCreateReturnStubCalls(int calls){
- myCreateReturnStubCalls.setExpected(calls);
+ public void setExpectedCreateCallExpectationCalls(int calls){
+ myCreateCallExpectationCalls.setExpected(calls);
}
- public void addExpectedCreateReturnStub(Object arg0){
- myCreateReturnStubParameter0Values.addExpected(arg0);
+ public void addExpectedCreateCallExpectation(Callable arg0){
+ myCreateCallExpectationParameter0Values.addExpected(arg0);
}
- public Callable createReturnStub(Object arg0){
- myCreateReturnStubCalls.inc();
- myCreateReturnStubParameter0Values.addActual(arg0);
- Object nextReturnValue = myActualCreateReturnStubReturnValues.getNext();
+ public Callable createCallExpectation(Callable arg0){
+ myCreateCallExpectationCalls.inc();
+ myCreateCallExpectationParameter0Values.addActual(arg0);
+ Object nextReturnValue = myActualCreateCallExpectationReturnValues.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);
- Object nextReturnValue = myActualCreateThrowStubReturnValues.getNext();
- if (nextReturnValue instanceof ExceptionalReturnValue && ((ExceptionalReturnValue)nextReturnValue).getException() instanceof RuntimeException)
- throw (RuntimeException)((ExceptionalReturnValue)nextReturnValue).getException();
- return (Callable) nextReturnValue;
+ public void setupExceptionCreateCallExpectation(Throwable arg){
+ myActualCreateCallExpectationReturnValues.add(new ExceptionalReturnValue(arg));
}
- public void setupExceptionCreateThrowStub(Throwable arg){
- myActualCreateThrowStubReturnValues.add(new ExceptionalReturnValue(arg));
+ public void setupCreateCallExpectation(Callable arg){
+ myActualCreateCallExpectationReturnValues.add(arg);
}
- public void setupCreateThrowStub(Callable arg){
- myActualCreateThrowStubReturnValues.add(arg);
+ public void setExpectedCreateMethodCallWithVoidCalls(int calls){
+ myCreateMethodCallWithVoidCalls.setExpected(calls);
}
- public void setExpectedCreateVoidStubCalls(int calls){
- myCreateVoidStubCalls.setExpected(calls);
+ public void addExpectedCreateMethodCallWithVoid(String arg0, Constraint[] arg1){
+ myCreateMethodCallWithVoidParameter0Values.addExpected(arg0);
+ myCreateMethodCallWithVoidParameter1Values.addExpectedMany(arg1);
}
- public Callable createVoidStub(){
- myCreateVoidStubCalls.inc();
- Object nextReturnValue = myActualCreateVoidStubReturnValues.getNext();
+ public Callable createMethodCallWithVoid(String arg0, Constraint[] arg1){
+ myCreateMethodCallWithVoidCalls.inc();
+ myCreateMethodCallWithVoidParameter0Values.addActual(arg0);
+ myCreateMethodCallWithVoidParameter1Values.addActualMany(arg1);
+ Object nextReturnValue = myActualCreateMethodCallWithVoidReturnValues.getNext();
if (nextReturnValue instanceof ExceptionalReturnValue && ((ExceptionalReturnValue)nextReturnValue).getException() instanceof RuntimeException)
throw (RuntimeException)((ExceptionalReturnValue)nextReturnValue).getException();
return (Callable) nextReturnValue;
}
- public void setupExceptionCreateVoidStub(Throwable arg){
- myActualCreateVoidStubReturnValues.add(new ExceptionalReturnValue(arg));
+ public void setupExceptionCreateMethodCallWithVoid(Throwable arg){
+ myActualCreateMethodCallWithVoidReturnValues.add(new ExceptionalReturnValue(arg));
}
- public void setupCreateVoidStub(Callable arg){
- myActualCreateVoidStubReturnValues.add(arg);
+ public void setupCreateMethodCallWithVoid(Callable arg){
+ myActualCreateMethodCallWithVoidReturnValues.add(arg);
}
- public void setExpectedCreateCallExpectationCalls(int calls){
- myCreateCallExpectationCalls.setExpected(calls);
+ public void setExpectedCreateMethodCallWithExceptionCalls(int calls){
+ myCreateMethodCallWithExceptionCalls.setExpected(calls);
}
- public void addExpectedCreateCallExpectation(Callable arg0){
- myCreateCallExpectationParameter0Values.addExpected(arg0);
+ public void addExpectedCreateMethodCallWithException(String arg0, Constraint[] arg1, Throwable arg2){
+ myCreateMethodCallWithExceptionParameter0Values.addExpected(arg0);
+ myCreateMethodCallWithExceptionParameter1Values.addExpectedMany(arg1);
+ myCreateMethodCallWithExceptionParameter2Values.addExpected(arg2);
}
- public Callable createCallExpectation(Callable arg0){
- myCreateCallExpectationCalls.inc();
- myCreateCallExpectationParameter0Values.addActual(arg0);
- Object nextReturnValue = myActualCreateCallExpectationReturnValues.getNext();
+ public Callable createMethodCallWithException(String arg0, Constraint[] arg1, Throwable arg2){
+ myCreateMethodCallWithExceptionCalls.inc();
+ myCreateMethodCallWithExceptionParameter0Values.addActual(arg0);
+ myCreateMethodCallWithExceptionParameter1Values.addActualMany(arg1);
+ myCreateMethodCallWithExceptionParameter2Values.addActual(arg2);
+ Object nextReturnValue = myActualCreateMethodCallWithExceptionReturnValues.getNext();
if (nextReturnValue instanceof ExceptionalReturnValue && ((ExceptionalReturnValue)nextReturnValue).getException() instanceof RuntimeException)
throw (RuntimeException)((ExceptionalReturnValue)nextReturnValue).getException();
return (Callable) nextReturnValue;
}
- public void setupExceptionCreateCallExpectation(Throwable arg){
- myActualCreateCallExpectationReturnValues.add(new ExceptionalReturnValue(arg));
+ public void setupExceptionCreateMethodCallWithException(Throwable arg){
+ myActualCreateMethodCallWithExceptionReturnValues.add(new ExceptionalReturnValue(arg));
}
- public void setupCreateCallExpectation(Callable arg){
- myActualCreateCallExpectationReturnValues.add(arg);
+ public void setupCreateMethodCallWithException(Callable arg){
+ myActualCreateMethodCallWithExceptionReturnValues.add(arg);
+ }
+
+ public void setExpectedCreateMethodCallWithReturnCalls(int calls){
+ myCreateMethodCallWithReturnCalls.setExpected(calls);
}
- public void setExpectedCreateCallSignatureCalls(int calls){
- myCreateCallSignatureCalls.setExpected(calls);
+ public void addExpectedCreateMethodCallWithReturn(String arg0, Constraint[] arg1, Object arg2){
+ myCreateMethodCallWithReturnParameter0Values.addExpected(arg0);
+ myCreateMethodCallWithReturnParameter1Values.addExpectedMany(arg1);
+ myCreateMethodCallWithReturnParameter2Values.addExpected(arg2);
}
- public void addExpectedCreateCallSignature(String arg0, ConstraintMatcher arg1, Callable arg2){
- myCreateCallSignatureParameter0Values.addExpected(arg0);
- myCreateCallSignatureParameter1Values.addExpectedMany(arg1.getConstraints());
- myCreateCallSignatureParameter2Values.addExpected(arg2);
- }
-
- public Callable createCallSignature(String arg0, ConstraintMatcher arg1, Callable arg2){
- myCreateCallSignatureCalls.inc();
- myCreateCallSignatureParameter0Values.addActual(arg0);
- myCreateCallSignatureParameter1Values.addActualMany(arg1.getConstraints());
- myCreateCallSignatureParameter2Values.addActual(arg2);
- Object nextReturnValue = myActualCreateCallSignatureReturnValues.getNext();
+ public Callable createMethodCallWithReturn(String arg0, Constraint[] arg1, Object arg2){
+ myCreateMethodCallWithReturnCalls.inc();
+ myCreateMethodCallWithReturnParameter0Values.addActual(arg0);
+ myCreateMethodCallWithReturnParameter1Values.addActualMany(arg1);
+ myCreateMethodCallWithReturnParameter2Values.addActual(arg2);
+ Object nextReturnValue = myActualCreateMethodCallWithReturnReturnValues.getNext();
if (nextReturnValue instanceof ExceptionalReturnValue && ((ExceptionalReturnValue)nextReturnValue).getException() instanceof RuntimeException)
throw (RuntimeException)((ExceptionalReturnValue)nextReturnValue).getException();
return (Callable) nextReturnValue;
}
- public void setupExceptionCreateCallSignature(Throwable arg){
- myActualCreateCallSignatureReturnValues.add(new ExceptionalReturnValue(arg));
+ public void setupExceptionCreateMethodCallWithReturn(Throwable arg){
+ myActualCreateMethodCallWithReturnReturnValues.add(new ExceptionalReturnValue(arg));
}
- public void setupCreateCallSignature(Callable arg){
- myActualCreateCallSignatureReturnValues.add(arg);
+ public void setupCreateMethodCallWithReturn(Callable arg){
+ myActualCreateMethodCallWithReturnReturnValues.add(arg);
}
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();
+ myCreateMethodCallWithVoidCalls.verify();
+ myCreateMethodCallWithVoidParameter0Values.verify();
+ myCreateMethodCallWithVoidParameter1Values.verify();
+ myCreateMethodCallWithExceptionCalls.verify();
+ myCreateMethodCallWithExceptionParameter0Values.verify();
+ myCreateMethodCallWithExceptionParameter1Values.verify();
+ myCreateMethodCallWithExceptionParameter2Values.verify();
+ myCreateMethodCallWithReturnCalls.verify();
+ myCreateMethodCallWithReturnParameter0Values.verify();
+ myCreateMethodCallWithReturnParameter1Values.verify();
+ myCreateMethodCallWithReturnParameter2Values.verify();
}
}
Index: CallSequenceTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/CallSequenceTest.java,v
retrieving revision 1.11
retrieving revision 1.11.2.1
diff -u -r1.11 -r1.11.2.1
--- CallSequenceTest.java 5 Jul 2003 16:35:20 -0000 1.11
+++ CallSequenceTest.java 6 Jul 2003 14:21:29 -0000 1.11.2.1
@@ -3,6 +3,7 @@
*/
package test.mockobjects.dynamic;
+import com.mockobjects.constraint.Constraint;
import com.mockobjects.dynamic.*;
import com.mockobjects.dynamic.C;
import com.mockobjects.dynamic.CallSignature;
@@ -26,7 +27,7 @@
final String[] METHOD_A_ARGS = new String[] { "a1", "a2" };
final ActiveCall METHOD_A_CALL = new ActiveCall(METHOD_A_NAME, METHOD_A_ARGS);
- final ConstraintMatcher METHOD_A_CONSTRAINTS = C.args(C.eq("a1"), C.eq("a2"));
+ final Constraint[] METHOD_A_CONSTRAINTS = C.args(C.eq("a1"), C.eq("a2"));
final String[] METHOD_B_ARGS = new String[] { "b1", "b2" };
final ActiveCall METHOD_B_CALL = new ActiveCall(METHOD_B_NAME, METHOD_B_ARGS);
|
×
Want the latest updates on software, tech news, and AI?
Get latest updates about software, tech news, and AI from SourceForge directly in your inbox once a month.
Thanks for helping keep SourceForge clean.
X