Add List-based support to Arguments API

junit-jupiter-params/src/main/java/org/junit/jupiter/params/provider/Arguments.java

@@ -13,6 +13,10 @@
 import static org.apiguardian.api.API.Status.EXPERIMENTAL;
 import static org.apiguardian.api.API.Status.STABLE;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
 import org.apiguardian.api.API;
 import org.jspecify.annotations.Nullable;
 import org.junit.platform.commons.util.Preconditions;
@@ -172,4 +176,72 @@ public String toString() {
 
 	}
 
+	/**
+	 * Factory method for creating an instance of {@code Arguments} based on
+	 * the supplied {@code arguments} as a {@link List}.
+	 *
+	 * @param arguments the arguments as a List to be used for an invocation
+	 * of the test method; must not be {@code null} but may contain {@code null}
+	 * @return an instance of {@code Arguments}; never {@code null}
+	 * @see #arguments(List)
+	 */
+	@API(status = EXPERIMENTAL, since = "6.0")
+	static Arguments of(@Nullable List<@Nullable Object> arguments) {
+		if (arguments == null) {
+			return of((Object) null); // Properly wrap null
+		}
+		if (arguments.isEmpty()) {
+			// Must still return empty arguments array
+			return of(new Object[0]);
+		}
+		return () -> arguments.toArray(new Object[0]);
+	}
+
+	/**
+	 * Factory method for creating an instance of {@code Arguments} based on
+	 * the supplied {@code arguments} as a {@link List}.
+	 *
+	 * <p>This method is an <em>alias</em> for {@link Arguments#of} and is
+	 * intended to be used when statically imported &mdash; for example, via:
+	 * {@code import static org.junit.jupiter.params.provider.Arguments.arguments;}
+	 *
+	 * @param arguments the arguments as a List to be used for an invocation of the test
+	 * method; must not be {@code null} but may contain {@code null}
+	 * @return an instance of {@code Arguments}; never {@code null}
+	 * @since 6.0
+	 * @see #argumentSet(String, Object...)
+	 */
+	@API(status = EXPERIMENTAL, since = "6.0")
+	static Arguments arguments(List<@Nullable Object> arguments) {
+		return of(arguments);
+	}
+
+	/**
+	 * Factory method for creating an {@link ArgumentSet} based on the supplied
+	 * {@code name} and {@code arguments} as a List.
+	 *
+	 * @param name the name of the argument set; must not be {@code null} or blank
+	 * @param arguments the arguments list to be used for an invocation of the test
+	 * method; must not be {@code null} but may contain {@code null}
+	 * @return an {@code ArgumentSet}; never {@code null}
+	 * @since 6.0
+	 */
+	@API(status = EXPERIMENTAL, since = "6.0")
+	static ArgumentSet argumentSet(String name, List<@Nullable Object> arguments) {
+		Preconditions.notBlank(name, "name must not be null or blank");
+		Preconditions.notNull(arguments, "arguments list must not be null");
+		return new ArgumentSet(name, arguments.toArray(new Object[0]));
+	}
+
+	/**
+	 * Convert the arguments to a mutable List.
+	 *
+	 * @return a mutable List of arguments; never {@code null} but may contain {@code null}
+	 * @since 6.0
+	 */
+	@API(status = EXPERIMENTAL, since = "6.0")
+	default List<@Nullable Object> toList() {
+		return new ArrayList<>(Arrays.asList(get()));
+	}
+
 }

junit-jupiter-params/src/main/java/org/junit/jupiter/params/provider/EmptyArgumentsProvider.java

@@ -57,7 +57,7 @@ public Stream<? extends Arguments> provideArguments(ParameterDeclarations parame
 			return Stream.of(arguments(Collections.emptySet()));
 		}
 		if (List.class.equals(parameterType)) {
-			return Stream.of(arguments(Collections.emptyList()));
+			return Stream.of(Arguments.of((Object) Collections.emptyList()));
 		}
 		if (Set.class.equals(parameterType)) {
 			return Stream.of(arguments(Collections.emptySet()));

jupiter-tests/src/test/java/org/junit/jupiter/params/provider/ArgumentsTests.java

@@ -15,7 +15,11 @@
 import static org.junit.jupiter.params.provider.Arguments.arguments;
 import static org.junit.jupiter.params.provider.Arguments.of;
 
+import java.util.Arrays;
+import java.util.List;
+
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.provider.Arguments.ArgumentSet;
 
 /**
  * Unit tests for {@link Arguments}.
@@ -56,4 +60,50 @@ void argumentsReturnsSameArrayUsedForCreating() {
 		assertThat(arguments.get()).isSameAs(input);
 	}
 
+	@Test
+	void ofSupportsList() {
+		List<Object> input = Arrays.asList(1, "two", null, 3.0);
+		Arguments arguments = Arguments.of(input);
+
+		assertArrayEquals(new Object[] { 1, "two", null, 3.0 }, arguments.get());
+	}
+
+	@Test
+	void argumentsSupportsListAlias() {
+		List<Object> input = Arrays.asList("a", 2, null);
+		Arguments arguments = Arguments.arguments(input);
+
+		assertArrayEquals(new Object[] { "a", 2, null }, arguments.get());
+	}
+
+	@Test
+	void argumentSetSupportsList() {
+		List<Object> input = Arrays.asList("x", null, 42);
+		ArgumentSet argumentSet = Arguments.argumentSet("list-test", input);
+
+		assertArrayEquals(new Object[] { "x", null, 42 }, argumentSet.get());
+		assertThat(argumentSet.getName()).isEqualTo("list-test");
+	}
+
+	@Test
+	void toListReturnsMutableListOfArguments() {
+		Arguments arguments = Arguments.of(Arrays.asList("a", 2, null));
+
+		List<Object> result = arguments.toList();
+
+		assertThat(result).containsExactly("a", 2, null); // preserves content
+		result.add("extra"); // confirms mutability
+		assertThat(result).contains("extra");
+	}
+
+	@Test
+	void toListWorksOnEmptyArguments() {
+		Arguments arguments = Arguments.of(Arrays.asList());
+
+		List<Object> result = arguments.toList();
+
+		assertThat(result).isEmpty();
+		result.add("extra");
+		assertThat(result).containsExactly("extra");
+	}
 }