Menu
▾
▴
[MO-java-dev] CVS: mockobjects-java/src/core/test/mockobjects/dynamic ExpectedCallTest.java,1.1,1.2 MockCallable.java,1.1,1.2 CTest.java,1.1,1.2 ConstraintMatcherTest.java,1.1,1.2 DummyInterface.java,1.1,1.2 CallBagTest.java,1.1,1.2 DummyThrowable.java,1.1,1.2 CallMatchTest.java,1.1,1.2 MockCallableAddable.java,1.1,1.2 ErrorMessageExamples.java,1.1,1.2 CallSequenceTest.java,1.5,1.6 StubTest.java,1.1,1.2 MockCallFactory.java,1.1,1.2 DynamicUtilTest.java,1.1,1.2 MockConstraintMatcher.java,1.1,1.2 MockConstraint.java,1.1,1.2 MockTest.java,1.8,1.9 CallCounterTest.java,1.5,NONE CallCollectionTest.java,1.1,NONE
Update of /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic
In directory sc8-pr-cvs1:/tmp/cvs-serv25351/core/test/mockobjects/dynamic
Modified Files:
MockTest.java
Added Files:
ExpectedCallTest.java MockCallable.java CTest.java
ConstraintMatcherTest.java DummyInterface.java
CallBagTest.java DummyThrowable.java CallMatchTest.java
MockCallableAddable.java ErrorMessageExamples.java
CallSequenceTest.java StubTest.java MockCallFactory.java
DynamicUtilTest.java MockConstraintMatcher.java
MockConstraint.java
Removed Files:
CallCounterTest.java CallCollectionTest.java
Log Message:
Integration with branch DynamicMockExperiment.
If you have problems - you can revert to Version 08.
Index: MockTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockTest.java,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -r1.8 -r1.9
--- MockTest.java 12 Nov 2002 17:42:38 -0000 1.8
+++ MockTest.java 18 May 2003 20:59:39 -0000 1.9
@@ -1,563 +1,412 @@
-/* Copyright (c) 2002 Nat Pryce. All rights reserved.
- *
- * Created on February 11, 2002, 12:34 AM
+/*
+ * Created on 04-Apr-2003
*/
package test.mockobjects.dynamic;
-import java.lang.reflect.Method;
-import java.lang.reflect.Proxy;
-import junit.framework.AssertionFailedError;
-
-import com.mockobjects.dynamic.*;
import com.mockobjects.constraint.*;
-import com.mockobjects.util.TestCaseMo;
+import com.mockobjects.constraint.IsEqual;
+import com.mockobjects.dynamic.*;
+import com.mockobjects.util.*;
+
+import junit.framework.*;
+
+
+public class MockTest extends TestCase {
+ private static final String MOCK_NAME = "Test mock";
+ final String METHOD_NOARG_NAME = "noArgMethodVoid";
+ final String METHOD_NOARGANDRETURN_NAME = "noArgMethod";
+ final String METHOD_NOARGANDRETURN_RESULT = "resultNoArgs";
+ final 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 ConstraintMatcher METHOD_ONEARG_CONSTRAINTS = C.args(C.eq("oneP1"));
+ final String[] METHOD_TWOARG_ARGS = new String[] { "twoP1", "twoP2" };
+ final ConstraintMatcher METHOD_TWOARG_CONSTRAINTS = C.args(C.eq("twoP1"), C.eq("twoP2"));
+ private DummyInterface proxy;
+ private Mock mock;
+ private MockCallFactory mockCallFactory = new MockCallFactory();
+ private MockCallable mockCallMatch = new MockCallable();
+ private MockCallable mockExpectedCall = new MockCallable();
+ private MockCallable mockReturnStub = new MockCallable();
+ private MockCallable mockThrowStub = new MockCallable();
+ private MockCallable mockVoidStub = new MockCallable();
+ private MockCallableAddable mockCallableAddable = new MockCallableAddable();
+
+ public MockTest(String name) throws Exception {
+ super(name);
+ }
+
+ public void setUp() {
+ mock = new Mock(mockCallFactory, mockCallableAddable, DummyInterface.class, MOCK_NAME);
+
+ try {
+ proxy = (DummyInterface)mock.proxy();
+ } catch (ClassCastException ex) {
+ fail("proxy is not of expected interface type");
+ }
+ }
+
+ public void testExpectManyAndVoid() throws Throwable {
+ mockCallFactory.setExpectedCreateVoidStubCalls(1);
+ mockCallFactory.setupCreateVoidStub(mockVoidStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockVoidStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
+ mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
+
+ mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
+
+ mock.expect(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testExpectNoneAndReturn() throws Throwable {
+ mockCallFactory.addExpectedCreateReturnStub(METHOD_NOARGANDRETURN_RESULT);
+ mockCallFactory.setupCreateReturnStub(mockReturnStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_NOARGANDRETURN_NAME, C.NO_ARGS, mockReturnStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
+ mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
+
+ mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
+
+ mock.expectAndReturn(METHOD_NOARGANDRETURN_NAME, METHOD_NOARGANDRETURN_RESULT);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testExpectNoneAndThrow() throws Throwable {
+ mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
+ mockCallFactory.setupCreateThrowStub(mockThrowStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_NOARGANDRETURN_NAME, C.NO_ARGS, mockThrowStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
+ mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
+
+ mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
+
+ mock.expectAndThrow(METHOD_NOARGANDRETURN_NAME, METHOD_EXCEPTION);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testExpectOneAndThrow() throws Throwable {
+ mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
+ mockCallFactory.setupCreateThrowStub(mockThrowStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
+ mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
+
+ mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
+
+ mock.expectAndThrow(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_EXCEPTION);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testExpectNoneAndVoid() throws Throwable {
+ mockCallFactory.setExpectedCreateVoidStubCalls(1);
+ mockCallFactory.setupCreateVoidStub(mockVoidStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_NOARG_NAME, C.NO_ARGS, mockVoidStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
+ mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
+
+ mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
+
+ mock.expect(METHOD_NOARG_NAME);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testExpectOneAndVoid() throws Throwable {
+ mockCallFactory.setExpectedCreateVoidStubCalls(1);
+ mockCallFactory.setupCreateVoidStub(mockVoidStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
+ mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
+
+ mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
+
+ mock.expect(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0]);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testExpectWithConstraint() throws Throwable {
+ mockCallFactory.setupCreateVoidStub(mockVoidStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
+
+ mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
+
+ mock.expect(METHOD_ONEARG_NAME, new IsEqual(METHOD_ONEARG_ARGS[0]));
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testExpectWithConstraintArray() throws Throwable {
+ mockCallFactory.setupCreateVoidStub(mockVoidStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockVoidStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
+
+ mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
+
+ mock.expect(METHOD_ONEARG_NAME, new Constraint[] { new IsEqual(METHOD_ONEARG_ARGS[0])});
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
+ }
+
+
+ public void testExpectManyAndReturn() throws Throwable {
+ mockCallFactory.addExpectedCreateReturnStub(METHOD_TWOARG_RESULT);
+ mockCallFactory.setupCreateReturnStub(mockReturnStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockReturnStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
+ mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
+
+ mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
+ mockCallableAddable.setupCall(METHOD_TWOARG_RESULT);
+
+ mock.expectAndReturn(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_TWOARG_RESULT);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testExpectManyAndThrow() throws Throwable {
+ mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
+ mockCallFactory.setupCreateThrowStub(mockThrowStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockThrowStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
+ mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
+
+ mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
+ mockCallableAddable.setupCall(METHOD_TWOARG_RESULT);
+
+ mock.expectAndThrow(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testExpectOneAndReturn() throws Throwable {
+ mockCallFactory.addExpectedCreateReturnStub(METHOD_ONEARG_RESULT);
+ mockCallFactory.setupCreateReturnStub(mockReturnStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+ mockCallFactory.addExpectedCreateExpectedCall(mockCallMatch);
+ mockCallFactory.setupCreateExpectedCall(mockExpectedCall);
+
+ mockCallableAddable.addExpectedAddExpect(mockExpectedCall);
+ mockCallableAddable.setupCall(METHOD_ONEARG_RESULT);
+
+ mock.expectAndReturn(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_ONEARG_RESULT);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testMatchManyAndReturn() throws Throwable {
+ mockCallFactory.addExpectedCreateReturnStub(METHOD_TWOARG_RESULT);
+ mockCallFactory.setupCreateReturnStub(mockReturnStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockReturnStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+
+ mockCallableAddable.addExpectedAddMatch(mockCallMatch);
+ mockCallableAddable.setupCall(METHOD_TWOARG_RESULT);
+
+ mock.matchAndReturn(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_TWOARG_RESULT);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testMatchNoneAndThrow() throws Throwable {
+ mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
+ mockCallFactory.setupCreateThrowStub(mockThrowStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_NOARG_NAME, C.NO_ARGS, mockThrowStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+
+ mockCallableAddable.addExpectedAddMatch(mockCallMatch);
+ mockCallableAddable.setupCall(METHOD_NOARGANDRETURN_RESULT);
+
+ mock.matchAndThrow(METHOD_NOARG_NAME, METHOD_EXCEPTION);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testMatchOneAndThrow() throws Throwable {
+ mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
+ mockCallFactory.setupCreateThrowStub(mockThrowStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockThrowStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+
+ mockCallableAddable.addExpectedAddMatch(mockCallMatch);
+ mockCallableAddable.setupCall(METHOD_ONEARG_RESULT);
+
+ mock.matchAndThrow(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_EXCEPTION);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testMatchManyAndThrow() throws Throwable {
+ mockCallFactory.addExpectedCreateThrowStub(METHOD_EXCEPTION);
+ mockCallFactory.setupCreateThrowStub(mockThrowStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, mockThrowStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+
+ mockCallableAddable.addExpectedAddMatch(mockCallMatch);
+ mockCallableAddable.setupCall(METHOD_TWOARG_RESULT);
+
+ mock.matchAndThrow(METHOD_TWOARG_NAME, METHOD_TWOARG_CONSTRAINTS, METHOD_EXCEPTION);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testMatchOneAndReturn() throws Throwable {
+ mockCallFactory.addExpectedCreateReturnStub(METHOD_ONEARG_RESULT);
+ mockCallFactory.setupCreateReturnStub(mockReturnStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_ONEARG_NAME, METHOD_ONEARG_CONSTRAINTS, mockReturnStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+
+ mockCallableAddable.addExpectedAddMatch(mockCallMatch);
+ mockCallableAddable.setupCall(METHOD_ONEARG_RESULT);
+
+ mock.matchAndReturn(METHOD_ONEARG_NAME, METHOD_ONEARG_ARGS[0], METHOD_ONEARG_RESULT);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testMatchNoneAndReturn() throws Throwable {
+ mockCallFactory.addExpectedCreateReturnStub(METHOD_NOARGANDRETURN_RESULT);
+ mockCallFactory.setupCreateReturnStub(mockReturnStub);
+ mockCallFactory.addExpectedCreateCallMatch(METHOD_NOARG_NAME, C.NO_ARGS, mockReturnStub);
+ mockCallFactory.setupCreateCallMatch(mockCallMatch);
+
+ mockCallableAddable.addExpectedAddMatch(mockCallMatch);
+ mockCallableAddable.setupCall(METHOD_ONEARG_RESULT);
+
+ mock.matchAndReturn(METHOD_NOARG_NAME, METHOD_NOARGANDRETURN_RESULT);
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testMockAnnotatesAssertionFailedErrors()
+ throws Throwable {
+ final String originalMessage = "original message";
+
+ mockCallableAddable.setupCall(new AssertionFailedError(originalMessage));
+
+ try {
+ proxy.noArgMethodVoid();
+ } catch (AssertionFailedError err) {
+ AssertMo.assertIncludes("should contain original message", originalMessage, err.getMessage());
+ AssertMo.assertIncludes("should contain mock name", MOCK_NAME, err.getMessage());
+ }
+ }
+
+ public void testMockNameFromClass() throws Exception {
+ assertEquals("mockString", Mock.mockNameFromClass(String.class));
+ }
+
+ public void testMockProxyReturnsConfiguredResult()
+ throws Throwable {
+ final String result = "configured result";
+
+ mockCallableAddable.setupCall(result);
+
+ assertSame("result is returned by mock", result, proxy.oneArgMethod(METHOD_TWOARG_ARGS[0]));
+ }
+
+ public void testMockProxySendsAllArgument() throws Throwable {
+ mockCallableAddable.addExpectedCall(mock, METHOD_TWOARG_NAME, METHOD_TWOARG_ARGS);
+ mockCallableAddable.setupCall("result ignored");
+
+ proxy.twoArgMethod(METHOD_TWOARG_ARGS[0], METHOD_TWOARG_ARGS[1]);
+
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testMockProxySendsEmptyArrayWhenNoArguments()
+ throws Exception {
+ mockCallableAddable.addExpectedCall(mock, METHOD_NOARG_NAME, METHOD_NOARG_ARGS);
+ mockCallableAddable.setupCall("result ignored");
+
+ proxy.noArgMethodVoid();
+
+ Verifier.verifyObject(this);
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testMockProxyThrowsConfiguredExceptions()
+ throws Throwable {
+ final Throwable throwable = new DummyThrowable();
+
+ mockCallableAddable.setupCall(new ThrowStub(throwable));
+
+ try {
+ proxy.noArgMethodVoid();
+ } catch (Throwable ex) {
+ assertSame("exception is caught by mock", throwable, ex);
+ }
+ }
+
+ public void testMockToStringContainsName() {
+ AssertMo.assertIncludes("result of toString() should include name", MOCK_NAME, mock.toString());
+ }
+
+ public void testMockVerifies() throws Exception {
+ mockCallableAddable.setExpectedVerifyCalls(1);
+ mock.verify();
-public class MockTest
- extends TestCaseMo
-{
- public static interface ExampleInterface {
- Object noArgs();
- void voidMethod();
- String objectTypes( Integer i );
- int primitiveTypes( int x, int y );
- void sideEffect( StringBuffer buf );
-
- // These are used to test default return values
- boolean booleanResult();
- byte byteResult();
- char charResult();
- short shortResult();
- int intResult();
- long longResult();
- float floatResult();
- double doubleResult();
- String stringResult();
-
- // Used to test ordered calls
- void first();
- void second();
- }
-
- private Mock _mock;
- private ExampleInterface _interface;
-
-
- public MockTest( String test ) {
- super(test);
- }
-
- public void setUp() {
- _mock = new Mock( ExampleInterface.class );
- _interface = (ExampleInterface)_mock.proxy();
- }
-
- public void tearDown() {
- _mock = null;
- _interface = null;
- }
-
- public void testNewMockVerifies() {
- _mock.verify();
- }
-
- public void testMockCallToNoArgMethod() {
- Object result = new Object();
-
- _mock.expectAndReturn( "noArgs", Mock.NO_ARGS, result );
-
- assertSame( result, _interface.noArgs() );
-
- _mock.verify();
- }
-
- public void testMockCallToVoidMethod() {
- _mock.expectVoid( "voidMethod", Mock.NO_ARGS );
-
- _interface.voidMethod();
-
- _mock.verify();
- }
-
- public void testObjectTypes() {
- _mock.expectAndReturn( "objectTypes",
- new Constraint[] { new IsEqual( new Integer(1) ) },
- "1" );
-
- assertEquals( "1", _interface.objectTypes( new Integer(1) ) );
- _mock.verify();
- }
-
- public void testPrimitiveTypes() {
- _mock.expectAndReturn( "primitiveTypes",
- new Constraint[] { new IsEqual( new Integer(2) ),
- new IsEqual( new Integer(3) ) },
- new Integer(6) );
-
- assertEquals( 6, _interface.primitiveTypes(2,3) );
- _mock.verify();
- }
-
- public void testLaterExpectationsOverrideEarlierExpectations() {
- Object result1 = new Object();
- Object result2 = new Object();
-
- _mock.expectAndReturn( "noArgs", Mock.NO_ARGS, result1 );
- _mock.expectAndReturn( "noArgs", Mock.NO_ARGS, result2 );
-
- assertSame( result2, _interface.noArgs() );
- assertSame( result2, _interface.noArgs() );
- _mock.verify();
- }
-
- public void testThrow() {
- _mock.expectAndThrow( "primitiveTypes",
- new Constraint[] { new IsEqual( new Integer(2) ),
- new IsEqual( new Integer(3) ) },
- new ArithmeticException("message") );
-
- try {
- _interface.primitiveTypes( 2, 3 );
- fail( "expected ArithmeticException to be thrown" );
- }
- catch( ArithmeticException ex ) {
- assertEquals( "message", ex.getMessage() );
- }
-
- _mock.verify();
- }
-
- public void testExpectCallWithSideEffect() {
- final StringBuffer buf = new StringBuffer();
- _mock.expect( "sideEffect", new MockCall() {
- public Object call( Object[] args ) throws Throwable {
- assertSame( "wrong buffer", buf, args[0] );
- buf.append("hello");
- return Mock.VOID;
- }
- } );
-
- _interface.sideEffect( buf );
- assertEquals( "hello", buf.toString() );
- _mock.verify();
- }
-
- public void testFailingExpectationInCallWithSideEffect() {
- final StringBuffer buf = new StringBuffer();
- _mock.expect( "sideEffect", new MockCall() {
- public Object call( Object[] args ) throws Throwable {
- assertSame( "wrong buffer", buf, args[0] );
- buf.append("hello");
- return Mock.VOID;
- }
- } );
-
- assertFails( "should fail with wrong buffer", new Runnable() {
- public void run() {
- _interface.sideEffect( new StringBuffer() );
- }
- } );
- }
-
- public void testNotAllMethodsCalled() {
- _mock.expectVoid("noArgs", Mock.NO_ARGS);
-
- assertFails("verify did not fail when not all of the expected methods were called",
- new Runnable() {
- public void run() { _mock.verify(); }
- });
- }
-
- public void testCalledExpectationClearedBySubsequentExpecation() {
- _mock.expectVoid( "voidMethod", Mock.NO_ARGS );
- _interface.voidMethod();
- _mock.expectVoid( "voidMethod", Mock.NO_ARGS );
-
- assertFails("verify did not fail when not all of the expected methods were called",
- new Runnable() {
- public void run() { _mock.verify(); }
- });
- }
-
- public void testUnexpectedMethodThrowsWhenStrict() {
- _mock.setStrict(true);
-
- assertFails("strict mock did not fail when unexpected method was called",
- new Runnable() {
- public void run() { _interface.voidMethod();}
- });
- }
-
- public void testUnexpectedMethodDoesNotThrowWhenNotStrict() {
- try {
- _interface.voidMethod();
- }
- catch( AssertionFailedError ex ) {
- fail( "unstrict mock failed when unexpected method was called" );
- }
- }
-
- public void testDefaultResultFromUnexpectedCalls() {
- assertEquals( false, _interface.booleanResult() );
- assertEquals( 0, _interface.byteResult() );
- assertEquals( '\0', _interface.charResult() );
- assertEquals( 0, _interface.shortResult() );
- assertEquals( 0, _interface.intResult() );
- assertEquals( 0L, _interface.longResult() );
- assertEquals( 0.0f, _interface.floatResult(), 0.0f );
- assertEquals( 0.0d, _interface.doubleResult(), 0.0d );
- assertEquals( "", _interface.stringResult() );
- }
-
- public void testSetupDefaultResult() {
- _mock.setupDefaultResult( boolean.class, new Boolean(true) );
- _mock.setupDefaultResult( byte.class, new Byte((byte)1) );
- _mock.setupDefaultResult( char.class, new Character( '2' ) );
- _mock.setupDefaultResult( short.class, new Short( (short)3 ) );
- _mock.setupDefaultResult( int.class, new Integer(4) );
- _mock.setupDefaultResult( long.class, new Long(5L) );
- _mock.setupDefaultResult( float.class, new Float(6.0f) );
- _mock.setupDefaultResult( double.class, new Double(7.0d) );
- _mock.setupDefaultResult( String.class, "8" );
-
- assertEquals( true, _interface.booleanResult() );
- assertEquals( (byte)1, _interface.byteResult() );
- assertEquals( '2', _interface.charResult() );
- assertEquals( 3, _interface.shortResult() );
- assertEquals( 4, _interface.intResult() );
- assertEquals( 5L, _interface.longResult() );
- assertEquals( 6.0f, _interface.floatResult(), 0.0f );
- assertEquals( 7.0d, _interface.doubleResult(), 0.0d );
- assertEquals( "8", _interface.stringResult() );
- }
-
- public void testWrongNumberOfArguments() {
- Constraint p = new IsEqual( new Integer(2) );
- Constraint q = new IsAnything();
-
- _mock.expectAndReturn( "objectTypes", new Constraint[]{p,q}, "2" );
-
- assertFails( "mock did not fail when wrong number of arguments passed",
- new Runnable() {
- public void run() { _interface.objectTypes( new Integer(1) ); }
- });
- }
-
- public void testArgumentsPassedToNoArgMethod() {
- Constraint p = new IsAnything();
-
- _mock.expectVoid( "voidMethod", new Constraint[]{p} );
-
- try {
- _interface.voidMethod();
- }
- catch( AssertionFailedError ex ) {
- return;
- }
-
- fail( "mock did not fail when arguments passed to void method" );
- }
-
- public void testPredicateFailure() {
- Constraint p = new IsEqual( new Integer(2) );
-
- _mock.expectAndReturn( "objectTypes", new Constraint[]{p}, "2" );
-
- assertTrue( !p.eval( new Integer(1) ) );
- try {
- _interface.objectTypes( new Integer(1) );
- }
- catch( AssertionFailedError ex ) {
- return;
- }
-
- fail( "mock did not fail when predicate returned false" );
- }
-
- public void testErrorWhenOrderedMethodsCalledInWrongOrder() {
- _mock.expectVoid( "first", Mock.NO_ARGS );
- _mock.expectVoid( "second", Mock.NO_ARGS );
-
- _mock.order( "first", "second" );
-
- try {
- _interface.second();
- }
- catch( AssertionFailedError ex ) {
- return;
- }
-
- fail( "mock did not enforce order of calls" );
- }
-
- public void testExpectNotCalled() {
- _mock.expectNotCalled("noArgs");
- try {
- _interface.noArgs();
- }
- catch( AssertionFailedError ex ) {
- return;
- }
-
- fail("AssertionFailedError expected");
- }
-
- public void testExpectNotCalledClearedBySubsequentExpectation() {
- _mock.expectNotCalled("voidMethod");
- _mock.expectVoid( "voidMethod", Mock.NO_ARGS );
-
- _interface.voidMethod();
-
- _mock.verify();
- }
-
- public void testSetupResult() {
- final String RESULT = "result";
-
- _mock.setupResult( "objectTypes", RESULT );
-
- assertEquals( RESULT, _interface.objectTypes(null) );
- assertEquals( RESULT, _interface.objectTypes(new Integer(0)) );
-
- _mock.verify();
- }
-
- public void testSetupThrow() {
- _mock.setupThrow( "objectTypes", new IllegalArgumentException() );
-
- try {
- _interface.objectTypes(null);
- fail("expected IllegalArgumentException");
- }
- catch( IllegalArgumentException ex ) {
- // expected
- }
-
- try {
- _interface.objectTypes(new Integer(0));
- fail("expected IllegalArgumentException");
- }
- catch( IllegalArgumentException ex ) {
- // expected
- }
-
- _mock.verify();
- }
-
- public void testSetupCallWithSideEffect() {
- final StringBuffer buf = new StringBuffer();
- _mock.setup( "sideEffect", new MockCall() {
- public Object call( Object[] args ) throws Throwable {
- buf.append("hello");
- return Mock.VOID;
- }
- } );
-
- _interface.sideEffect( buf );
- assertEquals( "hello", buf.toString() );
- _mock.verify();
- }
-
- public void testSetupResultDoesNotRequireCall() {
- _mock.setupResult( "objectTypes", "result" );
- _mock.verify();
- }
-
- public void testSetupThrowDoesNotRequireCall() {
- _mock.setupThrow( "objectTypes", new RuntimeException() );
- _mock.verify();
- }
-
- public void testSetupCallWithSideEffectDoesNotRequireCall() {
- _mock.setup( "sideEffect", new MockVoidCall() {
- public Object call( Object[] args ) throws Throwable {
- throw new RuntimeException("should not be called");
- }
- } );
-
- _mock.verify();
- }
-
- public void testNoErrorWhenOrderedMethodsCalledInCorrectOrder() {
- _mock.expectVoid( "first", Mock.NO_ARGS );
- _mock.expectVoid( "second", Mock.NO_ARGS );
-
- _mock.order( "first", "second" );
-
- _interface.first();
- _interface.second();
- }
-
- public void testErrorWhenMockedVoidMethodReturnsAValue() {
- _mock.expectAndReturn( "voidMethod", Mock.NO_ARGS, Boolean.TRUE );
-
- try {
- _interface.voidMethod();
- }
- catch( AssertionFailedError ex ) {
- return;
- }
- fail("should have thrown AssertionFailedError when return from void method");
- }
-
- public void testEquals() {
- assertEquals("Same interface should have same hashcode", _interface.hashCode(), _interface.hashCode());
- assertEquals("Same interface should be equal", _interface, _interface);
- }
-
- public static interface Interface1 {
- void method1();
- }
-
- public static interface Interface2 {
- void method2();
- }
-
- public static interface Interface3 {
- void method3();
- }
-
- public static interface Interface4 {
- void method4();
- }
-
- public static interface Interface5 {
- void method5();
- }
-
- public void testMockTwoInterfaces() {
- Mock mock = new Mock( Interface1.class, Interface2.class );
- assertInstanceOf( Interface1.class, mock.proxy() );
- assertInstanceOf( Interface2.class, mock.proxy() );
- }
-
- public void testMockThreeInterfaces() {
- Mock mock = new Mock( Interface1.class, Interface2.class,
- Interface3.class );
- assertInstanceOf( Interface1.class, mock.proxy() );
- assertInstanceOf( Interface2.class, mock.proxy() );
- assertInstanceOf( Interface3.class, mock.proxy() );
- }
-
- public void testMockFourInterfaces() {
- Mock mock = new Mock( Interface1.class, Interface2.class,
- Interface3.class, Interface4.class );
- assertInstanceOf( Interface1.class, mock.proxy() );
- assertInstanceOf( Interface2.class, mock.proxy() );
- assertInstanceOf( Interface3.class, mock.proxy() );
- assertInstanceOf( Interface4.class, mock.proxy() );
- }
-
- public void testMockFiveInterfaces() {
- Mock mock = new Mock( new Class[] {
- Interface1.class, Interface2.class, Interface3.class,
- Interface4.class, Interface5.class } );
-
- assertInstanceOf( Interface1.class, mock.proxy() );
- assertInstanceOf( Interface2.class, mock.proxy() );
- assertInstanceOf( Interface3.class, mock.proxy() );
- assertInstanceOf( Interface4.class, mock.proxy() );
- assertInstanceOf( Interface5.class, mock.proxy() );
- }
-
- private static void assertInstanceOf( Class klass, Object o ) {
- assertTrue( o + " should be an instance of " + klass,
- klass.isInstance(o) );
- }
-
- public void testFailureWhenExpectMethodNotOnMockedInterfaces() {
- final Mock mock = new Mock( Interface1.class, Interface2.class );
-
- assertFails( "should fail with bad method name", new Runnable() {
- public void run() {
- mock.expectVoid( "CeciNestPasUneMethode", Mock.NO_ARGS );
- }
- } );
- }
-
- public void testFailureWhenSetupMethodNotOnMockedInterfaces() {
- final Mock mock = new Mock( Interface1.class, Interface2.class );
-
- assertFails( "should fail with bad method name", new Runnable() {
- public void run() {
- mock.setupResult( "CeciNestPasUneMethode", new Object() );
- }
- } );
- }
-
- public void testFailureWhenExpectNotCalledMethodNotOnMockedInterfaces() {
- final Mock mock = new Mock( Interface1.class, Interface2.class );
-
- assertFails( "should fail with bad method name", new Runnable() {
- public void run() {
- mock.expectNotCalled( "CeciNestPasUneMethode" );
- }
- } );
- }
-
- public void testFailureWhenOrderMethodNotOnMockedInterfaces() {
- final Mock mock = new Mock( Interface1.class, Interface2.class );
-
- assertFails( "should fail with bad first method name", new Runnable() {
- public void run() {
- mock.order( "CeciNestPasUneMethode", "method2" );
- }
- } );
- assertFails( "should fail with bad second method name", new Runnable() {
- public void run() {
- mock.order( "method1", "CeciNestPasUneMethode" );
- }
- } );
- }
-
-
-
- public static class DerivedMock
- extends Mock
- {
- public boolean was_called = false;
-
- public DerivedMock() {
- super( ExampleInterface.class );
- }
-
- public void voidMethod() {
- this.was_called = true;
- }
-
- public String objectTypes( Integer n ) throws Throwable {
- Method method = getClass().getMethod("objectTypes", new Class[] { Integer.class } );
- return (String)mockCall(method , new Object[]{n} );
- }
- };
-
- public void testDerivedMockClass() {
- DerivedMock mock = new DerivedMock();
- ExampleInterface i = (ExampleInterface)Proxy.newProxyInstance(
- getClass().getClassLoader(),
- new Class[]{ ExampleInterface.class },
- mock );
-
- i.voidMethod();
-
- assertTrue( "mock method not called on derived class",
- mock.was_called );
- mock.verify();
- }
-
- public void testDerivedClassPassingInvocationToMockCall() {
- DerivedMock mock = new DerivedMock();
- ExampleInterface i = (ExampleInterface)Proxy.newProxyInstance(
- getClass().getClassLoader(),
- new Class[]{ ExampleInterface.class },
- mock );
-
- mock.expectAndReturn( "objectTypes",
- new Constraint[] { new IsAnything() },
- "result" );
-
- assertEquals( "result", i.objectTypes( new Integer(1) ) );
-
- mock.verify();
- }
+ mockCallableAddable.verifyExpectations();
+ }
+
+ public void testProxyEquality() throws Exception {
+ assertTrue("Should handle proxy equality without checking expectations", proxy.equals(proxy));
+ }
+
+ public void testProxyInEquality() throws Exception {
+ boolean IGNORED_RESULT = true;
+ CallStub ret = new ReturnStub(new Boolean(IGNORED_RESULT));
+ mockCallFactory.setupCreateReturnStub(ret);
+ mockCallFactory.setupCreateCallMatch(new CallMatch("call",C.anyArgs(1),ret));
+ mockCallableAddable.setupCall(new Boolean(false));
+
+ mock.matchAndReturn("call", C.anyArgs(1), IGNORED_RESULT);
+ assertFalse("Should handle proxy inequality by calling through", proxy.equals("not a proxy"));
+
+ Verifier.verifyObject(this);
+ }
+
+ public void testProxyToString() throws Exception {
+ assertEquals("Should get a mock name without touching the underlying mock", MOCK_NAME, DynamicUtil.proxyToString(proxy));
+ mock.verify(); // should not fail on a proxyToString call
+ }
}
--- CallCounterTest.java DELETED ---
--- CallCollectionTest.java DELETED ---
|
