Why parameterization reduces test duplication in JUnit - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to use the correct annotation for parameterized tests in JUnit.

JUnit

@[1]
public void testSum(int a, int b, int expected) {
    assertEquals(expected, a + b);
}

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

AParameterizedTest

BAfterEach

CTest

DBeforeEach

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Test instead of @ParameterizedTest causes the test to run only once.

Using lifecycle annotations like @BeforeEach instead of test annotations.

The @ParameterizedTest annotation tells JUnit to run the test multiple times with different parameters, reducing duplication.

2fill in blank

medium

Complete the code to provide multiple sets of parameters using the correct source annotation.

JUnit

@ParameterizedTest
@[1]({"1, 2, 3", "3, 4, 7", "5, 6, 11"})
public void testSum(int a, int b, int expected) {
    assertEquals(expected, a + b);
}

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

AValueSource

BEnumSource

CMethodSource

DCsvSource

Attempts:

3 left

💡 Hint

Common Mistakes

Using @ValueSource which supports only single parameter arrays.

Using @MethodSource without defining a method.

@CsvSource allows passing multiple comma-separated values as parameters to the test method, enabling parameterization.

3fill in blank

hard

Fix the error in the parameterized test method signature to match the parameters provided.

JUnit

@ParameterizedTest
@CsvSource({"2, 3, 5", "4, 5, 9"})
public void testSum([1]) {
    assertEquals(expected, a + b);
}

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

Aint a, int b, int expected

Bint a, int b

CString a, String b, String expected

Dint expected

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting the expected parameter causes compilation errors.

Using wrong parameter types like String instead of int.

The test method must have parameters matching the number and types of values in each CSV line: int a, int b, int expected.

4fill in blank

hard

Fill both blanks to correctly import and use the assertion method in JUnit 5.

JUnit

import static org.junit.jupiter.api.Assertions.[1];

@Test
public void testAddition() {
    [2](5, 2 + 3);
}

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

AassertEquals

BassertTrue

CassertFalse

DassertNull

Attempts:

3 left

💡 Hint

Common Mistakes

Using assertTrue or assertFalse when checking equality.

Forgetting to import the assertion method.

assertEquals is the correct assertion to check if two values are equal in JUnit 5.

5fill in blank

hard

Fill all three blanks to complete a parameterized test that uses a method source for input data.

JUnit

@ParameterizedTest
@MethodSource("[1]")
public void testMultiply(int a, int b, int expected) {
    assertEquals([2], a * b);
}

static Stream<Arguments> [3]() {
    return Stream.of(
        Arguments.of(2, 3, 6),
        Arguments.of(4, 5, 20),
        Arguments.of(6, 7, 42)
    );
}

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

AmultiplyData

Bexpected

Attempts:

3 left

💡 Hint

Common Mistakes

Mismatching method source name causes runtime errors.

Using wrong variable names in assertion.

The method source name must match the string in @MethodSource. The assertion compares expected with the product. The method providing data is named multiplyData.

Practice

1. Why does parameterization in JUnit help reduce test duplication?

easy

A. It allows running the same test method multiple times with different inputs.

B. It automatically fixes bugs in the test code.

C. It generates random test data for each test run.

D. It merges multiple test classes into one.

Solution

1. Step 1: Understand parameterization purpose

   Parameterization runs the same test method repeatedly with different input values.

2. Step 2: Compare with duplication

   This avoids writing separate test methods for each input, reducing repeated code.

3. Final Answer:

   It allows running the same test method multiple times with different inputs. -> Option A

4. Quick Check:

   Parameterization = multiple inputs, one test method [OK]

Hint: Parameterization runs one test many times with different data [OK]

Common Mistakes:

• Thinking parameterization fixes bugs automatically
• Confusing parameterization with random data generation
• Believing it merges test classes

2. Which of the following is the correct JUnit 5 syntax to create a parameterized test method?

easy

A. @Test
@ValueSource(strings = {"apple", "banana"})
void testFruit(String fruit) { }

