Update of /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic
In directory sc8-pr-cvs1:/tmp/cvs-serv11585/src/core/test/mockobjects/dynamic
Modified Files:
Tag: Nat_reworks_dynamics_from_0_09
StubTest.java MockConstraint.java DynamicUtilTest.java
CallOnceExpectationTest.java MockCallable.java
CallSequenceTest.java MockCallFactory.java CTest.java
MockTest.java
Added Files:
Tag: Nat_reworks_dynamics_from_0_09
NameMatcherTest.java CallDecoratorTest.java
ActiveCallTest.java ArgumentMatcherTest.java
CallSelectionTest.java CallCollectionBuilderTest.java
MockCompositeCallable.java
Removed Files:
Tag: Nat_reworks_dynamics_from_0_09
CallMatchTest.java ConstraintMatcherTest.java CallBagTest.java
MockCallableAddable.java MockConstraintMatcher.java
Log Message:
Branched and added Nat's latest reworking of the dynamic libraries
--- NEW FILE: NameMatcherTest.java ---
/** Created on Jun 12, 2003 by npryce
* Copyright (c) B13media Ltd.
*/
package test.mockobjects.dynamic;
import junit.framework.TestCase;
import com.mockobjects.dynamic.ActiveCall;
import com.mockobjects.dynamic.NameMatcher;
public class NameMatcherTest
extends TestCase
{
private final String METHOD_NAME = "methodName";
private final Object[] ARGS = { "arg1", "arg2" };
private final MockCallable delegate = new MockCallable();
private final ActiveCall CALL = new ActiveCall(
METHOD_NAME,
new Class[] { String.class, String.class },
String.class,
ARGS );
private final NameMatcher callName = new NameMatcher( METHOD_NAME, delegate );
public NameMatcherTest(String name) {
super(name);
}
public void testReturnsMethodNameAsDescription() {
assertEquals( "expected method name as description",
METHOD_NAME, callName.getDescription() );
}
public void testReturnsMethodNameFromGetMethodName() {
assertEquals( "expected method name",
METHOD_NAME, callName.getMethodName() );
}
public void testPassesMatchToDelegateIfMethodHasTheSameName() {
delegate.setExpectedMatches( CALL );
delegate.setupMatchesReturn(true);
callName.matches( CALL );
delegate.verifyExpectations();
}
public void testReturnsMatchResultFromDelegateIfMethodHasTheSameName() {
delegate.setExpectedMatches( CALL );
delegate.setupMatchesReturn(true);
assertTrue( "expected matches to return true",
callName.matches( CALL ) );
delegate.verifyExpectations();
delegate.setExpectedMatches( CALL );
delegate.setupMatchesReturn(false);
assertFalse( "expected matches to return false",
callName.matches( CALL ) );
delegate.verifyExpectations();
}
public void testMatchFailsIfMethodNameIsDifferent() {
final ActiveCall OTHER_CALL = new ActiveCall(
"other_" + METHOD_NAME,
new Class[] { String.class, String.class },
String.class,
ARGS );
delegate.setExpectedMatchesCount(0);
assertFalse( "expected matches to return false with other method name",
callName.matches( OTHER_CALL ) );
delegate.verifyExpectations();
}
public void testMatchesAnyMethodWithTheGivenNameWhateverTheArguments() {
delegate.setupMatchesReturn(true);
final ActiveCall CALL0 = new ActiveCall(
METHOD_NAME,
new Class[0],
String.class,
new Object[0] );
assertTrue( "expected matches to return true",
callName.matches(CALL0) );
final ActiveCall CALL1 = new ActiveCall(
METHOD_NAME,
new Class[] { String.class },
String.class,
new Object[]{"arg1"} );
assertTrue( "expected matches to return true",
callName.matches(CALL1) );
final ActiveCall CALL2 = new ActiveCall(
METHOD_NAME,
new Class[] { String.class, String.class },
String.class,
new Object[]{"arg1","arg2"} );
assertTrue( "expected matches to return true",
callName.matches(CALL2) );
final ActiveCall CALL3 = new ActiveCall(
METHOD_NAME,
new Class[] { String.class, String.class, String.class },
String.class,
new Object[]{"arg1","arg2","arg3"} );
assertTrue( "expected matches to return true",
callName.matches(CALL3) );
}
}
--- NEW FILE: CallDecoratorTest.java ---
/*
* Created on 04-Apr-2003
*/
package test.mockobjects.dynamic;
import junit.framework.TestCase;
import com.mockobjects.dynamic.ActiveCall;
import com.mockobjects.dynamic.CallDecorator;
public class CallDecoratorTest
extends TestCase
{
private static final Object[] METHOD_ARGS = { "arg1", "arg2" };
private static final String METHOD_NAME = "methodName";
private static final ActiveCall CALL = new ActiveCall(
METHOD_NAME, new Class[] { String.class, String.class }, String.class,
METHOD_ARGS );
MockCallable mockCallable = new MockCallable();
CallDecorator callDecorator = new CallDecorator(mockCallable);
public CallDecoratorTest(String name) {
super(name);
}
public void testPropagatesCallArgumentsToDecorated()
throws Throwable
{
final Object result = "result";
mockCallable.setExpectedCall(CALL);
mockCallable.setupCallReturn(result);
callDecorator.call(CALL);
mockCallable.verifyExpectations();
}
public void testPropagatesResultFromDecorated()
throws Throwable
{
final Object result = "result";
mockCallable.setExpectedCall(CALL);
mockCallable.setupCallReturn(result);
Object actual_result = callDecorator.call(CALL);
assertSame( "result should be propagated back from decorated",
result, actual_result );
mockCallable.verifyExpectations();
}
public void testPropagatesExceptionsFromDecorated()
throws Throwable
{
final Throwable thrown = new Throwable("thrown");
mockCallable.setExpectedCall(CALL);
mockCallable.setupCallThrow(thrown);
try {
callDecorator.call(CALL);
fail("expected exception to be thrown");
}
catch( Throwable t ) {
assertSame( "exception should be propagated back from decorated",
thrown, t );
}
mockCallable.verifyExpectations();
}
public void testPropagatesVerifyToDecorated() {
mockCallable.setExpectedVerifyCalls(1);
callDecorator.verify();
mockCallable.verifyExpectations();
}
public void testPropagatesMatchesArgumentsToDecorated()
throws Throwable
{
mockCallable.setExpectedMatches(CALL);
mockCallable.setupMatchesReturn(true);
callDecorator.matches(CALL);
mockCallable.verifyExpectations();
}
public void testPropagatesMatchesSuccessFromDecorated()
throws Throwable
{
mockCallable.setupMatchesReturn(true);
assertTrue( "matches should return true",
callDecorator.matches(CALL) );
mockCallable.verifyExpectations();
}
public void testPropagatesMatchesFailureFromDecorated()
throws Throwable
{
mockCallable.setupMatchesReturn(false);
assertFalse( "matches should return false",
callDecorator.matches(CALL) );
mockCallable.verifyExpectations();
}
}
--- NEW FILE: ActiveCallTest.java ---
/** Created on Jun 17, 2003 by npryce
* Copyright (c) B13media Ltd.
*/
package test.mockobjects.dynamic;
import java.lang.reflect.Method;
import java.util.Arrays;
import junit.framework.TestCase;
import com.mockobjects.dynamic.ActiveCall;
public class ActiveCallTest
extends TestCase
{
public String exampleMethod( int number, boolean flag ) {
return "hello, world";
}
final String METHOD_NAME = "exampleMethod";
final Class[] ARG_TYPES = { int.class, boolean.class };
final Class RETURN_TYPE = String.class;
final Object[] ARG_VALUES = { new Integer(0), Boolean.TRUE };
public ActiveCallTest(String name) {
super(name);
}
public void testCanBeConstructedWithExplicitCallDetails() {
ActiveCall call = new ActiveCall( METHOD_NAME, ARG_TYPES,
RETURN_TYPE, ARG_VALUES );
assertEquals( "name", METHOD_NAME, call.getName() );
assertEquals( "parameter types",
Arrays.asList(ARG_TYPES), call.getParameterTypes() );
assertEquals( "return type",
RETURN_TYPE, call.getReturnType() );
assertEquals( "argument values",
Arrays.asList(ARG_VALUES), call.getParameterValues() );
}
public void testCanBeConstructedFromAMethodObject() throws Exception {
Method method = getClass().getMethod( METHOD_NAME, ARG_TYPES );
ActiveCall call = new ActiveCall( method, ARG_VALUES );
assertEquals( "name", method.getName(), call.getName() );
assertEquals( "parameter types",
Arrays.asList(method.getParameterTypes()),
call.getParameterTypes() );
assertEquals( "return type",
method.getReturnType(), call.getReturnType() );
assertEquals( "argument values",
Arrays.asList(ARG_VALUES), call.getParameterValues() );
}
public void testConstructorInterpretsNullParameterValueArrayAsZeroArguments() {
ActiveCall call = new ActiveCall( METHOD_NAME, new Class[0],
RETURN_TYPE, null );
assertEquals( "expected no parameters values",
0, call.getParameterValues().size() );
}
public void testTestsForEqualityOnMethodSignatureAndArguments() {
ActiveCall call1 = new ActiveCall(
METHOD_NAME, (Class[])ARG_TYPES.clone(), RETURN_TYPE,
(Object[])ARG_VALUES.clone() );
ActiveCall call2 = new ActiveCall(
METHOD_NAME, (Class[])ARG_TYPES.clone(), RETURN_TYPE,
(Object[])ARG_VALUES.clone() );
ActiveCall differentName = new ActiveCall(
"other" + METHOD_NAME, (Class[])ARG_TYPES.clone(), RETURN_TYPE,
(Object[])ARG_VALUES.clone() );
ActiveCall differentReturnType = new ActiveCall(
"other" + METHOD_NAME, (Class[])ARG_TYPES.clone(), int.class,
(Object[])ARG_VALUES.clone() );
ActiveCall differentArgTypes = new ActiveCall(
"other" + METHOD_NAME, new Class[]{double.class}, RETURN_TYPE,
(Object[])ARG_VALUES.clone() );
ActiveCall differentArgValues = new ActiveCall(
"other" + METHOD_NAME, (Class[])ARG_TYPES.clone(), RETURN_TYPE,
new Object[] { new Integer(1), Boolean.FALSE } );
assertTrue( "should be equal to itself", call1.equals(call1) );
assertTrue( "identical calls should be equal", call1.equals(call2) );
assertFalse( "should not be equal to object that is not an ActiveCall",
call1.equals(new Object()) );
assertFalse( "should not be equal to null", call1.equals(null) );
assertFalse( "should not be equal if different name",
call1.equals(differentName) );
assertFalse( "should not be equal if different parameter types",
call1.equals(differentArgTypes) );
assertFalse( "should not be equal if different return type",
call1.equals(differentReturnType) );
assertFalse( "should not be equal if different argumentValues",
call1.equals(differentArgValues) );
}
public void testFollowsEqualsHashcodeProtocol() {
ActiveCall call1 = new ActiveCall(
METHOD_NAME, (Class[])ARG_TYPES.clone(), RETURN_TYPE,
(Object[])ARG_VALUES.clone() );
ActiveCall call2 = new ActiveCall(
METHOD_NAME, (Class[])ARG_TYPES.clone(), RETURN_TYPE,
(Object[])ARG_VALUES.clone() );
assertEquals( "should have equal hash codes",
call1.hashCode(), call2.hashCode() );
}
}
--- NEW FILE: ArgumentMatcherTest.java ---
/*
* Created on 04-Apr-2003
*/
package test.mockobjects.dynamic;
import junit.framework.TestCase;
import com.mockobjects.constraint.Constraint;
import com.mockobjects.dynamic.ActiveCall;
import com.mockobjects.dynamic.ArgumentMatcher;
public class ArgumentMatcherTest
extends TestCase
{
private final String METHOD_NAME = "methodName";
private final MockCallable mockCallable = new MockCallable();
public ArgumentMatcherTest(String name) {
super(name);
}
// Note: CallSignature extends CallDecorator (indirectly) and only
// overrides the matches method. Therefore the only tests that
// need to be written are those that exercise the matches method.
// All other tests have been removed from this test class.
// --Nat.
public void setUp() {
mockCallable.setupMatchesReturn(true);
}
public void testDoesNotMatchDifferentName()
throws Throwable
{
final ActiveCall call = new ActiveCall(
"otherName", new Class[0], void.class, null );
ArgumentMatcher callSignature =
new ArgumentMatcher( METHOD_NAME, new Constraint[0], mockCallable );
assertFalse( "call should not match", callSignature.matches(call) );
mockCallable.verifyExpectations();
}
public void testDoesNotMatchWhenTooManyArguments() throws Throwable {
String[] args = { "arg1", "arg2" };
ActiveCall call = new ActiveCall(
METHOD_NAME, new Class[]{String.class,String.class}, void.class,
args );
Constraint[] constraints = {
new MockConstraint("constraint1", args[0], true)
};
ArgumentMatcher callSignature =
new ArgumentMatcher( METHOD_NAME, constraints, mockCallable );
assertFalse( "should not match if too many arguments",
callSignature.matches(call) );
}
public void testDoesNotMatchWhenTooFewArguments()
throws Throwable
{
String[] args = { "arg1" };
ActiveCall call = new ActiveCall(
METHOD_NAME, new Class[]{String.class}, void.class, args );
Constraint[] constraints = {
new MockConstraint("constraint1", args[0], true),
new MockConstraint("constraint2", args[0], true)
};
ArgumentMatcher callSignature =
new ArgumentMatcher( METHOD_NAME, constraints, mockCallable );
assertFalse( "should not match if too few arguments",
callSignature.matches(call) );
}
public void testDoesNotMatchWhenConstraintIsViolated()
throws Throwable
{
String[] args = { "argA", "argB", "argC" };
ActiveCall call = new ActiveCall(
METHOD_NAME, new Class[]{String.class,String.class,String.class},
void.class, args );
Constraint[] constraints = {
new MockConstraint("constraintA", args[0], true),
new MockConstraint("constraintB", args[1], false),
new MockConstraint("constraintC", args[2], true)
};
ArgumentMatcher callSignature =
new ArgumentMatcher( METHOD_NAME, constraints, mockCallable );
assertFalse( "should not match if constraint is violated",
callSignature.matches(call) );
}
public void testDoesNotMatchWithNoArgumentsAndCalleeHasArguments()
throws Throwable
{
String[] args = new String[] { "arg1", "arg2" };
ActiveCall call = new ActiveCall(
METHOD_NAME, new Class[]{String.class,String.class}, void.class,
args );
Constraint[] constraints = new MockConstraint[0];
ArgumentMatcher callSignature =
new ArgumentMatcher( METHOD_NAME, constraints, mockCallable );
assertFalse( "should not match",
callSignature.matches(call) );
}
public void testMatchesWithNoArguments()
throws Throwable
{
String[] args = new String[0];
ActiveCall call = new ActiveCall(
METHOD_NAME, new Class[0], void.class, args );
Constraint[] constraints = new MockConstraint[0];
ArgumentMatcher callSignature =
new ArgumentMatcher( METHOD_NAME, constraints, mockCallable );
assertTrue( "should match",
callSignature.matches(call) );
}
public void testMatchesWhenConstraintsPass()
throws Throwable
{
String[] args = { "argA", "argB", "argC" };
ActiveCall call = new ActiveCall(
METHOD_NAME, new Class[]{ String.class, String.class, String.class },
void.class, args );
MockConstraint constraintA =
new MockConstraint("constraintA", args[0], true);
MockConstraint constraintB =
new MockConstraint("constraintB", args[1], true);
MockConstraint constraintC =
new MockConstraint("constraintC", args[2], true);
Constraint[] constraints = {
constraintA, constraintB, constraintC
};
ArgumentMatcher callSignature =
new ArgumentMatcher( METHOD_NAME, constraints, mockCallable );
assertTrue( "should match",
callSignature.matches(call) );
constraintA.verify();
constraintB.verify();
constraintC.verify();
}
public void testChecksThatDelegateMatchesWhenConstraintsMatch()
throws Throwable
{
String[] args = { "argA", "argB", "argC" };
ActiveCall call = new ActiveCall(
METHOD_NAME, new Class[]{ String.class, String.class, String.class },
void.class, args );
MockConstraint constraintA =
new MockConstraint("constraintA", args[0], true);
MockConstraint constraintB =
new MockConstraint("constraintB", args[1], true);
MockConstraint constraintC =
new MockConstraint("constraintC", args[2], true);
Constraint[] constraints = {
constraintA, constraintB, constraintC
};
mockCallable.setExpectedMatches(call);
mockCallable.setupMatchesReturn(false);
ArgumentMatcher callSignature =
new ArgumentMatcher( METHOD_NAME, constraints, mockCallable );
assertFalse( "should not match", callSignature.matches(call) );
mockCallable.verifyExpectations();
}
}
--- NEW FILE: CallSelectionTest.java ---
package test.mockobjects.dynamic;
import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
import com.mockobjects.constraint.Constraint;
import com.mockobjects.dynamic.*;
import com.mockobjects.util.AssertMo;
public class CallSelectionTest
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 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 );
private CallSelection callSelection = new CallSelection();
private MockCallable methodA = new MockCallable();
private MockCallable methodB = new MockCallable();
private MockCallable mockCallable = new MockCallable();
public CallSelectionTest(String name) {
super(name);
}
public void testCallFailsOnEmptySet() throws Throwable {
try {
callSelection.call(CALL_A);
} catch (AssertionFailedError ex) {
AssertMo.assertIncludes( "reports empty set in error message",
"no methods", ex.getMessage());
return;
}
fail("Should fail for a missing item");
}
public void testCallPassedToContainedElementsInReverseOrderOfAddition()
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);
callSelection.addCallable(methodA);
callSelection.addCallable(methodB);
assertSame("expected result from method A", METHOD_A_RESULT,
callSelection.call(CALL_A));
methodA.verifyExpectations();
methodB.verifyExpectations();
}
public void testMatchedCallStopsSearch()
throws Throwable
{
methodA.setExpectedCallCount(0);
methodB.setExpectedMatches(CALL_B);
methodB.setupMatchesReturn(true);
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));
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));
callSelection.verify();
}
public void testConfiguredResultReturned() throws Throwable {
mockCallable.setupCallReturn(METHOD_A_RESULT);
mockCallable.setupMatchesReturn(true);
callSelection.addCallable(mockCallable);
assertSame( "result is returned by mock",
METHOD_A_RESULT, callSelection.call(CALL_A));
}
public void testCallableThrowableThrown()
throws Throwable
{
mockCallable.setupMatchesReturn(true);
mockCallable.setupCallThrow(METHOD_A_EXCEPTION);
callSelection.addCallable(mockCallable);
try {
callSelection.call(CALL_A);
} catch (Throwable ex) {
assertSame("exception is caught by mock", METHOD_A_EXCEPTION, ex);
}
}
public void testEmptySetVerifies() throws Exception {
callSelection.verify();
}
public void testReportsFailureIfNoElementMatches() throws Throwable {
methodA.setExpectedMatches(CALL_C);
methodA.setupMatchesReturn(false);
methodA.setExpectedCallCount(0);
methodA.setupGetDescription("***methodA-description****");
methodB.setExpectedCall(CALL_C);
methodB.setupMatchesReturn(false);
methodB.setExpectedCallCount(0);
methodB.setupGetDescription("***methodB-description****");
callSelection.addCallable(methodA);
callSelection.addCallable(methodB);
try {
callSelection.call(CALL_C);
} catch (AssertionFailedError ex) {
AssertMo.assertIncludes("method name is in error message", "methodC", ex.getMessage());
AssertMo.assertIncludes("argument is in error message (1)", METHOD_C_ARGS[0], ex.getMessage());
AssertMo.assertIncludes("argument is in error message (2)", METHOD_C_ARGS[1], ex.getMessage());
AssertMo.assertIncludes("shows set contents (A)", methodA.getDescription(), ex.getMessage());
AssertMo.assertIncludes("shows set contents (B)", methodB.getDescription(), ex.getMessage());
return;
}
fail("Should fail for a missing item");
}
public void testVerifiesIfAllContainedElementsVerify()
throws Throwable {
methodA.setExpectedVerifyCalls(1);
methodB.setExpectedVerifyCalls(1);
callSelection.addCallable(methodA);
callSelection.addCallable(methodB);
callSelection.verify();
methodA.verifyExpectations();
methodB.verifyExpectations();
}
public void testVerifyFailsIfContainedElementDoesNotVerify()
throws Exception
{
methodA.setExpectedVerifyCalls(1);
methodA.setupVerifyThrow(new AssertionFailedError("verify failed"));
callSelection.addCallable(methodA);
try {
callSelection.verify();
} catch (AssertionFailedError ex) {
methodA.verifyExpectations();
return;
}
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);
assertFalse( "no method should match", callSelection.matches(CALL_C) );
}
}
--- NEW FILE: CallCollectionBuilderTest.java ---
/*
* Created on 04-Apr-2003
*/
package test.mockobjects.dynamic;
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;
public class CallCollectionBuilderTest
extends TestCase
{
final String METHOD_NOARG_NAME = "noArgMethodVoid";
final String METHOD_NOARGANDRETURN_NAME = "noArgMethod";
final String METHOD_NOARGANDRETURN_RESULT = "resultNoArgs";
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 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 String[] METHOD_TWOARG_ARGS = new String[] { "twoP1", "twoP2" };
final Constraint[] METHOD_TWOARG_CONSTRAINTS =
C.args(C.eq("twoP1"), C.eq("twoP2"));
private MockCallFactory mockCallFactory = new MockCallFactory();
private MockCallable mockCallable = new MockCallable();
private MockCallable mockArgumentMatcher = new MockCallable();
private MockCallable mockCallOnceExpectation = new MockCallable();
private MockCallable mockReturnStub = new MockCallable();
private MockCallable mockThrowStub = new MockCallable();
private MockCallable mockVoidStub = new MockCallable();
private MockCompositeCallable mockCompositeCallable =
new MockCompositeCallable();
private CallCollectionBuilder builder;
public CallCollectionBuilderTest(String name) throws Exception {
super(name);
}
public void setUp() {
builder = new CallCollectionBuilder( mockCallFactory,
mockCompositeCallable );
}
public void testAddsCallablesToComposite()
throws Throwable
{
mockCompositeCallable.addExpectedAddCallableValues( mockCallable );
builder.addCallable( mockCallable );
mockCompositeCallable.verifyExpectations();
}
public void testBuildsDecoratorToWrapExpectedCallableObject()
throws Throwable
{
mockCallFactory.addExpectedCreateArgumentMatcherValues(
METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS,
mockCallable );
mockCallFactory.setupCreateArgumentMatcher( mockArgumentMatcher );
mockCallFactory.addExpectedCreateCallOnceExpectationValues(
mockArgumentMatcher );
mockCallFactory.setupCreateCallOnceExpectation( mockCallOnceExpectation );
mockCompositeCallable.addExpectedAddCallableValues(mockCallOnceExpectation);
builder.expect( METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS,
mockCallable );
mockCallFactory.verify();
mockCompositeCallable.verifyExpectations();
}
public void testBuildsDecoratorsForExpectVoidWithConstraintArray()
throws Throwable
{
mockCallFactory.setExpectedCreateVoidStubCalls(1);
mockCallFactory.setupCreateVoidStub(mockVoidStub);
mockCallFactory.addExpectedCreateArgumentMatcherValues(
METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockVoidStub );
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
mockCallFactory.addExpectedCreateCallOnceExpectationValues(
mockArgumentMatcher );
mockCallFactory.setupCreateCallOnceExpectation(
mockCallOnceExpectation);
mockCompositeCallable.addExpectedAddCallableValues(
mockCallOnceExpectation);
builder.expectVoid(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS);
Verifier.verifyObject(this);
mockCompositeCallable.verifyExpectations();
}
public void testBuildsDecoratorsForExpectAndReturnWithNoArguments()
throws Throwable
{
mockCallFactory.addExpectedCreateReturnStubValues(
METHOD_NOARGANDRETURN_RESULT);
mockCallFactory.setupCreateReturnStub(mockReturnStub);
mockCallFactory.addExpectedCreateArgumentMatcherValues(
METHOD_NOARGANDRETURN_NAME, C.NO_ARGS, mockReturnStub);
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
mockCallFactory.addExpectedCreateCallOnceExpectationValues(
mockArgumentMatcher );
mockCallFactory.setupCreateCallOnceExpectation(
mockCallOnceExpectation );
mockCompositeCallable.addExpectedAddCallableValues(
mockCallOnceExpectation );
builder.expectAndReturn( METHOD_NOARGANDRETURN_NAME,
METHOD_NOARGANDRETURN_RESULT );
Verifier.verifyObject(this);
mockCompositeCallable.verifyExpectations();
}
public void testBuildsDecoratorsForExpectAndThrowWithNoArguments()
throws Throwable
{
mockCallFactory.addExpectedCreateThrowStubValues(
METHOD_EXCEPTION );
mockCallFactory.setupCreateThrowStub(mockThrowStub);
mockCallFactory.addExpectedCreateArgumentMatcherValues(
METHOD_NOARGANDRETURN_NAME, C.NO_ARGS, mockThrowStub );
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
mockCallFactory.addExpectedCreateCallOnceExpectationValues(
mockArgumentMatcher);
mockCallFactory.setupCreateCallOnceExpectation(
mockCallOnceExpectation );
mockCompositeCallable.addExpectedAddCallableValues(
mockCallOnceExpectation );
builder.expectAndThrow(METHOD_NOARGANDRETURN_NAME, METHOD_EXCEPTION);
Verifier.verifyObject(this);
mockCompositeCallable.verifyExpectations();
}
public void testBuildsDecoratorsForExpectAndThrowWithOneArgument()
throws Throwable
{
mockCallFactory.addExpectedCreateThrowStubValues(METHOD_EXCEPTION);
mockCallFactory.setupCreateThrowStub(mockThrowStub);
mockCallFactory.addExpectedCreateArgumentMatcherValues(
METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub );
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
mockCallFactory.addExpectedCreateCallOnceExpectationValues(
mockArgumentMatcher);
mockCallFactory.setupCreateCallOnceExpectation(
mockCallOnceExpectation );
mockCompositeCallable.addExpectedAddCallableValues(
mockCallOnceExpectation );
builder.expectAndThrow(
METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_EXCEPTION);
Verifier.verifyObject(this);
mockCompositeCallable.verifyExpectations();
}
public void testBuildsDecoratorsForExpectVoidWithNoArguments()
throws Throwable
{
mockCallFactory.setExpectedCreateVoidStubCalls(1);
mockCallFactory.setupCreateVoidStub(mockVoidStub);
mockCallFactory.addExpectedCreateArgumentMatcherValues(
METHOD_NOARG_NAME, C.NO_ARGS, mockVoidStub );
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
mockCallFactory.addExpectedCreateCallOnceExpectationValues(
mockArgumentMatcher );
mockCallFactory.setupCreateCallOnceExpectation(mockCallOnceExpectation);
mockCompositeCallable.addExpectedAddCallableValues(mockCallOnceExpectation);
builder.expectVoid( METHOD_NOARG_NAME );
Verifier.verifyObject(this);
mockCompositeCallable.verifyExpectations();
}
public void testBuildsDecoratorsForExpectVoidWithOneArgument()
throws Throwable
{
mockCallFactory.setExpectedCreateVoidStubCalls(1);
mockCallFactory.setupCreateVoidStub(mockVoidStub);
mockCallFactory.addExpectedCreateArgumentMatcherValues(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
mockCallFactory.addExpectedCreateCallOnceExpectationValues(mockArgumentMatcher);
mockCallFactory.setupCreateCallOnceExpectation(mockCallOnceExpectation);
mockCompositeCallable.addExpectedAddCallableValues(mockCallOnceExpectation);
builder.expectVoid(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0]);
Verifier.verifyObject(this);
mockCompositeCallable.verifyExpectations();
}
public void testBuildsDecoratorsForExpectVoidWithOneConstraint()
throws Throwable
{
mockCallFactory.setupCreateVoidStub(mockVoidStub);
mockCallFactory.addExpectedCreateArgumentMatcherValues(
METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub );
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
mockCallFactory.setupCreateCallOnceExpectation(
mockCallOnceExpectation );
mockCompositeCallable.addExpectedAddCallableValues(
mockCallOnceExpectation );
builder.expectVoid(
METHOD_ONEARG_NAME,
new IsEqual(METHOD_ONEARG_ARGS[0]) );
Verifier.verifyObject(this);
mockCompositeCallable.verifyExpectations();
}
public void testBuildsDecoratorsForExpectAndReturnWithManyConstraints()
throws Throwable
{
mockCallFactory.addExpectedCreateReturnStubValues(
METHOD_TWOARG_RESULT );
mockCallFactory.setupCreateReturnStub(mockReturnStub);
mockCallFactory.addExpectedCreateArgumentMatcherValues(
METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockReturnStub);
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
mockCallFactory.addExpectedCreateCallOnceExpectationValues(
mockArgumentMatcher);
mockCallFactory.setupCreateCallOnceExpectation(
mockCallOnceExpectation);
mockCompositeCallable.addExpectedAddCallableValues(
mockCallOnceExpectation);
builder.expectAndReturn( METHOD_TWOARG_NAME,
METHOD_TWOARG_CONSTRAINTS,
METHOD_TWOARG_RESULT);
Verifier.verifyObject(this);
mockCompositeCallable.verifyExpectations();
}
public void testBuildsDecoratorsForExpectAndThrowWithManyConstraints()
throws Throwable
{
mockCallFactory.addExpectedCreateThrowStubValues(METHOD_EXCEPTION);
mockCallFactory.setupCreateThrowStub(mockThrowStub);
mockCallFactory.addExpectedCreateArgumentMatcherValues(
METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockThrowStub );
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
mockCallFactory.addExpectedCreateCallOnceExpectationValues(
mockArgumentMatcher);
mockCallFactory.setupCreateCallOnceExpectation(
mockCallOnceExpectation);
mockCompositeCallable.addExpectedAddCallableValues(
mockCallOnceExpectation);
mockCompositeCallable.setupCallReturn(METHOD_TWOARG_RESULT);
builder.expectAndThrow( METHOD_TWOARG_NAME,
METHOD_TWOARG_CONSTRAINTS,
METHOD_EXCEPTION );
Verifier.verifyObject(this);
mockCompositeCallable.verifyExpectations();
}
public void testBuildsDecoratorsForExpectAndReturnWithOneArgument()
throws Throwable
{
mockCallFactory.addExpectedCreateReturnStubValues(
METHOD_ONEARG_RESULT );
mockCallFactory.setupCreateReturnStub(mockReturnStub);
mockCallFactory.addExpectedCreateArgumentMatcherValues(
METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub );
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
mockCallFactory.addExpectedCreateCallOnceExpectationValues(
mockArgumentMatcher );
mockCallFactory.setupCreateCallOnceExpectation(
mockCallOnceExpectation );
mockCompositeCallable.addExpectedAddCallableValues(
mockCallOnceExpectation );
mockCompositeCallable.setupCallReturn(METHOD_ONEARG_RESULT);
builder.expectAndReturn( METHOD_ONEARG_NAME,
METHOD_ONEARG_ARGS[0],
METHOD_ONEARG_RESULT );
Verifier.verifyObject(this);
mockCompositeCallable.verifyExpectations();
}
public void testBuildsDecoratorsForExpectAndReturnWithOneConstraint()
throws Throwable
{
mockCallFactory.addExpectedCreateReturnStubValues(
METHOD_ONEARG_RESULT );
mockCallFactory.setupCreateReturnStub(mockReturnStub);
mockCallFactory.addExpectedCreateArgumentMatcherValues(
METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub );
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
mockCallFactory.addExpectedCreateCallOnceExpectationValues(
mockArgumentMatcher );
mockCallFactory.setupCreateCallOnceExpectation(
mockCallOnceExpectation );
mockCompositeCallable.addExpectedAddCallableValues(
mockCallOnceExpectation );
mockCompositeCallable.setupCallReturn(METHOD_ONEARG_RESULT);
builder.expectAndReturn( METHOD_ONEARG_NAME,
METHOD_ONEARG_CONSTRAINTS[0],
METHOD_ONEARG_RESULT );
Verifier.verifyObject(this);
mockCompositeCallable.verifyExpectations();
}
public void testBuildsDecoratorsForExpectAndThrowWithOneConstraint()
throws Throwable
{
mockCallFactory.addExpectedCreateReturnStubValues(
METHOD_ONEARG_RESULT );
mockCallFactory.setupCreateThrowStub(mockThrowStub);
mockCallFactory.addExpectedCreateArgumentMatcherValues(
METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub );
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
mockCallFactory.addExpectedCreateCallOnceExpectationValues(
mockArgumentMatcher );
mockCallFactory.setupCreateCallOnceExpectation(
mockCallOnceExpectation );
mockCompositeCallable.addExpectedAddCallableValues(
mockCallOnceExpectation );
builder.expectAndThrow( METHOD_ONEARG_NAME,
METHOD_ONEARG_CONSTRAINTS[0],
METHOD_EXCEPTION );
Verifier.verifyObject(this);
mockCompositeCallable.verifyExpectations();
}
public void testBuildsDecoratorsForMatchAndReturnWithManyConstraints()
throws Throwable
{
mockCallFactory.addExpectedCreateReturnStubValues(
METHOD_TWOARG_RESULT );
mockCallFactory.setupCreateReturnStub(mockReturnStub);
mockCallFactory.addExpectedCreateArgumentMatcherValues(
METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockReturnStub);
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
mockCompositeCallable.addExpectedAddCallableValues(
mockArgumentMatcher);
builder.matchAndReturn( METHOD_TWOARG_NAME,
METHOD_TWOARG_CONSTRAINTS,
METHOD_TWOARG_RESULT);
Verifier.verifyObject(this);
mockCompositeCallable.verifyExpectations();
}
public void testBuildsDecoratorsForMatchAndThrowWithNoArguments()
throws Throwable
{
mockCallFactory.addExpectedCreateThrowStubValues(METHOD_EXCEPTION);
mockCallFactory.setupCreateThrowStub(mockThrowStub);
mockCallFactory.addExpectedCreateArgumentMatcherValues(METHOD_NOARG_NAME, C.NO_ARGS, mockThrowStub);
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
mockCompositeCallable.addExpectedAddCallableValues(
mockArgumentMatcher);
builder.matchAndThrow(METHOD_NOARG_NAME, METHOD_EXCEPTION);
Verifier.verifyObject(this);
mockCompositeCallable.verifyExpectations();
}
public void testBuildsDecoratorsForMatchAndThrowWithOneArgument()
throws Throwable
{
mockCallFactory.addExpectedCreateThrowStubValues(METHOD_EXCEPTION);
mockCallFactory.setupCreateThrowStub(mockThrowStub);
mockCallFactory.addExpectedCreateArgumentMatcherValues(
METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub);
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
mockCompositeCallable.addExpectedAddCallableValues(
mockArgumentMatcher);
builder.matchAndThrow( METHOD_ONEARG_NAME,
METHOD_ONEARG_ARGS[0],
METHOD_EXCEPTION);
Verifier.verifyObject(this);
mockCompositeCallable.verifyExpectations();
}
public void testBuildsDecoratorsForMatchAndThrowWithManyArguments()
throws Throwable
{
mockCallFactory.addExpectedCreateThrowStubValues(METHOD_EXCEPTION);
mockCallFactory.setupCreateThrowStub(mockThrowStub);
mockCallFactory.addExpectedCreateArgumentMatcherValues(
METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockThrowStub);
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
mockCompositeCallable.addExpectedAddCallableValues(
mockArgumentMatcher);
builder.matchAndThrow( METHOD_TWOARG_NAME,
METHOD_TWOARG_CONSTRAINTS,
METHOD_EXCEPTION );
Verifier.verifyObject(this);
mockCompositeCallable.verifyExpectations();
}
public void testBuildsDecoratorsForMatchAndReturnWithOneArgument()
throws Throwable
{
mockCallFactory.addExpectedCreateReturnStubValues(
METHOD_ONEARG_RESULT);
mockCallFactory.setupCreateReturnStub(mockReturnStub);
mockCallFactory.addExpectedCreateArgumentMatcherValues(
METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub);
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
mockCompositeCallable.addExpectedAddCallableValues(
mockArgumentMatcher );
builder.matchAndReturn( METHOD_ONEARG_NAME,
METHOD_ONEARG_ARGS[0],
METHOD_ONEARG_RESULT );
Verifier.verifyObject(this);
mockCompositeCallable.verifyExpectations();
}
public void testBuildsDecoratorsForMatchAndReturnWithNoArguments()
throws Throwable
{
mockCallFactory.addExpectedCreateReturnStubValues(
METHOD_NOARGANDRETURN_RESULT);
mockCallFactory.setupCreateReturnStub(mockReturnStub);
mockCallFactory.addExpectedCreateArgumentMatcherValues(
METHOD_NOARG_NAME, C.NO_ARGS, mockReturnStub);
mockCallFactory.setupCreateArgumentMatcher(mockArgumentMatcher);
mockCompositeCallable.addExpectedAddCallableValues(
mockArgumentMatcher);
builder.matchAndReturn( METHOD_NOARG_NAME,
METHOD_NOARGANDRETURN_RESULT);
Verifier.verifyObject(this);
mockCompositeCallable.verifyExpectations();
}
public void testBuildsCallSequenceAndWrapsItWithACallCollectionBuilder() {
final CallCollectionBuilder expectedSequenceBuilder =
new CallCollectionBuilder( mockCallFactory,
mockCompositeCallable );
mockCallFactory.setupCreateCallSequence( mockCompositeCallable );
mockCallFactory.addExpectedCreateCallCollectionBuilderValues(
mockCompositeCallable );
mockCallFactory.setupCreateCallCollectionBuilder(
expectedSequenceBuilder );
CallCollectionBuilder returnedSequenceBuilder =
builder.newCallSequence();
assertSame( "expected same builder for new sequence",
expectedSequenceBuilder, returnedSequenceBuilder );
mockCallFactory.verify();
}
public void testBuildsCallSelectionAndWrapsItWithACallCollectionBuilder() {
final CallCollectionBuilder expectedSelectionBuilder =
new CallCollectionBuilder( mockCallFactory,
mockCompositeCallable );
mockCallFactory.setupCreateCallSelection( mockCompositeCallable );
mockCallFactory.addExpectedCreateCallCollectionBuilderValues(
mockCompositeCallable );
mockCallFactory.setupCreateCallCollectionBuilder(
expectedSelectionBuilder );
CallCollectionBuilder returnedSelectionBuilder =
builder.newCallSelection();
assertSame( "expected same builder for new selection",
expectedSelectionBuilder, returnedSelectionBuilder );
mockCallFactory.verify();
}
}
--- NEW FILE: MockCompositeCallable.java ---
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.dynamic.Callable;
import com.mockobjects.dynamic.CompositeCallable;
public class MockCompositeCallable
extends MockCallable
implements CompositeCallable
{
private ExpectationCounter myAddCallableCalls = new ExpectationCounter("com.mockobjects.dynamic.CompositeCallable AddCallableCalls");
private ReturnValues myActualAddCallableReturnValues = new VoidReturnValues(false);
private ExpectationList myAddCallableParameter0Values = new ExpectationList("com.mockobjects.dynamic.CompositeCallable com.mockobjects.dynamic.Callable");
private ExpectationCounter myResetCalls = new ExpectationCounter("com.mockobjects.dynamic.CompositeCallable ResetCalls");
private ReturnValues myActualResetReturnValues = new VoidReturnValues(false);
public void setExpectedAddCallableCalls(int calls){
myAddCallableCalls.setExpected(calls);
}
public void addExpectedAddCallableValues(Callable arg0){
myAddCallableParameter0Values.addExpected(arg0);
}
public void addCallable(Callable arg0){
myAddCallableCalls.inc();
myAddCallableParameter0Values.addActual(arg0);
Object nextReturnValue = myActualAddCallableReturnValues.getNext();
if (nextReturnValue instanceof ExceptionalReturnValue && ((ExceptionalReturnValue)nextReturnValue).getException() instanceof RuntimeException)
throw (RuntimeException)((ExceptionalReturnValue)nextReturnValue).getException();
}
public void setupExceptionAddCallable(Throwable arg){
myActualAddCallableReturnValues.add(new ExceptionalReturnValue(arg));
}
public void setExpectedResetCalls(int calls){
myResetCalls.setExpected(calls);
}
public void reset(){
myResetCalls.inc();
Object nextReturnValue = myActualResetReturnValues.getNext();
if (nextReturnValue instanceof ExceptionalReturnValue && ((ExceptionalReturnValue)nextReturnValue).getException() instanceof RuntimeException)
throw (RuntimeException)((ExceptionalReturnValue)nextReturnValue).getException();
}
public void setupExceptionReset(Throwable arg){
myActualResetReturnValues.add(new ExceptionalReturnValue(arg));
}
}
Index: StubTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/StubTest.java,v
retrieving revision 1.3
retrieving revision 1.3.2.1
diff -u -r1.3 -r1.3.2.1
--- StubTest.java 12 Jun 2003 22:45:16 -0000 1.3
+++ StubTest.java 21 Jun 2003 14:01:07 -0000 1.3.2.1
@@ -3,15 +3,20 @@
*/
package test.mockobjects.dynamic;
-import com.mockobjects.dynamic.*;
+import junit.framework.TestCase;
-import junit.framework.*;
+import com.mockobjects.dynamic.ActiveCall;
+import com.mockobjects.dynamic.ReturnStub;
+import com.mockobjects.dynamic.ThrowStub;
+import com.mockobjects.dynamic.VoidStub;
-/**
- * @author dev
- */
-public class StubTest extends TestCase {
+public class StubTest
+ extends TestCase
+{
+ static final ActiveCall IGNORED_CALL = null;
+
+
public StubTest(String name) {
super(name);
}
@@ -20,25 +25,28 @@
final String result = "result";
ReturnStub stub = new ReturnStub(result);
- String ignoredMethodName = "methodName";
- Object[] ignoredArgs = new Object[0];
- assertSame( "Should be the same result object",
- result, stub.call( ignoredMethodName, ignoredArgs ) );
+ assertSame( "should be the same result object",
+ result, stub.call( IGNORED_CALL ) );
}
+ public void testVoidStub() throws Throwable {
+ VoidStub stub = new VoidStub();
+
+ assertNull( "should return null",
+ stub.call( IGNORED_CALL ) );
+ }
+
public void testThrowStub() {
final Throwable throwable = new DummyThrowable();
ThrowStub stub = new ThrowStub(throwable);
- String ignoredMethodName = "methodName";
- Object[] ignoredArgs = new Object[0];
try {
- stub.call( ignoredMethodName, ignoredArgs );
+ stub.call( IGNORED_CALL );
}
catch( Throwable t ) {
- assertSame( "Should be the same throwable", throwable, t );
+ assertSame( "should be the same throwable", throwable, t );
}
}
}
Index: MockConstraint.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockConstraint.java,v
retrieving revision 1.2
retrieving revision 1.2.2.1
diff -u -r1.2 -r1.2.2.1
--- MockConstraint.java 18 May 2003 20:59:39 -0000 1.2
+++ MockConstraint.java 21 Jun 2003 14:01:07 -0000 1.2.2.1
@@ -3,26 +3,28 @@
*/
package test.mockobjects.dynamic;
-import junit.framework.*;
+import junit.framework.Assert;
-import com.mockobjects.*;
-import com.mockobjects.constraint.*;
+import com.mockobjects.Verifiable;
+import com.mockobjects.constraint.Constraint;
-/**
- * @author dev
- */
-public class MockConstraint extends Assert implements Constraint, Verifiable {
+
+public class MockConstraint
+ extends Assert
+ implements Constraint, Verifiable
+{
private String description;
- private Object expectedArg;
+ private Object expectedArg;
private boolean result;
private boolean wasChecked = false;
+
public MockConstraint( String description, Object expectedArg, boolean result ) {
this.description = description;
this.expectedArg = expectedArg;
this.result = result;
}
-
+
public String toString() {
return description;
}
Index: DynamicUtilTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/DynamicUtilTest.java,v
retrieving revision 1.2
retrieving revision 1.2.2.1
diff -u -r1.2 -r1.2.2.1
--- DynamicUtilTest.java 18 May 2003 20:59:39 -0000 1.2
+++ DynamicUtilTest.java 21 Jun 2003 14:01:07 -0000 1.2.2.1
@@ -3,11 +3,11 @@
*/
package test.mockobjects.dynamic;
+import junit.framework.TestCase;
+
import com.mockobjects.dynamic.DynamicUtil;
import com.mockobjects.dynamic.Mock;
import com.mockobjects.util.AssertMo;
-
-import junit.framework.TestCase;
/**
* @author e2x
Index: CallOnceExpectationTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/CallOnceExpectationTest.java,v
retrieving revision 1.2
retrieving revision 1.2.2.1
diff -u -r1.2 -r1.2.2.1
--- CallOnceExpectationTest.java 12 Jun 2003 22:45:16 -0000 1.2
+++ CallOnceExpectationTest.java 21 Jun 2003 14:01:07 -0000 1.2.2.1
@@ -1,19 +1,25 @@
package test.mockobjects.dynamic;
-import com.mockobjects.dynamic.*;
-import com.mockobjects.util.*;
+import junit.framework.AssertionFailedError;
+import junit.framework.TestCase;
-import junit.framework.*;
+import com.mockobjects.dynamic.ActiveCall;
+import com.mockobjects.dynamic.CallOnceExpectation;
+import com.mockobjects.dynamic.DynamicUtil;
+import com.mockobjects.util.AssertMo;
-public class CallOnceExpectationTest extends TestCase {
-
+public class CallOnceExpectationTest
+ extends TestCase
+{
final String RESULT = "result!";
final String METHOD_NAME = "methodName";
final Object[] ARGS = { "arg1", "arg2" };
final String DECORATED_DESCRIPTION = DynamicUtil.methodToString( METHOD_NAME, ARGS );
-
- Mock ignoredMock = null;
+ final ActiveCall CALL = new ActiveCall(
+ METHOD_NAME, new Class[]{String.class,String.class}, String.class,
+ ARGS );
+
MockCallable mockCallable = new MockCallable();
CallOnceExpectation call = new CallOnceExpectation( mockCallable );
@@ -49,24 +55,24 @@
mockCallable.setupCallReturn( RESULT );
mockCallable.setExpectedVerifyCalls(1);
- call.call( METHOD_NAME, ARGS );
+ call.call( CALL );
call.verify();
mockCallable.verifyExpectations();
}
public void testMatchesDelegated() throws Throwable {
- mockCallable.setExpectedMatches( METHOD_NAME, ARGS );
+ mockCallable.setExpectedMatches(CALL);
mockCallable.setupMatchesReturn(true);
- assertTrue( "returns matches to be true", call.matches( METHOD_NAME, ARGS ) );
+ assertTrue( "returns matches to be true", call.matches(CALL) );
mockCallable.verifyExpectations();
}
public void testCallArgumentsPassedThrough() throws Throwable {
- mockCallable.setExpectedCall(ignoredMock, METHOD_NAME, ARGS);
+ mockCallable.setExpectedCall(CALL);
mockCallable.setupCallReturn(RESULT);
- call.call( METHOD_NAME, ARGS );
+ call.call( CALL );
mockCallable.verifyExpectations();
}
@@ -75,16 +81,16 @@
mockCallable.setupMatchesReturn(true);
mockCallable.setupCallReturn(RESULT);
- assertTrue( "First time should match", call.matches(METHOD_NAME, ARGS));
- call.call(METHOD_NAME, ARGS);
- assertFalse( "Second time should not match", call.matches(METHOD_NAME, ARGS));
+ assertTrue( "First time should match", call.matches(CALL));
+ call.call(CALL);
+ assertFalse( "Second time should not match", call.matches(CALL));
}
public void testDecoratedResultPassedThrough() throws Throwable {
mockCallable.setupCallReturn(RESULT);
assertSame( "should return decorated's result",
- RESULT, call.call( METHOD_NAME, ARGS ) );
+ RESULT, call.call(CALL) );
mockCallable.verifyExpectations();
}
@@ -95,7 +101,7 @@
mockCallable.setupCallThrow(exception);
try {
- call.call( METHOD_NAME, ARGS );
+ call.call(CALL);
fail("expected decorated's throwable to be thrown");
}
catch( DummyThrowable ex ) {
Index: MockCallable.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockCallable.java,v
retrieving revision 1.3
retrieving revision 1.3.2.1
diff -u -r1.3 -r1.3.2.1
--- MockCallable.java 12 Jun 2003 22:45:16 -0000 1.3
+++ MockCallable.java 21 Jun 2003 14:01:07 -0000 1.3.2.1
@@ -1,22 +1,22 @@
package test.mockobjects.dynamic;
-import junit.framework.*;
+import junit.framework.AssertionFailedError;
-import com.mockobjects.*;
+import com.mockobjects.ExpectationCounter;
+import com.mockobjects.ExpectationValue;
+import com.mockobjects.ReturnValue;
+import com.mockobjects.dynamic.ActiveCall;
import com.mockobjects.dynamic.Callable;
-import com.mockobjects.dynamic.Mock;
-import com.mockobjects.util.*;
+import com.mockobjects.util.Verifier;
public class MockCallable implements Callable {
private ExpectationCounter callCount = new ExpectationCounter("call.count");
- private ExpectationValue callMethodName = new ExpectationValue("call.methodName");
- private ExpectationList callArgs = new ExpectationList("call.args");
+ private ExpectationValue callCall = new ExpectationValue("call.call");
private ReturnValue callResult = new ReturnValue("call.return");
private Throwable callThrow = null;
- private ExpectationValue matchesMethodName = new ExpectationValue("matches.methodName");
- private ExpectationList matchesArgs = new ExpectationList("matches.args");
+ private ExpectationValue matchesCall = new ExpectationValue("matches.call");
private ReturnValue matchesResult = new ReturnValue("matches.return");
private ExpectationCounter matchesCount = new ExpectationCounter("matches.count");
@@ -30,9 +30,8 @@
callCount.setExpected(count);
}
- public void setExpectedCall( Mock mock, String methodName, Object[] args ) {
- callMethodName.setExpected(methodName);
- callArgs.addExpectedMany(args);
+ public void setExpectedCall( ActiveCall call ) {
+ callCall.setExpected(call);
}
public void setupCallReturn( Object result ) {
@@ -43,9 +42,8 @@
callThrow = thrown;
}
- public Object call(String methodName, Object[] args) throws Throwable {
- callMethodName.setActual(methodName);
- callArgs.addActualMany(args);
+ public Object call( ActiveCall call ) throws Throwable {
+ callCall.setActual(call);
callCount.inc();
if( callThrow != null ) {
@@ -55,9 +53,8 @@
}
}
- public void setExpectedMatches( String methodName, Object[] args ) {
- matchesMethodName.setExpected(methodName);
- matchesArgs.addExpectedMany(args);
+ public void setExpectedMatches( ActiveCall call )...
[truncated message content] |