What rules must a JUnit 5 @MethodSource factory method satisfy — must it be static, which return types are accepted — and how do you supply several arguments per invocation versus a single one?

## Why static is the default JUnit Jupiter's default test-instance lifecycle is `PER_METHOD`: a new instance of the test class is constructed for **every** test invocation, so that state cannot leak between tests. Argument resolution, however, happens *before* those instances exist — the engine must know how many invocations there are in order to create them. With no instance available, the factory has to be `static`. The escape hatch is the lifecycle itself: ```java @TestInstance(TestInstance.Lifecycle.PER_CLASS) class OrderTest { Stream<Arguments> cases() { ... } // non-static is now legal } ``` `PER_CLASS` creates one instance for the whole class, so a non-static factory (and non-static `@BeforeAll`) becomes possible. The trade is real: a single instance means fields are shared across all tests in the class, and you become responsible for resetting them. Reach for `PER_CLASS` when the factory genuinely needs instance state — an injected fixture, a value computed in a constructor — not to save typing `static`. A factory declared in a **different** class must always be static, regardless of the test class's lifecycle. ## Accepted return types JUnit accepts anything it can iterate: - `Stream<?>` — the common choice, including `Stream<Arguments>`. - `IntStream`, `LongStream`, `DoubleStream` — handy for numeric single-parameter tests: `IntStream.rangeClosed(1, 100)`. - `Iterable<?>`, `Iterator<?>`, `Collection<?>` — a `List<Arguments>` is perfectly idiomatic. - Arrays — `Object[][]` for multi-parameter cases, `int[]`/`String[]` for single-parameter ones. JUnit **closes** a returned `Stream` after consuming it. That makes ```java static Stream<String> lines() throws IOException { return Files.lines(Path.of("src/test/resources/cases.txt")); } ``` safe — no leaked file handle. The corollary is that you must not hand back a stream you plan to reuse elsewhere, and never a stream that has already been consumed (that throws `IllegalStateException` and the failure looks unrelated to the test). The factory itself is invoked **once per test method**, not once per invocation, so any expensive setup inside it is paid once. ## Element shape: the rule people get wrong The element type must match the *arity* of the test method: **Several parameters → `Arguments` per element.** ```java static Stream<Arguments> discounts() { return Stream.of( arguments(new Order(100), Tier.GOLD, new BigDecimal("10.00")), arguments(new Order(100), Tier.BASIC, BigDecimal.ZERO) ); } ``` `Arguments.of(...)` and its static shorthand `arguments(...)` both live in `org.junit.jupiter.params.provider.Arguments`. An `Object[]` per element works identically but loses readability. **One parameter → bare values.** ```java static Stream<String> blanks() { return Stream.of("", " ", "\t"); } ``` Wrapping single values in `Arguments` is legal; forgetting to wrap when there are two parameters is not, and produces an argument-count failure. ## Arguments and null `arguments(null, 3)` is fine — factories are the cleanest way to feed `null` into a parameterized test, since the value is a real reference rather than a text convention. Note the compiler may warn about an ambiguous varargs call with a lone `null`; cast it (`arguments((String) null)`) to be explicit. ## Typing and generics `Arguments` is untyped, so the compiler cannot check that the values in a row match the test method's parameter types. A wrong type surfaces at runtime as an argument-conversion or `ClassCastException`-style failure on the affected invocation only. If a table is large and homogeneous, an alternative is a factory returning `Stream<MyCase>` — a small record with named components — bound to a *single* parameter of that type; the test then reads `case.input()` and `case.expected()`, and the compiler checks everything. That pattern trades JUnit's per-argument display names for type safety, and is worth knowing as an option. ## Signature details - **Visibility** does not matter: `private static Stream<Arguments> cases()` works, since the engine uses reflection. Package-private is the common house style. - **Parameters**: keep factories argument-free. A no-arg factory is the portable, always-correct form. - **Checked exceptions** may be declared — `throws IOException` is fine, and a thrown exception fails the test method's container rather than one invocation. - **Return null or an empty stream** and you get no invocations, which JUnit reports as a failure by default rather than a silent pass — a good default, since a source that produced nothing is almost always a bug. ## Interview summary Static unless `PER_CLASS`; returns any iterable-ish type and JUnit closes streams; `Arguments` per element for multi-parameter tests and bare values for single-parameter ones; called once, not per invocation.