Custom conditions with @EnabledIf in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a test with @EnabledIf condition

Consider the following JUnit 5 test method using @EnabledIf. What will be the test execution result when the system property 'env' is set to 'prod'?

JUnit

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.condition.EnabledIf;

public class EnvTest {

    @Test
    @EnabledIf(expression = "'prod'.equals(System.getProperty('env'))", reason = "Only runs in prod environment")
    void testOnlyInProd() {
        System.out.println("Running in prod");
    }
}

A Test is skipped and does not run

B Test runs and passes, printing 'Running in prod'

C Test runs but fails with an exception

D Test runs and passes but prints nothing

💡 Hint

Check what the @EnabledIf expression evaluates to when 'env' is 'prod'.

The @EnabledIf annotation runs the test only if the expression evaluates to true. Since System.getProperty('env') returns 'prod', the expression 'prod'.equals('prod') is true, so the test runs and prints the message.

❓ assertion

intermediate

Assertion to verify @EnabledIf disables test

You want to assert that a test annotated with @EnabledIf(expression = "false") does not run. Which assertion correctly verifies this behavior in a JUnit 5 test suite?

A assertThrows(TestAbortedException.class, () -> runTest())

B assertTrue(runTest())

C assertFalse(runTest())

D assertEquals("Skipped", runTest())

💡 Hint

Tests disabled by @EnabledIf are aborted, not failed or passed.

When a test is disabled by @EnabledIf, JUnit aborts the test execution by throwing TestAbortedException. So asserting that this exception is thrown confirms the test was skipped.

🔧 Debug

advanced

Debug why @EnabledIf expression fails to enable test

Given this test method with @EnabledIf: @Test @EnabledIf(expression = "systemProperties['user.name'] == 'admin'", reason = "Only admin user") void adminOnlyTest() {} The test never runs even when the system property 'user.name' is set to 'admin'. What is the likely cause?

A The expression uses '==' instead of '.equals()' for string comparison

B The system property 'user.name' is not accessible in the test environment

C The @EnabledIf annotation requires a static method, missing here

D The test method must be static to use @EnabledIf

💡 Hint

Remember how string equality works in Java expressions.

In Java, '==' compares object references, not string content. The expression should use '.equals()' to compare string values. Using '==' causes the expression to be false, so the test is disabled.

🧠 Conceptual

advanced

Understanding @EnabledIf expression context

Which of the following statements about the expression used in @EnabledIf is TRUE?

A The expression can only check JUnit test annotations, not system properties

B The expression can execute arbitrary Java code including method calls with side effects

C The expression must be a constant boolean literal (true or false) only

D The expression can access system properties and environment variables via predefined variables

💡 Hint

Think about what data the expression can read to decide test execution.

The expression in @EnabledIf can access system properties and environment variables through predefined variables like 'systemProperties' and 'environment'. It cannot execute arbitrary Java code or have side effects.

❓ framework

expert

Custom condition class for @EnabledIf usage

You want to create a custom condition class to use with @EnabledIf to enable tests only on weekdays. Which implementation correctly defines the condition method?

JUnit

import org.junit.jupiter.api.extension.ConditionEvaluationResult;
import org.junit.jupiter.api.extension.ExecutionCondition;
import org.junit.jupiter.api.extension.ExtensionContext;
import java.time.DayOfWeek;
import java.time.LocalDate;

public class WeekdayCondition implements ExecutionCondition {

    @Override
    public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) {
        DayOfWeek day = LocalDate.now().getDayOfWeek();
        if (day == DayOfWeek.SATURDAY || day == DayOfWeek.SUNDAY) {
            return ConditionEvaluationResult.disabled("Weekend - test disabled");
        } else {
            return ConditionEvaluationResult.enabled("Weekday - test enabled");
        }
    }
}

A The class extends ConditionEvaluationResult and overrides isEnabled to check the day

B The class implements TestExecutionListener and overrides beforeTestExecution to skip tests on weekends

C The class implements ExecutionCondition and overrides evaluateExecutionCondition returning enabled or disabled based on day

D The class implements ExecutionCondition but returns null from evaluateExecutionCondition

💡 Hint

Check the interface and method required for custom conditions in JUnit 5.

To create a custom condition for @EnabledIf, implement ExecutionCondition and override evaluateExecutionCondition to return enabled or disabled results. Returning null or wrong interface will not work.

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