Menu
▾
▴
mockobjects-java-dev
|
From: Steve F. <sm...@us...> - 2003-06-27 16:03:23
|
Update of /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic
In directory sc8-pr-cvs1:/tmp/cvs-serv8319/src/core/test/mockobjects/dynamic
Modified Files:
Tag: Nat_reworks_dynamics_from_0_09
NameMatcherTest.java CallSelectionTest.java
CallDecoratorTest.java CallCollectionBuilderTest.java
MockCallFactory.java MockCompositeCallable.java
DefaultReturnStubTest.java MockTest.java
ArgumentMatcherTest.java
Log Message:
Further changes from Nat
Index: NameMatcherTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/Attic/NameMatcherTest.java,v
retrieving revision 1.1.2.2
retrieving revision 1.1.2.3
diff -u -r1.1.2.2 -r1.1.2.3
--- NameMatcherTest.java 26 Jun 2003 17:33:12 -0000 1.1.2.2
+++ NameMatcherTest.java 27 Jun 2003 16:03:20 -0000 1.1.2.3
@@ -22,28 +22,34 @@
String.class,
ARGS );
-
- private final NameMatcher callName = new NameMatcher( METHOD_NAME, delegate );
+
+ private final NameMatcher nameMatcher =
+ new NameMatcher( METHOD_NAME, delegate );
public NameMatcherTest(String name) {
super(name);
}
- public void testReturnsMethodNameAsDescription() {
+ public void testDescriptionIsMethodNamedPrefixedToDelegateDescription() {
+ String delegateDescription = "-delegate";
+
+ delegate.setupGetDescription(delegateDescription);
+
assertEquals( "expected method name as description",
- METHOD_NAME, callName.getDescription() );
+ METHOD_NAME + delegateDescription,
+ nameMatcher.getDescription() );
}
public void testReturnsMethodNameFromGetMethodName() {
assertEquals( "expected method name",
- METHOD_NAME, callName.getMethodName() );
+ METHOD_NAME, nameMatcher.getMethodName() );
}
public void testPassesMatchToDelegateIfMethodHasTheSameName() {
delegate.setExpectedMatches( CALL );
delegate.setupMatchesReturn(true);
- boolean result = callName.matches( CALL );
+ nameMatcher.matches( CALL );
delegate.verifyExpectations();
}
@@ -52,14 +58,14 @@
delegate.setExpectedMatches( CALL );
delegate.setupMatchesReturn(true);
assertTrue( "expected matches to return true",
- callName.matches( CALL ) );
+ nameMatcher.matches( CALL ) );
delegate.verifyExpectations();
delegate.setExpectedMatches( CALL );
delegate.setupMatchesReturn(false);
assertFalse( "expected matches to return false",
- callName.matches( CALL ) );
+ nameMatcher.matches( CALL ) );
delegate.verifyExpectations();
}
@@ -73,7 +79,7 @@
delegate.setExpectedMatchesCount(0);
assertFalse( "expected matches to return false with other method name",
- callName.matches( OTHER_CALL ) );
+ nameMatcher.matches( OTHER_CALL ) );
delegate.verifyExpectations();
}
@@ -87,7 +93,7 @@
String.class,
new Object[0] );
assertTrue( "expected matches to return true",
- callName.matches(CALL0) );
+ nameMatcher.matches(CALL0) );
final ActiveCall CALL1 = new ActiveCall(
METHOD_NAME,
@@ -95,7 +101,7 @@
String.class,
new Object[]{"arg1"} );
assertTrue( "expected matches to return true",
- callName.matches(CALL1) );
+ nameMatcher.matches(CALL1) );
final ActiveCall CALL2 = new ActiveCall(
METHOD_NAME,
@@ -103,7 +109,7 @@
String.class,
new Object[]{"arg1","arg2"} );
assertTrue( "expected matches to return true",
- callName.matches(CALL2) );
+ nameMatcher.matches(CALL2) );
final ActiveCall CALL3 = new ActiveCall(
METHOD_NAME,
@@ -111,6 +117,6 @@
String.class,
new Object[]{"arg1","arg2","arg3"} );
assertTrue( "expected matches to return true",
- callName.matches(CALL3) );
+ nameMatcher.matches(CALL3) );
}
}
Index: CallSelectionTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/Attic/CallSelectionTest.java,v
retrieving revision 1.1.2.1
retrieving revision 1.1.2.2
diff -u -r1.1.2.1 -r1.1.2.2
--- CallSelectionTest.java 21 Jun 2003 14:01:07 -0000 1.1.2.1
+++ CallSelectionTest.java 27 Jun 2003 16:03:20 -0000 1.1.2.2
@@ -8,30 +8,30 @@
import com.mockobjects.util.AssertMo;
public class CallSelectionTest
- extends TestCase
+ extends TestCase
{
final String METHOD_A_NAME = "methodA";
final String METHOD_A_RESULT = "resultA";
- 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 ActiveCall CALL_A = new ActiveCall(
- METHOD_A_NAME, new Class[]{String.class,String.class}, String.class,
- METHOD_A_ARGS );
+ 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 ActiveCall CALL_A = new ActiveCall(
+ METHOD_A_NAME, new Class[]{String.class,String.class}, String.class,
+ METHOD_A_ARGS );
final String METHOD_B_NAME = "methodB";
final String METHOD_B_RESULT = "resultB";
final String[] METHOD_B_ARGS = new String[] { "b1", "b2" };
- final ActiveCall CALL_B = new ActiveCall(
- METHOD_B_NAME, new Class[]{String.class,String.class}, String.class,
- METHOD_B_ARGS );
-
- final String METHOD_C_NAME = "methodC";
- final String[] METHOD_C_ARGS = { "c1", "c2" };
- final ActiveCall CALL_C = new ActiveCall(
- METHOD_C_NAME, new Class[]{String.class,String.class}, Void.class,
- METHOD_C_ARGS );
+ final ActiveCall CALL_B = new ActiveCall(
+ METHOD_B_NAME, new Class[]{String.class,String.class}, String.class,
+ METHOD_B_ARGS );
+
+ final String METHOD_C_NAME = "methodC";
+ final String[] METHOD_C_ARGS = { "c1", "c2" };
+ final ActiveCall CALL_C = new ActiveCall(
+ METHOD_C_NAME, new Class[]{String.class,String.class}, Void.class,
+ METHOD_C_ARGS );
private CallSelection callSelection = new CallSelection();
@@ -47,32 +47,30 @@
public void testCallFailsOnEmptySet() throws Throwable {
try {
callSelection.call(CALL_A);
- } catch (AssertionFailedError ex) {
+ fail("Should fail for a missing item");
+
+ } catch( AssertionFailedError ex ) {
AssertMo.assertIncludes( "reports empty set in error message",
- "no methods", ex.getMessage());
-
- return;
+ "no method calls", ex.getMessage());
}
-
- fail("Should fail for a missing item");
}
public void testCallPassedToContainedElementsInReverseOrderOfAddition()
- throws Throwable
- {
+ throws Throwable
+ {
methodA.setExpectedMatches(CALL_A);
methodA.setupMatchesReturn(true);
methodA.setExpectedCall(CALL_A);
methodA.setupCallReturn(METHOD_A_RESULT);
- methodB.setExpectedMatches(CALL_A);
- methodB.setupMatchesReturn(false);
+ methodB.setExpectedMatches(CALL_A);
+ methodB.setupMatchesReturn(false);
- callSelection.addCallable(methodA);
+ callSelection.addCallable(methodA);
callSelection.addCallable(methodB);
assertSame("expected result from method A", METHOD_A_RESULT,
- callSelection.call(CALL_A));
+ callSelection.call(CALL_A));
methodA.verifyExpectations();
methodB.verifyExpectations();
@@ -80,43 +78,41 @@
public void testMatchedCallStopsSearch()
throws Throwable
- {
- methodA.setExpectedCallCount(0);
+ {
+ methodA.setExpectedCallCount(0);
methodB.setExpectedMatches(CALL_B);
methodB.setupMatchesReturn(true);
- methodB.setExpectedCall(CALL_B);
- methodB.setupCallReturn(METHOD_B_RESULT);
+ methodB.setExpectedCall(CALL_B);
+ methodB.setupCallReturn(METHOD_B_RESULT);
callSelection.addCallable(methodA);
callSelection.addCallable(methodB);
assertSame( "expected result from method B",
- METHOD_B_RESULT, callSelection.call(CALL_B));
+ METHOD_B_RESULT, callSelection.call(CALL_B));
methodA.verifyExpectations();
methodB.verifyExpectations();
}
- public void testExpectationsOverrideEarlierMatchingExpectations()
- throws Throwable
- {
- Callable methodASignature =
- new ArgumentMatcher( METHOD_A_NAME, METHOD_A_CONSTRAINTS,
- new ReturnStub("result1"));
- Callable anotherMethodASignature =
- new ArgumentMatcher( METHOD_A_NAME, METHOD_A_CONSTRAINTS,
- new ReturnStub("result2"));
-
- callSelection.addCallable(methodASignature);
- callSelection.addCallable(new CallOnceExpectation(anotherMethodASignature));
-
- assertSame( "expected result from method A",
- "result2",
- callSelection.call(CALL_A));
+ public void testExpectationsOverrideEarlierMatchingExpectations()
+ throws Throwable
+ {
+ Callable methodASignature =
+ new NameMatcher( METHOD_A_NAME, new ReturnStub("result1"));
+ Callable anotherMethodASignature =
+ new NameMatcher( METHOD_A_NAME, new ReturnStub("result2"));
+
+ callSelection.addCallable(methodASignature);
+ callSelection.addCallable(new CallOnceExpectation(anotherMethodASignature));
+
+ assertSame( "expected result from method A",
+ "result2",
+ callSelection.call(CALL_A));
- callSelection.verify();
- }
+ callSelection.verify();
+ }
public void testConfiguredResultReturned() throws Throwable {
mockCallable.setupCallReturn(METHOD_A_RESULT);
@@ -125,12 +121,12 @@
callSelection.addCallable(mockCallable);
assertSame( "result is returned by mock",
- METHOD_A_RESULT, callSelection.call(CALL_A));
+ METHOD_A_RESULT, callSelection.call(CALL_A));
}
public void testCallableThrowableThrown()
throws Throwable
- {
+ {
mockCallable.setupMatchesReturn(true);
mockCallable.setupCallThrow(METHOD_A_EXCEPTION);
@@ -191,7 +187,7 @@
public void testVerifyFailsIfContainedElementDoesNotVerify()
throws Exception
- {
+ {
methodA.setExpectedVerifyCalls(1);
methodA.setupVerifyThrow(new AssertionFailedError("verify failed"));
callSelection.addCallable(methodA);
@@ -207,47 +203,47 @@
fail("Should have got a failure for contained element failing");
}
- public void testDoesNotMatchIfEmpty() {
- assertTrue( "empty selection does not match",
- !callSelection.matches(CALL_A) );
- }
-
- public void testPassesMatchesParametersToAllElements() {
- callSelection.addCallable( methodA );
- callSelection.addCallable( methodB );
-
- methodA.setExpectedMatches(CALL_A);
- methodA.setupMatchesReturn(true);
- methodB.setExpectedMatches(CALL_A);
- methodA.setupMatchesReturn(true);
-
- assertTrue( "should match", callSelection.matches(CALL_A) );
-
- callSelection.verify();
- }
-
- public void testMatchesIfAnyExpectedElementMatches() {
- callSelection.addCallable( methodA );
- callSelection.addCallable( methodB );
-
- methodA.setupMatchesReturn(true);
- methodB.setupMatchesReturn(false);
- assertTrue( "should match methodA", callSelection.matches(CALL_A) );
-
- methodA.setupMatchesReturn(false);
- methodB.setupMatchesReturn(true);
- assertTrue( "should match methodB", callSelection.matches(CALL_B) );
- }
-
- public void testDoesNotMatchIfNoElementsMatch() {
- callSelection.addCallable( methodA );
- callSelection.addCallable( methodB );
-
- methodA.setExpectedMatches(CALL_C);
- methodA.setupMatchesReturn(false);
- methodB.setExpectedMatches(CALL_C);
- methodB.setupMatchesReturn(false);
+ public void testDoesNotMatchIfEmpty() {
+ assertTrue( "empty selection does not match",
+ !callSelection.matches(CALL_A) );
+ }
+
+ public void testPassesMatchesParametersToAllElements() {
+ callSelection.addCallable( methodA );
+ callSelection.addCallable( methodB );
+
+ methodA.setExpectedMatches(CALL_A);
+ methodA.setupMatchesReturn(true);
+ methodB.setExpectedMatches(CALL_A);
+ methodA.setupMatchesReturn(true);
- assertFalse( "no method should match", callSelection.matches(CALL_C) );
- }
+ assertTrue( "should match", callSelection.matches(CALL_A) );
+
+ callSelection.verify();
+ }
+
+ public void testMatchesIfAnyExpectedElementMatches() {
+ callSelection.addCallable( methodA );
+ callSelection.addCallable( methodB );
+
+ methodA.setupMatchesReturn(true);
+ methodB.setupMatchesReturn(false);
+ assertTrue( "should match methodA", callSelection.matches(CALL_A) );
+
+ methodA.setupMatchesReturn(false);
+ methodB.setupMatchesReturn(true);
+ assertTrue( "should match methodB", callSelection.matches(CALL_B) );
+ }
+
+ public void testDoesNotMatchIfNoElementsMatch() {
+ callSelection.addCallable( methodA );
+ callSelection.addCallable( methodB );
+
+ methodA.setExpectedMatches(CALL_C);
+ methodA.setupMatchesReturn(false);
+ methodB.setExpectedMatches(CALL_C);
+ methodB.setupMatchesReturn(false);
+
+ assertFalse( "no method should match", callSelection.matches(CALL_C) );
+ }
}
Index: CallDecoratorTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/Attic/CallDecoratorTest.java,v
retrieving revision 1.1.2.2
retrieving revision 1.1.2.3
diff -u -r1.1.2.2 -r1.1.2.3
--- CallDecoratorTest.java 26 Jun 2003 17:33:12 -0000 1.1.2.2
+++ CallDecoratorTest.java 27 Jun 2003 16:03:20 -0000 1.1.2.3
@@ -91,7 +91,7 @@
mockCallable.setExpectedMatches(CALL);
mockCallable.setupMatchesReturn(true);
- boolean result = callDecorator.matches(CALL);
+ callDecorator.matches(CALL);
mockCallable.verifyExpectations();
}
Index: CallCollectionBuilderTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/Attic/CallCollectionBuilderTest.java,v
retrieving revision 1.1.2.1
retrieving revision 1.1.2.2
diff -u -r1.1.2.1 -r1.1.2.2
--- CallCollectionBuilderTest.java 21 Jun 2003 14:01:07 -0000 1.1.2.1
+++ CallCollectionBuilderTest.java 27 Jun 2003 16:03:20 -0000 1.1.2.2
@@ -6,7 +6,6 @@
import junit.framework.TestCase;
import com.mockobjects.constraint.Constraint;
-import com.mockobjects.constraint.IsEqual;
import com.mockobjects.dynamic.C;
import com.mockobjects.dynamic.CallCollectionBuilder;
import com.mockobjects.util.Verifier;
@@ -33,6 +32,7 @@
private MockCallFactory mockCallFactory = new MockCallFactory();
private MockCallable mockCallable = new MockCallable();
+ private MockCallable mockNameMatcher = new MockCallable();
private MockCallable mockArgumentMatcher = new MockCallable();
private MockCallable mockCallOnceExpectation = new MockCallable();
private MockCallable mockReturnStub = new MockCallable();
@@ -52,7 +52,7 @@
builder = new CallCollectionBuilder( mockCallFactory,
mockCompositeCallable );
}
-
+
public void testAddsCallablesToComposite()
throws Throwable
{
@@ -67,15 +67,20 @@
throws Throwable
{
mockCallFactory.addExpectedCreateArgumentMatcherValues(
- METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS,
- mockCallable );
+ METHOD_TWOARG_CONSTRAINTS, mockCallable );
mockCallFactory.setupCreateArgumentMatcher( mockArgumentMatcher );
+ mockCallFactory.addExpectedCreateNameMatcherValues(
+ METHOD_TWOARG_NAME, mockArgumentMatcher );
+ mockCallFactory.setupCreateNameMatcher(mockNameMatcher);
+
mockCallFactory.addExpectedCreateCallOnceExpectationValues(
- mockArgumentMatcher );
- mockCallFactory.setupCreateCallOnceExpectation( mockCallOnceExpectation );
+ mockNameMatcher );
+ mockCallFactory.setupCreateCallOnceExpectation(
+ mockCallOnceExpectation );
- mockCompositeCallable.addExpectedAddCallableValues(mockCallOnceExpectation);
+ mockCompositeCallable.addExpectedAddCallableValues(
+ mockCallOnceExpectation);
builder.expect( METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS,
mockCallable );
@@ -89,11 +94,17 @@
{
mockCallFactory.setExpectedCreateVoidStubCalls(1);
mockCallFactory.setupCreateVoidStub(mockVoidStub);
+
mockCallFactory.addExpectedCreateArgumentMatcherValues(
- METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockVoidStub );
+ METHOD_TWOARG_CONSTRAINTS, mockVoidStub );
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
- mockCallFactory.addExpectedCreateCallOnceExpectationValues(
- mockArgumentMatcher );
+
+ mockCallFactory.addExpectedCreateNameMatcherValues(
+ METHOD_TWOARG_NAME, mockArgumentMatcher );
+ mockCallFactory.setupCreateNameMatcher(mockNameMatcher);
+
+ mockCallFactory.addExpectedCreateCallOnceExpectationValues(
+ mockNameMatcher );
mockCallFactory.setupCreateCallOnceExpectation(
mockCallOnceExpectation);
@@ -113,10 +124,13 @@
METHOD_NOARGANDRETURN_RESULT);
mockCallFactory.setupCreateReturnStub(mockReturnStub);
mockCallFactory.addExpectedCreateArgumentMatcherValues(
- METHOD_NOARGANDRETURN_NAME, C.NO_ARGS, mockReturnStub);
+ C.NO_ARGS, mockReturnStub);
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
+ mockCallFactory.addExpectedCreateNameMatcherValues(
+ METHOD_NOARGANDRETURN_NAME, mockArgumentMatcher );
+ mockCallFactory.setupCreateNameMatcher(mockNameMatcher);
mockCallFactory.addExpectedCreateCallOnceExpectationValues(
- mockArgumentMatcher );
+ mockNameMatcher );
mockCallFactory.setupCreateCallOnceExpectation(
mockCallOnceExpectation );
@@ -133,14 +147,19 @@
public void testBuildsDecoratorsForExpectAndThrowWithNoArguments()
throws Throwable
{
- mockCallFactory.addExpectedCreateThrowStubValues(
- METHOD_EXCEPTION );
+ mockCallFactory.addExpectedCreateThrowStubValues(METHOD_EXCEPTION);
mockCallFactory.setupCreateThrowStub(mockThrowStub);
+
mockCallFactory.addExpectedCreateArgumentMatcherValues(
- METHOD_NOARGANDRETURN_NAME, C.NO_ARGS, mockThrowStub );
+ C.NO_ARGS, mockThrowStub );
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
- mockCallFactory.addExpectedCreateCallOnceExpectationValues(
- mockArgumentMatcher);
+
+ mockCallFactory.addExpectedCreateNameMatcherValues(
+ METHOD_NOARGANDRETURN_NAME, mockArgumentMatcher );
+ mockCallFactory.setupCreateNameMatcher(mockNameMatcher);
+
+ mockCallFactory.addExpectedCreateCallOnceExpectationValues(
+ mockNameMatcher);
mockCallFactory.setupCreateCallOnceExpectation(
mockCallOnceExpectation );
@@ -158,11 +177,17 @@
{
mockCallFactory.addExpectedCreateThrowStubValues(METHOD_EXCEPTION);
mockCallFactory.setupCreateThrowStub(mockThrowStub);
+
mockCallFactory.addExpectedCreateArgumentMatcherValues(
- METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub );
+ METHOD_ONEARG_CONSTRAINTS, mockThrowStub );
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
- mockCallFactory.addExpectedCreateCallOnceExpectationValues(
- mockArgumentMatcher);
+
+ mockCallFactory.addExpectedCreateNameMatcherValues(
+ METHOD_ONEARG_NAME, mockArgumentMatcher );
+ mockCallFactory.setupCreateNameMatcher(mockNameMatcher);
+
+ mockCallFactory.addExpectedCreateCallOnceExpectationValues(
+ mockNameMatcher);
mockCallFactory.setupCreateCallOnceExpectation(
mockCallOnceExpectation );
@@ -182,13 +207,18 @@
mockCallFactory.setExpectedCreateVoidStubCalls(1);
mockCallFactory.setupCreateVoidStub(mockVoidStub);
mockCallFactory.addExpectedCreateArgumentMatcherValues(
- METHOD_NOARG_NAME, C.NO_ARGS, mockVoidStub );
+ C.NO_ARGS, mockVoidStub );
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
+ mockCallFactory.addExpectedCreateNameMatcherValues(
+ METHOD_NOARG_NAME, mockArgumentMatcher );
+ mockCallFactory.setupCreateNameMatcher(mockNameMatcher);
mockCallFactory.addExpectedCreateCallOnceExpectationValues(
- mockArgumentMatcher );
- mockCallFactory.setupCreateCallOnceExpectation(mockCallOnceExpectation);
+ mockNameMatcher );
+ mockCallFactory.setupCreateCallOnceExpectation(
+ mockCallOnceExpectation);
- mockCompositeCallable.addExpectedAddCallableValues(mockCallOnceExpectation);
+ mockCompositeCallable.addExpectedAddCallableValues(
+ mockCallOnceExpectation);
builder.expectVoid( METHOD_NOARG_NAME );
@@ -201,10 +231,16 @@
{
mockCallFactory.setExpectedCreateVoidStubCalls(1);
mockCallFactory.setupCreateVoidStub(mockVoidStub);
- mockCallFactory.addExpectedCreateArgumentMatcherValues(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
+ mockCallFactory.addExpectedCreateArgumentMatcherValues(
+ METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
- mockCallFactory.addExpectedCreateCallOnceExpectationValues(mockArgumentMatcher);
- mockCallFactory.setupCreateCallOnceExpectation(mockCallOnceExpectation);
+ mockCallFactory.addExpectedCreateNameMatcherValues(
+ METHOD_ONEARG_NAME, mockArgumentMatcher );
+ mockCallFactory.setupCreateNameMatcher(mockNameMatcher);
+ mockCallFactory.addExpectedCreateCallOnceExpectationValues(
+ mockNameMatcher);
+ mockCallFactory.setupCreateCallOnceExpectation(
+ mockCallOnceExpectation);
mockCompositeCallable.addExpectedAddCallableValues(mockCallOnceExpectation);
@@ -218,18 +254,23 @@
throws Throwable
{
mockCallFactory.setupCreateVoidStub(mockVoidStub);
+
mockCallFactory.addExpectedCreateArgumentMatcherValues(
- METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub );
+ METHOD_ONEARG_CONSTRAINTS, mockVoidStub );
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
- mockCallFactory.setupCreateCallOnceExpectation(
+
+ mockCallFactory.addExpectedCreateNameMatcherValues(
+ METHOD_ONEARG_NAME, mockArgumentMatcher );
+ mockCallFactory.setupCreateNameMatcher(mockNameMatcher);
+
+ mockCallFactory.setupCreateCallOnceExpectation(
mockCallOnceExpectation );
-
mockCompositeCallable.addExpectedAddCallableValues(
mockCallOnceExpectation );
builder.expectVoid(
METHOD_ONEARG_NAME,
- new IsEqual(METHOD_ONEARG_ARGS[0]) );
+ METHOD_ONEARG_ARGS[0] );
Verifier.verifyObject(this);
mockCompositeCallable.verifyExpectations();
@@ -241,11 +282,17 @@
mockCallFactory.addExpectedCreateReturnStubValues(
METHOD_TWOARG_RESULT );
mockCallFactory.setupCreateReturnStub(mockReturnStub);
- mockCallFactory.addExpectedCreateArgumentMatcherValues(
- METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockReturnStub);
- mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
+
+ mockCallFactory.addExpectedCreateArgumentMatcherValues(
+ METHOD_TWOARG_CONSTRAINTS, mockReturnStub );
+ mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
+
+ mockCallFactory.addExpectedCreateNameMatcherValues(
+ METHOD_TWOARG_NAME, mockArgumentMatcher );
+ mockCallFactory.setupCreateNameMatcher(mockNameMatcher);
+
mockCallFactory.addExpectedCreateCallOnceExpectationValues(
- mockArgumentMatcher);
+ mockNameMatcher);
mockCallFactory.setupCreateCallOnceExpectation(
mockCallOnceExpectation);
@@ -265,11 +312,17 @@
{
mockCallFactory.addExpectedCreateThrowStubValues(METHOD_EXCEPTION);
mockCallFactory.setupCreateThrowStub(mockThrowStub);
- mockCallFactory.addExpectedCreateArgumentMatcherValues(
- METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockThrowStub );
- mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
- mockCallFactory.addExpectedCreateCallOnceExpectationValues(
- mockArgumentMatcher);
+
+ mockCallFactory.addExpectedCreateArgumentMatcherValues(
+ METHOD_TWOARG_CONSTRAINTS, mockThrowStub );
+ mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
+
+ mockCallFactory.addExpectedCreateNameMatcherValues(
+ METHOD_TWOARG_NAME, mockArgumentMatcher );
+ mockCallFactory.setupCreateNameMatcher(mockNameMatcher);
+
+ mockCallFactory.addExpectedCreateCallOnceExpectationValues(
+ mockNameMatcher);
mockCallFactory.setupCreateCallOnceExpectation(
mockCallOnceExpectation);
@@ -291,11 +344,17 @@
mockCallFactory.addExpectedCreateReturnStubValues(
METHOD_ONEARG_RESULT );
mockCallFactory.setupCreateReturnStub(mockReturnStub);
+
mockCallFactory.addExpectedCreateArgumentMatcherValues(
- METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub );
+ METHOD_ONEARG_CONSTRAINTS, mockReturnStub );
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
- mockCallFactory.addExpectedCreateCallOnceExpectationValues(
- mockArgumentMatcher );
+
+ mockCallFactory.addExpectedCreateNameMatcherValues(
+ METHOD_ONEARG_NAME, mockArgumentMatcher );
+ mockCallFactory.setupCreateNameMatcher(mockNameMatcher);
+
+ mockCallFactory.addExpectedCreateCallOnceExpectationValues(
+ mockNameMatcher );
mockCallFactory.setupCreateCallOnceExpectation(
mockCallOnceExpectation );
@@ -317,11 +376,17 @@
mockCallFactory.addExpectedCreateReturnStubValues(
METHOD_ONEARG_RESULT );
mockCallFactory.setupCreateReturnStub(mockReturnStub);
+
mockCallFactory.addExpectedCreateArgumentMatcherValues(
- METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub );
+ METHOD_ONEARG_CONSTRAINTS, mockReturnStub );
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
+
+ mockCallFactory.addExpectedCreateNameMatcherValues(
+ METHOD_ONEARG_NAME, mockArgumentMatcher );
+ mockCallFactory.setupCreateNameMatcher(mockNameMatcher);
+
mockCallFactory.addExpectedCreateCallOnceExpectationValues(
- mockArgumentMatcher );
+ mockNameMatcher );
mockCallFactory.setupCreateCallOnceExpectation(
mockCallOnceExpectation );
@@ -340,14 +405,20 @@
public void testBuildsDecoratorsForExpectAndThrowWithOneConstraint()
throws Throwable
{
- mockCallFactory.addExpectedCreateReturnStubValues(
- METHOD_ONEARG_RESULT );
+ mockCallFactory.addExpectedCreateThrowStubValues(
+ METHOD_EXCEPTION );
mockCallFactory.setupCreateThrowStub(mockThrowStub);
+
mockCallFactory.addExpectedCreateArgumentMatcherValues(
- METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub );
+ METHOD_ONEARG_CONSTRAINTS, mockThrowStub );
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
+
+ mockCallFactory.addExpectedCreateNameMatcherValues(
+ METHOD_ONEARG_NAME, mockArgumentMatcher );
+ mockCallFactory.setupCreateNameMatcher(mockNameMatcher);
+
mockCallFactory.addExpectedCreateCallOnceExpectationValues(
- mockArgumentMatcher );
+ mockNameMatcher );
mockCallFactory.setupCreateCallOnceExpectation(
mockCallOnceExpectation );
@@ -368,12 +439,16 @@
mockCallFactory.addExpectedCreateReturnStubValues(
METHOD_TWOARG_RESULT );
mockCallFactory.setupCreateReturnStub(mockReturnStub);
- mockCallFactory.addExpectedCreateArgumentMatcherValues(
- METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockReturnStub);
- mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
+
+ mockCallFactory.addExpectedCreateArgumentMatcherValues(
+ METHOD_TWOARG_CONSTRAINTS, mockReturnStub );
+ mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
+
+ mockCallFactory.addExpectedCreateNameMatcherValues(
+ METHOD_TWOARG_NAME, mockArgumentMatcher );
+ mockCallFactory.setupCreateNameMatcher(mockNameMatcher);
- mockCompositeCallable.addExpectedAddCallableValues(
- mockArgumentMatcher);
+ mockCompositeCallable.addExpectedAddCallableValues(mockNameMatcher);
builder.matchAndReturn( METHOD_TWOARG_NAME,
METHOD_TWOARG_CONSTRAINTS,
@@ -388,14 +463,20 @@
{
mockCallFactory.addExpectedCreateThrowStubValues(METHOD_EXCEPTION);
mockCallFactory.setupCreateThrowStub(mockThrowStub);
- mockCallFactory.addExpectedCreateArgumentMatcherValues(METHOD_NOARG_NAME, C.NO_ARGS, mockThrowStub);
+
+ mockCallFactory.addExpectedCreateArgumentMatcherValues(
+ C.NO_ARGS, mockThrowStub );
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
-
+
+ mockCallFactory.addExpectedCreateNameMatcherValues(
+ METHOD_NOARG_NAME, mockArgumentMatcher );
+ mockCallFactory.setupCreateNameMatcher(mockNameMatcher);
+
mockCompositeCallable.addExpectedAddCallableValues(
- mockArgumentMatcher);
-
+ mockNameMatcher);
+
builder.matchAndThrow(METHOD_NOARG_NAME, METHOD_EXCEPTION);
-
+
Verifier.verifyObject(this);
mockCompositeCallable.verifyExpectations();
}
@@ -405,12 +486,17 @@
{
mockCallFactory.addExpectedCreateThrowStubValues(METHOD_EXCEPTION);
mockCallFactory.setupCreateThrowStub(mockThrowStub);
+
mockCallFactory.addExpectedCreateArgumentMatcherValues(
- METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub);
+ METHOD_ONEARG_CONSTRAINTS, mockThrowStub);
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
-
+
+ mockCallFactory.addExpectedCreateNameMatcherValues(
+ METHOD_ONEARG_NAME, mockArgumentMatcher );
+ mockCallFactory.setupCreateNameMatcher(mockNameMatcher);
+
mockCompositeCallable.addExpectedAddCallableValues(
- mockArgumentMatcher);
+ mockNameMatcher);
builder.matchAndThrow( METHOD_ONEARG_NAME,
METHOD_ONEARG_ARGS[0],
@@ -425,12 +511,17 @@
{
mockCallFactory.addExpectedCreateThrowStubValues(METHOD_EXCEPTION);
mockCallFactory.setupCreateThrowStub(mockThrowStub);
+
mockCallFactory.addExpectedCreateArgumentMatcherValues(
- METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockThrowStub);
+ METHOD_TWOARG_CONSTRAINTS, mockThrowStub);
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
+ mockCallFactory.addExpectedCreateNameMatcherValues(
+ METHOD_TWOARG_NAME, mockArgumentMatcher );
+ mockCallFactory.setupCreateNameMatcher(mockNameMatcher);
+
mockCompositeCallable.addExpectedAddCallableValues(
- mockArgumentMatcher);
+ mockNameMatcher);
builder.matchAndThrow( METHOD_TWOARG_NAME,
METHOD_TWOARG_CONSTRAINTS,
@@ -446,12 +537,17 @@
mockCallFactory.addExpectedCreateReturnStubValues(
METHOD_ONEARG_RESULT);
mockCallFactory.setupCreateReturnStub(mockReturnStub);
+
mockCallFactory.addExpectedCreateArgumentMatcherValues(
- METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub);
+ METHOD_ONEARG_CONSTRAINTS, mockReturnStub);
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
-
+
+ mockCallFactory.addExpectedCreateNameMatcherValues(
+ METHOD_ONEARG_NAME, mockArgumentMatcher );
+ mockCallFactory.setupCreateNameMatcher(mockNameMatcher);
+
mockCompositeCallable.addExpectedAddCallableValues(
- mockArgumentMatcher );
+ mockNameMatcher );
builder.matchAndReturn( METHOD_ONEARG_NAME,
METHOD_ONEARG_ARGS[0],
@@ -467,12 +563,17 @@
mockCallFactory.addExpectedCreateReturnStubValues(
METHOD_NOARGANDRETURN_RESULT);
mockCallFactory.setupCreateReturnStub(mockReturnStub);
+
mockCallFactory.addExpectedCreateArgumentMatcherValues(
- METHOD_NOARG_NAME, C.NO_ARGS, mockReturnStub);
+ C.NO_ARGS, mockReturnStub);
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
+ mockCallFactory.addExpectedCreateNameMatcherValues(
+ METHOD_NOARG_NAME, mockArgumentMatcher );
+ mockCallFactory.setupCreateNameMatcher(mockNameMatcher);
+
mockCompositeCallable.addExpectedAddCallableValues(
- mockArgumentMatcher);
+ mockNameMatcher);
builder.matchAndReturn( METHOD_NOARG_NAME,
METHOD_NOARGANDRETURN_RESULT);
@@ -481,6 +582,44 @@
mockCompositeCallable.verifyExpectations();
}
+ public void testBuildsDecoratorsForMatchNameAndReturn() {
+ mockCallFactory.addExpectedCreateReturnStubValues(
+ METHOD_NOARGANDRETURN_RESULT);
+ mockCallFactory.setupCreateReturnStub(mockReturnStub);
+
+ mockCallFactory.addExpectedCreateNameMatcherValues(
+ METHOD_NOARG_NAME, mockReturnStub );
+ mockCallFactory.setupCreateNameMatcher(mockNameMatcher);
+
+ mockCompositeCallable.addExpectedAddCallableValues(
+ mockNameMatcher);
+
+ builder.matchNameAndReturn( METHOD_NOARG_NAME,
+ METHOD_NOARGANDRETURN_RESULT);
+
+ Verifier.verifyObject(this);
+ mockCompositeCallable.verifyExpectations();
+ }
+
+ public void testBuildsDecoratorsForMatchNameAndThrow()
+ throws Throwable
+ {
+ mockCallFactory.addExpectedCreateThrowStubValues(METHOD_EXCEPTION);
+ mockCallFactory.setupCreateThrowStub(mockThrowStub);
+
+ mockCallFactory.addExpectedCreateNameMatcherValues(
+ METHOD_NOARG_NAME, mockThrowStub );
+ mockCallFactory.setupCreateNameMatcher(mockNameMatcher);
+
+ mockCompositeCallable.addExpectedAddCallableValues(
+ mockNameMatcher );
+
+ builder.matchNameAndThrow(METHOD_NOARG_NAME, METHOD_EXCEPTION);
+
+ Verifier.verifyObject(this);
+ mockCompositeCallable.verifyExpectations();
+ }
+
public void testBuildsCallSequenceAndWrapsItWithACallCollectionBuilder() {
final CallCollectionBuilder expectedSequenceBuilder =
new CallCollectionBuilder( mockCallFactory,
@@ -498,7 +637,8 @@
assertSame( "expected same builder for new sequence",
expectedSequenceBuilder, returnedSequenceBuilder );
- mockCallFactory.verify();
+ Verifier.verifyObject(this);
+ mockCompositeCallable.verifyExpectations();
}
public void testBuildsCallSelectionAndWrapsItWithACallCollectionBuilder() {
@@ -518,6 +658,7 @@
assertSame( "expected same builder for new selection",
expectedSelectionBuilder, returnedSelectionBuilder );
- mockCallFactory.verify();
+ Verifier.verifyObject(this);
+ mockCompositeCallable.verifyExpectations();
}
}
Index: MockCallFactory.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockCallFactory.java,v
retrieving revision 1.4.2.2
retrieving revision 1.4.2.3
diff -u -r1.4.2.2 -r1.4.2.3
--- MockCallFactory.java 26 Jun 2003 17:33:12 -0000 1.4.2.2
+++ MockCallFactory.java 27 Jun 2003 16:03:20 -0000 1.4.2.3
@@ -1,12 +1,15 @@
package test.mockobjects.dynamic;
import mockmaker.ReturnValues;
-import com.mockobjects.*;
+
+import com.mockobjects.ExceptionalReturnValue;
+import com.mockobjects.ExpectationCounter;
+import com.mockobjects.ExpectationList;
+import com.mockobjects.constraint.Constraint;
+import com.mockobjects.dynamic.CallCollectionBuilder;
import com.mockobjects.dynamic.CallFactory;
import com.mockobjects.dynamic.Callable;
-import com.mockobjects.constraint.Constraint;
import com.mockobjects.dynamic.CompositeCallable;
-import com.mockobjects.dynamic.CallCollectionBuilder;
public class MockCallFactory implements CallFactory{
private ExpectationCounter myCreateReturnStubCalls = new ExpectationCounter("com.mockobjects.dynamic.CallFactory CreateReturnStubCalls");
private ReturnValues myActualCreateReturnStubReturnValues = new ReturnValues(false);
@@ -21,9 +24,8 @@
private ExpectationList myCreateCallOnceExpectationParameter0Values = new ExpectationList("com.mockobjects.dynamic.CallFactory com.mockobjects.dynamic.Callable");
private ExpectationCounter myCreateArgumentMatcherCalls = new ExpectationCounter("com.mockobjects.dynamic.CallFactory CreateArgumentMatcherCalls");
private ReturnValues myActualCreateArgumentMatcherReturnValues = new ReturnValues(false);
- private ExpectationList myCreateArgumentMatcherParameter0Values = new ExpectationList("com.mockobjects.dynamic.CallFactory java.lang.String");
- private ExpectationList myCreateArgumentMatcherParameter1Values = new ExpectationList("com.mockobjects.dynamic.CallFactory com.mockobjects.constraint.Constraint");
- private ExpectationList myCreateArgumentMatcherParameter2Values = new ExpectationList("com.mockobjects.dynamic.CallFactory com.mockobjects.dynamic.Callable");
+ private ExpectationList myCreateArgumentMatcherParameter0Values = new ExpectationList("com.mockobjects.dynamic.CallFactory com.mockobjects.constraint.Constraint");
+ private ExpectationList myCreateArgumentMatcherParameter1Values = new ExpectationList("com.mockobjects.dynamic.CallFactory com.mockobjects.dynamic.Callable");
private ExpectationCounter myCreateNameMatcherCalls = new ExpectationCounter("com.mockobjects.dynamic.CallFactory CreateNameMatcherCalls");
private ReturnValues myActualCreateNameMatcherReturnValues = new ReturnValues(false);
private ExpectationList myCreateNameMatcherParameter0Values = new ExpectationList("com.mockobjects.dynamic.CallFactory java.lang.String");
@@ -114,16 +116,14 @@
public void setExpectedCreateArgumentMatcherCalls(int calls){
myCreateArgumentMatcherCalls.setExpected(calls);
}
- public void addExpectedCreateArgumentMatcherValues(String arg0, Constraint[] arg1, Callable arg2){
- myCreateArgumentMatcherParameter0Values.addExpected(arg0);
- myCreateArgumentMatcherParameter1Values.addExpectedMany(arg1);
- myCreateArgumentMatcherParameter2Values.addExpected(arg2);
+ public void addExpectedCreateArgumentMatcherValues(Constraint[] arg0, Callable arg1){
+ myCreateArgumentMatcherParameter0Values.addExpectedMany(arg0);
+ myCreateArgumentMatcherParameter1Values.addExpected(arg1);
}
- public Callable createArgumentMatcher(String arg0, Constraint[] arg1, Callable arg2){
+ public Callable createArgumentMatcher(Constraint[] arg0, Callable arg1){
myCreateArgumentMatcherCalls.inc();
- myCreateArgumentMatcherParameter0Values.addActual(arg0);
- myCreateArgumentMatcherParameter1Values.addActualMany(arg1);
- myCreateArgumentMatcherParameter2Values.addActual(arg2);
+ myCreateArgumentMatcherParameter0Values.addActualMany(arg0);
+ myCreateArgumentMatcherParameter1Values.addActual(arg1);
Object nextReturnValue = myActualCreateArgumentMatcherReturnValues.getNext();
if (nextReturnValue instanceof ExceptionalReturnValue && ((ExceptionalReturnValue)nextReturnValue).getException() instanceof RuntimeException)
throw (RuntimeException)((ExceptionalReturnValue)nextReturnValue).getException();
@@ -220,7 +220,6 @@
myCreateArgumentMatcherCalls.verify();
myCreateArgumentMatcherParameter0Values.verify();
myCreateArgumentMatcherParameter1Values.verify();
- myCreateArgumentMatcherParameter2Values.verify();
myCreateNameMatcherCalls.verify();
myCreateNameMatcherParameter0Values.verify();
myCreateNameMatcherParameter1Values.verify();
Index: MockCompositeCallable.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/Attic/MockCompositeCallable.java,v
retrieving revision 1.1.2.1
retrieving revision 1.1.2.2
diff -u -r1.1.2.1 -r1.1.2.2
--- MockCompositeCallable.java 21 Jun 2003 14:01:07 -0000 1.1.2.1
+++ MockCompositeCallable.java 27 Jun 2003 16:03:20 -0000 1.1.2.2
@@ -1,10 +1,6 @@
package test.mockobjects.dynamic;
-import com.mockobjects.ExceptionalReturnValue;
-import com.mockobjects.ExpectationCounter;
-import com.mockobjects.ExpectationList;
-import com.mockobjects.VoidReturnValues;
-import com.mockobjects.ReturnValues;
+import com.mockobjects.*;
import com.mockobjects.dynamic.Callable;
import com.mockobjects.dynamic.CompositeCallable;
Index: DefaultReturnStubTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/Attic/DefaultReturnStubTest.java,v
retrieving revision 1.1.2.1
retrieving revision 1.1.2.2
diff -u -r1.1.2.1 -r1.1.2.2
--- DefaultReturnStubTest.java 26 Jun 2003 17:33:12 -0000 1.1.2.1
+++ DefaultReturnStubTest.java 27 Jun 2003 16:03:20 -0000 1.1.2.2
@@ -2,12 +2,12 @@
*/
package test.mockobjects.dynamic;
+import junit.framework.AssertionFailedError;
+import junit.framework.TestCase;
+
import com.mockobjects.dynamic.ActiveCall;
import com.mockobjects.dynamic.DefaultReturnStub;
import com.mockobjects.util.AssertMo;
-
-import junit.framework.AssertionFailedError;
-import junit.framework.TestCase;
public class DefaultReturnStubTest
extends TestCase
Index: MockTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockTest.java,v
retrieving revision 1.12.2.1
retrieving revision 1.12.2.2
diff -u -r1.12.2.1 -r1.12.2.2
--- MockTest.java 21 Jun 2003 14:01:07 -0000 1.12.2.1
+++ MockTest.java 27 Jun 2003 16:03:20 -0000 1.12.2.2
@@ -140,8 +140,12 @@
public void testProxyInEquality() throws Exception {
boolean IGNORED_RESULT = true;
Stub ret = new ReturnStub(new Boolean(IGNORED_RESULT));
+ ArgumentMatcher args = new ArgumentMatcher(C.anyArgs(1),ret);
+ NameMatcher name = new NameMatcher("call",args);
+
mockCallFactory.setupCreateReturnStub(ret);
- mockCallFactory.setupCreateArgumentMatcher(new ArgumentMatcher("call",C.anyArgs(1),ret));
+ mockCallFactory.setupCreateArgumentMatcher(args);
+ mockCallFactory.setupCreateNameMatcher(name);
mockCompositeCallable.setupCallReturn(new Boolean(false));
mock.matchAndReturn("call", C.anyArgs(1), IGNORED_RESULT);
Index: ArgumentMatcherTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/Attic/ArgumentMatcherTest.java,v
retrieving revision 1.1.2.1
retrieving revision 1.1.2.2
diff -u -r1.1.2.1 -r1.1.2.2
--- ArgumentMatcherTest.java 21 Jun 2003 14:01:07 -0000 1.1.2.1
+++ ArgumentMatcherTest.java 27 Jun 2003 16:03:20 -0000 1.1.2.2
@@ -8,6 +8,7 @@
import com.mockobjects.constraint.Constraint;
import com.mockobjects.dynamic.ActiveCall;
import com.mockobjects.dynamic.ArgumentMatcher;
+import com.mockobjects.util.AssertMo;
public class ArgumentMatcherTest
@@ -31,16 +32,19 @@
mockCallable.setupMatchesReturn(true);
}
- public void testDoesNotMatchDifferentName()
+ public void testIgnoresMethodNames()
throws Throwable
{
- final ActiveCall call = new ActiveCall(
- "otherName", new Class[0], void.class, null );
-
+ final ActiveCall call1 = new ActiveCall(
+ "name1", new Class[0], void.class, null );
+ final ActiveCall call2 = new ActiveCall(
+ "name2", new Class[0], void.class, null );
+
ArgumentMatcher callSignature =
- new ArgumentMatcher( METHOD_NAME, new Constraint[0], mockCallable );
+ new ArgumentMatcher( new Constraint[0], mockCallable );
- assertFalse( "call should not match", callSignature.matches(call) );
+ assertTrue( "call1 should match", callSignature.matches(call1) );
+ assertTrue( "call2 should match", callSignature.matches(call2) );
mockCallable.verifyExpectations();
}
@@ -55,7 +59,7 @@
};
ArgumentMatcher callSignature =
- new ArgumentMatcher( METHOD_NAME, constraints, mockCallable );
+ new ArgumentMatcher( constraints, mockCallable );
assertFalse( "should not match if too many arguments",
callSignature.matches(call) );
@@ -73,13 +77,13 @@
};
ArgumentMatcher callSignature =
- new ArgumentMatcher( METHOD_NAME, constraints, mockCallable );
+ new ArgumentMatcher( constraints, mockCallable );
assertFalse( "should not match if too few arguments",
callSignature.matches(call) );
}
- public void testDoesNotMatchWhenConstraintIsViolated()
+ public void testDoesNotMatchAndDoesNotDelegateWhenConstraintFails()
throws Throwable
{
String[] args = { "argA", "argB", "argC" };
@@ -93,7 +97,7 @@
};
ArgumentMatcher callSignature =
- new ArgumentMatcher( METHOD_NAME, constraints, mockCallable );
+ new ArgumentMatcher( constraints, mockCallable );
assertFalse( "should not match if constraint is violated",
callSignature.matches(call) );
@@ -109,7 +113,7 @@
Constraint[] constraints = new MockConstraint[0];
ArgumentMatcher callSignature =
- new ArgumentMatcher( METHOD_NAME, constraints, mockCallable );
+ new ArgumentMatcher( constraints, mockCallable );
assertFalse( "should not match",
callSignature.matches(call) );
@@ -124,7 +128,7 @@
Constraint[] constraints = new MockConstraint[0];
ArgumentMatcher callSignature =
- new ArgumentMatcher( METHOD_NAME, constraints, mockCallable );
+ new ArgumentMatcher( constraints, mockCallable );
assertTrue( "should match",
callSignature.matches(call) );
@@ -149,7 +153,7 @@
};
ArgumentMatcher callSignature =
- new ArgumentMatcher( METHOD_NAME, constraints, mockCallable );
+ new ArgumentMatcher( constraints, mockCallable );
assertTrue( "should match",
callSignature.matches(call) );
@@ -159,9 +163,7 @@
constraintC.verify();
}
- public void testChecksThatDelegateMatchesWhenConstraintsMatch()
- throws Throwable
- {
+ public void testChecksThatDelegateMatchesWhenConstraintsMatch() {
String[] args = { "argA", "argB", "argC" };
ActiveCall call = new ActiveCall(
METHOD_NAME, new Class[]{ String.class, String.class, String.class },
@@ -181,10 +183,34 @@
mockCallable.setupMatchesReturn(false);
ArgumentMatcher callSignature =
- new ArgumentMatcher( METHOD_NAME, constraints, mockCallable );
+ new ArgumentMatcher( constraints, mockCallable );
assertFalse( "should not match", callSignature.matches(call) );
mockCallable.verifyExpectations();
+ }
+
+ public void testDescriptionContainsAllConstraints() {
+ MockConstraint constraintA =
+ new MockConstraint("constraintA", "argA", true);
+ MockConstraint constraintB =
+ new MockConstraint("constraintB", "argB", true);
+ Constraint[] constraints = { constraintA, constraintB };
+
+ ArgumentMatcher matcher =
+ new ArgumentMatcher( constraints, mockCallable );
+
+ String description = matcher.getDescription();
+
+ assertTrue( "description should start with open parenthesis",
+ description.startsWith("(") );
+ AssertMo.assertIncludes(
+ "description should contain constraintA description",
+ constraintA.toString(), description );
+ AssertMo.assertIncludes(
+ "description should contain constraintB description",
+ constraintB.toString(), description );
+ assertTrue( "description should end with close parenthesis",
+ description.endsWith(")") );
}
}
|
×
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