- @Before and @After methods are run before and after each set of attempted parameters

  on a Theory

- Refactoring removed duplication that used to exist in classes MethodRoadie and ClassRoadie

Author: dsaff

build.xml

@@ -4,7 +4,7 @@
 	<property file="${user.home}/.junit.properties" />
 	<property name="src" value="src" />
 	<property name="bin" value="bin" />
-	<property name="version" value="4.4" />
+	<property name="version" value="4.5-SNAPSHOT-${timestamp}" />
 	<property name="dist"  value="junit${version}" />
 	<property name="versionfile"  value="${src}/junit/runner/Version.java" />
 	<property name="zipfile"  value="${dist}.zip" />

doc/ReleaseNotes4.4.txt

@@ -1,3 +1,10 @@
+## Summary of Changes in version 4.5 ##
+
+- `@Before` and `@After` methods are run before and after each set of attempted parameters
+  on a Theory
+  
+- Refactoring removed duplication that used to exist in classes MethodRoadie and ClassRoadie
+
 ## Summary of Changes in version 4.4 ##
 
 JUnit is designed to efficiently capture developers' intentions about

src/org/junit/experimental/test/theories/TheoriesTest.java

@@ -11,13 +11,15 @@
 import static org.junit.experimental.results.ResultMatchers.isSuccessful;
 import static org.junit.matchers.StringContains.containsString;
 import org.hamcrest.Matcher;
+import org.junit.Before;
 import org.junit.Test;
 import org.junit.experimental.results.ResultMatchers;
 import org.junit.experimental.theories.DataPoint;
 import org.junit.experimental.theories.Theories;
 import org.junit.experimental.theories.Theory;
 import org.junit.experimental.theories.suppliers.TestedOn;
 import org.junit.internal.runners.TestClass;
+import org.junit.runner.JUnitCore;
 import org.junit.runner.RunWith;
 
 @SuppressWarnings("restriction")
@@ -211,4 +213,28 @@ public void allStringsAreNonNull(String s) {
 	public void shouldFilterNull() {
 		assertThat(testResult(ShouldFilterNull.class), isSuccessful());
 	}
+	
+	// TODO: (Jul 20, 2007 1:58:18 PM) too complex
+	
+	@RunWith(Theories.class)
+	public static class BeforeAndAfterEachTime {
+		public static int befores = 0;
+		
+		@DataPoint public static String A = "A";
+		@DataPoint public static String B = "B";
+		
+		@Before public void incrementBefore() {
+			befores++;
+		}
+		
+		@Theory public void stringsAreOK(String string) {
+		}
+	}
+	
+	@Test public void beforeIsCalledOnEachParameterSet() {
+		BeforeAndAfterEachTime.befores = 0;
+		JUnitCore.runClasses(BeforeAndAfterEachTime.class);
+		assertThat(BeforeAndAfterEachTime.befores, is(2));
+	}
+
 }

src/org/junit/experimental/theories/Theories.java

