[MO-java-dev] CVS: mockobjects-java/src/core/test/mockobjects/dynamic Test_Predicates.java,NONE,1.1 Test_Mock.java,NONE,1.1

[Steve F. <sm...@us...>]

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

Added Files:
	Test_Predicates.java Test_Mock.java 
Log Message:
moved test classes to a new package

--- NEW FILE: Test_Predicates.java ---
/*  Copyright (c) 2002 Nat Pryce. All rights reserved.
 *  
 *  Created on February 10, 2002, 11:24 PM
 */
package test.mockobjects.dynamic;

import com.mockobjects.dynamic.*;

import java.util.EventObject;



public class Test_Predicates 
    extends junit.framework.TestCase
{
    class True implements Predicate {
        public boolean eval( Object o ) { return true; }
    }
    
    class False implements Predicate {
        public boolean eval( Object o ) { return false; }
    }
    
    /** Creates a new instance of Test_Predicates
      */
    public Test_Predicates( String test ) {
        super(test);
    }
    
    public void testIsNull() {
        Predicate p = new IsNull();
        
        assertTrue( p.eval(null) );
        assertTrue( !p.eval(new Object()) );
    }
    
    public void testIsSame() {
        Object o1 = new Object();
        Object o2 = new Object();
        Predicate p = new IsSame(o1);
        
        assertTrue( p.eval(o1) );
        assertTrue( !p.eval(o2) );
    }
    
    public void testIsEqual() {
        Integer i1 = new Integer(1);
        Integer i2 = new Integer(2);
        Predicate p = new IsEqual(i1);
        
        assertTrue( p.eval(i1) );
        assertTrue( p.eval( new Integer(1) ) );
        assertTrue( !p.eval(i2) );
    }
    
    public void testIsGreaterThan() {
        Predicate p = new IsGreaterThan( new Integer(1) );
        
        assertTrue( !p.eval( new Integer(0) ) );
        assertTrue( !p.eval( new Integer(1) ) );
        assertTrue( p.eval( new Integer(2) ) );
    }
    
    public void testIsLessThan() {
        Predicate p = new IsLessThan( new Integer(1) );
        
        assertTrue( p.eval( new Integer(0) ) );
        assertTrue( !p.eval( new Integer(1) ) );
        assertTrue( !p.eval( new Integer(2) ) );
    }
    
    public void testIsAnything() {
        Predicate p = new IsAnything();
        assertTrue( p.eval(null) );
        assertTrue( p.eval( new Object() ) );
    }
    
    public void testIsInstanceOf() {
        Predicate p = new IsInstanceOf( Number.class );
        assertTrue( p.eval( new Integer(1) ) );
        assertTrue( p.eval( new Double(1.0) ) );
        assertTrue( !p.eval("a string") );
        assertTrue( !p.eval(null) );
    }
    
    public void testIsNot() {
        Predicate p = new IsNot( new True() );
        assertTrue( !p.eval(null) );
        assertTrue( !p.eval( new Object() ) );
    }
    
    public void testAnd() {
        Object o = new Object();
        assertTrue( new And( new True(), new True() ).eval(o) );
        assertTrue( !new And( new False(), new True() ).eval(o) );
        assertTrue( !new And( new True(), new False() ).eval(o) );
        assertTrue( !new And( new False(), new False() ).eval(o) );
    }
    
    public void testOr() {
        Object o = new Object();
        assertTrue( new Or( new True(), new True() ).eval(o) );
        assertTrue( new Or( new False(), new True() ).eval(o) );
        assertTrue( new Or( new True(), new False() ).eval(o) );
        assertTrue( !new Or( new False(), new False() ).eval(o) );
    }
    
    public void testIsEventFrom() {
        Object o = new Object();
        EventObject ev = new EventObject(o);
        EventObject ev2 = new EventObject( new Object() );
        
        Predicate p = new IsEventFrom(o);
        
        assertTrue( p.eval(ev) );
        assertTrue( "p should eval to false for an event not from o",
                    !p.eval(ev2) );
        assertTrue( "p should eval to false for objects that are not events",
                    !p.eval(o) );
    }
    
    private static class DerivedEvent extends EventObject {
        public DerivedEvent( Object source ) {
            super(source);
        }
    }
    
    public void testIsEventSubtypeFrom() {
        Object o = new Object();
        DerivedEvent good_ev = new DerivedEvent(o);
        DerivedEvent wrong_source = new DerivedEvent(new Object());
        EventObject wrong_type = new EventObject(o);
        EventObject wrong_source_and_type = new EventObject(new Object());
        
        Predicate p = new IsEventFrom( DerivedEvent.class, o );
        
        assertTrue( p.eval(good_ev) );
        assertTrue( "p should eval to false for an event not from o",
                    !p.eval(wrong_source) );
        assertTrue( "p should eval to false for an event of the wrong type",
                    !p.eval(wrong_type) );
        assertTrue( "p should eval to false for an event of the wrong type "+
                    "and from the wrong source",
                    !p.eval(wrong_source_and_type) );
    }

    public void testIsCloseTo() {
        Predicate p = new IsCloseTo( 1.0, 0.5 );
        
        assertTrue( p.eval( new Double(1.0) ) );
        assertTrue( p.eval( new Double(0.5) ) );
        assertTrue( p.eval( new Double(1.5) ) );
        
        assertTrue( p.eval( new Float(1.0) ) );
        assertTrue( p.eval( new Integer(1) ) );
        
        assertTrue( "number too large", !p.eval( new Double(2.0) ) );
        assertTrue( "number too small", !p.eval( new Double(0.0) ) );
        
        try {
            p.eval("wrong type");
            fail("ClassCastException expected for wrong type of argument");
        }
        catch( ClassCastException ex ) {
            // expected
        }
    }
}

