Custom argument providers in JUnit - Test Execution Trace

Test Overview

This test uses a custom argument provider to supply multiple sets of input data to a parameterized test method. It verifies that the sum of two integers matches the expected result for each data set.

Test Code - JUnit 5

JUnit

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.ArgumentsProvider;
import org.junit.jupiter.params.provider.ArgumentsSource;
import org.junit.jupiter.api.extension.ExtensionContext;
import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertEquals;

class CustomArgumentProviderTest {

    static class SumArgumentsProvider implements ArgumentsProvider {
        @Override
        public Stream<Arguments> provideArguments(ExtensionContext context) {
            return Stream.of(
                Arguments.of(1, 2, 3),
                Arguments.of(5, 7, 12),
                Arguments.of(10, 15, 25)
            );
        }
    }

    @ParameterizedTest
    @ArgumentsSource(SumArgumentsProvider.class)
    void testSum(int a, int b, int expectedSum) {
        int actualSum = a + b;
        assertEquals(expectedSum, actualSum, () -> String.format("Sum of %d and %d should be %d", a, b, expectedSum));
    }
}

Execution Trace - 6 Steps

Step	Action	System State	Assertion	Result
1	Test runner starts and identifies the parameterized test method with custom argument provider	JUnit test environment initialized, SumArgumentsProvider ready to supply arguments	—	PASS
2	SumArgumentsProvider.provideArguments() is called to get test data stream	Stream of argument sets [(1,2,3), (5,7,12), (10,15,25)] prepared	—	PASS
3	Test method testSum is invoked with arguments (1, 2, 3)	Test method running with a=1, b=2, expectedSum=3	assertEquals(3, 1+2)	PASS
4	Test method testSum is invoked with arguments (5, 7, 12)	Test method running with a=5, b=7, expectedSum=12	assertEquals(12, 5+7)	PASS
5	Test method testSum is invoked with arguments (10, 15, 25)	Test method running with a=10, b=15, expectedSum=25	assertEquals(25, 10+15)	PASS
6	All parameterized test invocations complete, test run ends	All assertions passed for all argument sets	—	PASS

Failure Scenario

Failing Condition: One of the expected sums does not match the actual sum of the inputs

Execution Trace Quiz - 3 Questions

What does the custom argument provider supply to the test method?

A The test report format

B Multiple sets of input arguments for the test

C The test method's return values

D The test method's annotations

Key Result

Using a custom argument provider helps run the same test logic with different data sets, improving test coverage and reducing code duplication.

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