@EnabledIfSystemProperty in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding @EnabledIfSystemProperty usage

What does the JUnit annotation @EnabledIfSystemProperty(named = "os.name", matches = "Windows.*") do when applied to a test method?

A Runs the test only if the operating system name starts with "Windows".

B Runs the test only if the system property "os.name" is exactly "Windows".

C Disables the test if the operating system name contains "Windows" anywhere.

D Runs the test regardless of the operating system.

💡 Hint

Think about how the matches attribute uses regular expressions.

The annotation @EnabledIfSystemProperty runs the test only if the specified system property matches the given regular expression. Here, matches = "Windows.*" means the property value must start with "Windows".

❓ Predict Output

intermediate

Test execution with @EnabledIfSystemProperty

Given the following test class, what will be the output when running on a Linux system where os.name is "Linux"?

JUnit

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

public class SystemPropertyTest {

    @Test
    @EnabledIfSystemProperty(named = "os.name", matches = "Windows.*")
    void testWindowsOnly() {
        System.out.println("Windows test executed");
    }

    @Test
    void testAlways() {
        System.out.println("Always executed");
    }
}

A Both "Windows test executed" and "Always executed" are printed.

B Only "Always executed" is printed.

C Only "Windows test executed" is printed.

D No output is printed because tests are skipped.

💡 Hint

Check which tests are enabled based on the system property.

The test annotated with @EnabledIfSystemProperty runs only if os.name matches "Windows.*". On Linux, it does not match, so that test is skipped. The other test runs always.

❓ assertion

advanced

Assertion on test enablement with @EnabledIfSystemProperty

Which assertion correctly verifies that a test method annotated with @EnabledIfSystemProperty(named = "env", matches = "prod") runs only when the system property env is set to "prod"?

A assertTrue(System.getProperty("env").equals("prod"));

B assertTrue(System.getProperty("env").contains("prod"));

C assertFalse(System.getProperty("env").equals("prod"));

D assertNull(System.getProperty("env"));

💡 Hint

The annotation requires exact match to "prod".

The matches attribute expects the system property to exactly match "prod". The assertion must check equality, not containment or null.

🔧 Debug

advanced

Debugging skipped test with @EnabledIfSystemProperty

A test annotated with @EnabledIfSystemProperty(named = "user.language", matches = "en") is unexpectedly skipped on a machine where user.language is "en_US". What is the most likely cause?

A The annotation requires the property to be null to run.

B The system property "user.language" is not set correctly.

C The regex "en" does not match "en_US" because it expects an exact match.

D JUnit does not support regex in @EnabledIfSystemProperty.

💡 Hint

Consider how regex matching works in Java.

The matches attribute uses Java regex which must match the entire string. "en" matches only the exact string "en", not "en_US".

❓ framework

expert

Combining @EnabledIfSystemProperty with other conditional annotations

Consider a test method annotated with both @EnabledIfSystemProperty(named = "env", matches = "prod") and @EnabledOnOs(OS.WINDOWS). Under which condition will this test run?

A When either the system property "env" is "prod" or the OS is Windows.

B Never runs because the annotations conflict.

C Always runs regardless of system property or OS.

D Only when the system property "env" is "prod" and the OS is Windows.

💡 Hint

Think about how multiple conditional annotations combine in JUnit.

JUnit requires all conditional annotations on a test to be true for the test to run. Both conditions must be met.

Practice

1. What is the primary purpose of the @EnabledIfSystemProperty annotation in JUnit tests?

easy

A. To enable a test only on weekends

B. To disable a test permanently

C. To run a test only if a specific system property matches a given value

D. To run a test multiple times automatically

Solution

1. Step 1: Understand the annotation's purpose

   <code>@EnabledIfSystemProperty

2. Step 2: Analyze the options

   To run a test only if a specific system property matches a given value correctly states that the test runs only if a system property matches a value. Options B, C, and D describe unrelated behaviors.

3. Final Answer:

   To run a test only if a specific system property matches a given value -> Option C

4. Quick Check:

   @EnabledIfSystemProperty = Conditional test run [OK]

Hint: It runs tests only when system property matches [OK]

Common Mistakes:

• Confusing it with @Disabled or @Enabled annotations
• Thinking it runs tests based on date or time
• Assuming it runs tests multiple times automatically

2. Which of the following is the correct syntax to enable a test only when the system property env equals prod using @EnabledIfSystemProperty?

easy