@@ -23,6 +23,8 @@ public Theories(Class<?> klass) throws InitializationError {
 
 	@Override
 	protected List<Method> getTestMethods() {
+		// TODO: (Jul 20, 2007 2:02:44 PM) Only get methods once
+
 		List<Method> testMethods= super.getTestMethods();
 		testMethods.addAll(getTestClass().getAnnotatedMethods(Theory.class));
 		return testMethods;

src/org/junit/experimental/theories/internal/TheoryMethod.java

@@ -14,6 +14,7 @@
 import org.junit.experimental.theories.PotentialParameterValue;
 import org.junit.experimental.theories.Theory;
 import org.junit.experimental.theories.PotentialParameterValue.CouldNotGenerateValueException;
+import org.junit.internal.runners.Roadie;
 import org.junit.internal.runners.TestClass;
 import org.junit.internal.runners.TestMethod;
 
@@ -29,7 +30,8 @@ public PotentialMethodValues(List<PotentialParameterValue> concat) {
 			fSources= concat;
 		}
 
-		Object[] getValues(boolean nullsOk) throws CouldNotGenerateValueException {
+		Object[] getValues(boolean nullsOk)
+				throws CouldNotGenerateValueException {
 			Object[] values= new Object[fSources.size()];
 			for (int i= 0; i < values.length; i++) {
 				values[i]= fSources.get(i).getValue();
@@ -51,23 +53,31 @@ PotentialMethodValues concat(PotentialParameterValue source) {
 
 	private List<AssumptionViolatedException> fInvalidParameters= new ArrayList<AssumptionViolatedException>();
 
+	private int successes= 0;
+
+	protected Throwable thrown = null;
+
 	public TheoryMethod(Method method, TestClass testClass) {
 		super(method, testClass);
 		fMethod= method;
 	}
 
 	@Override
-	public void invoke(Object test) throws IllegalArgumentException,
-			IllegalAccessException, InvocationTargetException {
-		int runCount= 0;
+	protected void runTestProtected(Roadie context) {
+		runTestUnprotected(context);
+	}
+
+	@Override
+	public void invoke(Roadie context)
+			throws IllegalArgumentException, IllegalAccessException,
+			InvocationTargetException {
 		try {
-			runCount+= runWithDiscoveredParameterValues(test,
-					new PotentialMethodValues(), ParameterSignature
-							.signatures(fMethod));
+			runWithDiscoveredParameterValues(context, new PotentialMethodValues(),
+					ParameterSignature.signatures(fMethod));
 		} catch (Throwable e) {
 			throw new InvocationTargetException(e);
 		}
-		if (runCount == 0)
+		if (successes == 0)
 			Assert
 					.fail("Never found parameters that satisfied method.  Violated assumptions: "
 							+ fInvalidParameters);
@@ -80,45 +90,48 @@ public boolean nullsOk() {
 		return annotation.nullsAccepted();
 	}
 
-	int invokeWithActualParameters(Object target, Object[] params)
+	void invokeWithActualParameters(Object target, Object[] params)
 			throws Throwable {
 		try {
 			try {
 				fMethod.invoke(target, params);
+				successes++;
 			} catch (InvocationTargetException e) {
 				throw e.getTargetException();
 			}
 		} catch (AssumptionViolatedException e) {
 			fInvalidParameters.add(e);
-			return 0;
 		} catch (Throwable e) {
 			if (params.length == 0)
 				throw e;
 			throw new ParameterizedAssertionError(e, fMethod.getName(), params);
 		}
-		return 1;
 	}
 
-	int runWithDiscoveredParameterValues(Object target,
-			PotentialMethodValues valueSources, List<ParameterSignature> sigs)
-			throws Throwable {
+	void runWithDiscoveredParameterValues(final Roadie context,
+			PotentialMethodValues valueSources, List<ParameterSignature> sigs) throws Throwable {
 		if (sigs.size() == 0) {
 			try {
-				return invokeWithActualParameters(target, valueSources
-						.getValues(nullsOk()));
+				final Object[] values= valueSources.getValues(nullsOk());
+				context.runProtected(this, new Runnable() {
+					public void run() {
+						try {
+							invokeWithActualParameters(context.getTarget(), values);
+						} catch (Throwable e) {
+							thrown = e;
+						}
+					}
+				});
+				if (thrown != null)
+					throw thrown;
 			} catch (CouldNotGenerateValueException e) {
-				return 0;
+			}
+		} else {
+			for (PotentialParameterValue source : sigs.get(0)
+					.getPotentialValues(context.getTarget())) {
+				runWithDiscoveredParameterValues(context, valueSources
+						.concat(source), sigs.subList(1, sigs.size()));
 			}
 		}
-
-		int count= 0;
-
-		for (PotentialParameterValue source : sigs.get(0).getPotentialValues(
-				target)) {
-			count+= runWithDiscoveredParameterValues(target, valueSources
-					.concat(source), sigs.subList(1, sigs.size()));
-		}
-
-		return count;
 	}
 }

src/org/junit/internal/runners/JUnit4ClassRunner.java

@@ -39,11 +39,11 @@ protected void validate() throws InitializationError {
 
 	@Override
 	public void run(final RunNotifier notifier) {
-		new ClassRoadie(notifier, fTestClass, getDescription(), new Runnable() {
+		fTestClass.runProtected(notifier, getDescription(), new Runnable() {
 			public void run() {
 				runMethods(notifier);
 			}
-		}).runProtected();
+		});
 	}
 
 	protected void runMethods(final RunNotifier notifier) {
@@ -85,7 +85,7 @@ protected void invokeTestMethod(Method method, RunNotifier notifier) {
 			return;
 		}
 		TestMethod testMethod= wrapMethod(method);
-		new MethodRoadie(test, testMethod, notifier, description).run();
+		testMethod.run(new Roadie(notifier, description, test));
 	}
 
 	protected TestMethod wrapMethod(Method method) {

src/org/junit/internal/runners/JavaElement.java

@@ -0,0 +1,11 @@
+package org.junit.internal.runners;
+
+import java.lang.reflect.Method;
+import java.util.List;
+
+
+public abstract class JavaElement {
+	protected abstract List<Method> getAfters();
+
+	protected abstract List<Method> getBefores();
+}