@NullAndEmptySource in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a JUnit test using @NullAndEmptySource with String parameter

Consider this JUnit 5 parameterized test using @NullAndEmptySource. What will be the total number of test invocations executed?

JUnit

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

class SampleTest {
    @ParameterizedTest
    @NullAndEmptySource
    void testWithNullAndEmpty(String input) {
        System.out.println(input == null ? "null" : input);
    }
}

A 0

B 1

C 2

D 3

💡 Hint

Think about how many inputs @NullAndEmptySource provides to the test method.

The @NullAndEmptySource annotation provides exactly two inputs to the test method: null and an empty string "". So the test runs twice.

❓ assertion

intermediate

Correct assertion for @NullAndEmptySource inputs

In a parameterized test using @NullAndEmptySource for a String parameter, which assertion correctly verifies that the input is either null or empty?

JUnit

import static org.junit.jupiter.api.Assertions.*;

@ParameterizedTest
@NullAndEmptySource
void testInput(String input) {
    // Which assertion is correct here?
}

A assertFalse(input == null || input.isEmpty());

B assertNotNull(input);

C assertEquals("", input);

D assertTrue(input == null || input.isEmpty());

💡 Hint

Remember @NullAndEmptySource provides null and empty string inputs.

The inputs are either null or empty string "". The assertion must check for both conditions combined with OR.

🔧 Debug

advanced

Why does this @NullAndEmptySource test fail with a NullPointerException?

Given this test code, why does it throw a NullPointerException during execution?

JUnit

import static org.junit.jupiter.api.Assertions.*;

@ParameterizedTest
@NullAndEmptySource
void testLength(String input) {
    assertTrue(input.length() == 0);
}

A Because empty string has no length property.

B Because input can be null, calling length() on null causes NullPointerException.

C Because @NullAndEmptySource does not provide any inputs.

D Because assertTrue is used incorrectly.

💡 Hint

Think about what happens when input is null and you call a method on it.

@NullAndEmptySource provides null and empty string. Calling input.length() when input is null causes a NullPointerException.

🧠 Conceptual

advanced

Behavior of @NullAndEmptySource combined with @ValueSource

What happens when you combine @NullAndEmptySource with @ValueSource(strings = {"test"}) in a parameterized test method with a String parameter?

JUnit

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

@ParameterizedTest
@NullAndEmptySource
@ValueSource(strings = {"test"})
void testCombined(String input) {
    System.out.println(input);
}

A The test runs three times with inputs: null, empty string, and "test".

B The test runs only once with input "test".

C The test runs twice with inputs: null and empty string only.

D The test fails to run due to conflicting annotations.

💡 Hint

Think about how multiple sources combine in JUnit parameterized tests.

JUnit combines all sources, so the test runs once for each input from both annotations: null, empty string, and "test".

❓ framework

expert

How does JUnit 5 internally handle @NullAndEmptySource for parameterized tests?

Which statement best describes how JUnit 5 processes the @NullAndEmptySource annotation when running a parameterized test?

A JUnit 5 provides two arguments to the test method: null and an empty string, by internally creating these values as test inputs.

B JUnit 5 reads @NullAndEmptySource and skips the test method if the parameter is not nullable.

C JUnit 5 requires the user to manually provide null and empty string values; @NullAndEmptySource is just a marker.

D JUnit 5 converts @NullAndEmptySource into a single empty string input only.

💡 Hint

Consider how parameterized tests get their input values from annotations.

@NullAndEmptySource is a built-in source that automatically supplies two inputs: null and empty string "" to the test method.

Practice

1. What is the main purpose of using @NullAndEmptySource in JUnit tests?

easy

A. To run tests only when inputs are non-null and non-empty

B. To skip tests that have null or empty inputs

C. To automatically provide null and empty values as test inputs

D. To generate random test data for parameterized tests

Solution

1. Step 1: Understand the role of @NullAndEmptySource

   @NullAndEmptySource is used to add null and empty values automatically to parameterized tests.

2. Step 2: Identify its purpose in testing

   This helps test how the code behaves with missing or empty inputs without manually adding those cases.

3. Final Answer:

   To automatically provide null and empty values as test inputs -> Option C

4. Quick Check:

   @NullAndEmptySource adds null and empty inputs [OK]

Hint: Remember: @NullAndEmptySource adds null and empty inputs [OK]

Common Mistakes:

• Thinking it skips tests with null or empty inputs
• Confusing it with random data generators
• Assuming it filters out null or empty values

2. Which of the following is the correct way to use @NullAndEmptySource in a JUnit 5 parameterized test method?

