assumingThat for conditional assertions in JUnit - Build an Automation Script

Use assumingThat to run assertions conditionally in JUnit

Preconditions (2)

Step 1: Create a test method

Step 2: Define a boolean condition (e.g., isWindows = true if OS is Windows)

Step 3: Use assumingThat with the condition and a lambda containing assertions

Step 4: Run the test

Step 5: Verify that assertions inside assumingThat run only if the condition is true

Step 6: Verify that if the condition is false, the assertions inside assumingThat are skipped but the test does not fail

✅ Expected Result: Assertions inside assumingThat run only when the condition is true. If the condition is false, those assertions are skipped without failing the test.

Automation Requirements - JUnit 5

Assertions Needed:

Verify that assumingThat runs assertions only when condition is true

Verify that test passes when condition is false and assertions inside assumingThat are skipped

Best Practices:

Use @Test annotation for test methods

Use org.junit.jupiter.api.Assumptions.assumingThat for conditional assertions

Keep assertions inside lambda passed to assumingThat

Use descriptive assertion messages

Avoid side effects inside assumingThat lambda

Automated Solution

JUnit

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

public class ConditionalAssertionTest {

    @Test
    void testConditionalAssertion() {
        boolean isWindows = System.getProperty("os.name").toLowerCase().contains("win");

        assumingThat(isWindows, () -> {
            // This assertion runs only if isWindows is true
            assertEquals("windows 10", System.getProperty("os.name").toLowerCase(), "OS name should be windows 10");
        });

        // This assertion always runs
        assertEquals(5, 2 + 3, "Basic math should work");
    }
}

This test method testConditionalAssertion uses assumingThat to run an assertion only if the isWindows condition is true. The condition checks if the OS name contains "win" (case-insensitive).

If the condition is true, the assertion inside the lambda verifies the OS name equals "windows 10" (lowercase). If false, this assertion is skipped without failing the test.

The second assertion assertEquals(5, 2 + 3) runs always to show the test continues normally.

This approach helps run assertions only when relevant, avoiding false failures on other platforms.

Common Mistakes - 3 Pitfalls

Using assumingThat without a lambda expression

{'mistake': 'Putting side effects or state changes inside assumingThat lambda', 'why_bad': "If the condition is false, the lambda is skipped, so side effects won't run, causing inconsistent test behavior.", 'correct_approach': 'Keep only assertions inside assumingThat lambda; do side effects outside to ensure consistent test setup.'}

Using assumingThat for test setup instead of assertions

Bonus Challenge

Now add data-driven testing with 3 different OS names to verify assumingThat behavior

Show Hint

Practice

1. What is the main purpose of assumingThat in JUnit tests?

easy

A. To run assertions only if a specific condition is true

B. To always run assertions regardless of conditions

C. To skip all tests unconditionally

D. To replace all assertions with print statements

Solution

1. Step 1: Understand the role of assumingThat

   assumingThat is used to run assertions only when a given condition is true, otherwise it skips them.

2. Step 2: Compare options with this behavior

   Only "To run assertions only if a specific condition is true" correctly describes this conditional behavior. Options A, B, and C do not match the purpose.

3. Final Answer:

   To run assertions only if a specific condition is true -> Option A

4. Quick Check:

   Conditional assertions = run only if true [OK]

Hint: Remember: assumingThat runs assertions only when condition is true [OK]

Common Mistakes:

• Thinking assumingThat always runs assertions
• Confusing assumingThat with skipping all tests
• Believing assumingThat replaces assertions

2. Which of the following is the correct syntax to use assumingThat in a JUnit 5 test?

easy

A. assumingThat(assertEquals(5, result), condition);

B. assumingThat(condition, assertEquals(5, result));

C. assumingThat(condition, () -> assertEquals(5, result));

D. assumingThat(() -> assertEquals(5, result), condition);

Solution

1. Step 1: Recall the method signature of assumingThat

   It takes a boolean condition first, then a lambda expression with assertions.

