HHH-10058 Parameterized test runner compatible with CustomRunner

(cherry picked from commit d9b456b)

Author: rvansa

hibernate-testing/src/main/java/org/hibernate/testing/junit4/CustomParameterized.java

@@ -0,0 +1,334 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
+ * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ */
+package org.hibernate.testing.junit4;
+
+import org.junit.runner.Runner;
+import org.junit.runner.manipulation.NoTestsRemainException;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Suite;
+import org.junit.runners.model.FrameworkField;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.Statement;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Field;
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+/**
+ * Allows the {@link CustomRunner} features in parameterized tests.
+ * This is mostly copy-paste from {@link Parameterized} since the methods could not be overridden.
+ *
+ * The static {@link org.junit.BeforeClass} and {@link org.junit.AfterClass} methods will be executed
+ * only once before and after all tests (since these should prepare static members).
+ * Hibernate-specific {@link org.hibernate.testing.BeforeClassOnce} and {@link org.hibernate.testing.AfterClassOnce}
+ * will be executed before and after each set of tests with given parameters.
+ *
+ * Class can override the parameters list (annotated by {@link org.junit.runners.Parameterized.Parameters}
+ * by defining static method of the same name in inheriting class (this works although usually static
+ * methods cannot override each other in Java).
+ *
+ * When there are multiple methods providing the parameters list, the used parameters list is a cross product
+ * of all the options, concatenating the argument list according to {@link Order} values.
+ *
+ * Contrary to {@link Parameterized}, non-static parameters methods are allowed, but the test class needs
+ * to have parameterless constructor, and therefore use {@link org.junit.runners.Parameterized.Parameter}
+ * for setting these parameters. This allow type-safe overriding of the method; note that only the base
+ * method needs the {@link org.junit.runners.Parameterized.Parameters} annotation, overriding methods
+ * are invoked automatically.
+ *
+ * @author Radim Vansa &lt;[email protected]&gt;
+ */
+public class CustomParameterized extends Suite {
+
+	private static final List<Runner> NO_RUNNERS = Collections.emptyList();
+
+	private final ArrayList<Runner> runners = new ArrayList<Runner>();
+
+	/**
+	 * Only called reflectively. Do not use programmatically.
+	 */
+	public CustomParameterized(Class<?> klass) throws Throwable {
+		super(klass, NO_RUNNERS);
+		List<FrameworkMethod> parametersMethods = getParametersMethods();
+		createRunnersForParameters(allParameters(parametersMethods), concatNames(parametersMethods));
+	}
+
+	private String concatNames(List<FrameworkMethod> parametersMethods) {
+		StringBuilder sb = new StringBuilder();
+		for (FrameworkMethod method : parametersMethods) {
+			Parameterized.Parameters parameters = method.getAnnotation(Parameterized.Parameters.class);
+			if (sb.length() != 0) {
+				sb.append(", ");
+			}
+			sb.append(parameters.name());
+		}
+		return sb.toString();
+	}
+
+	@Override
+	protected List<Runner> getChildren() {
+		return runners;
+	}
+
+	private Iterable<Object[]> allParameters(List<FrameworkMethod> parametersMethods) throws Throwable {
+		ArrayList<Iterable<Object[]>> returnedParameters = new ArrayList<Iterable<Object[]>>();
+		ArrayList<Object[]> allParameters = new ArrayList<Object[]>();
+		Object cachedInstance = null;
+		for (FrameworkMethod method : parametersMethods) {
+			Object parameters;
+			if (method.isStatic()) {
+				parameters = method.invokeExplosively(null);
+			}
+			else {
+				if (cachedInstance == null) {
+					cachedInstance = getTestClass().getOnlyConstructor().newInstance();
+				}
+				parameters = method.invokeExplosively(cachedInstance);
+			}
+			if (parameters instanceof Iterable) {
+				returnedParameters.add((Iterable<Object[]>) parameters);
+			}
+			else {
+				throw parametersMethodReturnedWrongType(method);
+			}
+		}
+		for (Iterable<Object[]> parameters : returnedParameters) {
+			if (allParameters.isEmpty()) {
+				for (Object[] array : parameters) {
+					allParameters.add(array);
+				}
+			}
+			else {
+				ArrayList<Object[]> newAllParameters = new ArrayList<Object[]>();
+				for (Object[] prev : allParameters) {
+					for (Object[] array : parameters) {
+						Object[] next = Arrays.copyOf(prev, prev.length + array.length);
+						System.arraycopy(array, 0, next, prev.length, array.length);
+						newAllParameters.add(next);
+					}
+				}
+				allParameters = newAllParameters;
+			}
+		}
+		return allParameters;
+	}
+
+	private List<FrameworkMethod> getParametersMethods() throws Exception {
+		List<FrameworkMethod> methods = getTestClass().getAnnotatedMethods(
+				Parameterized.Parameters.class);
+		SortedMap<Integer, FrameworkMethod> sortedMethods = new TreeMap<Integer, FrameworkMethod>();
+		for (FrameworkMethod each : methods) {
+			if (each.isPublic()) {
+				if (!each.isStatic()) {
+					if (getTestClass().getOnlyConstructor().getParameterTypes().length != 0) {
+						throw new Exception("Method " + each.getMethod() + " is annotated with @Parameters, it is not static and there is no parameter-less constructor!");
+					}
+				}
+				Order order = each.getAnnotation(Order.class);
+				int value = order == null ? 0 : order.value();
+				FrameworkMethod prev = sortedMethods.put(value, each);
+				if (prev != null) {
+					throw new Exception(String.format("There are more methods annotated with @Parameters and @Order(value=%d): %s (%s) and %s (%s)",
+							value, prev.getMethod(), prev.getAnnotation(Order.class), each.getMethod(), order));
+				}
+			}
+			else {
+				throw new Exception("Method " + each.getMethod() + " is annotated with @Parameters but it is not public!");
+			}
+		}
+		if (sortedMethods.isEmpty()) {
+			throw new Exception("No public static parameters method on class "
+					+ getTestClass().getName());
+		}
+		return new ArrayList<FrameworkMethod>(sortedMethods.values());
+	}
+
+	private void createRunnersForParameters(Iterable<Object[]> allParameters, String namePattern) throws Exception {
+		int i = 0;
+		for (Object[] parametersOfSingleTest : allParameters) {
+			String name = nameFor(namePattern, i, parametersOfSingleTest);
+			CustomRunnerForParameters runner = new CustomRunnerForParameters(
+					getTestClass().getJavaClass(), parametersOfSingleTest,
+					name);
+			runners.add(runner);
+			++i;
+		}
+	}
+
+	private String nameFor(String namePattern, int index, Object[] parameters) {
+		String finalPattern = namePattern.replaceAll("\\{index\\}",
+				Integer.toString(index));
+		String name = MessageFormat.format(finalPattern, parameters);
+		return "[" + name + "]";
+	}
+
+	private Exception parametersMethodReturnedWrongType(FrameworkMethod method) throws Exception {
+		String className = getTestClass().getName();
+		String methodName = method.getName();
+		String message = MessageFormat.format(
+				"{0}.{1}() must return an Iterable of arrays.",
+				className, methodName);
+		return new Exception(message);
+	}
+
+	private List<FrameworkField> getAnnotatedFieldsByParameter() {
+		return getTestClass().getAnnotatedFields(Parameterized.Parameter.class);
+	}
+
+	private boolean fieldsAreAnnotated() {
+		return !getAnnotatedFieldsByParameter().isEmpty();
+	}
+
+	private class CustomRunnerForParameters extends CustomRunner {
+		private final Object[] parameters;
+		private final String name;
+
+		CustomRunnerForParameters(Class<?> type, Object[] parameters, String name) throws InitializationError, NoTestsRemainException {
+			super(type);
+			this.parameters = parameters;
+			this.name = name;
+		}
+
+		@Override
+		protected Object getTestInstance() throws Exception {
+			if (testInstance == null) {
+				if (fieldsAreAnnotated()) {
+					testInstance = createTestUsingFieldInjection();
+				}
+				else {
+					testInstance = createTestUsingConstructorInjection();
+				}
+			}
+			return testInstance;
+		}
+
+		private Object createTestUsingConstructorInjection() throws Exception {
+			return getTestClass().getOnlyConstructor().newInstance(parameters);
+		}
+
+		private Object createTestUsingFieldInjection() throws Exception {
+			List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
+			if (annotatedFieldsByParameter.size() != parameters.length) {
+				throw new Exception("Wrong number of parameters and @Parameter fields." +
+						" @Parameter fields counted: " + annotatedFieldsByParameter.size() + ", available parameters: " + parameters.length + ".");
+			}
+			Object testClassInstance = getTestClass().getJavaClass().newInstance();
+			for (FrameworkField each : annotatedFieldsByParameter) {
+				Field field = each.getField();
+				Parameterized.Parameter annotation = field.getAnnotation(Parameterized.Parameter.class);
+				int index = annotation.value();
+				try {
+					field.set(testClassInstance, parameters[index]);
+				}
+				catch (IllegalArgumentException iare) {
+					throw new Exception(getTestClass().getName() + ": Trying to set " + field.getName() +
+							" with the value " + parameters[index] +
+							" that is not the right type (" + parameters[index].getClass().getSimpleName() + " instead of " +
+							field.getType().getSimpleName() + ").", iare);
+				}
+			}
+			return testClassInstance;
+		}
+
+		@Override
+		protected String getName() {
+			return name;
+		}
+
+		@Override
+		protected String testName(FrameworkMethod method) {
+			return method.getName() + getName();
+		}
+
+		@Override
+		protected void validateConstructor(List<Throwable> errors) {
+			validateOnlyOneConstructor(errors);
+			if (fieldsAreAnnotated()) {
+				validateZeroArgConstructor(errors);
+			}
+		}
+
+		@Override
+		protected void validateFields(List<Throwable> errors) {
+			super.validateFields(errors);
+			if (fieldsAreAnnotated()) {
+				List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
+				int[] usedIndices = new int[annotatedFieldsByParameter.size()];
+				for (FrameworkField each : annotatedFieldsByParameter) {
+					int index = each.getField().getAnnotation(Parameterized.Parameter.class).value();
+					if (index < 0 || index > annotatedFieldsByParameter.size() - 1) {
+						errors.add(
+								new Exception("Invalid @Parameter value: " + index + ". @Parameter fields counted: " +
+										annotatedFieldsByParameter.size() + ". Please use an index between 0 and " +
+										(annotatedFieldsByParameter.size() - 1) + ".")
+						);
+					}
+					else {
+						usedIndices[index]++;
+					}
+				}
+				for (int index = 0; index < usedIndices.length; index++) {
+					int numberOfUse = usedIndices[index];
+					if (numberOfUse == 0) {
+						errors.add(new Exception("@Parameter(" + index + ") is never used."));
+					}
+					else if (numberOfUse > 1) {
+						errors.add(new Exception("@Parameter(" + index + ") is used more than once (" + numberOfUse + ")."));
+					}
+				}
+			}
+		}
+
+		@Override
+		protected Statement classBlock(RunNotifier notifier) {
+			Statement statement = childrenInvoker(notifier);
+			statement = withBeforeClasses(statement);
+			statement = withAfterClasses(statement);
+			// no class rules executed! These will be executed for the whole suite.
+			return statement;
+		}
+
+		@Override
+		protected Statement withBeforeClasses(Statement statement) {
+			if ( isAllTestsIgnored() ) {
+				return statement;
+			}
+			return new BeforeClassCallbackHandler( this, statement );
+		}
+
+		@Override
+		protected Statement withAfterClasses(Statement statement) {
+			if ( isAllTestsIgnored() ) {
+				return statement;
+			}
+			return new AfterClassCallbackHandler( this, statement );
+		}
+
+		@Override
+		protected Annotation[] getRunnerAnnotations() {
+			return new Annotation[0];
+		}
+	}
+
+	@Retention(value = RetentionPolicy.RUNTIME)
+	@Target(ElementType.METHOD)
+	public @interface Order {
+		int value();
+	}
+}

hibernate-testing/src/main/java/org/hibernate/testing/junit4/CustomRunner.java

@@ -65,7 +65,7 @@ public TestClassMetadata getTestClassMetadata() {
 
 	private Boolean isAllTestsIgnored;
 
-	private boolean isAllTestsIgnored() {
+	protected boolean isAllTestsIgnored() {
 		if ( isAllTestsIgnored == null ) {
 			if ( computeTestMethods().isEmpty() ) {
 				isAllTestsIgnored = true;
@@ -132,7 +132,7 @@ protected Statement methodBlock(FrameworkMethod method) {
 		);
 	}
 
-	private Object testInstance;
+	protected Object testInstance;
 
 	protected Object getTestInstance() throws Exception {
 		if ( testInstance == null ) {