/*
* 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 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;
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;
/**
* 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 <rvansa@redhat.com>
*/
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().getParameterCount() != 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();
}
}