Menu
▾
▴
[MO-java-dev] CVS: mockobjects-java/src/core/test/mockobjects/dynamic CallSetTest.java,1.1.2.3,1.1.2.4
|
From: Steve F. <sm...@us...> - 2003-04-10 21:26:14
|
Update of /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic
In directory sc8-pr-cvs1:/tmp/cvs-serv3069/src/core/test/mockobjects/dynamic
Modified Files:
Tag: DynamicMockExperiment
CallSetTest.java
Log Message:
renamed constant values
Added test for matchOneArgument
Index: CallSetTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/Attic/CallSetTest.java,v
retrieving revision 1.1.2.3
retrieving revision 1.1.2.4
diff -u -r1.1.2.3 -r1.1.2.4
--- CallSetTest.java 7 Apr 2003 17:38:49 -0000 1.1.2.3
+++ CallSetTest.java 10 Apr 2003 21:26:09 -0000 1.1.2.4
@@ -23,15 +23,15 @@
private Mock unusedMock = null;
private MockCallMocker methodA = new MockCallMocker();
private MockCallMocker methodB = new MockCallMocker();
- final String methodAName = "methodA";
- final String[] methodAArgs = new String[] { "a1", "a2" };
- final Constraint[] methodAConstraints = C.args( C.eq("a1"), C.eq("a2") );
- final String methodAResult = "resultA";
- final Throwable methodAException = new DummyThrowable("Configured test throwable");
-
- final String methodBName = "methodB";
- final String[] methodBArgs = new String[] { "b1", "b2" };
- final String methodBResult = "resultB";
+ final String METHOD_A_NAME = "methodA";
+ final String[] METHOD_A_ARGS = new String[] { "a1", "a2" };
+ final Constraint[] METHOD_A_CONSTRAINTS = C.args( C.eq("a1"), C.eq("a2") );
+ final String METHOD_A_RESULT = "resultA";
+ final Throwable METHOD_A_EXCEPTION = new DummyThrowable("Configured test throwable");
+
+ final String METHOD_B_NAME = "methodB";
+ final String[] METHOD_B_ARGS = new String[] { "b1", "b2" };
+ final String METHOD_B_RESULT = "resultB";
public CallSetTest(String name) {
@@ -70,55 +70,73 @@
public void testExpectAndReturn() throws Throwable{
mockExpectedCall.setupMatchesReturn(true);
- mockExpectedCall.setupCallReturn(methodAResult);
+ mockExpectedCall.setupCallReturn(METHOD_A_RESULT);
- mockCallFactory.addExpectedCreateReturnStub( methodAResult );
+ mockCallFactory.addExpectedCreateReturnStub( METHOD_A_RESULT );
mockCallFactory.setupCreateReturnStub( mockReturnStub );
- mockCallFactory.addExpectedCreateCallMatch( methodAName, methodAConstraints, mockReturnStub );
+ mockCallFactory.addExpectedCreateCallMatch( METHOD_A_NAME, METHOD_A_CONSTRAINTS, mockReturnStub );
mockCallFactory.setupCreateCallMatch( mockCallMatch );
mockCallFactory.addExpectedCreateExpectedCall( mockCallMatch );
mockCallFactory.setupCreateExpectedCall( mockExpectedCall );
- callSet.expectAndReturn( methodAName, methodAConstraints, methodAResult );
+ callSet.expectAndReturn( METHOD_A_NAME, METHOD_A_CONSTRAINTS, METHOD_A_RESULT );
assertSame( "should be result of calling expected call",
- methodAResult, callSet.call( unusedMock, methodAName, methodAArgs ) );
+ METHOD_A_RESULT, callSet.call( unusedMock, METHOD_A_NAME, METHOD_A_ARGS ) );
Verifier.verifyObject(this);
}
public void testPermitAndReturn() throws Throwable{
mockCallMatch.setupMatchesReturn(true);
- mockCallMatch.setupCallReturn(methodAResult);
+ mockCallMatch.setupCallReturn(METHOD_A_RESULT);
- mockCallFactory.addExpectedCreateReturnStub( methodAResult );
+ mockCallFactory.addExpectedCreateReturnStub( METHOD_A_RESULT );
mockCallFactory.setupCreateReturnStub( mockReturnStub );
- mockCallFactory.addExpectedCreateCallMatch( methodAName, methodAConstraints, mockReturnStub );
+ mockCallFactory.addExpectedCreateCallMatch( METHOD_A_NAME, METHOD_A_CONSTRAINTS, mockReturnStub );
mockCallFactory.setupCreateCallMatch( mockCallMatch );
- callSet.permitAndReturn( methodAName, methodAConstraints, methodAResult );
+ callSet.matchAndReturn( METHOD_A_NAME, METHOD_A_CONSTRAINTS, METHOD_A_RESULT );
assertSame( "should be result of calling expected call",
- methodAResult, callSet.call( unusedMock, methodAName, methodAArgs ) );
+ METHOD_A_RESULT, callSet.call( unusedMock, METHOD_A_NAME, METHOD_A_ARGS ) );
Verifier.verifyObject(this);
}
+ public void testPermitOneAndReturn() throws Throwable{
+ final String PARAMETER = "One Arg Method";
+ mockCallMatch.setupMatchesReturn(true);
+ mockCallMatch.setupCallReturn(METHOD_A_RESULT);
+
+ mockCallFactory.addExpectedCreateReturnStub( METHOD_A_RESULT );
+ mockCallFactory.setupCreateReturnStub( mockReturnStub );
+ mockCallFactory.addExpectedCreateCallMatch( "oneArgMethod", C.args(C.eq(PARAMETER)), mockReturnStub );
+ mockCallFactory.setupCreateCallMatch( mockCallMatch );
+
+ callSet.matchAndReturn( "oneArgMethod", PARAMETER, METHOD_A_RESULT );
+
+ assertSame( "should be result of calling expected call",
+ METHOD_A_RESULT, callSet.call( unusedMock, "oneArgMethod", new Object[] {PARAMETER}) );
+
+ Verifier.verifyObject(this);
+ }
+
public void testExpectAndThrow() throws Throwable{
mockExpectedCall.setupMatchesReturn(true);
- mockExpectedCall.setupCallThrow(methodAException);
+ mockExpectedCall.setupCallThrow(METHOD_A_EXCEPTION);
- mockCallFactory.addExpectedCreateThrowStub(methodAException);
+ mockCallFactory.addExpectedCreateThrowStub(METHOD_A_EXCEPTION);
mockCallFactory.setupCreateThrowStub( mockThrowStub );
- mockCallFactory.addExpectedCreateCallMatch( methodAName, methodAConstraints, mockThrowStub );
+ mockCallFactory.addExpectedCreateCallMatch( METHOD_A_NAME, METHOD_A_CONSTRAINTS, mockThrowStub );
mockCallFactory.setupCreateCallMatch( mockCallMatch );
mockCallFactory.addExpectedCreateExpectedCall( mockCallMatch );
mockCallFactory.setupCreateExpectedCall( mockExpectedCall );
- callSet.expectAndThrow( methodAName, methodAConstraints, methodAException );
+ callSet.expectAndThrow( METHOD_A_NAME, METHOD_A_CONSTRAINTS, METHOD_A_EXCEPTION );
try {
- callSet.call( unusedMock, methodAName, methodAArgs );
+ callSet.call( unusedMock, METHOD_A_NAME, METHOD_A_ARGS );
} catch (DummyThrowable ex) {
Verifier.verifyObject(this);
return;
@@ -129,17 +147,17 @@
public void testPermitAndThrow() throws Throwable{
mockCallMatch.setupMatchesReturn(true);
- mockCallMatch.setupCallThrow(methodAException);
+ mockCallMatch.setupCallThrow(METHOD_A_EXCEPTION);
- mockCallFactory.addExpectedCreateThrowStub(methodAException);
+ mockCallFactory.addExpectedCreateThrowStub(METHOD_A_EXCEPTION);
mockCallFactory.setupCreateThrowStub( mockThrowStub );
- mockCallFactory.addExpectedCreateCallMatch( methodAName, methodAConstraints, mockThrowStub );
+ mockCallFactory.addExpectedCreateCallMatch( METHOD_A_NAME, METHOD_A_CONSTRAINTS, mockThrowStub );
mockCallFactory.setupCreateCallMatch( mockCallMatch );
- callSet.permitAndThrow( methodAName, methodAConstraints, methodAException );
+ callSet.matchAndThrow( METHOD_A_NAME, METHOD_A_CONSTRAINTS, METHOD_A_EXCEPTION );
try {
- callSet.call( unusedMock, methodAName, methodAArgs );
+ callSet.call( unusedMock, METHOD_A_NAME, METHOD_A_ARGS );
} catch (DummyThrowable ex) {
Verifier.verifyObject(this);
return;
@@ -149,10 +167,10 @@
}
public void testCallPassedToContainedElements() throws Throwable {
- methodA.setExpectedMatches( methodAName, methodAArgs );
+ methodA.setExpectedMatches( METHOD_A_NAME, METHOD_A_ARGS );
methodA.setupMatchesReturn(true);
- methodA.setExpectedCall( unusedMock, methodAName, methodAArgs );
- methodA.setupCallReturn(methodAResult);
+ methodA.setExpectedCall( unusedMock, METHOD_A_NAME, METHOD_A_ARGS );
+ methodA.setupCallReturn(METHOD_A_RESULT);
methodB.setExpectedCallCount( 0 );
@@ -160,27 +178,27 @@
callSet.add( methodB );
assertSame( "expected result from method A",
- methodAResult, callSet.call( unusedMock, methodAName, methodAArgs ) );
+ METHOD_A_RESULT, callSet.call( unusedMock, METHOD_A_NAME, METHOD_A_ARGS ) );
methodA.verifyExpectations();
methodB.verifyExpectations();
}
public void testCallPassedToContainedElementsOtherOrder() throws Throwable {
- methodA.setExpectedMatches( methodBName, methodBArgs );
+ methodA.setExpectedMatches( METHOD_B_NAME, METHOD_B_ARGS );
methodA.setupMatchesReturn(false);
methodA.setExpectedCallCount( 0 );
- methodB.setExpectedCall( unusedMock, methodBName, methodBArgs );
+ methodB.setExpectedCall( unusedMock, METHOD_B_NAME, METHOD_B_ARGS );
- methodB.setupCallReturn(methodBResult);
- methodB.setExpectedMatches( methodBName, methodBArgs );
+ methodB.setupCallReturn(METHOD_B_RESULT);
+ methodB.setExpectedMatches( METHOD_B_NAME, METHOD_B_ARGS );
methodB.setupMatchesReturn(true);
callSet.add( methodA );
callSet.add( methodB );
assertSame( "expected result from method B",
- methodBResult, callSet.call( unusedMock, methodBName, methodBArgs ) );
+ METHOD_B_RESULT, callSet.call( unusedMock, METHOD_B_NAME, METHOD_B_ARGS ) );
methodA.verifyExpectations();
methodB.verifyExpectations();
|
