Menu
▾
▴
[MO-java-dev] CVS: mockobjects-java/src/core/test/mockobjects/dynamic MockConstraintMatcher.java,NONE,1.1.2.1 ErrorMessageExamples.java,NONE,1.1.2.1 ConstraintMatcherTest.java,NONE,1.1.2.1 CTest.java,NONE,1.1.2.1 CallMatchTest.java,1.1.2.5,1.1.2.6 CallSequenceTest.java,1.5.2.4,1.5.2.5 CallBagTest.java,1.1.2.2,1.1.2.3 MockTest.java,1.8.2.9,1.8.2.10 MockConstraint.java,1.1.2.1,1.1.2.2 DummyThrowable.java,1.1.2.1,1.1.2.2 ExpectedCallTest.java,1.1.2.6,1.1.2.7 MockCallFactory.java,1.1.2.3,1.1.2.4
Update of /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic
In directory sc8-pr-cvs1:/tmp/cvs-serv17720/core/test/mockobjects/dynamic
Modified Files:
Tag: DynamicMockExperiment
CallMatchTest.java CallSequenceTest.java CallBagTest.java
MockTest.java MockConstraint.java DummyThrowable.java
ExpectedCallTest.java MockCallFactory.java
Added Files:
Tag: DynamicMockExperiment
MockConstraintMatcher.java ErrorMessageExamples.java
ConstraintMatcherTest.java CTest.java
Log Message:
Tests for change from Constraint[] to ConstraintMatcher as well
as Object[] parameters
Before making this change refactored the tests after realisation that
if a CallMatch matches returns true, then CallMatch.call does not
need to do additional constraint checking - it just performs the call.
--- NEW FILE: MockConstraintMatcher.java ---
package test.mockobjects.dynamic;
import com.mockobjects.*;
import com.mockobjects.dynamic.ConstraintMatcher;
public class MockConstraintMatcher implements ConstraintMatcher{
private ExpectationCounter myMatchesCalls = new ExpectationCounter("MockConstraintMatcher.matches(Object[])");
private ReturnValues myActualMatchesReturnValues = new ReturnValues("MockConstraintMatcher.matches(Object[])", true);
private ExpectationList myMatchesParameter0Values = new ExpectationList("MockConstraintMatcher.matches(Object[]) java.lang.Object");
private ExpectationCounter myGetConstraintsCalls = new ExpectationCounter("MockConstraintMatcher.getConstraints()");
private ReturnValues myActualGetConstraintsReturnValues = new ReturnValues("MockConstraintMatcher.getConstraints()", true);
public void setExpectedMatchesCalls(int calls){
myMatchesCalls.setExpected(calls);
}
public void addExpectedMatches(Object[] arg0){
myMatchesParameter0Values.addExpected(arg0);
}
public boolean matches(Object[] arg0){
myMatchesCalls.inc();
myMatchesParameter0Values.addActual(arg0);
Object nextReturnValue = myActualMatchesReturnValues.getNext();
if (nextReturnValue instanceof ExceptionalReturnValue && ((ExceptionalReturnValue)nextReturnValue).getException() instanceof RuntimeException)
throw (RuntimeException)((ExceptionalReturnValue)nextReturnValue).getException();
return ((Boolean) nextReturnValue).booleanValue();
}
public void setupExceptionMatches(Throwable arg){
myActualMatchesReturnValues.add(new ExceptionalReturnValue(arg));
}
public void setupMatches(boolean arg){
myActualMatchesReturnValues.add(new Boolean(arg));
}
public void setExpectedGetConstraintsCalls(int calls){
myGetConstraintsCalls.setExpected(calls);
}
public Object[] getConstraints(){
myGetConstraintsCalls.inc();
Object nextReturnValue = myActualGetConstraintsReturnValues.getNext();
if (nextReturnValue instanceof ExceptionalReturnValue && ((ExceptionalReturnValue)nextReturnValue).getException() instanceof RuntimeException)
throw (RuntimeException)((ExceptionalReturnValue)nextReturnValue).getException();
return (Object[]) nextReturnValue;
}
public void setupExceptionGetConstraints(Throwable arg){
myActualGetConstraintsReturnValues.add(new ExceptionalReturnValue(arg));
}
public void setupGetConstraints(Object[] arg){
myActualGetConstraintsReturnValues.add(arg);
}
public void verify(){
myMatchesCalls.verify();
myMatchesParameter0Values.verify();
myGetConstraintsCalls.verify();
}
}
--- NEW FILE: ErrorMessageExamples.java ---
/*
* Created on 30-Apr-03
*/
package test.mockobjects.dynamic;
import junit.framework.Assert;
import junit.textui.TestRunner;
public class ErrorMessageExamples {
public static void main(String[] args) {
TestRunner.main(new String[] { ErrorMessageExamples.class.getName() });
//TODO work out how to build up test methods to be run just by this app
}
public void testUncalledMethodError() {
Assert.assertEquals("should not be equa1", "a", "b");
}
}
--- NEW FILE: ConstraintMatcherTest.java ---
/*
* Created on 20-Apr-03
*/
package test.mockobjects.dynamic;
import com.mockobjects.dynamic.*;
import com.mockobjects.dynamic.ConstraintMatcher;
import junit.framework.TestCase;
public class ConstraintMatcherTest extends TestCase {
private final String METHOD_NAME = "methodA";
public ConstraintMatcherTest(String name) {
super(name);
}
public void testNoMatchWhenTooManyArguments() throws Throwable {
String[] args = { "arg1", "arg2" };
MockConstraint[] constraints = { new MockConstraint("constraint1", args[0], true) };
ConstraintMatcher constraintMatcher = new FullConstraintMatcher(constraints);
assertFalse("Should not match if too many arguments", constraintMatcher.matches(args));
}
public void testNoMatchWhenTooFewArguments() throws Throwable {
String[] args = { "arg1" };
MockConstraint[] constraints = { new MockConstraint("constraint1", args[0], true), new MockConstraint("constraint2", args[0], true) };
ConstraintMatcher constraintMatcher = new FullConstraintMatcher(constraints);
assertFalse("Should not match if too few arguments", constraintMatcher.matches(args));
}
public void testNoMatchWhenConstraintIsViolated() throws Throwable {
String[] args = { "argA", "argB", "argC" };
MockConstraint[] constraints = {
new MockConstraint("constraintA", args[0], true), new MockConstraint("constraintB", args[1], false),
new MockConstraint("constraintC", args[2], true)
};
ConstraintMatcher constraintMatcher = new FullConstraintMatcher(constraints);
assertFalse("Should not match", constraintMatcher.matches(args));
}
public void testNoMatchWithNoArgumentsAndCalleeHasArguments()
throws Throwable {
String[] args = new String[] { "arg1", "arg2" };
MockConstraint[] constraints = new MockConstraint[0];
ConstraintMatcher constraintMatcher = new FullConstraintMatcher(constraints);
assertFalse("Should not match", constraintMatcher.matches(args));
}
public void testMatchWithNoArguments() throws Throwable {
String[] args = new String[0];
MockConstraint[] constraints = new MockConstraint[0];
ConstraintMatcher constraintMatcher = new FullConstraintMatcher(constraints);
assertTrue("Should match", constraintMatcher.matches(args));
}
public void testMatchAndArgumentsCheckedAgainstConstraints()
throws Throwable {
String[] args = { "argA", "argB", "argC" };
MockConstraint constraintA = new MockConstraint("constraintA", args[0], true);
MockConstraint constraintB = new MockConstraint("constraintB", args[1], true);
MockConstraint constraintC = new MockConstraint("constraintC", args[2], true);
MockConstraint[] constraints = { constraintA, constraintB, constraintC };
ConstraintMatcher constraintMatcher = new FullConstraintMatcher(constraints);
assertTrue("Should match", constraintMatcher.matches(args));
constraintA.verify();
constraintB.verify();
constraintC.verify();
}
public void testMatchWithArgument() throws Throwable {
String[] args = { "argA" };
MockConstraint constraintA = new MockConstraint("constraintA", args[0], true);
ConstraintMatcher constraintMatcher = new FullConstraintMatcher(new MockConstraint[] { constraintA });
assertTrue("Should match", constraintMatcher.matches(args));
}
}
--- NEW FILE: CTest.java ---
/*
* Created on 30-Apr-03
*/
package test.mockobjects.dynamic;
import com.mockobjects.dynamic.C;
import junit.framework.TestCase;
public class CTest extends TestCase {
public CTest(String name) {
super(name);
}
public void testEqObjectArray() {
assertTrue("Should be equals for object arrays", C.eq(new String[]{"a", "b"}).eval(new String[]{"a","b"}));
}
}
Index: CallMatchTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/Attic/CallMatchTest.java,v
retrieving revision 1.1.2.5
retrieving revision 1.1.2.6
diff -u -r1.1.2.5 -r1.1.2.6
--- CallMatchTest.java 16 Apr 2003 22:16:08 -0000 1.1.2.5
+++ CallMatchTest.java 5 May 2003 22:47:09 -0000 1.1.2.6
@@ -3,255 +3,102 @@
*/
package test.mockobjects.dynamic;
-import com.mockobjects.constraint.*;
+import junit.framework.TestCase;
+
import com.mockobjects.dynamic.*;
-import com.mockobjects.util.*;
-import junit.framework.*;
public class CallMatchTest extends TestCase {
+ private static final Object[] IGNORED_ARGS = new Object[0];
+ final String METHOD_NAME = "methodName";
+ Mock mock = new Mock(DummyInterface.class, "mock");
+ MockCallable mockCallable = new MockCallable();
+ MockConstraintMatcher mockConstraintMatcher = new MockConstraintMatcher();
+ CallMatch callMatch = new CallMatch(METHOD_NAME, mockConstraintMatcher, mockCallable);
+
+ public CallMatchTest(String name) {
+ super(name);
+ }
+
+ public void testCallArgumentsArePropagatedToDecorated()
+ throws Throwable {
+ final Object[] arguments = IGNORED_ARGS;
+ final String result = "result";
+
+ mockCallable.setExpectedCall(mock, METHOD_NAME, arguments);
+ mockCallable.setupCallReturn(result);
+
+ callMatch.call(mock, METHOD_NAME, arguments);
+
+ mockCallable.verifyExpectations();
+ }
+
+ public void testUncalledCallVerifies() {
+ mockCallable.setExpectedVerifyCalls(1);
+
+ callMatch.verify();
+
+ mockCallable.verifyExpectations();
+ }
+
+ public void testCallSuccessVerifies() throws Throwable {
+ mockCallable.setExpectedVerifyCalls(1);
+ mockCallable.setupCallReturn("result");
+
+ callMatch.call(mock, "methodName", IGNORED_ARGS);
+ callMatch.verify();
+
+ mockCallable.verifyExpectations();
+ }
+
+ public void testMultipleCallsSucceed() throws Throwable {
+ mockCallable.setupCallReturn("result");
+
+ callMatch.call(mock, METHOD_NAME, IGNORED_ARGS);
+ callMatch.call(mock, METHOD_NAME, IGNORED_ARGS);
+
+ mockCallable.verifyExpectations();
+ }
+
+ public void testCallFailure() throws Throwable {
+ // na
+ }
+
+ public void testCallDoesNotMatchWhenWrongName() throws Throwable {
+ CallMatch call = new CallMatch(METHOD_NAME, C.ANY_ARGS, mockCallable);
+
+ assertFalse("call does not match", callMatch.matches("anotherName", IGNORED_ARGS));
+ mockCallable.verifyExpectations();
+ }
+
+ public void testMatchesAfterCalls() throws Throwable {
+ mockCallable.setupCallReturn("result");
+ mockCallable.setupMatchesReturn(true);
+
+ mockConstraintMatcher.setupMatches(true);
+
+ callMatch.call(mock, METHOD_NAME, IGNORED_ARGS);
+ assertTrue("matches after first call", callMatch.matches(METHOD_NAME, IGNORED_ARGS));
+ callMatch.call(mock, METHOD_NAME, IGNORED_ARGS);
+ assertTrue("matches after further calls", callMatch.matches(METHOD_NAME, IGNORED_ARGS));
+
+ 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", callMatch.matches(METHOD_NAME, args));
+ mockConstraintMatcher.verify();
+ }
+
+ public void testMatchesFailure() throws Throwable {
+ mockConstraintMatcher.setupMatches(false);
- final String METHOD_NAME = "methodName";
- Mock mock = new Mock(DummyInterface.class,"mock");
- MockCallable mockCallable = new MockCallable();
- CallMatch call = new CallMatch( METHOD_NAME, new Constraint[0], mockCallable );
-
- public CallMatchTest(String name) {
- super(name);
- }
-
- public void testCallArgumentsArePropagatedToDecorated() throws Throwable {
- final Object[] arguments = new Object[0];
- final String result = "result";
-
- mockCallable.setExpectedCall( mock, METHOD_NAME, arguments );
- mockCallable.setupCallReturn( result );
-
- call.call(mock, METHOD_NAME, arguments);
-
- mockCallable.verifyExpectations();
- }
-
- public void testUncalledCallVerifies() {
- mockCallable.setExpectedVerifyCalls(1);
- call.verify();
-
- mockCallable.verifyExpectations();
- }
-
- public void testSuccessfulCallVerifies() throws Throwable {
- mockCallable.setExpectedVerifyCalls(1);
- mockCallable.setupCallReturn("result");
-
- call.call( mock, "methodName", new Object[0] );
- call.verify();
-
- mockCallable.verifyExpectations();
- }
-
- public void testMultipleCallsSucceed() throws Throwable {
- mockCallable.setupCallReturn("result");
-
- call.call( mock, METHOD_NAME, new Object[0] );
- call.call( mock, METHOD_NAME, new Object[0] );
-
- mockCallable.verifyExpectations();
- }
-
- public void testArgumentsCheckedAgainstConstraints() throws Throwable {
- String[] args = { "arg1", "arg2", "arg3" };
- MockConstraint[] constraints = {
- new MockConstraint( "constraint1", args[0], true ),
- new MockConstraint( "constraint2", args[1], true ),
- new MockConstraint( "constraint3", args[2], true )
- };
- mockCallable.setupCallReturn("result");
-
- CallMatch call = new CallMatch( METHOD_NAME, (Constraint[])constraints, mockCallable );
-
- call.call( mock, METHOD_NAME, args );
-
- for( int i = 0; i < constraints.length; i++ ) {
- constraints[i].verify();
- }
-
- mockCallable.verifyExpectations();
- }
-
- public void testWrongNumberOfArguments() throws Throwable {
- String[] args = { "arg1", "arg2" };
- MockConstraint[] constraints = {
- new MockConstraint( "constraint1", args[0], true ),
- new MockConstraint( "constraint2", args[1], true ),
- new MockConstraint( "constraint3", args[1], true )
- };
-
- CallMatch call = new CallMatch( METHOD_NAME, (Constraint[])constraints, mockCallable );
-
- boolean passed = true;
- try {
- call.call( mock, METHOD_NAME, args );
- passed = false;
- } catch (AssertionFailedError ex) {
- AssertMo.assertIncludes("Should show expected number of arguments",
- Integer.toString(constraints.length), ex.getMessage());
- AssertMo.assertIncludes("Should show actual number of arguments",
- Integer.toString(args.length), ex.getMessage());
- AssertMo.assertIncludes("Should include the method name",
- METHOD_NAME, ex.getMessage());
- }
-
- assertTrue("Should fail is call doesn't give an exception", passed);
- mockCallable.verifyExpectations();
- }
-
- public void testConstraintFailure() throws Throwable {
- String[] args = { "argA", "argB", "argC" };
- MockConstraint[] constraints = {
- new MockConstraint( "constraintA", args[0], true ),
- new MockConstraint( "constraintB", args[1], false ),
- new MockConstraint( "constraintC", args[2], true )
- };
-
- CallMatch call = new CallMatch( METHOD_NAME, (Constraint[])constraints, mockCallable );
-
- boolean passed = true;
- try {
- call.call( mock, METHOD_NAME, args );
- passed = false;
- } catch (AssertionFailedError ex) {
- AssertMo.assertIncludes("Should include the method name",
- METHOD_NAME, ex.getMessage());
- AssertMo.assertIncludes("Should show index of failed argument",
- "1", ex.getMessage() );
- AssertMo.assertIncludes("Should show expected arguments",
- DynamicUtil.join(constraints), ex.getMessage());
- AssertMo.assertIncludes("Should show actual arguments",
- DynamicUtil.join(args), ex.getMessage());
- }
-
- assertTrue("Should fail is call doesn't give an exception", passed);
- mockCallable.verifyExpectations();
- }
-
-
- public void testCallMatchesArguments() throws Throwable {
- String[] args = { "arg1", "arg2", "arg3" };
- MockConstraint[] constraints = {
- new MockConstraint( "constraint1", args[0], true ),
- new MockConstraint( "constraint2", args[1], true ),
- new MockConstraint( "constraint3", args[2], true )
- };
-
- mockCallable.setExpectedMatches( METHOD_NAME, args );
- mockCallable.setupMatchesReturn(true);
-
- CallMatch call = new CallMatch( METHOD_NAME, (Constraint[])constraints, mockCallable );
-
- assertTrue( "call matches", call.matches( METHOD_NAME, args) );
- mockCallable.verifyExpectations();
- }
-
- public void testCallMatchesWithNoArguments() throws Throwable {
- String[] args = new String[0];
- MockConstraint[] constraints = new MockConstraint[0];
-
- mockCallable.setExpectedMatches( METHOD_NAME, args );
- mockCallable.setupMatchesReturn(true);
-
- CallMatch call = new CallMatch( METHOD_NAME, (Constraint[])constraints, mockCallable );
-
- assertTrue( "call should match", call.matches( METHOD_NAME, args) );
- mockCallable.verifyExpectations();
- }
-
- public void testCallMatchesWithAnyArguments() throws Throwable {
- String[] args = new String[] {"anyArg" };
-
- mockCallable.setExpectedMatches( METHOD_NAME, args );
- mockCallable.setupMatchesReturn(true);
-
- CallMatch call = new CallMatch( METHOD_NAME, C.anyArgs(1), mockCallable );
-
- assertTrue( "call should match", call.matches( METHOD_NAME, args) );
- mockCallable.verifyExpectations();
- }
-
- public void testCallMatchesWithNoArgumentsAndCalleeHasArguments() throws Throwable {
- String[] args = new String[] {"arg1", "arg2"};
- MockConstraint[] constraints = new MockConstraint[0];
-
- mockCallable.setExpectedMatchesCount(0);
-
- CallMatch call = new CallMatch( METHOD_NAME, (Constraint[])constraints, mockCallable );
-
- assertFalse( "call should not match", call.matches( METHOD_NAME, args) );
- mockCallable.verifyExpectations();
- }
-
- public void testCallDoesNotMatchIfDelegateDoesNotMatch() throws Throwable {
- String[] args = { "arg1", "arg2", "arg3" };
- MockConstraint[] constraints = {
- new MockConstraint( "constraint1", args[0], true ),
- new MockConstraint( "constraint2", args[1], true ),
- new MockConstraint( "constraint3", args[2], true )
- };
-
- mockCallable.setExpectedMatches( METHOD_NAME, args );
- mockCallable.setupMatchesReturn(false);
-
- CallMatch call = new CallMatch( METHOD_NAME, (Constraint[])constraints, mockCallable );
-
- assertFalse( "call does not match when delegate does not match", call.matches( METHOD_NAME, args) );
- mockCallable.verifyExpectations();
- }
-
- public void testCallDoesNotMatchWhenWrongName() throws Throwable {
- CallMatch call = new CallMatch( METHOD_NAME, new Constraint[0], mockCallable );
-
- assertFalse( "call does not match", call.matches( "anotherName", new Object[0]) );
- mockCallable.verifyExpectations();
- }
-
- public void testCallDoesNotMatchWhenWrongNumberOfArguments() throws Throwable {
- String[] args = { "arg1", "arg2" };
- MockConstraint[] constraints = {
- new MockConstraint( "constraint1", args[0], true ),
- new MockConstraint( "constraint2", args[1], true ),
- new MockConstraint( "constraint3", args[1], true )
- };
-
- CallMatch call = new CallMatch( METHOD_NAME, (Constraint[])constraints, mockCallable );
-
- assertFalse( "call does not match", call.matches( METHOD_NAME, args) );
- mockCallable.verifyExpectations();
- }
-
- public void testCallDoesNotMatchWhenConstraintIsViolated() throws Throwable {
- String[] args = { "argA", "argB", "argC" };
- MockConstraint[] constraints = {
- new MockConstraint( "constraintA", args[0], true ),
- new MockConstraint( "constraintB", args[1], false ),
- new MockConstraint( "constraintC", args[2], true )
- };
-
- CallMatch call = new CallMatch( METHOD_NAME, (Constraint[])constraints, mockCallable );
-
- assertFalse( "call does not match", call.matches( METHOD_NAME, args) );
- mockCallable.verifyExpectations();
- }
-
- public void testMatchesAfterCalls() throws Throwable {
- mockCallable.setupCallReturn("result");
- mockCallable.setupMatchesReturn(true);
-
- CallMatch call = new CallMatch(METHOD_NAME, C.args(), mockCallable );
-
- call.call( mock, METHOD_NAME, new Object[0] );
- assertTrue( "matches after first call", call.matches( METHOD_NAME, new Object[0]) );
- call.call( mock, METHOD_NAME, new Object[0] );
- assertTrue( "matches after further calls", call.matches( METHOD_NAME, new Object[0]) );
-
- mockCallable.verifyExpectations();
- }
+ assertFalse("Should not match if constraint matcher doesn't", callMatch.matches(METHOD_NAME, IGNORED_ARGS));
+ }
}
Index: CallSequenceTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/Attic/CallSequenceTest.java,v
retrieving revision 1.5.2.4
retrieving revision 1.5.2.5
diff -u -r1.5.2.4 -r1.5.2.5
--- CallSequenceTest.java 17 Apr 2003 16:17:27 -0000 1.5.2.4
+++ CallSequenceTest.java 5 May 2003 22:47:09 -0000 1.5.2.5
@@ -3,8 +3,7 @@
*/
package test.mockobjects.dynamic;
-import com.mockobjects.constraint.Constraint;
-
+import com.mockobjects.dynamic.*;
import com.mockobjects.dynamic.C;
import com.mockobjects.dynamic.CallMatch;
import com.mockobjects.dynamic.CallSequence;
@@ -26,7 +25,7 @@
final String METHOD_B_RESULT = "resultB";
final Throwable METHOD_A_EXCEPTION = new DummyThrowable("Configured test throwable");
final String[] METHOD_A_ARGS = new String[] { "a1", "a2" };
- final Constraint[] METHOD_A_CONSTRAINTS = C.args(C.eq("a1"), C.eq("a2"));
+ final ConstraintMatcher METHOD_A_CONSTRAINTS = C.args(C.eq("a1"), C.eq("a2"));
final String[] METHOD_B_ARGS = new String[] { "b1", "b2" };
private CallSequence callSequence = new CallSequence();
private Mock unusedMock = null;
@@ -113,7 +112,7 @@
assertSame("expected result from method B", METHOD_B_RESULT, callSequence.call(unusedMock, METHOD_B_NAME, METHOD_B_ARGS));
} catch (AssertionFailedError ex) {
String message = ex.getMessage();
- AssertMo.assertIncludes("Should have expected error message", "Unexpected call to methodB", message);
+ AssertMo.assertIncludes("Should have expected error message", "Unexpected call: methodB", message);
AssertMo.assertIncludes("Should have arguments in error message (1)", METHOD_B_ARGS[0], message);
AssertMo.assertIncludes("Should have arguments in error message (2)", METHOD_B_ARGS[1], message);
AssertMo.assertIncludes("Should have Index pointer next to correct item", methodA.getDescription() + " <<<", message);
Index: CallBagTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/Attic/CallBagTest.java,v
retrieving revision 1.1.2.2
retrieving revision 1.1.2.3
diff -u -r1.1.2.2 -r1.1.2.3
--- CallBagTest.java 17 Apr 2003 16:17:27 -0000 1.1.2.2
+++ CallBagTest.java 5 May 2003 22:47:09 -0000 1.1.2.3
@@ -3,7 +3,6 @@
*/
package test.mockobjects.dynamic;
-import com.mockobjects.constraint.*;
import com.mockobjects.dynamic.*;
import com.mockobjects.util.*;
@@ -21,7 +20,7 @@
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 ConstraintMatcher METHOD_A_CONSTRAINTS = C.args(C.eq("a1"), C.eq("a2"));
final String[] METHOD_B_ARGS = new String[] { "b1", "b2" };
private CallBag callSet = new CallBag();
private Mock unusedMock = null;
Index: MockTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockTest.java,v
retrieving revision 1.8.2.9
retrieving revision 1.8.2.10
diff -u -r1.8.2.9 -r1.8.2.10
--- MockTest.java 17 Apr 2003 16:17:25 -0000 1.8.2.9
+++ MockTest.java 5 May 2003 22:47:09 -0000 1.8.2.10
@@ -3,7 +3,8 @@
*/
package test.mockobjects.dynamic;
-import com.mockobjects.constraint.Constraint;
+import com.mockobjects.constraint.*;
+import com.mockobjects.constraint.IsEqual;
import com.mockobjects.dynamic.*;
import com.mockobjects.util.*;
@@ -22,9 +23,9 @@
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 ConstraintMatcher 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"));
+ final ConstraintMatcher METHOD_TWOARG_CONSTRAINTS = C.args(C.eq("twoP1"), C.eq("twoP2"));
private DummyInterface proxy;
private Mock mock;
private MockCallFactory mockCallFactory = new MockCallFactory();
@@ -144,6 +145,35 @@
Verifier.verifyObject(this);
mockCallableAddable.verifyExpectations();
}
+
+ public void testExpectWithConstraint() throws Throwable {
+ mockCallFactory.setupCreateVoidStub(mockVoidStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
+
+ mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
+
+ mock.expect(METHOD_ONEARG_NAME, new IsEqual(METHOD_ONEARG_ARGS[0]));
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testExpectWithConstraintArray() throws Throwable {
+ mockCallFactory.setupCreateVoidStub(mockVoidStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.setupCreateExpectedCall(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);
Index: MockConstraint.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/Attic/MockConstraint.java,v
retrieving revision 1.1.2.1
retrieving revision 1.1.2.2
diff -u -r1.1.2.1 -r1.1.2.2
--- MockConstraint.java 7 Apr 2003 14:27:00 -0000 1.1.2.1
+++ MockConstraint.java 5 May 2003 22:47:10 -0000 1.1.2.2
@@ -27,8 +27,8 @@
return description;
}
- public boolean eval( Object o ) {
- assertSame( "should be expected argument", expectedArg, o );
+ public boolean eval( Object arg ) {
+ assertSame( "Should be expected argument", expectedArg, arg );
wasChecked = true;
return result;
}
Index: DummyThrowable.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/Attic/DummyThrowable.java,v
retrieving revision 1.1.2.1
retrieving revision 1.1.2.2
diff -u -r1.1.2.1 -r1.1.2.2
--- DummyThrowable.java 7 Apr 2003 14:26:59 -0000 1.1.2.1
+++ DummyThrowable.java 5 May 2003 22:47:10 -0000 1.1.2.2
@@ -16,12 +16,4 @@
super(message);
}
- public DummyThrowable(String message, Throwable cause) {
- super(message, cause);
- }
-
- public DummyThrowable(Throwable cause) {
- super(cause);
- }
-
}
Index: ExpectedCallTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/Attic/ExpectedCallTest.java,v
retrieving revision 1.1.2.6
retrieving revision 1.1.2.7
diff -u -r1.1.2.6 -r1.1.2.7
--- ExpectedCallTest.java 16 Apr 2003 22:17:04 -0000 1.1.2.6
+++ ExpectedCallTest.java 5 May 2003 22:47:10 -0000 1.1.2.7
@@ -33,8 +33,8 @@
public void testDescription() {
AssertMo.assertIncludes( "should contain decorated's description",
DECORATED_DESCRIPTION, call.getDescription() );
- AssertMo.assertIncludes( "should say that decorated call is mandatory",
- "mandatory", call.getDescription() );
+ AssertMo.assertIncludes( "should say that decorated call has called status",
+ "called", call.getDescription() );
}
public void testDoesNotVerifyIfNotCalled() {
Index: MockCallFactory.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/Attic/MockCallFactory.java,v
retrieving revision 1.1.2.3
retrieving revision 1.1.2.4
diff -u -r1.1.2.3 -r1.1.2.4
--- MockCallFactory.java 11 Apr 2003 15:38:20 -0000 1.1.2.3
+++ MockCallFactory.java 5 May 2003 22:47:10 -0000 1.1.2.4
@@ -3,9 +3,9 @@
import com.mockobjects.*;
import com.mockobjects.dynamic.CallFactory;
import com.mockobjects.dynamic.Callable;
-import com.mockobjects.constraint.Constraint;
+import com.mockobjects.dynamic.ConstraintMatcher;
-public class MockCallFactory implements CallFactory, Verifiable {
+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");
@@ -17,11 +17,11 @@
private ExpectationCounter myCreateExpectedCallCalls = new ExpectationCounter("MockCallFactory.createExpectedCall(Callable)");
private ReturnValues myActualCreateExpectedCallReturnValues = new ReturnValues("MockCallFactory.createExpectedCall(Callable)", true);
private ExpectationList myCreateExpectedCallParameter0Values = new ExpectationList("MockCallFactory.createExpectedCall(Callable) com.mockobjects.dynamic.Callable");
- private ExpectationCounter myCreateCallMatchCalls = new ExpectationCounter("MockCallFactory.createCallMatch(String, Constraint[], Callable)");
- private ReturnValues myActualCreateCallMatchReturnValues = new ReturnValues("MockCallFactory.createCallMatch(String, Constraint[], Callable)", true);
- private ExpectationList myCreateCallMatchParameter0Values = new ExpectationList("MockCallFactory.createCallMatch(String, Constraint[], Callable) java.lang.String");
- private ExpectationList myCreateCallMatchParameter1Values = new ExpectationList("MockCallFactory.createCallMatch(String, Constraint[], Callable) com.mockobjects.constraint.Constraint");
- private ExpectationList myCreateCallMatchParameter2Values = new ExpectationList("MockCallFactory.createCallMatch(String, Constraint[], Callable) com.mockobjects.dynamic.Callable");
+ private ExpectationCounter myCreateCallMatchCalls = new ExpectationCounter("MockCallFactory.createCallMatch(String, ConstraintMatcher, Callable)");
+ private ReturnValues myActualCreateCallMatchReturnValues = new ReturnValues("MockCallFactory.createCallMatch(String, ConstraintMatcher, Callable)", true);
+ private ExpectationList myCreateCallMatchParameter0Values = new ExpectationList("MockCallFactory.createCallMatch(String, ConstraintMatcher, Callable) java.lang.String");
+ private ExpectationList myCreateCallMatchParameter1Values = new ExpectationList("MockCallFactory.createCallMatch(String, ConstraintMatcher, Callable) com.mockobjects.dynamic.ConstraintMatcher");
+ private ExpectationList myCreateCallMatchParameter2Values = new ExpectationList("MockCallFactory.createCallMatch(String, ConstraintMatcher, Callable) com.mockobjects.dynamic.Callable");
public void setExpectedCreateReturnStubCalls(int calls){
myCreateReturnStubCalls.setExpected(calls);
@@ -122,16 +122,16 @@
myCreateCallMatchCalls.setExpected(calls);
}
- public void addExpectedCreateCallMatch(String arg0, Constraint[] arg1, Callable arg2){
+ public void addExpectedCreateCallMatch(String arg0, ConstraintMatcher arg1, Callable arg2){
myCreateCallMatchParameter0Values.addExpected(arg0);
- myCreateCallMatchParameter1Values.addExpectedMany(arg1);
+ myCreateCallMatchParameter1Values.addExpectedMany(arg1.getConstraints());
myCreateCallMatchParameter2Values.addExpected(arg2);
}
- public Callable createCallMatch(String arg0, Constraint[] arg1, Callable arg2){
+ public Callable createCallMatch(String arg0, ConstraintMatcher arg1, Callable arg2){
myCreateCallMatchCalls.inc();
myCreateCallMatchParameter0Values.addActual(arg0);
- myCreateCallMatchParameter1Values.addActualMany(arg1);
+ myCreateCallMatchParameter1Values.addActualMany(arg1.getConstraints());
myCreateCallMatchParameter2Values.addActual(arg2);
Object nextReturnValue = myActualCreateCallMatchReturnValues.getNext();
if (nextReturnValue instanceof ExceptionalReturnValue && ((ExceptionalReturnValue)nextReturnValue).getException() instanceof RuntimeException)
|
