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,80 @@ 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 {@link List} of {@code arguments}.
+	 *
+	 * @param arguments the arguments 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 {@link List} of {@code arguments}.
+	 *
+	 * <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 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 {@link List} of {@code arguments}.
+	 *
+	 * <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 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 +249,4 @@ public String toString() {
 		}
 
 	}
-
 }

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

@@ -15,7 +15,12 @@
 import static org.junit.jupiter.params.provider.Arguments.arguments;
 import static org.junit.jupiter.params.provider.Arguments.of;
 
+import java.util.ArrayList;
+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 +61,75 @@ void argumentsReturnsSameArrayUsedForCreating() {
 		assertThat(arguments.get()).isSameAs(input);
 	}
 
+	@Test
+	void fromSupportsList() {
+		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 fromSupportsListDefensiveCopy() {
+		List<Object> input = new ArrayList<>(Arrays.asList(1, "two", null, 3.0));
+		Arguments arguments = Arguments.from(input);
+
+		// Modify input
+		input.set(1, "changed");
+		input.add("new");
+
+		// Assert that arguments are unchanged
+		assertArrayEquals(new Object[] { 1, "two", null, 3.0 }, arguments.get());
+	}
+
+	@Test
+	void argumentsFromSupportsList() {
+		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.of("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 toListDoesNotAffectInternalArgumentsState() {
+		Arguments arguments = Arguments.of("a", 2, null);
+
+		List<Object> result = arguments.toList();
+		result.add("extra"); // mutate the returned list
+
+		// Confirm that internal state was not modified
+		List<Object> freshCopy = arguments.toList();
+		assertThat(freshCopy).containsExactly("a", 2, null);
+	}
+
+	@Test
+	void toListWorksOnEmptyArguments() {
+		Arguments arguments = Arguments.of();
+
+		List<Object> result = arguments.toList();
+
+		assertThat(result).isEmpty();
+		result.add("extra");
+		assertThat(result).containsExactly("extra");
+	}
 }