assumingThat for conditional assertions in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of assumingThat with true condition

What is the output of the following JUnit test snippet when the condition is true?

JUnit

import static org.junit.jupiter.api.Assumptions.assumingThat;
import static org.junit.jupiter.api.Assertions.assertEquals;

boolean isFeatureEnabled = true;

assumingThat(isFeatureEnabled, () -> {
    assertEquals(5, 2 + 3);
});

System.out.println("Test completed");

A Test completed (test fails with AssertionError)

B Test completed (test passes)

C Test skipped due to failed assumption

D Compilation error due to syntax

💡 Hint

Think about what assumingThat does when the condition is true.

The assumingThat method runs the assertion only if the condition is true. Here, since isFeatureEnabled is true, the assertion assertEquals(5, 2 + 3) runs and passes. The test completes successfully and prints "Test completed".

❓ Predict Output

intermediate

Output of assumingThat with false condition

What happens when the condition in assumingThat is false in this JUnit snippet?

JUnit

import static org.junit.jupiter.api.Assumptions.assumingThat;
import static org.junit.jupiter.api.Assertions.assertEquals;

boolean isFeatureEnabled = false;

assumingThat(isFeatureEnabled, () -> {
    assertEquals(5, 2 + 2);
});

System.out.println("Test completed");

A Test completed (test passes)

B Test completed (test fails with AssertionError)

C Runtime exception due to null pointer

D Test skipped due to failed assumption

💡 Hint

What does assumingThat do when the condition is false?

When the condition is false, assumingThat skips the assertion inside the lambda. So the assertion assertEquals(5, 2 + 2) is not executed. The test continues and prints "Test completed". The test passes because no assertion failed.

❓ assertion

advanced

Correct use of assumingThat for environment-based test

You want to run an assertion only if the environment variable "ENV" equals "prod". Which of the following JUnit code snippets correctly uses assumingThat for this?

A assumingThat(System.getenv("ENV") != null, () -> assertEquals(10, calculate()));

B assumingThat(System.getenv("ENV") == "prod", () -> assertEquals(10, calculate()));

C assumingThat(System.getenv("ENV").equalsIgnoreCase("prod"), () -> assertEquals(10, calculate()));

D assumingThat(System.getenv("ENV").equals("prod"), () -> assertEquals(10, calculate()));

💡 Hint

Use .equals to compare strings in Java, not ==.

Option D correctly uses .equals("prod") to compare the environment variable string. Option D uses == which compares references, not string content, so it may fail. Option D only checks for non-null but does not check the value. Option D uses equalsIgnoreCase which is not exactly the requirement.

🔧 Debug

advanced

Why does this assumingThat assertion fail unexpectedly?

Consider this JUnit code snippet: boolean isReady = false; assumingThat(isReady = true, () -> assertEquals(1, 2)); Why does the assertion run and fail even though isReady was false initially?

JUnit

boolean isReady = false;
assumingThat(isReady = true, () -> assertEquals(1, 2));

A Because the assignment operator '=' sets isReady to true, so the condition is true and assertion runs

B Because assumingThat ignores the condition and always runs the assertion

C Because isReady was false, so the assertion should not run but a bug causes it to run

D Because assertEquals(1, 2) is always executed regardless of assumingThat

💡 Hint

Check the difference between '=' and '==' in Java conditions.

The condition uses isReady = true which is an assignment, not a comparison. This sets isReady to true and returns true, so the assertion runs and fails. To check equality, use isReady == true or simply isReady.

🧠 Conceptual

expert

Behavior of assumingThat with multiple assertions inside

In a JUnit test, you use assumingThat with a condition that is false. Inside the lambda, you have multiple assertions. What happens to those assertions during test execution?

A All assertions run but failures are ignored

B Only the first assertion runs and others are skipped

C None of the assertions inside the lambda run; the entire block is skipped

D Assertions run but results are logged without failing the test

💡 Hint

Think about how assumingThat controls execution flow based on the condition.

When the condition in assumingThat is false, the entire lambda block is skipped. None of the assertions inside run, so no failures or logs occur from them.