fix: validate argument count for ParameterizedClass field injection

Author: jihun4452

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

@@ -27,9 +27,7 @@
 import java.util.List;
 import java.util.function.Predicate;
 
-import org.jspecify.annotations.Nullable;
 import org.junit.jupiter.api.TestInstance;
-import org.junit.jupiter.api.extension.ParameterResolutionException;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.platform.commons.JUnitException;
 import org.junit.platform.commons.support.HierarchyTraversalMode;
@@ -133,10 +131,6 @@ public ResolverFacade getResolverFacade() {
 	public ParameterizedClassInvocationContext createInvocationContext(ParameterizedInvocationNameFormatter formatter,
 			Arguments arguments, int invocationIndex) {
 
-		if (this.injectionType == InjectionType.FIELDS) {
-			assertEnoughArgumentsForFieldInjection(arguments);
-		}
-
 		return new ParameterizedClassInvocationContext(this, formatter, arguments, invocationIndex);
 	}
 
@@ -179,65 +173,6 @@ private static <A extends Annotation> A getAnnotation(Method method, Class<A> an
 				.orElseThrow(() -> new JUnitException("Method not annotated with @" + annotationType.getSimpleName()));
 	}
 
-	private void assertEnoughArgumentsForFieldInjection(Arguments arguments) {
-		@SuppressWarnings("NullAway")
-		final Object[] providedArguments = (arguments == null ? new Object[0] : arguments.get());
-		final int providedArgumentCount = providedArguments.length;
-
-		final List<Field> parameterFields = findParameterAnnotatedFields(this.testClass);
-		if (parameterFields.isEmpty()) {
-			return;
-		}
-
-		final int requiredArgumentCount = requiredArgumentCountForParameterFields(parameterFields);
-		if (providedArgumentCount >= requiredArgumentCount) {
-			return;
-		}
-
-		final @Nullable Field firstMissingField = firstMissingParameterFieldByIndex(parameterFields,
-			providedArgumentCount);
-
-		final String missingTargetDescription = (firstMissingField != null)
-				? "field '%s' (index %d, type %s)".formatted(firstMissingField.getName(),
-					firstMissingField.getAnnotation(Parameter.class).value(), firstMissingField.getType().getName())
-				: "parameter at index %d".formatted(providedArgumentCount);
-
-		throw new ParameterResolutionException(
-			"Not enough arguments for @ParameterizedClass field injection in %s: %s cannot be injected because only %d argument(s) were provided; at least %d are required.".formatted(
-				this.testClass.getName(), missingTargetDescription, providedArgumentCount, requiredArgumentCount));
-	}
-
-	private static int requiredArgumentCountForParameterFields(List<Field> parameterFields) {
-		int maxIndex = -1;
-		for (Field field : parameterFields) {
-			Parameter param = field.getAnnotation(Parameter.class);
-			if (param != null) {
-				int index = param.value();
-				if (index >= 0 && index > maxIndex) {
-					maxIndex = index;
-				}
-			}
-		}
-		return maxIndex + 1;
-	}
-
-	private static @Nullable Field firstMissingParameterFieldByIndex(List<Field> parameterFields,
-			int providedArgumentCount) {
-		Field candidate = null;
-		int minIndex = Integer.MAX_VALUE;
-		for (Field field : parameterFields) {
-			Parameter param = field.getAnnotation(Parameter.class);
-			if (param != null) {
-				int index = param.value();
-				if (index >= 0 && index >= providedArgumentCount && index < minIndex) {
-					candidate = field;
-					minIndex = index;
-				}
-			}
-		}
-		return candidate;
-	}
-
 	enum InjectionType {
 		CONSTRUCTOR, FIELDS
 	}

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

@@ -65,6 +65,8 @@ 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

@@ -464,6 +464,43 @@ 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
@@ -495,6 +532,8 @@ 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 {
 				return this.argumentConverter.convert(argument, fieldContext);

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

@@ -560,7 +560,7 @@ void failsWithMeaningfulErrorWhenTooFewArgumentsProvidedForFieldInjection() {
 			results.containerEvents().assertThatEvents()
 					.haveExactly(1, event(finishedWithFailure(
 							instanceOf(org.junit.jupiter.api.extension.ParameterResolutionException.class),
-							message(it -> it.contains("field 's")
+							message(it -> it.contains("field 's'")
 									&& it.contains("index 1")
 									&& it.contains("only 1 argument")
 									&& it.contains("at least 2"))