A. @EnabledIfSystemProperty(named = "env", matches = "prod")

B. @EnabledIfSystemProperty(name = "env", value = "prod")

C. @EnabledIfSystemProperty(property = "env", equals = "prod")

D. @EnabledIfSystemProperty(key = "env", match = "prod")

Solution

1. Step 1: Recall the annotation parameters

   The correct parameters are named for the system property name and matches for the regex pattern to match.

2. Step 2: Compare options with correct syntax

   @EnabledIfSystemProperty(named = "env", matches = "prod") uses named and matches correctly. Other options use incorrect parameter names.

3. Final Answer:

   @EnabledIfSystemProperty(named = "env", matches = "prod") -> Option A

4. Quick Check:

   named + matches = correct syntax [OK]

Hint: Use named and matches parameters exactly [OK]

Common Mistakes:

• Using 'name' instead of 'named'
• Using 'value' or 'equals' instead of 'matches'
• Mixing parameter names incorrectly

3. Consider the following JUnit test snippet:

@EnabledIfSystemProperty(named = "os.name", matches = "Windows.*")
void testWindowsFeature() {
    System.out.println("Windows test executed");
}

If the system property os.name is set to Windows 10, what will be the output when running this test?

medium

A. Test skipped silently

B. Windows test executed

C. Runtime exception occurs

D. Test fails with assertion error

Solution

1. Step 1: Understand the system property condition

   The test runs only if os.name matches the regex Windows.*. The value Windows 10 matches this pattern.

2. Step 2: Predict test behavior

   Since the condition is true, the test runs and prints "Windows test executed".

3. Final Answer:

   Windows test executed -> Option B

4. Quick Check:

   Property matches regex = test runs [OK]

Hint: Regex match true means test runs and prints output [OK]

Common Mistakes:

• Assuming test skips because of partial match
• Expecting exceptions from annotation
• Confusing output with test failure

4. Given this test method:

@EnabledIfSystemProperty(named = "user.language", matches = "en")
void testEnglishFeature() {
    // test code
}

The test never runs even when the system property user.language is set to en. What is the most likely cause?

medium

A. The system property is not set before test execution

B. The regex pattern should be "en.*" to match properly

C. The annotation parameter should be 'name' not 'named'

D. JUnit does not support @EnabledIfSystemProperty

Solution

1. Step 1: Check system property availability

   If the system property user.language is not set before running tests, the condition fails and test is skipped.

2. Step 2: Validate other options

   The regex pattern should be "en.*" to match properly is unnecessary because exact match "en" works. The annotation parameter should be 'name' not 'named' is incorrect because 'named' is the correct parameter. JUnit does not support @EnabledIfSystemProperty is false; JUnit supports this annotation.

3. Final Answer:

   The system property is not set before test execution -> Option A

4. Quick Check:

   Property must be set before test runs [OK]

Hint: Ensure system property is set before running tests [OK]

Common Mistakes:

• Confusing 'named' with 'name' parameter
• Assuming regex must be partial match
• Believing JUnit lacks support for this annotation

5. You want to write a test that runs only if the system property env is set to either dev or test. Which @EnabledIfSystemProperty annotation correctly implements this?

hard

A. @EnabledIfSystemProperty(named = "env", matches = "dev?test")

B. @EnabledIfSystemProperty(named = "env", matches = "dev,test")

C. @EnabledIfSystemProperty(named = "env", matches = "[dev,test]")

D. @EnabledIfSystemProperty(named = "env", matches = "dev|test")

Solution

1. Step 1: Understand regex for multiple options

   The regex dev|test means match either "dev" or "test" exactly.

2. Step 2: Evaluate each option's regex

   @EnabledIfSystemProperty(named = "env", matches = "dev|test") uses correct regex with alternation. @EnabledIfSystemProperty(named = "env", matches = "dev,test") uses comma which matches literal comma, not alternation. @EnabledIfSystemProperty(named = "env", matches = "[dev,test]") uses square brackets which match single characters, not words. @EnabledIfSystemProperty(named = "env", matches = "dev?test") uses question mark which means optional character, not alternation.

3. Final Answer:

   @EnabledIfSystemProperty(named = "env", matches = "dev|test") -> Option D

4. Quick Check:

   Use regex alternation with | for multiple matches [OK]

Hint: Use regex 'dev|test' to match either value [OK]

Common Mistakes:

• Using commas instead of | in regex
• Using square brackets which match single chars
• Misusing ? for alternation