@NullSource and @EmptySource in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Purpose of @NullSource in JUnit 5

What is the main purpose of using the @NullSource annotation in JUnit 5 parameterized tests?

A To provide a single null argument to the test method to check how it handles null inputs.

B To provide an empty string as input to the test method.

C To provide multiple null values to the test method.

D To skip the test if the input is null.

💡 Hint

Think about testing how your code behaves when it receives no object.

@NullSource adds a single null argument to the parameterized test, allowing you to verify how your code handles null inputs safely.

🧠 Conceptual

intermediate

Effect of @EmptySource in JUnit 5

Which of the following inputs does the @EmptySource annotation provide to a parameterized test method?

A Only an empty string regardless of parameter type.

B A null value only.

C Random non-empty values.

D Empty values such as empty string, empty collection, or empty array depending on the parameter type.

💡 Hint

Consider what 'empty' means for different data types.

@EmptySource provides empty values appropriate to the parameter type, such as "" for strings, empty lists for collections, or empty arrays.

❓ Predict Output

advanced

Output of Parameterized Test with @NullSource and @EmptySource

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

JUnit

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.NullSource;
import org.junit.jupiter.params.provider.EmptySource;

class SampleTest {
    @ParameterizedTest
    @NullSource
    @EmptySource
    void testWithNullAndEmpty(String input) {
        System.out.println("Input: '" + input + "'");
    }
}

A 2 test invocations: one with null and one with empty string.

B 1 test invocation: only with null input.

C 3 test invocations: null, empty string, and one default value.

D 4 test invocations: null, empty string, empty array, and empty collection.

💡 Hint

Count how many inputs @NullSource and @EmptySource provide for a String parameter.

@NullSource provides one null input, and @EmptySource provides one empty string input for String parameters, so total 2 invocations.

❓ assertion

advanced

Assertion Behavior with @NullSource and @EmptySource

Given a parameterized test using @NullSource and @EmptySource on a String parameter, which assertion correctly verifies that the input is either null or empty?

JUnit

import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.NullSource;
import org.junit.jupiter.params.provider.EmptySource;

class AssertionTest {
    @ParameterizedTest
    @NullSource
    @EmptySource
    void testInput(String input) {
        // Which assertion is correct here?
    }
}

A assertEquals("", input);

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

C assertNotNull(input);

D assertFalse(input.isEmpty());

💡 Hint

Remember that input can be null or empty string.

Since input can be null or empty string, the assertion must allow both conditions.

🔧 Debug

expert

Debugging a Failing Parameterized Test with @NullSource and @EmptySource

A parameterized test uses @NullSource and @EmptySource on a method with a non-nullable primitive int parameter. What error will occur when running the test?

JUnit

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.NullSource;
import org.junit.jupiter.params.provider.EmptySource;

class DebugTest {
    @ParameterizedTest
    @NullSource
    @EmptySource
    void testPrimitive(int number) {
        System.out.println(number);
    }
}

A Test runs successfully with 0 as default value for null input.

B Test fails with NumberFormatException due to empty input.

C Test fails with a ParameterResolutionException because null cannot be assigned to primitive int.

D Test runs only once with empty input converted to 0.

💡 Hint

Consider how Java primitives handle null values.

Primitive types like int cannot accept null values, so @NullSource causes a ParameterResolutionException.

Practice

1. What is the main purpose of the @NullSource annotation in JUnit parameterized tests?

easy

A. To provide a null value as input to the test method parameter

B. To provide an empty string as input to the test method parameter

C. To provide multiple non-null values to the test method

D. To skip the test when the input is null

Solution

1. Step 1: Understand @NullSource role

   @NullSource is used to supply a null value as input to a parameterized test method.

2. Step 2: Differentiate from other sources

   @EmptySource provides empty values like empty strings or collections, not null. Other options do not match @NullSource behavior.

3. Final Answer:

   To provide a null value as input to the test method parameter -> Option A

4. Quick Check:

   @NullSource = null input [OK]

Hint: NullSource always means null input for tests [OK]

Common Mistakes:

• Confusing @NullSource with @EmptySource
• Thinking @NullSource provides empty strings
• Assuming @NullSource skips tests

2. Which of the following is the correct way to use both @NullSource and @EmptySource together in a JUnit 5 parameterized test?

easy

A. @ParameterizedTest
@NullSource
void testMethod(@EmptySource String input) { ... }

