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-serv31865/src/core/test/mockobjects/dynamic

Modified Files:
	MockTest.java CallCounterTest.java CallSequenceTest.java 
Log Message:
Fixed tests broken by MethodExpectation class
Replaced createInterface methods with interface references passed to constructor, and the proxy() method to "cast" the mock to its proxy.

Index: MockTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/MockTest.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- MockTest.java	5 Nov 2002 16:26:59 -0000	1.4
+++ MockTest.java	6 Nov 2002 15:54:34 -0000	1.5
@@ -36,23 +36,7 @@
         void first();
         void second();
     }
-    
-    public static class DerivedMock
-        extends Mock
-    {
-        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;
     
@@ -62,9 +46,8 @@
     }
     
     public void setUp() {
-        _mock = new Mock();
-        _interface = 
-            (ExampleInterface)_mock.createInterface( ExampleInterface.class );
+        _mock = new Mock( ExampleInterface.class );
+        _interface = (ExampleInterface)_mock.proxy();
     }
     
     public void tearDown() {
@@ -415,6 +398,91 @@
         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 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(
@@ -443,10 +511,5 @@
         assertEquals( "result", i.objectTypes( new Integer(1) ) );
         
         mock.verify();
-    }
-    
-    public void testEquals() {
-    	assertEquals("Same interface should have same hashcode", _interface.hashCode(), _interface.hashCode());    	
-    	assertEquals("Same interface should be equal", _interface, _interface);
     }
 }

Index: CallCounterTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/CallCounterTest.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- CallCounterTest.java	31 Oct 2002 17:03:47 -0000	1.1
+++ CallCounterTest.java	6 Nov 2002 15:54:35 -0000	1.2
@@ -19,33 +19,18 @@
         super(test);
     }
     
-    public void testCallCounterPassesArguments()
-        throws Throwable
-    {
-        Mock mock_call = new Mock();
-        CallCounter counter = new CallCounter(
-            1, (MockCall)mock_call.createInterface(MockCall.class) );
-        
-        final Object[] ARGS = { new Object() };
-        mock_call.expectVoid( "call", P.args( P.same(ARGS) ) );
-        
-        counter.call( ARGS );
-        
-        mock_call.verify();
-        counter.verify();
-    }
-    
-    public void testCallCounterReturnsValue() 
+    public void testCallCounterPassesArgumentsAndReturnsValue() 
         throws Throwable 
     {
-        Mock mock_call = new Mock();
+        Mock mock_call = new Mock(MockCall.class);
         CallCounter counter = new CallCounter(
-            1, (MockCall)mock_call.createInterface(MockCall.class) );
+            1, (MockCall)mock_call.proxy() );
         
+        final Object[] ARGS = { new Object() };
         final Object RESULT = new Object();
-        mock_call.expectReturn( "call", P.ANY_ARGS, RESULT );
+        mock_call.expectReturn( "call", ARGS, RESULT );
         
-        assertSame( RESULT, counter.call( new Object[0] ) );
+        assertSame( RESULT, counter.call(ARGS) );
         
         mock_call.verify();
         counter.verify();
@@ -54,9 +39,9 @@
     public void testCallCounterThrowsException() 
         throws Throwable 
     {
-        Mock mock_call = new Mock();
+        Mock mock_call = new Mock(MockCall.class);
         CallCounter counter = new CallCounter(
-            1, (MockCall)mock_call.createInterface(MockCall.class) );
+            1, (MockCall)mock_call.proxy() );
         
         final Object RESULT = new Object();
         mock_call.expectThrow( "call", P.ANY_ARGS, new ExampleException() );
@@ -75,9 +60,9 @@
     public void testTooManyCalls()
         throws Throwable
     {
-        Mock mock_call = new Mock();
+        Mock mock_call = new Mock(MockCall.class);
         final CallCounter counter = new CallCounter(
-            2, (MockCall)mock_call.createInterface(MockCall.class) );
+            2, (MockCall)mock_call.proxy() );
         
         counter.call( new Object[0] );
         counter.call( new Object[0] );
@@ -95,9 +80,9 @@
     public void testTooFewCalls()
         throws Throwable
     {
-        Mock mock_call = new Mock();
+        Mock mock_call = new Mock(MockCall.class);
         final CallCounter counter = new CallCounter(
-            2, (MockCall)mock_call.createInterface(MockCall.class) );
+            2, (MockCall)mock_call.proxy() );
         
         counter.call( new Object[0] );
         

Index: CallSequenceTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/test/mockobjects/dynamic/CallSequenceTest.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- CallSequenceTest.java	1 Nov 2002 15:35:20 -0000	1.1
+++ CallSequenceTest.java	6 Nov 2002 15:54:35 -0000	1.2
@@ -39,50 +39,22 @@
         fail( "call to empty call list should fail" );
     }
     
-    public void testCallListPassesArguments()
+    public void testCallListPassesArgumentsAndReturnsValue()
         throws Throwable
     {
-        Mock mock_call_1 = new Mock();
-        Mock mock_call_2 = new Mock();
+        Mock mock_call_1 = new Mock(MockCall.class);
+        Mock mock_call_2 = new Mock(MockCall.class);
         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[] ARGS_2 = { 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_1.expectReturn( "call", ARGS_1, RESULT_1 );
+        call_list.expect( (MockCall)mock_call_1.proxy() );
             
-        mock_call_2.expectReturn( "call", P.args(P.eq(ARGS_2)), RESULT_2 );
-        call_list.expect(
-            (MockCall)mock_call_2.createInterface(MockCall.class) );
-        
+        mock_call_2.expectReturn( "call", ARGS_2, RESULT_2 );
+        call_list.expect( (MockCall)mock_call_2.proxy() );
         
         assertSame( RESULT_1, call_list.call( ARGS_1 ) );
         assertSame( RESULT_2, call_list.call( ARGS_2 ) );
@@ -91,12 +63,12 @@
         mock_call_2.verify();
         call_list.verify();
     }
-
+    
     public void testCallListThrowsExceptionValue() 
         throws Throwable 
     {
-        Mock mock_call_1 = new Mock();
-        Mock mock_call_2 = new Mock();
+        Mock mock_call_1 = new Mock(MockCall.class);
+        Mock mock_call_2 = new Mock(MockCall.class);
         CallSequence call_list = new CallSequence();
         final Object[] ARGS_1 = { new Object() };
         final Object[] ARGS_2 = { new Object() };
@@ -105,11 +77,10 @@
         
         mock_call_1.expectThrow( "call", P.args(P.same(ARGS_1)), EXCEPTION_1 );
         call_list.expect(
-            (MockCall)mock_call_1.createInterface(MockCall.class) );
+            (MockCall)mock_call_1.proxy() );
             
         mock_call_2.expectThrow( "call", P.args(P.eq(ARGS_2)), EXCEPTION_2 );
-        call_list.expect(
-            (MockCall)mock_call_2.createInterface(MockCall.class) );
+        call_list.expect( (MockCall)mock_call_2.proxy() );
         
         try {
             call_list.call( ARGS_1 );