B. @ParameterizedTest
@ValueSource(strings = {"apple", "banana"})
void testFruit(String fruit) { }

C. @Test
@Parameters({"apple", "banana"})
void testFruit(String fruit) { }

D. @ParameterizedTest
@TestSource(strings = {"apple", "banana"})
void testFruit(String fruit) { }

Solution

1. Step 1: Identify correct annotation for parameterized tests

   JUnit 5 uses @ParameterizedTest to mark parameterized test methods.

2. Step 2: Check data source annotation

   @ValueSource provides input values; it must be combined with @ParameterizedTest.

3. Final Answer:

   @ParameterizedTest with @ValueSource is correct syntax. -> Option B

4. Quick Check:

   @ParameterizedTest + @ValueSource = correct syntax [OK]

Hint: Use @ParameterizedTest with @ValueSource for parameterized tests [OK]

Common Mistakes:

• Using @Test instead of @ParameterizedTest
• Using non-existent @Parameters or @TestSource annotations
• Mixing annotations incorrectly

3. Given the following JUnit 5 parameterized test, what will be the output when running the test?

@ParameterizedTest
@ValueSource(ints = {2, 4, 6})
void testIsEven(int number) {
    assertTrue(number % 2 == 0);
}

medium

A. Some tests pass and some fail depending on the number.

B. All tests fail because the assertion is incorrect.

C. All tests pass because all numbers are even.

D. Test will not run due to syntax error.

Solution

1. Step 1: Analyze input values

   The input values are 2, 4, and 6, all even numbers.

2. Step 2: Check assertion logic

   The assertion checks if number % 2 == 0, which is true for all inputs.

3. Final Answer:

   All tests pass because all numbers are even. -> Option C

4. Quick Check:

   All inputs even -> assertion true -> tests pass [OK]

Hint: Check if all inputs satisfy the assertion condition [OK]

Common Mistakes:

• Assuming some numbers are odd without checking
• Confusing assertion logic
• Thinking syntax error exists when it does not

4. Identify the error in this JUnit 5 parameterized test code:

@ParameterizedTest
@ValueSource(strings = {"test", "JUnit"})
void testLength(int length) {
    assertTrue(length > 0);
}

medium

A. assertTrue cannot be used in parameterized tests.

B. The @ValueSource annotation is missing parentheses.

C. The test method must return a value.

D. The parameter type should be String, not int.

Solution

1. Step 1: Check parameter type against @ValueSource data

   @ValueSource provides strings, but method parameter is int, causing a type mismatch.

2. Step 2: Understand correct parameter type

   The method parameter should be String to match the input data type.

3. Final Answer:

   The parameter type should be String, not int. -> Option D

4. Quick Check:

   Parameter type must match @ValueSource data type [OK]

Hint: Match method parameter type with @ValueSource data type [OK]

Common Mistakes:

• Using wrong parameter type
• Forgetting parentheses in annotations (not the case here)
• Thinking test methods must return values
• Believing assertTrue is disallowed in parameterized tests

5. You have multiple test methods checking if numbers are positive, negative, or zero. How does parameterization reduce duplication in this scenario?

hard

A. By combining all checks into one parameterized test method with input and expected result parameters.

B. By writing separate test classes for each number type.

C. By removing assertions and relying on manual checks.

D. By running tests only once with a fixed number.

Solution

1. Step 1: Understand test duplication problem

   Multiple test methods for positive, negative, zero numbers cause repeated code.

2. Step 2: Apply parameterization to combine tests

   Use one parameterized test method with inputs and expected results to cover all cases.

3. Final Answer:

   By combining all checks into one parameterized test method with input and expected result parameters. -> Option A

4. Quick Check:

   One method + multiple inputs = less duplication [OK]

Hint: Use one test method with inputs and expected outputs [OK]

Common Mistakes:

• Writing separate test classes instead of parameterizing
• Removing assertions which breaks test automation
• Testing only one fixed input