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;
@@ -125,6 +129,77 @@ static ArgumentSet argumentSet(String name, @Nullable Object... arguments) {
 		return new ArgumentSet(name, arguments);
 	}
 
+	/**
+	 * 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}
+	 * @since 6.0
+	 * @see #argumentsFrom(List)
+	 */
+	@API(status = EXPERIMENTAL, since = "6.0")
+	static Arguments from(List<@Nullable Object> arguments) {
+		Preconditions.notNull(arguments, "arguments must not be null");
+		return of(arguments.toArray());
+	}
+
+	/**
+	 * 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#from} and is
+	 * intended to be used when statically imported &mdash; for example, via:
+	 * {@code import static org.junit.jupiter.params.provider.Arguments.argumentsFrom;}
+	 *
+	 * @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 argumentsFrom(List<@Nullable Object> arguments) {
+		return from(arguments);
+	}
+
+	/**
+	 * Factory method for creating an {@link ArgumentSet} based on the supplied
+	 * {@code name} and {@code arguments} as a {@link List}.
+	 *
+	 * <p>This method is a convenient alternative to {@link #argumentSet(String, Object...)}
+	 * when working with {@link List} based inputs.
+	 *
+	 * @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
+	 * @see #argumentSet(String, Object...)
+	 */
+	@API(status = EXPERIMENTAL, since = "6.0")
+	static ArgumentSet argumentSetFrom(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());
+	}
+
+	/**
+	 * Convert the arguments to a new mutable {@link List} containing the same
+	 * elements as {@link #get()}.
+	 *
+	 * <p>This is useful for test logic that benefits from {@code List} operations such as filtering,
+	 * transformation, or assertions.
+	 *
+	 * @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()));
+	}
+
 	/**
 	 * Specialization of {@link Arguments} that associates a {@link #getName() name}
 	 * with a set of {@link #get() arguments}.
@@ -171,5 +246,4 @@ public String toString() {
 		}
 
 	}
-
 }

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.from(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.argumentsFrom(input);
+
+		assertArrayEquals(new Object[] { "a", 2, null }, arguments.get());
+	}
+
+	@Test
+	void argumentSetSupportsList() {
+		List<Object> input = Arrays.asList("x", null, 42);
+		ArgumentSet argumentSet = Arguments.argumentSetFrom("list-test", input);
+
+		assertArrayEquals(new Object[] { "x", null, 42 }, argumentSet.get());
+		assertThat(argumentSet.getName()).isEqualTo("list-test");
+	}
+
+	@Test
+	void toListReturnsMutableListOfArguments() {
+		Arguments arguments = Arguments.from(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.from(Arrays.asList());
+
+		List<Object> result = arguments.toList();
+
+		assertThat(result).isEmpty();
+		result.add("extra");
+		assertThat(result).containsExactly("extra");
+	}
 }