@EnabledIfSystemProperty in JUnit

Introduction

This annotation helps run tests only when a specific system property has a certain value. It avoids running tests in the wrong environment.

Run tests only on a developer's machine with a special setup.

Skip tests when running on a continuous integration server.

Run tests only if a feature flag is enabled via system properties.

Avoid running tests on unsupported operating systems.

Control test execution based on environment variables passed as system properties.

Syntax

JUnit

@EnabledIfSystemProperty(named = "propertyName", matches = "valueRegex")

The named attribute specifies the system property key.

The matches attribute uses a regular expression to match the property value.

Examples

This test runs only if the system property env equals exactly dev.

JUnit

@EnabledIfSystemProperty(named = "env", matches = "dev")
void testOnlyOnDev() {
    // test code
}

This test runs only on Windows operating systems by matching the os.name property.

JUnit

@EnabledIfSystemProperty(named = "os.name", matches = ".*Windows.*")
void testOnlyOnWindows() {
    // test code
}

Sample Program

The first test runs only if the system property runSpecialTests is set to true. The second test always runs.

JUnit

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

public class SystemPropertyTest {

    @Test
    @EnabledIfSystemProperty(named = "runSpecialTests", matches = "true")
    void testRunsOnlyIfPropertyTrue() {
        assertTrue("true".equals(System.getProperty("runSpecialTests")));
    }

    @Test
    void testAlwaysRuns() {
        assertTrue(true);
    }
}

Important Notes

System properties can be set when running tests using JVM arguments like -DrunSpecialTests=true.

If the property is missing or does not match, the test is skipped, not failed.

This helps keep tests clean and environment-aware without manual checks inside test code.

Summary

@EnabledIfSystemProperty runs tests only when a system property matches a pattern.

It helps control test execution based on environment settings.

Use it to skip or run tests automatically depending on where and how tests run.

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