Move required parameter validation into ArgumentCountValidator

Author: marcphilipp

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

@@ -13,6 +13,7 @@
 import java.util.Arrays;
 import java.util.Optional;
 
+import org.jspecify.annotations.Nullable;
 import org.junit.jupiter.api.extension.ExtensionConfigurationException;
 import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
@@ -36,6 +37,7 @@ class ArgumentCountValidator {
 	}
 
 	void validate(ExtensionContext extensionContext) {
+		validateRequiredArgumentsArePresent();
 		ArgumentCountValidationMode argumentCountValidationMode = getArgumentCountValidationMode(extensionContext);
 		switch (argumentCountValidationMode) {
 			case DEFAULT, NONE -> {
@@ -45,17 +47,34 @@ void validate(ExtensionContext extensionContext) {
 					this.arguments);
 				int totalCount = this.arguments.getTotalLength();
 				Preconditions.condition(consumedCount == totalCount,
-					() -> "Configuration error: @%s consumes %s %s but there %s %s %s provided.%nNote: the provided arguments were %s".formatted(
-						this.declarationContext.getAnnotationName(), consumedCount,
-						pluralize(consumedCount, "parameter", "parameters"), pluralize(totalCount, "was", "were"),
-						totalCount, pluralize(totalCount, "argument", "arguments"),
-						Arrays.toString(this.arguments.getAllPayloads())));
+					() -> wrongNumberOfArgumentsMessages("consumes", consumedCount, null, null));
 			}
 			default -> throw new ExtensionConfigurationException(
 				"Unsupported argument count validation mode: " + argumentCountValidationMode);
 		}
 	}
 
