@ArgumentsSource with custom providers in JUnit - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of the @ArgumentsSource annotation in JUnit?

It allows you to provide custom argument sources for parameterized tests by specifying a class that implements the <code>ArgumentsProvider</code> interface.

beginner

What interface must a custom argument provider implement to be used with @ArgumentsSource?

The custom provider must implement the ArgumentsProvider interface and override the provideArguments(ExtensionContext context) method.

intermediate

How does the provideArguments method work in a custom ArgumentsProvider?

It returns a Stream<Arguments> that supplies the test method with different sets of parameters for each test invocation.

intermediate

Why would you use a custom @ArgumentsSource instead of built-in sources like @ValueSource or @CsvSource?

Custom providers let you generate complex or dynamic test data that built-in sources cannot easily provide, such as data from files, databases, or computed values.

beginner

Show a simple example of a custom <code>ArgumentsProvider</code> class for <code>@ArgumentsSource</code>.

public class SimpleArgumentsProvider implements ArgumentsProvider {
  @Override
  public Stream<Arguments> provideArguments(ExtensionContext context) {
    return Stream.of(
      Arguments.of("apple", 1),
      Arguments.of("banana", 2)
    );
  }
}

Which interface must a class implement to be used with @ArgumentsSource in JUnit?

A TestTemplateInvocationContextProvider

B TestSource

C ArgumentsProvider

D ParameterResolver

The ArgumentsProvider interface is required to supply arguments for parameterized tests using @ArgumentsSource.

What does the provideArguments method return in a custom ArgumentsProvider?

A Stream<Arguments>

B List<String>

C Set<Object>

D Map<String, Object>

The method returns a Stream<Arguments> to supply multiple argument sets to the test method.

Why use a custom @ArgumentsSource instead of @ValueSource?

A To generate complex or dynamic test data

B Because <code>@ValueSource</code> is deprecated

C To provide simple fixed values only

D To run tests without parameters

Custom providers allow complex or dynamic data, such as from files or computations, which @ValueSource cannot handle.

Which of these is a valid way to use @ArgumentsSource in a test method?

A @ArgumentsSource("SimpleArgumentsProvider") void test(String fruit) { ... }

B @ArgumentsSource(SimpleArgumentsProvider.class) void test(String fruit, int number) { ... }

C @ArgumentsSource void test(int number) { ... }

D @ArgumentsSource(SimpleArgumentsProvider) void test() { ... }

You must specify the class with .class and match the method parameters to the arguments provided.

What happens if your custom ArgumentsProvider returns an empty stream?

A The test runs once with null arguments

B JUnit throws an exception

C The test is skipped

D The test runs zero times (no invocations)

If no arguments are provided, the parameterized test runs zero times.

Explain how to create and use a custom argument provider with @ArgumentsSource in JUnit.

Think about the steps to supply custom data to parameterized tests.

Describe scenarios where using a custom @ArgumentsSource is better than built-in sources.

Consider when simple fixed values are not enough.