Custom conditions with @EnabledIf in JUnit - Test Execution Trace

Test Overview

This test uses JUnit's @EnabledIf annotation to run a test only when a custom condition method returns true. It verifies that the condition controls test execution.

Test Code - JUnit 5

JUnit

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.condition.EnabledIf;
import static org.junit.jupiter.api.Assertions.assertTrue;

public class CustomConditionTest {

    @Test
    @EnabledIf("customCondition")
    void testRunsOnlyIfConditionTrue() {
        assertTrue(true, "This test runs only if customCondition returns true");
    }

    boolean customCondition() {
        // Custom logic, here simply returns true
        return true;
    }
}

Execution Trace - 4 Steps

Step	Action	System State	Assertion	Result
1	JUnit test runner starts and scans for tests	Test class CustomConditionTest is loaded	—	PASS
2	JUnit evaluates @EnabledIf annotation by calling customCondition()	customCondition() method returns true	Check if customCondition() returns true to enable test	PASS
3	JUnit executes testRunsOnlyIfConditionTrue() test method	Inside test method, assertion assertTrue(true) runs	assertTrue(true) verifies condition is true	PASS
4	Test completes successfully	Test result recorded as passed	—	PASS

Failure Scenario

Failing Condition: customCondition() returns false causing test to be disabled

Execution Trace Quiz - 3 Questions

What does the @EnabledIf annotation do in this test?

A Runs the test only if the customCondition method returns true

B Always runs the test regardless of any condition

C Disables the test permanently

D Runs the test only if an exception is thrown

Key Result

Using @EnabledIf with a custom method helps run tests conditionally, improving test suite flexibility and avoiding unnecessary test runs.

Practice

1. What is the primary purpose of using @EnabledIf in JUnit tests?

easy

A. To run a test only if a custom condition returns true

B. To disable a test permanently

C. To mark a test as expected to fail

D. To repeat a test multiple times

Solution

1. Step 1: Understand the role of @EnabledIf

   @EnabledIf is used to conditionally enable a test based on a custom boolean expression or method.

2. Step 2: Compare with other annotations

   Unlike disabling or repeating tests, @EnabledIf controls test execution dynamically based on conditions.

3. Final Answer:

   To run a test only if a custom condition returns true -> Option A

4. Quick Check:

   @EnabledIf runs test if condition true [OK]

Hint: Remember: @EnabledIf controls test run by condition [OK]

Common Mistakes:

• Confusing @EnabledIf with @Disabled
• Thinking it repeats tests
• Assuming it marks tests as expected failures

2. Which of the following is the correct syntax to enable a test only if a static method isFeatureEnabled() returns true using @EnabledIf?

easy

A. @EnabledIf("isFeatureEnabled()")

B. @EnabledIf(expression = "isFeatureEnabled()")

C. @EnabledIf("isFeatureEnabled")

D. @EnabledIf(condition = "isFeatureEnabled()")

Solution

1. Step 1: Check correct attribute name

   The correct attribute for the condition expression is unnamed, so just a string is passed to @EnabledIf.

2. Step 2: Validate method call syntax

   The method must be called with parentheses inside the string: "isFeatureEnabled()".

3. Final Answer:

   @EnabledIf("isFeatureEnabled()") -> Option A

4. Quick Check:

   Use @EnabledIf("method()") syntax [OK]

Hint: Use @EnabledIf("method()") with parentheses [OK]

Common Mistakes:

• Using expression attribute which does not exist
• Omitting parentheses in method call
• Using incorrect attribute name like condition

3. Given the following code snippet, what will be the output when running the test?

public class FeatureTest {
  static boolean isFeatureEnabled() { return false; }

  @Test
  @EnabledIf("isFeatureEnabled()")
  void testFeature() {
    System.out.println("Feature test executed");
  }
}

medium

A. Feature test executed

B. Test skipped, no output

C. Compilation error due to @EnabledIf

D. Runtime exception thrown

Solution

1. Step 1: Evaluate the condition method

   The method isFeatureEnabled() returns false, so the condition for @EnabledIf is false.

2. Step 2: Understand @EnabledIf behavior

   When the condition is false, the test is skipped and the test method body does not run.

3. Final Answer:

   Test skipped, no output -> Option B

4. Quick Check:

   False condition skips test [OK]

Hint: False condition means test does not run [OK]

Common Mistakes:

• Expecting test to run despite false condition
• Thinking it causes errors
• Confusing with @Disabled

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

public class SampleTest {
  @Test
  @EnabledIf("checkCondition")
  void testSomething() {}

  boolean checkCondition() { return true; }
}

medium

A. checkCondition must return String, not boolean

B. @EnabledIf requires expression attribute

C. checkCondition method must be static

D. Method checkCondition must be public

Solution

1. Step 1: Check method signature requirements

   The method used in @EnabledIf must be static because JUnit calls it without instance.

2. Step 2: Verify method return type and visibility

   Return type boolean is correct and method visibility can be default or public, but static is mandatory.

3. Final Answer:

   checkCondition method must be static -> Option C

4. Quick Check:

   Condition method must be static [OK]

Hint: Condition methods must be static [OK]

Common Mistakes:

• Making condition method non-static
• Expecting expression attribute in @EnabledIf
• Confusing return type requirements

5. You want to enable a test only if the system property env equals prod and a static method isReady() returns true. Which @EnabledIf expression correctly combines these conditions?

hard

A. @EnabledIf(expression = "System.getProperty('env').equals('prod') && isReady()")

B. @EnabledIf("System.getProperty('env') == 'prod' && isReady()")

C. @EnabledIf("System.getProperty('env').equals('prod') & isReady()")

D. @EnabledIf("'prod'.equals(System.getProperty('env')) && isReady()")

Solution

1. Step 1: Understand string comparison in Java expressions

   Use 'prod'.equals(System.getProperty('env')) to avoid NullPointerException if property is null.

2. Step 2: Combine conditions with logical AND

   Use && to combine boolean expressions correctly in the string.

3. Step 3: Validate syntax of @EnabledIf

   The expression is passed as a single string without attribute name; @EnabledIf("'prod'.equals(System.getProperty('env')) && isReady()") matches this.

4. Final Answer:

   @EnabledIf("'prod'.equals(System.getProperty('env')) && isReady()") -> Option D

5. Quick Check:

   Use safe equals and && in string expression [OK]

Hint: Use 'prod'.equals(...) and && for safe combined condition [OK]

Common Mistakes:

• Using == for string comparison
• Using single & instead of &&
• Adding expression attribute which is invalid