easy

A. @Test
@NullAndEmptySource
void testMethod(String input) { ... }

B. @Test
@NullAndEmptySource
void testMethod() { ... }

C. @ParameterizedTest
@NullAndEmptySource
void testMethod() { ... }

D. @ParameterizedTest
@NullAndEmptySource
void testMethod(String input) { ... }

Solution

1. Step 1: Check annotation compatibility

   @NullAndEmptySource must be used with @ParameterizedTest to supply parameters.

2. Step 2: Verify method signature

   The test method must accept a parameter to receive the null or empty value.

3. Final Answer:

   @ParameterizedTest @NullAndEmptySource void testMethod(String input) { ... } -> Option D

4. Quick Check:

   @NullAndEmptySource needs @ParameterizedTest and parameter [OK]

Hint: Use @NullAndEmptySource only with @ParameterizedTest and parameters [OK]

Common Mistakes:

• Using @NullAndEmptySource with @Test instead of @ParameterizedTest
• Writing test methods without parameters
• Forgetting to annotate with @ParameterizedTest

3. Given the following test code, what will be the total number of test invocations executed?

@ParameterizedTest
@NullAndEmptySource
@ValueSource(strings = {"hello", "world"})
void testStrings(String input) {
    // test logic here
}

medium

A. 4

B. 3

C. 2

D. 5

Solution

1. Step 1: Count inputs from @NullAndEmptySource

   @NullAndEmptySource adds two inputs: null and empty string ("").

2. Step 2: Count inputs from @ValueSource

   @ValueSource provides two strings: "hello" and "world".

3. Step 3: Calculate total invocations

   Total = 2 (null and empty) + 2 (hello, world) = 4 test runs.

4. Final Answer:

   4 -> Option A

5. Quick Check:

   2 null/empty + 2 values = 4 [OK]

Hint: Add null and empty plus other values for total tests [OK]

Common Mistakes:

• Counting only @ValueSource inputs
• Counting null and empty as one input
• Forgetting that @NullAndEmptySource adds two inputs

4. Identify the error in the following JUnit test code using @NullAndEmptySource:

@ParameterizedTest
@NullAndEmptySource
void testInput() {
    // test logic
}

medium

A. Cannot use @NullAndEmptySource without @ValueSource

B. Missing parameter in test method to receive input values

C. Incorrect annotation; should use @Test instead of @ParameterizedTest

D. Test method must be static when using @NullAndEmptySource

Solution

1. Step 1: Check method signature

   The test method has no parameters, but @NullAndEmptySource provides inputs that must be accepted.

2. Step 2: Understand parameterized test requirements

   Parameterized test methods must have parameters matching the sources; missing parameter causes error.

3. Final Answer:

   Missing parameter in test method to receive input values -> Option B

4. Quick Check:

   Parameterized test needs method parameter [OK]

Hint: Parameterized tests need method parameters to accept inputs [OK]

Common Mistakes:

• Leaving test method parameterless with @NullAndEmptySource
• Confusing @Test and @ParameterizedTest annotations
• Thinking @NullAndEmptySource requires @ValueSource

5. You want to test a method that processes user input strings, including null and empty values, plus some specific strings. Which annotation combination correctly covers null, empty, and the strings "admin" and "guest" in a single parameterized test?

hard

A. @ParameterizedTest
@NullAndEmptySource
@ValueSource(strings = {"admin", "guest"})

B. @ParameterizedTest
@EmptySource
@ValueSource(strings = {"admin", "guest"})

C. @ParameterizedTest
@NullSource
@ValueSource(strings = {"admin", "guest"})

D. @ParameterizedTest
@ValueSource(strings = {null, "", "admin", "guest"})

Solution

1. Step 1: Identify annotations for null and empty

   @NullAndEmptySource adds both null and empty string automatically.

2. Step 2: Add specific string inputs

   @ValueSource(strings = {"admin", "guest"}) adds the required specific strings.

3. Step 3: Verify combined usage

   Combining @NullAndEmptySource with @ValueSource covers all needed inputs in one test.

4. Final Answer:

   @ParameterizedTest @NullAndEmptySource @ValueSource(strings = {"admin", "guest"}) -> Option A

5. Quick Check:

   Use @NullAndEmptySource plus @ValueSource for all inputs [OK]

Hint: Combine @NullAndEmptySource with @ValueSource for null, empty, and values [OK]

Common Mistakes:

• Using only @EmptySource or @NullSource missing one input
• Trying to put null in @ValueSource strings (not allowed)
• Not combining annotations properly