Test method naming conventions in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Identify the correct JUnit test method naming convention

Which of the following method names follows the recommended JUnit 5 test method naming conventions for clarity and readability?

A TestCalculateSum

B calculateSumTest

C testCalculateSum_whenInputIsValid_shouldReturnCorrectSum

D calculate_sum_test

💡 Hint

JUnit 5 encourages descriptive method names that explain the test scenario and expected behavior.

Option C uses a clear, descriptive naming style that explains the method under test, the condition, and the expected result. This improves test readability.

Options B, C, and D do not follow the recommended style: B is less descriptive, C starts with uppercase which is unconventional for methods, and D uses underscores which is uncommon in Java method names.

❓ assertion

intermediate

Determine the test method name from assertion purpose

You have a test that verifies the login method throws an exception when credentials are invalid. Which method name best reflects this test purpose?

A testLogin

B loginShouldThrowExceptionForInvalidCredentials

C invalidCredentialsTest

D checkLoginException

💡 Hint

Good test method names describe the expected behavior and condition clearly.

Option B clearly states the method under test, the expected behavior (throw exception), and the condition (invalid credentials).

Options A, C, and D are less descriptive or ambiguous.

❓ Predict Output

advanced

What is the output of the test report for this method name?

Given the following JUnit 5 test method, what will be the displayed test name in the test report by default?

JUnit

import org.junit.jupiter.api.Test;

public class CalculatorTest {
    @Test
    void addTwoNumbers_shouldReturnSum() {
        // test code
    }
}

A addTwoNumbersShouldReturnSum()

B addTwoNumbers should return sum

C addTwoNumbers_shouldReturnSum()

D addTwoNumbers-shouldReturnSum

💡 Hint

JUnit 5 by default shows the method name as is unless a display name is specified.

JUnit 5 displays the test method name exactly as declared if no @DisplayName annotation is used.

So the test report will show 'addTwoNumbersShouldReturnSum()'.

🔧 Debug

advanced

Find the naming issue causing test discovery failure

A JUnit 5 test method is not being executed by the test runner. Which method name is causing this issue?

JUnit

import org.junit.jupiter.api.Test;

public class SampleTest {
    @Test
    public void TestAddition() {
        // test code
    }
}

A TestAddition

B testAddition

C additionTest

D test_addition

💡 Hint

JUnit 5 requires test methods to be non-static and annotated with @Test; method name casing does not prevent execution.

In JUnit 5, method names are case-sensitive but the test runner executes any method annotated with @Test regardless of name casing.

However, some build tools or IDEs may expect lowercase 'test' prefix for legacy reasons.

But here, the method is public and annotated, so it should run despite the uppercase 'T'.

Therefore, none of the options cause discovery failure by name alone.

But since the question asks which name causes failure, the answer is D because some legacy runners expect lowercase 'test' prefix.

❓ framework

expert

Which naming style best supports behavior-driven development (BDD) in JUnit tests?

In BDD style testing with JUnit, which test method naming style is most appropriate to clearly express behavior and expected outcomes?

A validInputTest

B testValidInputReturnsTrue

C checkInput

D shouldReturnTrueWhenInputIsValid

💡 Hint

BDD style emphasizes expressing behavior in method names starting with 'should'.

Option D uses a BDD style naming convention that clearly states the expected behavior.

Options B, C, and D are less expressive or do not follow BDD naming conventions.

Practice

1. Which of the following is the best practice for naming a JUnit test method?

easy

A. test1

B. check

C. shouldReturnTrueWhenInputIsValid

D. runTest

Solution

1. Step 1: Understand naming clarity

   Good test method names clearly describe what is tested and the expected behavior.

2. Step 2: Evaluate options

   shouldReturnTrueWhenInputIsValid uses camelCase and starts with 'should', describing expected behavior. Others are vague or generic.

3. Final Answer:

   shouldReturnTrueWhenInputIsValid -> Option C

4. Quick Check:

   Clear descriptive names = shouldReturnTrueWhenInputIsValid [OK]

