Spike for expression language evaluation in display names

gradle/libs.versions.toml

@@ -55,6 +55,7 @@ mavenSurefirePlugin = { module = "org.apache.maven.plugins:maven-surefire-plugin
 memoryfilesystem = { module = "com.github.marschall:memoryfilesystem", version = "2.8.1" }
 mockito-core = { module = "org.mockito:mockito-core", version.ref = "mockito" }
 mockito-junit-jupiter = { module = "org.mockito:mockito-junit-jupiter", version.ref = "mockito" }
+mustache = { module = "com.github.spullara.mustache.java:compiler", version = "0.9.10"}
 nohttp-checkstyle = { module = "io.spring.nohttp:nohttp-checkstyle", version = "0.0.11" }
 opentest4j = { module = "org.opentest4j:opentest4j", version.ref = "opentest4j" }
 openTestReporting-cli = { module = "org.opentest4j.reporting:open-test-reporting-cli", version.ref = "openTestReporting" }

junit-jupiter-params/src/jmh/java/org/junit/jupiter/params/ParameterizedTestNameFormatterBenchmarks.java

@@ -11,6 +11,7 @@
 package org.junit.jupiter.params;
 
 import java.util.List;
+import java.util.Optional;
 import java.util.stream.IntStream;
 
 import org.junit.jupiter.params.provider.Arguments;
@@ -47,7 +48,7 @@ public void formatTestNames(Blackhole blackhole) throws Exception {
 		var method = TestCase.class.getDeclaredMethod("parameterizedTest", int.class);
 		var formatter = new ParameterizedTestNameFormatter(
 			ParameterizedTest.DISPLAY_NAME_PLACEHOLDER + " " + ParameterizedTest.DEFAULT_DISPLAY_NAME + " ({0})",
-			"displayName", new ParameterizedTestMethodContext(method, method.getAnnotation(ParameterizedTest.class)),
+			"displayName", new ParameterizedTestMethodContext(method, method.getAnnotation(ParameterizedTest.class), Optional.ofNullable(method.getAnnotation(ExpressionLanguage.class))),
 			512);
 		for (int i = 0; i < argumentsList.size(); i++) {
 			Arguments arguments = argumentsList.get(i);

junit-jupiter-params/src/main/java/org/junit/jupiter/params/ArgumentCountValidator.java

@@ -69,7 +69,7 @@ private void validateArgumentCount(ExtensionContext extensionContext, Arguments
 	}
 
 	private ArgumentCountValidationMode getArgumentCountValidationMode(ExtensionContext extensionContext) {
-		ParameterizedTest parameterizedTest = methodContext.annotation;
+		ParameterizedTest parameterizedTest = methodContext.parameterizedTestAnnotation;
 		if (parameterizedTest.argumentCountValidation() != ArgumentCountValidationMode.DEFAULT) {
 			return parameterizedTest.argumentCountValidation();
 		}

junit-jupiter-params/src/main/java/org/junit/jupiter/params/ArgumentsContext.java

@@ -0,0 +1,16 @@
+package org.junit.jupiter.params;
+
+import org.junit.jupiter.params.provider.Arguments;
+
+public class ArgumentsContext {
+
+	final int invocationIndex;
+	final Arguments arguments;
+	final Object[] consumedArguments;
+
+	ArgumentsContext(int invocationIndex, Arguments arguments, Object[] consumedArguments) {
+		this.invocationIndex = invocationIndex;
+		this.arguments = arguments;
+		this.consumedArguments = consumedArguments;
+	}
+}

junit-jupiter-params/src/main/java/org/junit/jupiter/params/ExpressionLanguage.java

@@ -0,0 +1,11 @@
+
+package org.junit.jupiter.params;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ExpressionLanguage {
+
+	Class<? extends ExpressionLanguageAdapter> value();
+}

junit-jupiter-params/src/main/java/org/junit/jupiter/params/ExpressionLanguageAdapter.java

@@ -0,0 +1,9 @@
+
+package org.junit.jupiter.params;
+
+public interface ExpressionLanguageAdapter {
+
+	void compile(String template);
+
+	void format(Object scope, StringBuffer result);
+}

junit-jupiter-params/src/main/java/org/junit/jupiter/params/ParameterizedTestExtension.java

@@ -46,13 +46,16 @@ public boolean supportsTestTemplate(ExtensionContext context) {
 		}
 
 		Method templateMethod = context.getTestMethod().get();
-		Optional<ParameterizedTest> annotation = findAnnotation(templateMethod, ParameterizedTest.class);
-		if (!annotation.isPresent()) {
+		Optional<ExpressionLanguage> expressionLanguageAnnotation = findAnnotation(templateMethod,
+			ExpressionLanguage.class);
+		Optional<ParameterizedTest> parameterizedTestAnnotation = findAnnotation(templateMethod,
+			ParameterizedTest.class);
+		if (!parameterizedTestAnnotation.isPresent()) {
 			return false;
 		}
 
 		ParameterizedTestMethodContext methodContext = new ParameterizedTestMethodContext(templateMethod,
-			annotation.get());
+			parameterizedTestAnnotation.get(), expressionLanguageAnnotation);
 
 		Preconditions.condition(methodContext.hasPotentiallyValidSignature(),
 			() -> String.format(
@@ -86,15 +89,15 @@ public Stream<TestTemplateInvocationContext> provideTestTemplateInvocationContex
 					return createInvocationContext(formatter, methodContext, arguments, invocationCount.intValue());
 				})
 				.onClose(() ->
-						Preconditions.condition(invocationCount.get() > 0 || methodContext.annotation.allowZeroInvocations(),
+						Preconditions.condition(invocationCount.get() > 0 || methodContext.parameterizedTestAnnotation.allowZeroInvocations(),
 								"Configuration error: You must configure at least one set of arguments for this @ParameterizedTest"));
 		// @formatter:on
 	}
 
 	@Override
 	public boolean mayReturnZeroTestTemplateInvocationContexts(ExtensionContext extensionContext) {
 		ParameterizedTestMethodContext methodContext = getMethodContext(extensionContext);
-		return methodContext.annotation.allowZeroInvocations();
+		return methodContext.parameterizedTestAnnotation.allowZeroInvocations();
 	}
 
 	private ParameterizedTestMethodContext getMethodContext(ExtensionContext extensionContext) {
@@ -115,7 +118,7 @@ private TestTemplateInvocationContext createInvocationContext(ParameterizedTestN
 	private ParameterizedTestNameFormatter createNameFormatter(ExtensionContext extensionContext,
 			ParameterizedTestMethodContext methodContext) {
 
-		String name = methodContext.annotation.name();
+		String name = methodContext.parameterizedTestAnnotation.name();
 		String pattern = name.equals(DEFAULT_DISPLAY_NAME)
 				? extensionContext.getConfigurationParameter(DISPLAY_NAME_PATTERN_KEY) //
 						.orElse(ParameterizedTest.DEFAULT_DISPLAY_NAME)

junit-jupiter-params/src/main/java/org/junit/jupiter/params/ParameterizedTestMethodContext.java

@@ -44,15 +44,19 @@
 class ParameterizedTestMethodContext {
 
 	final Method method;
-	final ParameterizedTest annotation;
+	final ParameterizedTest parameterizedTestAnnotation;
+	final Optional<ExpressionLanguage> expressionLanguageAnnotation;
 
 	private final Parameter[] parameters;
 	private final Resolver[] resolvers;
 	private final List<ResolverType> resolverTypes;
 
-	ParameterizedTestMethodContext(Method method, ParameterizedTest annotation) {
+	ParameterizedTestMethodContext(Method method, ParameterizedTest parameterizedTestAnnotation,
+			Optional<ExpressionLanguage> expressionLanguageAnnotation) {
 		this.method = Preconditions.notNull(method, "method must not be null");
-		this.annotation = Preconditions.notNull(annotation, "annotation must not be null");
+		this.parameterizedTestAnnotation = Preconditions.notNull(parameterizedTestAnnotation,
+			"parameterizedTestAnnotation must not be null");
+		this.expressionLanguageAnnotation = expressionLanguageAnnotation;
 		this.parameters = method.getParameters();
 		this.resolvers = new Resolver[this.parameters.length];
 		this.resolverTypes = new ArrayList<>(this.parameters.length);

junit-jupiter-params/src/main/java/org/junit/jupiter/params/ParameterizedTestNameFormatter.java

@@ -19,6 +19,7 @@
 import static org.junit.jupiter.params.ParameterizedTest.INDEX_PLACEHOLDER;
 import static org.junit.platform.commons.util.StringUtils.isNotBlank;
 
+import java.lang.reflect.InvocationTargetException;
 import java.text.FieldPosition;
 import java.text.Format;
 import java.text.MessageFormat;
@@ -27,12 +28,14 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.function.Function;
 import java.util.stream.IntStream;
 
+import org.jetbrains.annotations.NotNull;
 import org.junit.jupiter.api.Named;
 import org.junit.jupiter.api.extension.ExtensionConfigurationException;
 import org.junit.jupiter.params.provider.Arguments;
@@ -96,12 +99,12 @@ private PartialFormatter[] parse(String pattern, String displayName, Parameteriz
 		while (isNotBlank(unparsedSegment)) {
 			PlaceholderPosition position = findFirstPlaceholder(formatters, unparsedSegment);
 			if (position == null) {
-				result.add(determineNonPlaceholderFormatter(unparsedSegment, argumentMaxLength));
+				result.add(determineNonPlaceholderFormatter(methodContext, unparsedSegment, argumentMaxLength));
 				break;
 			}
 			if (position.index > 0) {
 				String before = unparsedSegment.substring(0, position.index);
-				result.add(determineNonPlaceholderFormatter(before, argumentMaxLength));
+				result.add(determineNonPlaceholderFormatter(methodContext, before, argumentMaxLength));
 			}
 			result.add(formatters.get(position.placeholder));
 			unparsedSegment = unparsedSegment.substring(position.index + position.placeholder.length());
@@ -110,6 +113,24 @@ private PartialFormatter[] parse(String pattern, String displayName, Parameteriz
 		return result.toArray(new PartialFormatter[0]);
 	}
 
+	@NotNull
+	private static Optional<ExpressionLanguageAdapter> createExpressionLanguageAdapter(
+			ParameterizedTestMethodContext methodContext,
+			String segment
+	) {
+			return methodContext.expressionLanguageAnnotation.map(ExpressionLanguage::value).map(adapterClass -> {
+				try {
+					ExpressionLanguageAdapter adapterInstance = adapterClass.getDeclaredConstructor().newInstance();
+					adapterInstance.compile(segment);
+					return adapterInstance;
+				} catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException ex) {
+					String message = "Failed to initialize expression language for parameterized test. "
+							+ "See nested exception for further details.";
+					throw new JUnitException(message, ex);
+				}
+			});
+	}
+
 	private static PlaceholderPosition findFirstPlaceholder(PartialFormatters formatters, String segment) {
 		if (segment.length() < formatters.minimumPlaceholderLength) {
 			return null;
@@ -129,10 +150,11 @@ else if (minimum == null || index < minimum.index) {
 		return minimum;
 	}
 
-	private static PartialFormatter determineNonPlaceholderFormatter(String segment, int argumentMaxLength) {
-		return segment.contains("{") //
-				? new MessageFormatPartialFormatter(segment, argumentMaxLength) //
-				: (context, result) -> result.append(segment);
+	private NonPlaceholderFormatter determineNonPlaceholderFormatter(
+			ParameterizedTestMethodContext methodContext, String segment, int argumentMaxLength) {
+		return createExpressionLanguageAdapter(methodContext, segment)
+				.map(expressionLanguageAdapter -> (NonPlaceholderFormatter) new ExpressionLanguageNonPlaceholderFormatter(expressionLanguageAdapter))
+				.orElseGet(() -> new DefaultNonPlaceholderFormatter(segment, argumentMaxLength));
 	}
 
 	private PartialFormatters createPartialFormatters(String displayName, ParameterizedTestMethodContext methodContext,
@@ -143,15 +165,15 @@ private PartialFormatters createPartialFormatters(String displayName, Parameteri
 				argumentMaxLength));
 
 		PartialFormatters formatters = new PartialFormatters();
-		formatters.put(INDEX_PLACEHOLDER, PartialFormatter.INDEX);
+		formatters.put(INDEX_PLACEHOLDER, PlaceholderFormatter.INDEX);
 		formatters.put(DISPLAY_NAME_PLACEHOLDER, (context, result) -> result.append(displayName));
-		formatters.put(ARGUMENT_SET_NAME_PLACEHOLDER, PartialFormatter.ARGUMENT_SET_NAME);
+		formatters.put(ARGUMENT_SET_NAME_PLACEHOLDER, PlaceholderFormatter.ARGUMENT_SET_NAME);
 		formatters.put(ARGUMENTS_WITH_NAMES_PLACEHOLDER, argumentsWithNamesFormatter);
 		formatters.put(ARGUMENTS_PLACEHOLDER, new CachingByArgumentsLengthPartialFormatter(
 			length -> new MessageFormatPartialFormatter(argumentsPattern(length), argumentMaxLength)));
 		formatters.put(ARGUMENT_SET_NAME_OR_ARGUMENTS_WITH_NAMES_PLACEHOLDER, (context, result) -> {
 			PartialFormatter formatterToUse = context.arguments instanceof ArgumentSet //
-					? PartialFormatter.ARGUMENT_SET_NAME //
+					? PlaceholderFormatter.ARGUMENT_SET_NAME //
 					: argumentsWithNamesFormatter;
 			formatterToUse.append(context, result);
 		});
@@ -183,37 +205,29 @@ private static class PlaceholderPosition {
 
 	}
 
-	private static class ArgumentsContext {
-
-		private final int invocationIndex;
-		private final Arguments arguments;
-		private final Object[] consumedArguments;
+	@FunctionalInterface
+	private interface PartialFormatter {
 
-		ArgumentsContext(int invocationIndex, Arguments arguments, Object[] consumedArguments) {
-			this.invocationIndex = invocationIndex;
-			this.arguments = arguments;
-			this.consumedArguments = consumedArguments;
-		}
+		void append(ArgumentsContext context, StringBuffer result);
 	}
 
-	@FunctionalInterface
-	private interface PartialFormatter {
+	private interface PlaceholderFormatter extends PartialFormatter {
 
 		PartialFormatter INDEX = (context, result) -> result.append(context.invocationIndex);
 
 		PartialFormatter ARGUMENT_SET_NAME = (context, result) -> {
 			if (!(context.arguments instanceof ArgumentSet)) {
 				throw new ExtensionConfigurationException(
-					String.format("When the display name pattern for a @ParameterizedTest contains %s, "
-							+ "the arguments must be supplied as an ArgumentSet.",
-						ARGUMENT_SET_NAME_PLACEHOLDER));
+						String.format("When the display name pattern for a @ParameterizedTest contains %s, "
+										+ "the arguments must be supplied as an ArgumentSet.",
+								ARGUMENT_SET_NAME_PLACEHOLDER));
 			}
 			result.append(((ArgumentSet) context.arguments).getName());
 		};
-
-		void append(ArgumentsContext context, StringBuffer result);
 	}
 
+	private interface NonPlaceholderFormatter extends PartialFormatter {}
+
 	private static class MessageFormatPartialFormatter implements PartialFormatter {
 
 		@SuppressWarnings("UnnecessaryUnicodeEscape")
@@ -289,4 +303,34 @@ Set<String> placeholders() {
 		}
 	}
 
+	private static class DefaultNonPlaceholderFormatter implements NonPlaceholderFormatter {
+
+		private final PartialFormatter delegate;
+
+		public DefaultNonPlaceholderFormatter(String segment, int argumentMaxLength) {
+			this.delegate = segment.contains("{") //
+				? new MessageFormatPartialFormatter(segment, argumentMaxLength) //
+				: (context, result) -> result.append(segment);
+		}
+
+		@Override
+		public void append(ArgumentsContext context, StringBuffer result) {
+			delegate.append(context, result);
+		}
+	}
+
+	private static class ExpressionLanguageNonPlaceholderFormatter implements NonPlaceholderFormatter {
+
+		private final ExpressionLanguageAdapter expressionLanguageAdapter;
+
+		public ExpressionLanguageNonPlaceholderFormatter(ExpressionLanguageAdapter expressionLanguageAdapter) {
+			this.expressionLanguageAdapter = expressionLanguageAdapter;
+
+		}
+
+		@Override
+		public void append(ArgumentsContext argumentsContext, StringBuffer result) {
+			expressionLanguageAdapter.format(argumentsContext.arguments.get()[0], result);
+		}
+	}
 }

jupiter-tests/jupiter-tests.gradle.kts

@@ -25,6 +25,7 @@ dependencies {
 	testImplementation(testFixtures(projects.junitJupiterEngine))
 	testImplementation(testFixtures(projects.junitPlatformLauncher))
 	testImplementation(testFixtures(projects.junitPlatformReporting))
+	implementation(libs.mustache)
 }
 
 tasks {