B. @ParameterizedTest
@EmptySource
@NullSource
void testMethod() { ... }

C. @ParameterizedTest
@NullSource
@EmptySource
void testMethod(String input) { ... }

D. @ParameterizedTest
@NullSource
@EmptySource
void testMethod() { ... }

Solution

1. Step 1: Check annotation placement

   Both @NullSource and @EmptySource must be placed above the test method along with @ParameterizedTest.

2. Step 2: Verify method signature

   The test method must accept a parameter matching the input type (e.g., String input) to receive values from sources.

3. Final Answer:

   @ParameterizedTest @NullSource @EmptySource void testMethod(String input) { ... } -> Option C

4. Quick Check:

   Annotations above method with parameter = correct [OK]

Hint: Put both sources above method with matching parameter [OK]

Common Mistakes:

• Placing @EmptySource inside method parameters
• Missing parameter in test method
• Wrong order or missing @ParameterizedTest

3. Given the following test method, what inputs will it receive during execution?

@ParameterizedTest
@NullSource
@EmptySource
void testInput(String input) {
    System.out.println(input == null ? "null" : "'" + input + "'");
}

medium

A. Only an empty string printed as: ''

B. null and an empty string printed as: null and ''

C. Only null printed as: null

D. null, empty string, and a string with spaces

Solution

1. Step 1: Identify inputs from annotations

   @NullSource provides a null input, and @EmptySource provides an empty string input.

2. Step 2: Understand output behavior

   The method prints "null" if input is null, otherwise prints the input in quotes. So outputs will be "null" and "''" for empty string.

3. Final Answer:

   null and an empty string printed as: null and '' -> Option B

4. Quick Check:

   NullSource + EmptySource = null + "" [OK]

Hint: NullSource gives null, EmptySource gives empty string [OK]

Common Mistakes:

• Assuming EmptySource provides null
• Expecting extra inputs like spaces
• Ignoring null input from NullSource

4. Consider this test code snippet:

@ParameterizedTest
@NullSource
@EmptySource
void test(String input) {
    assertNotNull(input);
}

What will happen when this test runs?

medium

A. Test fails with AssertionError due to null input

B. Test passes for all inputs

C. Compilation error because of missing imports

D. Test is skipped because of null input

Solution

1. Step 1: Analyze inputs from sources

   @NullSource provides a null input, and @EmptySource provides an empty string input.

2. Step 2: Check assertion behavior

   assertNotNull(input) will fail when input is null, causing an AssertionError.

3. Final Answer:

   Test fails with AssertionError due to null input -> Option A

4. Quick Check:

   assertNotNull fails on null input [OK]

Hint: assertNotNull fails if input is null from NullSource [OK]

Common Mistakes:

• Thinking test passes because empty string is valid
• Assuming test skips null input
• Confusing compilation errors with runtime failures

5. You want to test a method that should accept null, empty, and non-empty strings. Which combination of annotations correctly tests all these cases in one parameterized test?

hard

A. @ParameterizedTest
@NullSource
@ValueSource(strings = {"test"})
void testMethod(String input) { ... }

B. @ParameterizedTest
@EmptySource
@ValueSource(strings = {"test"})
void testMethod(String input) { ... }

C. @ParameterizedTest
@NullSource
@EmptySource
void testMethod() { ... }

D. @ParameterizedTest
@NullSource
@EmptySource
@ValueSource(strings = {"test"})
void testMethod(String input) { ... }

Solution

1. Step 1: Identify needed inputs

   You need null (from @NullSource), empty string (from @EmptySource), and a non-empty string (from @ValueSource).

2. Step 2: Verify method signature and annotations

   Method must accept a parameter to receive inputs. @ParameterizedTest @NullSource @EmptySource @ValueSource(strings = {"test"}) void testMethod(String input) { ... } includes all three annotations and a parameter.

3. Final Answer:

   @ParameterizedTest @NullSource @EmptySource @ValueSource(strings = {"test"}) void testMethod(String input) { ... } -> Option D

4. Quick Check:

   Combine NullSource, EmptySource, and ValueSource for all cases [OK]

Hint: Combine NullSource, EmptySource, and ValueSource for full coverage [OK]

Common Mistakes:

• Omitting NullSource or EmptySource
• Missing method parameter
• Using annotations without @ParameterizedTest