+	private void validateRequiredArgumentsArePresent() {
+		var requiredParameterCount = this.declarationContext.getResolverFacade().getRequiredParameterCount();
+		if (requiredParameterCount != null) {
+			var totalCount = this.arguments.getTotalLength();
+			Preconditions.condition(requiredParameterCount.value() <= totalCount,
+				() -> wrongNumberOfArgumentsMessages("has", requiredParameterCount.value(), "required",
+					requiredParameterCount.reason()));
+		}
+	}
+
+	private String wrongNumberOfArgumentsMessages(String verb, int actualCount, @Nullable String parameterAdjective,
+			@Nullable String reason) {
+		int totalCount = this.arguments.getTotalLength();
+		return "Configuration error: @%s %s %s %s%s%s but there %s %s %s provided.%nNote: the provided arguments were %s".formatted(
+			this.declarationContext.getAnnotationName(), verb, actualCount,
+			parameterAdjective == null ? "" : parameterAdjective + " ",
+			pluralize(actualCount, "parameter", "parameters"), reason == null ? "" : " (due to %s)".formatted(reason),
+			pluralize(totalCount, "was", "were"), totalCount, pluralize(totalCount, "argument", "arguments"),
+			Arrays.toString(this.arguments.getAllPayloads()));
+	}
+
 	private ArgumentCountValidationMode getArgumentCountValidationMode(ExtensionContext extensionContext) {
 		ArgumentCountValidationMode mode = declarationContext.getArgumentCountValidationMode();
 		if (mode != ArgumentCountValidationMode.DEFAULT) {

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

@@ -65,8 +65,6 @@ private ClassTemplateConstructorParameterResolver createExtensionForConstructorI
 	}
 
 	private Extension createExtensionForFieldInjection() {
-		this.declarationContext.getResolverFacade().assertEnoughFieldArguments(this.arguments);
-
 		ResolverFacade resolverFacade = this.declarationContext.getResolverFacade();
 		TestInstance.Lifecycle lifecycle = this.declarationContext.getTestInstanceLifecycle();
 		return switch (lifecycle) {

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

@@ -98,7 +98,9 @@ static ResolverFacade create(Class<?> clazz, List<Field> fields) {
 		Stream.concat(uniqueIndexedParameters.values().stream(), aggregatorParameters.stream()) //
 				.forEach(declaration -> makeAccessible(declaration.getField()));
 
-		return new ResolverFacade(clazz, uniqueIndexedParameters, aggregatorParameters, 0);
+		var requiredParameterCount = new RequiredParameterCount(uniqueIndexedParameters.size(), "field injection");
+
+		return new ResolverFacade(clazz, uniqueIndexedParameters, aggregatorParameters, 0, requiredParameterCount);
 	}
 
 	static ResolverFacade create(Constructor<?> constructor, ParameterizedClass annotation) {
@@ -155,27 +157,35 @@ else if (aggregatorParameters.isEmpty()) {
 			}
 		}
 		return new ResolverFacade(executable, indexedParameters, new LinkedHashSet<>(aggregatorParameters.values()),
-			indexOffset);
+			indexOffset, null);
 	}
 
 	private final int parameterIndexOffset;
 	private final Map<ParameterDeclaration, Resolver> resolvers;
 	private final DefaultParameterDeclarations indexedParameterDeclarations;
 	private final Set<? extends ResolvableParameterDeclaration> aggregatorParameters;
+	private final @Nullable RequiredParameterCount requiredParameterCount;
 
 	private ResolverFacade(AnnotatedElement sourceElement,
 			NavigableMap<Integer, ? extends ResolvableParameterDeclaration> indexedParameters,
-			Set<? extends ResolvableParameterDeclaration> aggregatorParameters, int parameterIndexOffset) {
+			Set<? extends ResolvableParameterDeclaration> aggregatorParameters, int parameterIndexOffset,
+			@Nullable RequiredParameterCount requiredParameterCount) {
 		this.aggregatorParameters = aggregatorParameters;
 		this.parameterIndexOffset = parameterIndexOffset;
 		this.resolvers = new ConcurrentHashMap<>(indexedParameters.size() + aggregatorParameters.size());
 		this.indexedParameterDeclarations = new DefaultParameterDeclarations(sourceElement, indexedParameters);
+		this.requiredParameterCount = requiredParameterCount;
 	}
 
 	ParameterDeclarations getIndexedParameterDeclarations() {
 		return this.indexedParameterDeclarations;
 	}
 
+	@Nullable
+	RequiredParameterCount getRequiredParameterCount() {
+		return this.requiredParameterCount;
+	}
+
 	boolean isSupportedParameter(ParameterContext parameterContext, EvaluatedArgumentSet arguments) {
 		int index = toLogicalIndex(parameterContext);
 		if (this.indexedParameterDeclarations.get(index).isPresent()) {
@@ -464,43 +474,6 @@ private static ParameterResolutionException parameterResolutionException(String
 		return new ParameterResolutionException(fullMessage, cause);
 	}
 
-	private static void assertFieldAvailableOrThrow(FieldContext fieldContext, EvaluatedArgumentSet arguments) {
-		int parameterIndex = fieldContext.getParameterIndex();
-		int provided = arguments.getTotalLength();
-		int required = parameterIndex + 1;
-
-		if (provided < required) {
-			Field field = fieldContext.getField();
-			throw new org.junit.jupiter.api.extension.ParameterResolutionException(
-				("Not enough arguments for @ParameterizedClass field injection: "
-						+ "field '%s' (index %d, type %s) cannot be injected because "
-						+ "only %d argument(s) were provided; at least %d are required.").formatted(field.getName(),
-							parameterIndex, field.getType().getName(), provided, required));
-		}
-	}
-
-	void assertEnoughFieldArguments(EvaluatedArgumentSet arguments) {
-		int provided = arguments.getTotalLength();
-		int required = determineConsumedArgumentLength(Integer.MAX_VALUE);
-
-		if (provided < required) {
-			int missingIndex = provided;
-			var maybeDecl = getIndexedParameterDeclarations().get(missingIndex);
-			if (maybeDecl.isPresent() && maybeDecl.get() instanceof FieldParameterDeclaration fpd) {
-				Field field = fpd.getField();
-				throw new org.junit.jupiter.api.extension.ParameterResolutionException(
-					("Not enough arguments for @ParameterizedClass field injection: "
-							+ "field '%s' (index %d, type %s) cannot be injected because "
-							+ "only %d argument(s) were provided; at least %d are required.").formatted(field.getName(),
-								missingIndex, field.getType().getName(), provided, required));
-			}
-			throw new org.junit.jupiter.api.extension.ParameterResolutionException(
-				"Not enough arguments for @ParameterizedClass field injection: "
-						+ "index %d cannot be injected because only %d argument(s) were provided; at least %d are required.".formatted(
-							missingIndex, provided, required));
-		}
-	}
-
 	private interface Resolver {
 
 		@Nullable
@@ -532,7 +505,6 @@ private record Converter(ArgumentConverter argumentConverter) implements Resolve
 		@Override
 		public @Nullable Object resolve(FieldContext fieldContext, ExtensionContext extensionContext,
 				EvaluatedArgumentSet arguments, int invocationIndex) {
-			ResolverFacade.assertFieldAvailableOrThrow(fieldContext, arguments);
 
 			Object argument = arguments.getConsumedPayload(fieldContext.getParameterIndex());
 			try {
@@ -791,4 +763,7 @@ public boolean supports(ParameterContext parameterContext) {
 					invocationIndex, Optional.of(parameterContext)));
 		}
 	}
+
+	record RequiredParameterCount(int value, String reason) {
+	}
 }

jupiter-tests/src/test/java/org/junit/jupiter/params/ParameterizedClassIntegrationTests.java

@@ -557,14 +557,11 @@ void declaredIndexMustBeUnique() {
 		void failsWithMeaningfulErrorWhenTooFewArgumentsProvidedForFieldInjection() {
 			var results = executeTestsForClass(NotEnoughArgumentsForFieldsTestCase.class);
 
-			results.containerEvents().assertThatEvents()
-					.haveExactly(1, event(finishedWithFailure(
-							instanceOf(org.junit.jupiter.api.extension.ParameterResolutionException.class),
-							message(it -> it.contains("field 's'")
-									&& it.contains("index 1")
-									&& it.contains("only 1 argument")
-									&& it.contains("at least 2"))
-					)));
+			results.containerEvents().assertThatEvents() //
+					.haveExactly(1, finishedWithFailure(message(
+						"""
+								Configuration error: @ParameterizedClass has 2 required parameters (due to field injection) but there was 1 argument provided.
+								Note: the provided arguments were [1]""")));
 		}
 	}