Custom display names for parameters in JUnit - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of custom display names for parameters in JUnit tests?

Custom display names make test output easier to read by showing meaningful names for parameters instead of default values or indexes.

beginner

How do you specify a custom display name for a parameter in a JUnit 5 parameterized test?

Use the @ParameterizedTest annotation with the name attribute, for example: @ParameterizedTest(name = "Test with input={0} and expected={1}").

intermediate

What placeholders can you use in the name attribute for custom display names in JUnit 5 parameterized tests?

You can use placeholders like {index} for the invocation index, {0}, {1}, etc. for parameter values by position.

beginner

Why is using custom display names for parameters helpful when running tests in an IDE or CI environment?

It helps quickly identify which input caused a test failure without digging into the code or logs, improving debugging speed.

beginner

Show a simple example of a JUnit 5 parameterized test method with a custom display name for parameters.

@ParameterizedTest(name = "Run {index}: input={0}, expected={1}") @CsvSource({"apple, 5", "banana, 6"}) void testLength(String input, int expected) { assertEquals(expected, input.length()); }

What annotation attribute in JUnit 5 allows you to set custom display names for parameterized test runs?

A value

B name

C displayName

D label

The 'name' attribute in @ParameterizedTest sets the custom display name format.

Which placeholder represents the current test invocation index in a JUnit 5 parameterized test name?

A {run}

B {param}

C {count}

D {index}

The placeholder '{index}' shows the current invocation number starting at 1.

In the name attribute, how do you refer to the first parameter's value?

A {param1}

B {1}

C {0}

D {first}

Parameters are zero-indexed, so '{0}' refers to the first parameter.

Why should you use custom display names for parameters in tests?

A To improve test output readability

B To make test code shorter

C To speed up test execution

D To avoid writing assertions

Custom display names improve readability of test results, especially on failures.

Which JUnit 5 annotation is used to run a test multiple times with different parameters?

A @ParameterizedTest

B @TestFactory

C @RepeatedTest

D @Test

@ParameterizedTest runs the same test method with different parameters.

Explain how to create custom display names for parameters in a JUnit 5 parameterized test and why it is useful.

Think about how test output looks and how placeholders work.

Describe the placeholders available for custom display names in JUnit 5 parameterized tests and give an example of their usage.

Focus on how to refer to parameters and the test run number.

Practice

1. What is the main purpose of using custom display names for parameters in JUnit tests?

easy

A. To speed up test execution time

B. To make test results easier to understand by showing meaningful names

C. To automatically fix failing tests

D. To generate test data automatically

Solution

1. Step 1: Understand the role of display names

   Custom display names help testers and developers read test reports more clearly by showing descriptive names instead of default method names.

2. Step 2: Identify the benefit in test results

   Meaningful names improve readability and debugging, making it easier to know what each test case checks.

3. Final Answer:

   To make test results easier to understand by showing meaningful names -> Option B

4. Quick Check:

   Custom display names = clearer test reports [OK]

Hint: Custom names improve report clarity, not speed or fixing [OK]

Common Mistakes:

• Thinking display names speed up tests
• Assuming display names fix test failures
• Confusing display names with test data generation

2. Which annotation syntax correctly sets a custom display name pattern for a parameterized test in JUnit 5?

easy

A. @ParameterizedTest(name = "Test {index} with value {0}")

B. @TestDisplay(name = "Test {index} with value {0}")

C. @DisplayNamePattern("Test {index} with value {0}")

D. @TestName("Test {index} with value {0}")

Solution

1. Step 1: Recall the correct annotation for parameterized test names

   JUnit 5 uses @ParameterizedTest with the 'name' attribute to set custom display names for parameters.

2. Step 2: Verify syntax correctness

   @ParameterizedTest(name = "Test {index} with value {0}") is the correct syntax; other options are invalid annotations.

3. Final Answer:

   @ParameterizedTest(name = "Test {index} with value {0}") -> Option A

4. Quick Check:

   @ParameterizedTest(name=...) = correct syntax [OK]

Hint: Use @ParameterizedTest(name = "...") for custom parameter names [OK]

Common Mistakes:

• Using non-existent annotations like @TestDisplay
• Confusing @DisplayName with parameterized name attribute
• Misspelling annotation names

3. Given the following test code snippet, what will be the display name of the second test execution?

@ParameterizedTest(name = "Run {index}: input={0}")
@ValueSource(strings = {"apple", "banana"})
void testFruits(String fruit) { /* test code */ }

medium

A. Run 1: input=apple

B. Run 1: input=banana

C. Run 2: input=banana

D. Run 2: input=apple

Solution

1. Step 1: Understand the index and parameter mapping

   The index starts at 1 for the first parameter, so the second test run has index 2 and parameter "banana".

2. Step 2: Substitute values into the display name pattern

   Replacing {index} with 2 and {0} with "banana" gives "Run 2: input=banana".

3. Final Answer:

   Run 2: input=banana -> Option C

4. Quick Check:

   Index 2 + second value banana = Run 2: input=banana [OK]

Hint: Index starts at 1; match parameter order [OK]

Common Mistakes:

• Assuming index starts at 0
• Mixing parameter values between runs
• Confusing index with parameter value

4. Identify the error in this JUnit 5 parameterized test code that tries to set a custom display name:

@ParameterizedTest(name = "Test {index} - {0}")
@ValueSource(ints = {1, 2, 3})
void testNumbers(int number) {
    assertTrue(number > 0);
}

medium

A. There is no error; the code is correct

B. The annotation @ParameterizedTest does not support 'name' attribute

C. The placeholder {0} cannot be used for int parameters

D. The method parameter type int is invalid for @ValueSource

Solution

1. Step 1: Check if 'name' attribute is valid in @ParameterizedTest

   @ParameterizedTest supports the 'name' attribute to customize display names.

2. Step 2: Verify placeholders and parameter types

   {0} correctly refers to the first parameter, which can be an int from @ValueSource.

3. Step 3: Confirm method and annotation compatibility

   Using int parameter with @ValueSource(ints = {...}) is valid and assertTrue is a valid assertion.

4. Final Answer:

   There is no error; the code is correct -> Option A

5. Quick Check:

   Valid syntax and usage = no error [OK]

Hint: Check if syntax matches JUnit 5 docs exactly [OK]

Common Mistakes:

• Thinking {0} can't be used with primitive types
• Believing 'name' attribute is unsupported
• Confusing parameter types with annotation requirements

5. You want to create a parameterized test in JUnit 5 that shows the test index, parameter value, and a custom message "Check value" in the display name. Which of the following is the correct way to write the @ParameterizedTest annotation to achieve this?

hard

A. @ParameterizedTest(name = "{index} - {0} - Check value")

B. @ParameterizedTest(name = "Test {index}: {0} - Check value")

C. @ParameterizedTest(name = "Check value - {index} - {0}")

D. All of the following are correct

Solution

1. Step 1: Understand the 'name' attribute flexibility

   The 'name' attribute accepts any string with placeholders {index} and {0} to customize display names.

2. Step 2: Check each option's format

   The three provided formats all correctly use {index} and {0} with additional text to form valid display names.

3. Step 3: Confirm all options are valid

   Since all formats are syntactically correct and achieve the goal, all are acceptable.

4. Final Answer:

   All of the following are correct -> Option D

5. Quick Check:

   Any string with {index} and {0} works [OK]

Hint: Any string with {index} and {0} placeholders is valid [OK]

Common Mistakes:

• Thinking only one exact format is allowed
• Misplacing placeholders causing syntax errors
• Forgetting to include both {index} and {0}