Hint: Start test names with 'should' and describe behavior [OK]

Common Mistakes:

• Using vague names like 'test1' or 'check'
• Starting names with 'run' without context
• Not using camelCase for readability

2. Which of the following is a syntactically correct JUnit 5 test method name?

easy

A. 2ShouldReturnFalseWhenInputIsNull

B. shouldReturnFalseWhenInputIsNull

C. should return false when input is null

D. should-return_false_when_input_is_null

Solution

1. Step 1: Recall Java identifier rules for method names

   Java method names must be valid identifiers: start with letter/$_ , no spaces, hyphens, or starting digits; conventionally camelCase.

2. Step 2: Check each option

   shouldReturnFalseWhenInputIsNull uses valid camelCase. The option starting with '2' can't start with digit. The option with hyphen '-' is invalid. The option with spaces is invalid.

3. Final Answer:

   shouldReturnFalseWhenInputIsNull -> Option B

4. Quick Check:

   CamelCase method names = shouldReturnFalseWhenInputIsNull [OK]

Hint: Use camelCase valid Java identifiers, no spaces/hyphens/digit starts [OK]

Common Mistakes:

• Starting method names with digits
• Using hyphens or spaces in method names
• Ignoring Java identifier syntax rules

3. Given the following test method name, what behavior is it most likely testing?
shouldThrowExceptionWhenInputIsNegative

medium

A. The method tests that negative input is accepted without error

B. The method tests that negative input returns false

C. The method tests that input is positive

D. The method tests that an exception is thrown for negative input

Solution

1. Step 1: Analyze the method name parts

   The name starts with 'shouldThrowException' indicating expected exception behavior.

2. Step 2: Understand the condition

   'WhenInputIsNegative' means the test triggers when input is negative.

3. Final Answer:

   The method tests that an exception is thrown for negative input -> Option D

4. Quick Check:

   Method name meaning = exception thrown on negative input [OK]

Hint: Look for 'should' + action + condition in test names [OK]

Common Mistakes:

• Ignoring 'ThrowException' meaning
• Confusing exception with return values
• Misreading the condition part of the name

4. Identify the problem in this JUnit test method name:
testshouldReturnTrueWhenValid

medium

A. It mixes 'test' prefix with 'should' which is redundant

B. It uses invalid characters

C. It is too short

D. It does not start with a verb

Solution

1. Step 1: Understand naming redundancy

   Using both 'test' prefix and 'should' is redundant and not recommended.

2. Step 2: Check other options

   No invalid characters are present, length is sufficient, and 'should' implies verb usage.

3. Final Answer:

   It mixes 'test' prefix with 'should' which is redundant -> Option A

4. Quick Check:

   Redundant prefixes = test + should [OK]

Hint: Avoid combining 'test' prefix with 'should' in names [OK]

Common Mistakes:

• Using both 'test' and 'should' together
• Assuming length affects correctness
• Ignoring naming conventions for verbs

5. You want to write a JUnit test method name that clearly shows it tests if a user login fails when the password is empty. Which is the best name?

hard

A. shouldFailLoginWhenPasswordIsEmpty

B. testLoginFailEmptyPassword

C. loginFailsEmptyPassword

D. failLoginEmptyPasswordTest

Solution

1. Step 1: Check clarity and style

   shouldFailLoginWhenPasswordIsEmpty uses 'should' + verb + condition, making it clear and readable.

2. Step 2: Evaluate other options

   Options B, C, and D are less clear or mix styles, making them harder to understand quickly.

3. Final Answer:

   shouldFailLoginWhenPasswordIsEmpty -> Option A

4. Quick Check:

   Clear, descriptive, camelCase with 'should' = shouldFailLoginWhenPasswordIsEmpty [OK]

Hint: Use 'should' + action + condition for clear test names [OK]

Common Mistakes:

• Using unclear or mixed naming styles
• Omitting 'should' for behavior clarity
• Using underscores or inconsistent casing