2. Step 2: Match options to this signature

   assumingThat(condition, () -> assertEquals(5, result)); matches: assumingThat(condition, () -> assertion). Others have wrong order or missing lambda.

3. Final Answer:

   assumingThat(condition, () -> assertEquals(5, result)); -> Option C

4. Quick Check:

   Condition first, then lambda [OK]

Hint: Syntax: assumingThat(condition, () -> assertion) [OK]

Common Mistakes:

• Putting assertion before condition
• Not using a lambda for the assertion
• Passing assertion directly without lambda

3. Consider the following code snippet:

int value = 10;
assumingThat(value > 5, () -> assertTrue(value < 20));
assumingThat(value < 5, () -> assertTrue(value > 0));

What will be the result of running this test?

medium

A. Both assertions run and pass

B. First assertion runs and passes; second is skipped

C. First assertion fails; second runs and passes

D. Both assertions are skipped

Solution

1. Step 1: Evaluate the first condition and assertion

   Condition: value > 5 is true (10 > 5). So assertion value < 20 runs and passes.

2. Step 2: Evaluate the second condition and assertion

   Condition: value < 5 is false (10 < 5). So assertion value > 0 is skipped.

3. Final Answer:

   First assertion runs and passes; second is skipped -> Option B

4. Quick Check:

   True condition runs assertion, false skips [OK]

Hint: Only assertions with true conditions run [OK]

Common Mistakes:

• Assuming all assertions run regardless of condition
• Confusing which assertions are skipped
• Thinking skipped assertions cause failure

4. Identify the error in this JUnit 5 test using assumingThat:

int x = 3;
x = 4;
assumingThat(() -> x > 0, () -> assertEquals(3, x));

medium

A. The variable x is not final or effectively final

B. The assertion lambda is missing parentheses

C. The condition should be a boolean, not a lambda

D. The assertEquals method is used incorrectly

Solution

1. Step 1: Check the variable capture rules for lambdas

   Local variables used in lambdas must be final or effectively final. Here, x is reassigned (x = 4), so it is not effectively final.

2. Step 2: Identify the error in the code

   This causes a compilation error because lambdas cannot capture non-effectively final variables.

3. Final Answer:

   The variable x is not final or effectively final -> Option A

4. Quick Check:

   Lambda locals must be effectively final [OK]

Hint: Lambdas capture effectively final locals only [OK]

Common Mistakes:

• Modifying local variables used in lambdas
• Not declaring local variables as final when needed
• Ignoring Java lambda capture rules

5. You want to write a test that only checks if a list is empty when the environment variable ENV equals "test". Which code snippet correctly uses assumingThat to achieve this?

hard

A. assumingThat(System.getenv("ENV").equals("test"), assertTrue(list.isEmpty()));

B. assumingThat(() -> System.getenv("ENV").equals("test"), assertTrue(list.isEmpty()));

C. assumingThat(System.getenv("ENV") == "test", () -> assertTrue(list.isEmpty()));

D. assumingThat(System.getenv("ENV").equals("test"), () -> assertTrue(list.isEmpty()));

Solution

1. Step 1: Check the condition type

   The condition must be a boolean expression, so System.getenv("ENV").equals("test") is correct.

2. Step 2: Verify the assertion lambda

   The assertion must be inside a lambda: () -> assertTrue(list.isEmpty()).

3. Step 3: Evaluate each option

   A matches both requirements. B uses lambda for condition and passes assertion without lambda. C uses == for string comparison (wrong). D passes assertion without lambda.

4. Final Answer:

   assumingThat(System.getenv("ENV").equals("test"), () -> assertTrue(list.isEmpty())); -> Option D

5. Quick Check:

   Boolean condition + assertion lambda = correct [OK]

Hint: Condition boolean, assertion inside lambda [OK]

Common Mistakes:

• Using lambda for condition instead of boolean
• Using == for string comparison
• Passing assertion without lambda