Custom argument providers in JUnit - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a class that implements the ArgumentsProvider interface.

JUnit

public class MyArgumentsProvider implements [1] {
    @Override
    public Stream<? extends Arguments> provideArguments(ExtensionContext context) {
        return Stream.of(Arguments.of(1, 2), Arguments.of(3, 4));
    }
}

Drag options to blanks, or click blank then click option'

AExtensionContext

BTest

CArgumentsSource

DArgumentsProvider

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Test annotation instead of implementing ArgumentsProvider.

Implementing the wrong interface like ArgumentsSource.

The class must implement the ArgumentsProvider interface to provide custom arguments for parameterized tests.

2fill in blank

medium

Complete the code to annotate a parameterized test method to use the custom argument provider.

JUnit

@ParameterizedTest
@[1](MyArgumentsProvider.class)
void testWithCustomProvider(int a, int b) {
    assertTrue(a < b);
}

Drag options to blanks, or click blank then click option'

AValueSource

BCsvSource

CArgumentsSource

DTest

Attempts:

3 left

💡 Hint

Common Mistakes

Using @ValueSource or @CsvSource which are for built-in sources.

Using @Test instead of @ParameterizedTest.

The @ArgumentsSource annotation is used to specify a custom ArgumentsProvider class for parameterized tests.

3fill in blank

hard

Fix the error in the method signature to correctly override provideArguments.

JUnit

@Override
public Stream<? extends Arguments> [1](ExtensionContext context) {
    return Stream.of(Arguments.of("hello", 5));
}

Drag options to blanks, or click blank then click option'

AprovideArguments

BprovideArgument

CgetArguments

DargumentsProvider

Attempts:

3 left

💡 Hint

Common Mistakes

Misspelling the method name as provideArgument or getArguments.

Using a different method name that does not override the interface.

The method to override in ArgumentsProvider is provideArguments with an 's' at the end.

4fill in blank

hard

Fill both blanks to create a stream of arguments with a string and an integer.

JUnit

return Stream.of(Arguments.of([1], [2]));

Drag options to blanks, or click blank then click option'

A"JUnit"

B5

Ctrue

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Using boolean or null instead of expected types.

Not quoting the string argument.

Arguments.of takes the values to pass to the test method. Here a string "JUnit" and integer 5 are correct.

5fill in blank

hard

Fill all three blanks to create a parameterized test with a custom argument provider and assert the sum.

JUnit

@ParameterizedTest
@ArgumentsSource([1].class)
void testSum(int x, int y) {
    int sum = x + y;
    assertEquals([2], sum);
}

public static class [3] implements ArgumentsProvider {
    @Override
    public Stream<? extends Arguments> provideArguments(ExtensionContext context) {
        return Stream.of(Arguments.of(2, 3), Arguments.of(4, 5));
    }
}

Drag options to blanks, or click blank then click option'

ASumArgumentsProvider

B5

CMyArgumentsProvider

D7

Attempts:

3 left

💡 Hint

Common Mistakes

Mismatching class names between annotation and class.

Using wrong expected sum values in assertion.

The test uses MyArgumentsProvider as the source, asserts sum equals 5 for first pair, and the class name is MyArgumentsProvider.

Practice

1. What is the main purpose of a custom argument provider in JUnit?

easy

A. To generate test reports

B. To create new test methods automatically

C. To supply test data to parameterized tests in a custom way

D. To replace the @Test annotation

Solution

1. Step 1: Understand the role of argument providers

   Argument providers supply data to parameterized tests, allowing tests to run multiple times with different inputs.

2. Step 2: Identify the purpose of custom argument providers

   Custom argument providers let you define your own way to supply test data beyond built-in sources.

3. Final Answer:

   To supply test data to parameterized tests in a custom way -> Option C

4. Quick Check:

   Custom argument providers = supply test data [OK]

Hint: Custom providers supply test data uniquely for parameterized tests [OK]

Common Mistakes:

• Confusing argument providers with test method creators
• Thinking they replace @Test annotation
• Assuming they generate reports

2. Which interface must you implement to create a custom argument provider in JUnit?

easy

A. ArgumentsSource

B. ArgumentsProvider