--- NEW FILE: Test_Mock.java ---
/*  Copyright (c) 2002 Nat Pryce. All rights reserved.
 *  
 *  Created on February 11, 2002, 12:34 AM
 */
package test.mockobjects.dynamic;

import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import junit.framework.AssertionFailedError;
import com.mockobjects.dynamic.*;


public class Test_Mock
    extends junit.framework.TestCase
{
    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();
    }
    
    public static class DerivedMock
        extends Mock
    {
        DerivedMock( String name ) {
            super(name);
        }
        
        public boolean was_called = false;
        
        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} );
        }
    };
    
    
    private Mock _mock;
    private ExampleInterface _interface;
    
    
    public Test_Mock( String test ) {
        super(test);
    }
    
    public void setUp() {
        _mock = new Mock();
        _interface = 
            (ExampleInterface)_mock.createInterface( ExampleInterface.class );
    }
    
    public void tearDown() {
        _mock = null;
        _interface = null;
    }
    
    public void testNewMockVerifies() {
        _mock.verify();
    }
    
    public void testNamedMock() {
        Mock mock = new Mock("Name");
        assertEquals( "Name", mock.toString() );
    }
    
    public void testMockCallToNoArgMethod() {
        Object result = new Object();
        
        _mock.expectReturn( "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.expectReturn( "objectTypes", 
                            new Predicate[] { new IsEqual( new Integer(1) ) },
                            "1" );
        
        assertEquals( "1", _interface.objectTypes( new Integer(1) ) );
        _mock.verify();
    }
    
    public void testPrimitiveTypes() {
        _mock.expectReturn( "primitiveTypes",
                            new Predicate[] { 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.expectReturn( "noArgs", Mock.NO_ARGS, result1 );
        _mock.expectReturn( "noArgs", Mock.NO_ARGS, result2 );
        
        assertSame( result2, _interface.noArgs() );
        assertSame( result2, _interface.noArgs() );
        _mock.verify();
    }
    
    public void testThrow() {
        _mock.expectThrow( "primitiveTypes",
                           new Predicate[] { 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 testExpectCallWithSideEffects() {
        final StringBuffer buf = new StringBuffer();
        _mock.expect( 
            new ExpectedCall( "sideEffect",
                              new Predicate[]{ new IsSame(buf) } )
            {
                public Object eval( Object[] args ) throws Throwable {
                    buf.append("hello");
                    return null;
                }
            } );
        
        _interface.sideEffect( buf );
        assertEquals( "hello", buf.toString() );
        _mock.verify();
    }
    
    public void testNotAllMethodsCalled() {
        _mock.expectVoid( "noArgs", Mock.NO_ARGS );
        
        try {
            _mock.verify();
        }
        catch( AssertionFailedError ex ) {
            return;
        }
        
        fail( "verify did not fail when all expected methods were not called" );
    }
    
    public void testCalledExpectationClearedBySubsequentExpecation() {
        _mock.expectVoid( "noArgs", Mock.NO_ARGS );
        _interface.noArgs();
        _mock.expectVoid( "noArgs", Mock.NO_ARGS );
        
        try {
            _mock.verify();
        }
        catch( AssertionFailedError ex ) {
            return;
        }
        
        fail( "verify did not fail when all expected methods were not called" );
    }
    
    public void testUnexpectedMethodThrowsWhenStrict() {
        _mock.setStrict(true);
        
        try {
            _interface.voidMethod();
        }
        catch( AssertionFailedError ex ) {
            return;
        }
        
        fail( "strict mock did not fail when unexpected method was called" );
    }

    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() {
        Predicate p = new IsEqual( new Integer(2) );
        Predicate q = new IsAnything();
        
        _mock.expectReturn( "objectTypes", new Predicate[]{p,q}, "2" );
        
        try {
            _interface.objectTypes( new Integer(1) );
        }
        catch( AssertionFailedError ex ) {
            return;
        }
        
        fail( "mock did not fail when wrong number of arguments passed" );
    }

    public void testArgumentsPassedToNoArgMethod() {
        Predicate p = new IsAnything();
        
        _mock.expectVoid( "voidMethod", new Predicate[]{p} );
        
        try {
            _interface.voidMethod();
        }
        catch( AssertionFailedError ex ) {
            return;
        }
        
        fail( "mock did not fail when arguments passed to void method" );
    }
    
    public void testPredicateFailure() {
        Predicate p = new IsEqual( new Integer(2) );
        
        _mock.expectReturn( "objectTypes", new Predicate[]{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("noArgs");
        _mock.expectVoid( "noArgs", Mock.NO_ARGS );
        
        _interface.noArgs();
        
        _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( new ExpectedCall("sideEffect") {
            public Object eval( Object[] args ) throws Throwable {
                buf.append("hello");
                return null;
            }
        } );
        
        _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( new ExpectedCall("sideEffect") {
            public Object eval( 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 testDerivedMockClass() {
        DerivedMock mock = new DerivedMock("Derived");
        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("Derived");
        ExampleInterface i = (ExampleInterface)Proxy.newProxyInstance(
            getClass().getClassLoader(),
            new Class[]{ ExampleInterface.class },
            mock );
        
        mock.expectReturn( "objectTypes", 
                           new Predicate[] { new IsAnything() },
                           "result" );
        
        assertEquals( "result", i.objectTypes( new Integer(1) ) );
        
        mock.verify();
    }
}