Custom display names for parameters in JUnit - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to use a custom display name for a parameter in a JUnit 5 test.

JUnit

@ParameterizedTest
@ValueSource(strings = {"apple", "banana"})
void testWithCustomName(@[1]("fruit") String fruit) {
    assertNotNull(fruit);
}

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

ADisplayNameValue

BDisplayName

CName

DParameterName

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Name instead of @DisplayName.

Using @ParameterName which does not exist.

The @DisplayName annotation is used to provide a custom display name for a parameter in JUnit 5.

2fill in blank

medium

Complete the code to set a custom display name for a parameter in a JUnit 5 parameterized test.

JUnit

@ParameterizedTest(name = "Test with fruit: {0}")
@ValueSource(strings = {"apple", "banana"})
void testFruit(@[1]("fruitName") String fruit) {
    assertFalse(fruit.isEmpty());
}

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

AName

BDisplayNameValue

CParameterName

DDisplayName

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing @DisplayName with @Name.

Trying to use @ParameterName which is not valid.

Use @DisplayName to assign a custom name to the parameter for better test reporting.

3fill in blank

hard

Fix the error in the code to correctly use a custom display name for a parameter in JUnit 5.

JUnit

@ParameterizedTest
@ValueSource(strings = {"cat", "dog"})
void testAnimals(@[1]("animal") String animal) {
    assertTrue(animal.length() > 0);
}

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

ADisplayName

BParamName

CName

DDisplayNameValue

Attempts:

3 left

💡 Hint

Common Mistakes

Using @DisplayNameValue which is not a valid annotation.

Using @ParamName which does not exist.

The correct annotation to set a custom display name for a parameter is @DisplayName.

4fill in blank

hard

Fill both blanks to create a parameterized test with a custom display name for the parameter and a custom test name.

JUnit

@ParameterizedTest(name = "Test with number: {0}")
@ValueSource(ints = {1, 2, 3})
void testNumbers(@[1]("num") int number, @[2]("value") int value) {
    assertEquals(number, value);
}

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

ADisplayName

BParameterName

DName

Attempts:

3 left

💡 Hint

Common Mistakes

Using different or invalid annotations for parameters.

Using @ParameterName which is not valid.

Both parameters use @DisplayName to set custom display names for better test reports.

5fill in blank

hard

Fill all three blanks to create a parameterized test with custom display names for parameters and a custom test name pattern.

JUnit

@ParameterizedTest(name = "Run {index}: {0} - {1} - {2}")
@CsvSource({"apple, red, 1", "banana, yellow, 2"})
void testFruits(@[1]("fruit") String fruit, @[2]("color") String color, @[3]("count") int count) {
    assertNotNull(fruit);
    assertNotNull(color);
    assertTrue(count > 0);
}

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

ADisplayName

DParameterName

Attempts:

3 left

💡 Hint

Common Mistakes

Using @ParameterName or other invalid annotations.

Mixing different annotations for parameters.

All parameters use @DisplayName to provide custom names for clearer test reports.

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}