@EnabledIfSystemProperty in JUnit - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the @EnabledIfSystemProperty annotation do in JUnit?

It enables a test or test class only if a specified system property matches a given value. If the condition is not met, the test is skipped.

beginner

How do you specify the system property name and value in @EnabledIfSystemProperty?

You use the attributes 'named' for the system property name and 'matches' for the expected value pattern. For example: @EnabledIfSystemProperty(named = "os.name", matches = "Windows.*")

intermediate

Can @EnabledIfSystemProperty use regular expressions for matching the property value?

Yes, the 'matches' attribute accepts a regular expression to match the system property value.

beginner

What happens if the system property specified in @EnabledIfSystemProperty is not set?

The test is disabled (skipped) because the condition to enable it is not met.

beginner

Write a simple example of a test method enabled only on Linux OS using @EnabledIfSystemProperty.

@EnabledIfSystemProperty(named = "os.name", matches = "Linux.*") void testOnlyOnLinux() { // test code here }

What does @EnabledIfSystemProperty do in JUnit?

A Runs a test only if an environment variable is set

B Disables a test permanently

C Runs a test only if a system property matches a value

D Runs all tests regardless of conditions

The annotation enables tests only when a system property matches the specified value.

Which attribute specifies the system property name in @EnabledIfSystemProperty?

A named

B propertyName

C value

D key

The 'named' attribute is used to specify the system property name.

If the system property does not exist, what happens to the test with @EnabledIfSystemProperty?

A Test runs normally

B Test is skipped

C Test fails

D Test runs twice

The test is skipped because the enabling condition is not met.

Can the 'matches' attribute in @EnabledIfSystemProperty use regular expressions?

A Yes, it supports regex

B It accepts only numeric values

C Only wildcards (*) are allowed

D No, only exact matches

The 'matches' attribute supports regular expressions for flexible matching.

Which of these is a valid use of @EnabledIfSystemProperty?

A @EnabledIfSystemProperty(enabled = true)

B @EnabledIfSystemProperty(env = "PATH")

C @EnabledIfSystemProperty(property = "user.home")

D @EnabledIfSystemProperty(named = "java.version", matches = "17.*")

Only option A correctly uses 'named' and 'matches' attributes.

Explain how @EnabledIfSystemProperty controls test execution in JUnit.

Think about how system properties can control when tests run.

Describe a scenario where using @EnabledIfSystemProperty would be helpful.

Consider different machines or environments where 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