[MO-java-dev] CVS: mockobjects-java/src/core/functional/test/mockobjects/dynamic VoidMockTest.java,NONE,1.1 MockTestActions.java,NONE,1.1 ThrowableMockTest.java,NONE,1.1 ReturnMockTest.java,NONE,1.1 MockTest.java,1.3,1.4

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

Update of /cvsroot/mockobjects/mockobjects-java/src/core/functional/test/mockobjects/dynamic
In directory sc8-pr-cvs1:/tmp/cvs-serv25759/src/core/functional/test/mockobjects/dynamic

Modified Files:
	MockTest.java 
Added Files:
	VoidMockTest.java MockTestActions.java ThrowableMockTest.java 
	ReturnMockTest.java 
Log Message:
Restructured functional tests to repeat behaviour.

--- NEW FILE: VoidMockTest.java ---
/*
 * Copyright mockobjects.com 09-Oct-2003
 *
 */
package functional.test.mockobjects.dynamic;

import com.mockobjects.dynamic.Mock;

public class VoidMockTest extends MockTest {
	public interface TargetType {
		void noParams();
		void oneParam(Object aParam);
	}

	public class VoidMockTestActions implements MockTestActions {
		private Mock mockTarget = new Mock(TargetType.class);
		private TargetType targetType = ((TargetType)mockTarget.proxy());

		public void expectNoParams() { mockTarget.expect("noParams"); }
		public void expectOneParam() { mockTarget.expect("oneParam", "one"); }
		public void expectNotNoParams() { mockTarget.expect("notNoParams"); }
		public void callNoParams() { targetType.noParams(); }
		public void callOneParam() { targetType.oneParam("one"); }
		public void callOneIncorrectParam() { targetType.oneParam("two"); }
		public void verifyMock() { mockTarget.verify(); }
	}

	public MockTestActions createActions() {
		return new VoidMockTestActions();
	}

	public void testMethodToMakeTestRunnerNoticeTestCase() {}
}

--- NEW FILE: MockTestActions.java ---
/*
 * copyright mockobjects.com 08-Oct-2003
 */
package functional.test.mockobjects.dynamic;

public interface MockTestActions {
	void expectNoParams();
	void expectOneParam();
	void expectNotNoParams();
	void callNoParams();
	void callOneParam();
	void callOneIncorrectParam();
	void verifyMock();
}
--- NEW FILE: ThrowableMockTest.java ---
/*
 * Copyright mockobjects.com 09-Oct-2003
 *
 */
package functional.test.mockobjects.dynamic;

import com.mockobjects.dynamic.Mock;

public class ThrowableMockTest extends MockTest {
	public class TargetException extends Exception {};
	public interface TargetType {
		Object noParams() throws TargetException;
		Object oneParam(Object aParam) throws TargetException;
	}

	public class ReturnMockTestActions implements MockTestActions {
		private Mock mockTarget = new Mock(TargetType.class);
		private TargetType targetType = ((TargetType)mockTarget.proxy());

		public void expectNoParams() { mockTarget.expectAndThrow("noParams", new TargetException()); }
		public void expectOneParam() { mockTarget.expectAndThrow("oneParam", "one", new TargetException()); }
		public void expectNotNoParams() { mockTarget.expectAndThrow("notNoParams", new TargetException()); }
		public void callNoParams() {
			try {
				targetType.noParams();
			} catch (TargetException expected) {
				return;
			}
			fail("Should have thrown exception");
		}
		public void callOneParam() {
			try {
				targetType.oneParam("one");
			} catch (TargetException expected) {
				return;
			} 
			fail("Should have thrown exception");
 		}
		public void callOneIncorrectParam() { 
			try {
				targetType.oneParam("two");
			} catch (TargetException e) {
				return; // skip
			} 
		}
		public void verifyMock() { mockTarget.verify(); }
	}

	public MockTestActions createActions() {
		return new ReturnMockTestActions();
	}

	public void testMethodToMakeTestRunnerNoticeTestCase() {}
}

--- NEW FILE: ReturnMockTest.java ---
/*
 * Copyright mockobjects.com 09-Oct-2003
 *
 */
package functional.test.mockobjects.dynamic;

import com.mockobjects.dynamic.Mock;

public class ReturnMockTest extends MockTest {
	public interface TargetType {
		Object noParams();
		Object oneParam(Object aParam);
	}

	public class ThrowableMockTestActions implements MockTestActions {
		private Mock mockTarget = new Mock(TargetType.class);
		private TargetType targetType = ((TargetType)mockTarget.proxy());

