mockobjects-java-dev

[Nat P. <np...@us...>]

Update of /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic
In directory usw-pr-cvs1:/tmp/cvs-serv31724/src/core/test/mockobjects/dynamic

Added Files:
	CallSequenceTest.java 
Log Message:
Added CallSequence class that tests sequences of calls to a method

--- NEW FILE: CallSequenceTest.java ---
/** Created on Oct 31, 2002 by npryce
 *  Copyright (c) B13media Ltd.
 */
package test.mockobjects.dynamic;

import junit.framework.AssertionFailedError;

import com.mockobjects.dynamic.CallSequence;
import com.mockobjects.dynamic.Mock;
import com.mockobjects.dynamic.MockCall;
import com.mockobjects.dynamic.P;
import com.mockobjects.util.TestCaseMo;

public class CallSequenceTest 
    extends TestCaseMo 
{
    public CallSequenceTest(String name) {
        super(name);
    }
    
    public void testCallListInitiallyExpectsNoCalls()
        throws Throwable
    {
        CallSequence call_list = new CallSequence();
        call_list.verify();
    }
    
    public void testCallToEmptyCallListFails()
        throws Throwable
    {
        CallSequence call_list = new CallSequence();
        try {
            call_list.call( new Object[0] );
        }
        catch( AssertionFailedError expected ) {
            return;
        }
        
        fail( "call to empty call list should fail" );
    }
    
    public void testCallListPassesArguments()
        throws Throwable
    {
        Mock mock_call_1 = new Mock();
        Mock mock_call_2 = new Mock();
        CallSequence call_list = new CallSequence();
        final Object[] ARGS_1 = { new Object() };
        final Object[] ARGS_2 = { new Object() };
        
        mock_call_1.expectVoid( "call", P.args( P.same(ARGS_1) ) );
        call_list.expect(
            (MockCall)mock_call_1.createInterface(MockCall.class) );
            
        mock_call_2.expectVoid( "call", P.args( P.same(ARGS_2) ) );
        call_list.expect(
            (MockCall)mock_call_2.createInterface(MockCall.class) );
        
        
        call_list.call( ARGS_1 );
        call_list.call( ARGS_2 );
        mock_call_1.verify();
        mock_call_2.verify();
        call_list.verify();
    }

    public void testCallListReturnsValue() 
        throws Throwable 
    {
        Mock mock_call_1 = new Mock();
        Mock mock_call_2 = new Mock();
        CallSequence call_list = new CallSequence();
        final Object[] ARGS_1 = { new Object() };
        final Object[] ARGS_2 = { new Object() };
        final Object RESULT_1 = new Object();
        final Object RESULT_2 = new Object();
        
        mock_call_1.expectReturn( "call", P.args(P.same(ARGS_1)), RESULT_1 );
        call_list.expect(
            (MockCall)mock_call_1.createInterface(MockCall.class) );
            
        mock_call_2.expectReturn( "call", P.args(P.eq(ARGS_2)), RESULT_2 );
        call_list.expect(
            (MockCall)mock_call_2.createInterface(MockCall.class) );
        
        
        assertSame( RESULT_1, call_list.call( ARGS_1 ) );
        assertSame( RESULT_2, call_list.call( ARGS_2 ) );
        
        mock_call_1.verify();
        mock_call_2.verify();
        call_list.verify();
    }

    public void testCallListThrowsExceptionValue() 
        throws Throwable 
    {
        Mock mock_call_1 = new Mock();
        Mock mock_call_2 = new Mock();
        CallSequence call_list = new CallSequence();
        final Object[] ARGS_1 = { new Object() };
        final Object[] ARGS_2 = { new Object() };
        final ExampleException EXCEPTION_1 = new ExampleException();
        final ExampleException EXCEPTION_2 = new ExampleException();
        
        mock_call_1.expectThrow( "call", P.args(P.same(ARGS_1)), EXCEPTION_1 );
        call_list.expect(
            (MockCall)mock_call_1.createInterface(MockCall.class) );
            
        mock_call_2.expectThrow( "call", P.args(P.eq(ARGS_2)), EXCEPTION_2 );
        call_list.expect(
            (MockCall)mock_call_2.createInterface(MockCall.class) );
        
        try {
            call_list.call( ARGS_1 );
            fail("expected ExampleException to be thrown");
        }
        catch( ExampleException ex ) {
            assertSame( EXCEPTION_1, ex );
        }
        
        try {
            call_list.call( ARGS_2 );
            fail("expected ExampleException to be thrown");
        }
        catch( ExampleException ex ) {
            assertSame( EXCEPTION_2, ex );
        }
        
        mock_call_1.verify();
        mock_call_2.verify();
        call_list.verify();
    }
    
    static final MockCall CALL = new MockCall() {
        public Object call( Object[] args ) throws Throwable {
            return Mock.VOID;
        }
    };
    
    static final Object[] NO_ARGS = {};

    public void testTooManyCalls()
        throws Throwable
    {
        CallSequence call_list = new CallSequence();
        
        call_list.expect(CALL);
        call_list.expect(CALL);
        
        call_list.call( NO_ARGS );
        call_list.call( NO_ARGS );
        try {
            call_list.call( NO_ARGS );
        }
        catch( AssertionFailedError expected ) {
            return;
        }
        
        fail("third call should have failed");
    }
    
    public void testTooFewCalls()
        throws Throwable
    {
        CallSequence call_list = new CallSequence();
        
        call_list.expect(CALL);
        call_list.expect(CALL);
        
        call_list.call( NO_ARGS );
        try {
            call_list.verify();
        }
        catch( AssertionFailedError expected ) {
            return;
        }
        
        fail("verify should have failed");
    }
    
    private static class ExampleException extends Exception {
    }
}