C. TestTemplateInvocationContextProvider

D. TestInstancePostProcessor

Solution

1. Step 1: Recall JUnit interfaces for argument providers

   The interface to implement for custom argument providers is ArgumentsProvider.

2. Step 2: Differentiate from other interfaces

   ArgumentsSource is an annotation, not an interface. The others serve different purposes.

3. Final Answer:

   ArgumentsProvider -> Option B

4. Quick Check:

   Implement ArgumentsProvider for custom data [OK]

Hint: Implement ArgumentsProvider interface for custom data supply [OK]

Common Mistakes:

• Confusing ArgumentsSource annotation with interface
• Choosing unrelated interfaces
• Not overriding provideArguments method

3. Given this custom argument provider code snippet, what will be the output when the parameterized test runs?

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

@ParameterizedTest
@ArgumentsSource(MyProvider.class)
void testFruits(String fruit) {
    System.out.println(fruit);
}

medium

A. apple\nbanana (each on separate lines)

B. apple banana

C. Compilation error due to missing imports

D. Runtime error due to wrong method signature

Solution

1. Step 1: Analyze the provideArguments method

   The method returns a stream with two Arguments: "apple" and "banana".

2. Step 2: Understand parameterized test execution

   The test runs twice, once with "apple" and once with "banana", printing each on its own line.

3. Final Answer:

   apple\nbanana (each on separate lines) -> Option A

4. Quick Check:

   Stream of Arguments runs test twice [OK]

Hint: Each argument runs test once, prints on separate lines [OK]

Common Mistakes:

• Assuming output is on one line
• Thinking code has syntax errors without imports
• Confusing method signature correctness

4. Identify the error in this custom argument provider implementation:

public class BadProvider implements ArgumentsProvider {
    public Stream<Arguments> provideArguments() {
        return Stream.of(Arguments.of(1), Arguments.of(2));
    }
}

medium

A. Method provideArguments must have ExtensionContext parameter

B. Missing @Override annotation

C. Arguments.of() cannot take integers

D. Class must extend ArgumentsSource

Solution

1. Step 1: Check method signature requirements

   The provideArguments method must override the interface method and accept ExtensionContext as a parameter.

2. Step 2: Identify the missing parameter

   The code's provideArguments method lacks the ExtensionContext parameter, causing a signature mismatch.

3. Final Answer:

   Method provideArguments must have ExtensionContext parameter -> Option A

4. Quick Check:

   Correct method signature requires ExtensionContext [OK]

Hint: provideArguments must accept ExtensionContext parameter [OK]

Common Mistakes:

• Ignoring method signature parameters
• Thinking @Override is mandatory but not fixing signature
• Confusing Arguments.of() usage

5. You want to create a custom argument provider that supplies pairs of integers where the second is always double the first. Which implementation correctly achieves this?

public class DoubleProvider implements ArgumentsProvider {
    @Override
    public Stream<Arguments> provideArguments(ExtensionContext context) {
        // Fill in the blank
    }
}

hard

A. return Stream.of(Arguments.of(1, 3), Arguments.of(2, 5), Arguments.of(3, 7));

B. return Stream.of(Arguments.of(1, 1), Arguments.of(2, 2), Arguments.of(3, 3));

C. return Stream.empty();

D. return Stream.of(Arguments.of(1, 2), Arguments.of(2, 4), Arguments.of(3, 6));

Solution

1. Step 1: Understand the requirement

   Each pair must have the second integer double the first.

2. Step 2: Evaluate each option

   return Stream.of(Arguments.of(1, 2), Arguments.of(2, 4), Arguments.of(3, 6)); correctly pairs (1,2), (2,4), (3,6). Other options provide pairs like (1,3),(2,5),(3,7) or equal numbers (1,1),(2,2),(3,3), or an empty stream.

3. Final Answer:

   return Stream.of(Arguments.of(1, 2), Arguments.of(2, 4), Arguments.of(3, 6)); -> Option D

4. Quick Check:

   Second integer = 2 * first integer [OK]

Hint: Check if second number is double the first in pairs [OK]

Common Mistakes:

• Providing pairs where second is not double
• Returning empty stream by mistake
• Confusing argument order