		public void expectNoParams() { mockTarget.expectAndReturn("noParams", "result"); }
		public void expectOneParam() { mockTarget.expectAndReturn("oneParam", "one", "result"); }
		public void expectNotNoParams() { mockTarget.expectAndReturn("notNoParams", "result"); }
		public void callNoParams() { 
			assertEquals("Should be no params result", "result", targetType.noParams()); 
		}
		public void callOneParam() { 			
			assertEquals("Should be one params result", "result", targetType.oneParam("one")); 
 		}
		public void callOneIncorrectParam() { targetType.oneParam("two"); }
		public void verifyMock() { mockTarget.verify(); }
	}

	public MockTestActions createActions() {
		return new ThrowableMockTestActions();
	}

	public void testMethodToMakeTestRunnerNoticeTestCase() {}
}

Index: MockTest.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/functional/test/mockobjects/dynamic/MockTest.java,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- MockTest.java	5 Oct 2003 09:28:16 -0000	1.3
+++ MockTest.java	8 Oct 2003 23:45:44 -0000	1.4
@@ -5,57 +5,66 @@
 
 import junit.framework.AssertionFailedError;
 import junit.framework.TestCase;
-import com.mockobjects.dynamic.*;
+
+import com.mockobjects.dynamic.Mock;
 
 /**
  * High level test of dynamic mock class.
  */
-public class MockTest extends TestCase {
-	public class TestException extends Exception {}
-	public interface TargetType {
-		void noParams() throws TestException;
-		void oneParam(Object aParam);
-		String noParamsWithResult();
-	}
-
-	private Mock mockTarget = new Mock(TargetType.class);
-	private TargetType targetType = ((TargetType)mockTarget.proxy());
+public abstract class MockTest extends TestCase {
+	private MockTestActions actions;
 
+	public abstract MockTestActions createActions();
+	
+	public void setUp() {
+		actions = createActions();
+	}
+	
 	public void testHasDefaultNameBasedOnMockedType()
 	{
-		assertEquals("Should have same name", "mockMockTest$TargetType", mockTarget.toString() );
+		Mock mock = new Mock(MockTestActions.class);
+		assertEquals("Should have same name", "mockMockTestActions", mock.toString() );
 	}
 	
 	public void testCanBeExplicitlyNamed()
 	{
-		Mock otherMock = new Mock(TargetType.class, "otherMock");
+		Mock otherMock = new Mock(MockTestActions.class, "otherMock");
 		assertEquals("Should have same name", "otherMock", otherMock.toString());
 	}
 	
-	public void testPassesIfMockedMethodCalled() throws TestException {
-		mockTarget.expect("noParams");
-		
-		targetType.noParams();
-		
-		mockTarget.verify();
+	public void testPassesIfMockedMethodCalled() {
+		actions.expectNoParams();
+		actions.callNoParams();
+		actions.verifyMock();
+	}
+
+	public void testFailsIfMockedMethodCalledTwice() {
+		actions. expectNoParams();
+		actions.callNoParams();
+		try {
+			actions.callNoParams();
+			fail("Should have throw exception");
+		} catch (AssertionFailedError expected) {
+			return;
+		}	
 	}
 
 	public void testFailsIfMockedMethodNotCalled() {
-		mockTarget.expect("noParams");
+		actions.expectNoParams();
 		
 		try {
-			mockTarget.verify();
+			actions.verifyMock();
 		} catch (AssertionFailedError unused) {
 			return;
 		}
 		fail("Should have thrown exception");
 	}
 
-	public void testFailsImmediatelyIfUnexpectedMethodCalled() throws TestException {
-		mockTarget.expect("notNoParams");
+	public void testFailsImmediatelyIfUnexpectedMethodCalled()  {
+		actions.expectNotNoParams();
 		
 		try {
-			targetType.noParams();
+			actions.callNoParams();
 		} catch (AssertionFailedError unused) {
 			return;
 		}
@@ -63,36 +72,20 @@
 	}
 
 	public void testPassesIfMockedMethodCalledWithParameter() {
-		mockTarget.expect("oneParam", "one");
-		
-		targetType.oneParam("one");
-		
-		mockTarget.verify();
+		actions.expectOneParam();
+		actions.callOneParam();
+		actions.verifyMock();
 	}
 
 	public void testInvocationFailsIfParameterValueIncorrect() {
-		mockTarget.expect("oneParam", "one");
+		actions.expectOneParam();
 		
 		try {
-			targetType.oneParam("two");
+			actions.callOneIncorrectParam();
 		} catch (AssertionFailedError unused) {
 			return;
 		}
 		fail("Should have thrown exception");
 	}
-
-	public void testCanReturnAResult() {
-		mockTarget.matchAndReturn("noParamsWithResult", "a result");
-		
-		assertEquals("Should be returned result", "a result", targetType.noParamsWithResult());
-	}
 	
-	public void testCanThrowAnExpection() {
-		mockTarget.matchAndThrow("noParams", new TestException());
-		
-		try {
-			targetType.noParams();
-			fail("Should have thrown text exception");
-		} catch (TestException unused ) {};
-	}
 }