Why parameterization reduces test duplication in JUnit - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why does parameterization reduce test duplication?

Imagine you have multiple tests that check the same logic but with different input values. How does parameterization help reduce duplication in such cases?

A It replaces all test inputs with a single fixed value to simplify testing.

B It merges all tests into one big test that runs all inputs at once without separation.

C It automatically generates new test methods for each input without needing code changes.

D It allows running the same test method multiple times with different inputs, avoiding writing separate methods for each case.

💡 Hint

Think about how you can reuse the same code but test different values.

Parameterization lets you write one test method that runs multiple times with different inputs. This avoids copying the same test code multiple times for each input, reducing duplication.

❓ Predict Output

intermediate

Output of parameterized JUnit test run

Given this JUnit 5 parameterized test, what will be the output when running it?

JUnit

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import static org.junit.jupiter.api.Assertions.assertTrue;

class SampleTest {
    @ParameterizedTest
    @ValueSource(strings = {"racecar", "radar", "hello"})
    void testPalindrome(String word) {
        assertTrue(new StringBuilder(word).reverse().toString().equals(word));
    }
}

A All tests pass because all words are palindromes.

B Test fails because 'hello' is not a palindrome.

C Test fails due to syntax error in annotation.

D Test is skipped because no test method is found.

💡 Hint

Check which input strings are palindromes.

The test runs three times with inputs 'racecar', 'radar', and 'hello'. The first two are palindromes, so they pass. The last input 'hello' is not a palindrome, so the test fails on that run.

❓ assertion

advanced

Correct assertion in parameterized test

Which assertion correctly verifies that a number is even inside a JUnit parameterized test?

JUnit

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import static org.junit.jupiter.api.Assertions.assertTrue;

class NumberTest {
    @ParameterizedTest
    @ValueSource(ints = {2, 4, 5, 8})
    void testEven(int number) {
        // Which assertion is correct here?
    }
}

A assertTrue(number % 2 == 0);

B assertEquals(number / 2, 0);

C assertNull(number % 2);

D assertFalse(number % 2 == 0);

💡 Hint

Think about how to check if a number is even using modulo.

To check if a number is even, the remainder when divided by 2 should be zero. So number % 2 == 0 is true for even numbers. The assertion assertTrue(number % 2 == 0) correctly verifies this.

🔧 Debug

advanced

Why does this parameterized test fail to run?

Look at this JUnit 5 parameterized test code. Why does it fail to run any tests?

JUnit

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

class DebugTest {
    @ParameterizedTest
    @ValueSource(strings = {"apple", "banana"})
    void testFruit() {
        System.out.println("Fruit test");
    }
}

A The test method must be static to run parameterized tests.

B The @ValueSource annotation is missing required attributes.

C The test method must accept a parameter matching the ValueSource type.

D JUnit 5 does not support @ParameterizedTest with @ValueSource.

💡 Hint

Check the method signature and parameters.

The parameterized test method must accept a parameter of the type provided by @ValueSource. Here, the method testFruit() has no parameters, but @ValueSource provides strings. This mismatch causes the test not to run.

❓ framework

expert

How does JUnit 5 parameterized test runner handle multiple inputs?

In JUnit 5, when using @ParameterizedTest with multiple inputs, how does the test runner execute the tests?

A It runs the test method once for each input value, reporting each as a separate test case.

B It combines all inputs into one test run and reports a single pass/fail result.

C It randomly selects one input to run per test execution.

D It requires manual looping inside the test method to run all inputs.

💡 Hint

Think about how parameterized tests show results in test reports.

JUnit 5 runs the parameterized test method once for each input value separately. Each run is reported as an individual test case in the test report, allowing clear visibility of which inputs passed or failed.