Validate that there are enough arguments to inject @Parameter fields

`ArgumentCountValidator` now also validates that there are enough
arguments for all required parameters which is currently only the case
for indexed `@Parameter` fields.

Fixes #5079.

---------

Co-authored-by: Marc Philipp <mail@marcphilipp.de>

Author: jihun4452

documentation/src/docs/asciidoc/release-notes/release-notes-5.14.1.adoc

@@ -45,7 +45,8 @@ repository on GitHub.
 [[release-notes-5.14.1-junit-jupiter-new-features-and-improvements]]
 ==== New Features and Improvements
 
-* ❓
+* Improve error message when using `@ParameterizedClass` with field injection and not
+  providing enough arguments.
 
 
 [[release-notes-5.14.1-junit-vintage]]

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:
@@ -45,19 +47,35 @@ void validate(ExtensionContext extensionContext) {
 				int consumedCount = this.declarationContext.getResolverFacade().determineConsumedArgumentCount(
 					this.arguments);
 				int totalCount = this.arguments.getTotalLength();
-				Preconditions.condition(consumedCount == totalCount, () -> String.format(
-					"Configuration error: @%s consumes %s %s but there %s %s %s provided.%nNote: the provided arguments were %s",
-					this.declarationContext.getAnnotationName(), consumedCount,
-					pluralize(consumedCount, "parameter", "parameters"), pluralize(totalCount, "was", "were"),
-					totalCount, pluralize(totalCount, "argument", "arguments"),
-					Arrays.toString(this.arguments.getAllPayloads())));
-				break;
-			default:
-				throw new ExtensionConfigurationException(
-					"Unsupported argument count validation mode: " + argumentCountValidationMode);
+				Preconditions.condition(consumedCount == totalCount,
+					() -> 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/ParameterizedClassContext.java

@@ -129,6 +129,7 @@ public ResolverFacade getResolverFacade() {
 	@Override
 	public ClassTemplateInvocationContext createInvocationContext(ParameterizedInvocationNameFormatter formatter,
 			Arguments arguments, int invocationIndex) {
+
 		return new ParameterizedClassInvocationContext(this, formatter, arguments, invocationIndex);
 	}
 

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

@@ -96,7 +96,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) {
@@ -146,27 +148,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()) {
@@ -491,6 +501,7 @@ public Object resolve(ParameterContext parameterContext, int parameterIndex, Ext
 		@Override
 		public Object resolve(FieldContext fieldContext, ExtensionContext extensionContext,
 				EvaluatedArgumentSet arguments, int invocationIndex) {
+
 			Object argument = arguments.getConsumedPayload(fieldContext.getParameterIndex());
 			try {
 				return this.argumentConverter.convert(argument, fieldContext);
@@ -769,4 +780,7 @@ public Object resolve(ParameterContext parameterContext, ExtensionContext extens
 					invocationIndex, Optional.of(parameterContext)));
 		}
 	}
+
+	record RequiredParameterCount(int value, String reason) {
+	}
 }

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

@@ -549,6 +549,17 @@ void declaredIndexMustBeUnique() {
 						"Configuration error: duplicate index declared in @Parameter(0) annotation on fields [int %s.i, long %s.l].".formatted(
 							classTemplateClass.getName(), classTemplateClass.getName()))));
 		}
+
+		@Test
+		void failsWithMeaningfulErrorWhenTooFewArgumentsProvidedForFieldInjection() {
+			var results = executeTestsForClass(NotEnoughArgumentsForFieldsTestCase.class);
+
+			results.containerEvents().assertThatEvents() //
+					.haveExactly(1, finishedWithFailure(message(withPlatformSpecificLineSeparator(
+						"""
+								Configuration error: @ParameterizedClass has 2 required parameters (due to field injection) but there was 1 argument provided.
+								Note: the provided arguments were [1]"""))));
+		}
 	}
 
 	@Nested
@@ -723,13 +734,12 @@ void failsForLifecycleMethodWithInvalidParameters() {
 
 			var results = executeTestsForClass(LifecycleMethodWithInvalidParametersTestCase.class);
 
-			var expectedMessage = """
-					2 configuration errors:
-					- parameter 'value' with index 0 is incompatible with the parameter declared on the parameterized class: expected type 'int' but found 'long'
-					- parameter 'anotherValue' with index 1 must not be annotated with @ConvertWith
-					""";
-			expectedMessage = expectedMessage.trim() //
-					.replace("\n", System.lineSeparator()); // use platform-specific line separators
+			var expectedMessage = withPlatformSpecificLineSeparator(
+				"""
+						2 configuration errors:
+						- parameter 'value' with index 0 is incompatible with the parameter declared on the parameterized class: \
+						expected type 'int' but found 'long'
+						- parameter 'anotherValue' with index 1 must not be annotated with @ConvertWith""");
 
 			var failedResult = getFirstTestExecutionResult(results.containerEvents().failed());
 			assertThat(failedResult.getThrowable().orElseThrow()) //
@@ -792,6 +802,10 @@ void lifecycleMethodsMustNotBeDeclaredInRegularTestClasses() {
 		}
 	}
 
+	private static String withPlatformSpecificLineSeparator(String textBlock) {
+		return textBlock.replace("\n", System.lineSeparator());
+	}
+
 	// -------------------------------------------------------------------
 
 	private static Stream<String> invocationDisplayNames(EngineExecutionResults results) {
@@ -1689,6 +1703,22 @@ void test() {
 		}
 	}
 
+	@ParameterizedClass
+	@ValueSource(ints = 1)
+	static class NotEnoughArgumentsForFieldsTestCase {
+
+		@Parameter(0)
+		int i;
+
+		@Parameter(1)
+		String s;
+
+		@org.junit.jupiter.api.Test
+		void test() {
+			fail("should not be called");
+		}
+	}
+
 	@ParameterizedClass
 	@CsvSource({ "unused1, foo, unused2, bar", "unused4, baz, unused5, qux" })
 	static class InvalidUnusedParameterIndexesTestCase {