@Tag for categorization in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Purpose of @Tag in JUnit 5

What is the main purpose of using the @Tag annotation in JUnit 5 tests?

A To mark tests that should be ignored during execution.

B To define the order in which tests are executed.

C To categorize tests so you can run specific groups of tests selectively.

D To specify the timeout duration for a test method.

💡 Hint

Think about how you might run only some tests and not all.

The @Tag annotation allows you to label tests with categories. This helps when you want to run only tests with certain tags, for example, 'fast' or 'database'.

❓ Predict Output

intermediate

Output of Tagged Test Execution

Given the following JUnit 5 test class, what tests will run if you execute tests with the tag integration?

JUnit

import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;

public class SampleTest {

    @Test
    @Tag("unit")
    void unitTest() {
        System.out.println("Unit test running");
    }

    @Test
    @Tag("integration")
    void integrationTest() {
        System.out.println("Integration test running");
    }

    @Test
    void noTagTest() {
        System.out.println("No tag test running");
    }
}

A Only 'Integration test running' is printed.

B All three tests print their messages.

C 'Unit test running' and 'Integration test running' are printed.

D Only 'No tag test running' is printed.

💡 Hint

Remember that running tests by tag only runs tests with that tag.

When running tests filtered by the tag 'integration', only tests annotated with @Tag("integration") run. Tests without this tag or with other tags are skipped.

❓ assertion

advanced

Correct Assertion for Tag Presence

Which assertion correctly verifies that a test method is annotated with the tag slow using JUnit 5's reflection API?

JUnit

import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
import java.lang.reflect.Method;
import static org.junit.jupiter.api.Assertions.*;

public class TagTest {

    @Test
    @Tag("slow")
    void slowTest() {}

    @Test
    void checkTag() throws Exception {
        Method method = TagTest.class.getMethod("slowTest");
        // Which assertion below is correct?
    }
}

A assertFalse(method.isAnnotationPresent(Tag.class));

B assertTrue(method.isAnnotationPresent(Tag.class) && method.getAnnotation(Tag.class).value().equals("slow"));

C assertTrue(method.getAnnotationsByType(Tag.class).length == 1);

D assertEquals("slow", method.getAnnotation(Tag.class).value());

💡 Hint

Check both presence and value of the annotation.

Option B checks that the @Tag annotation is present and that its value is exactly 'slow'. Option B would fail if the annotation is missing (NullPointerException). Option B only checks presence count, not value. Option B is incorrect.

🔧 Debug

advanced

Why Does This Tagged Test Not Run?

Consider this JUnit 5 test class:

import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;

public class DebugTest {

    @Test
    @Tag("fast")
    void fastTest() {
        System.out.println("Fast test");
    }

    @Test
    @Tag("slow")
    void slowTest() {
        System.out.println("Slow test");
    }
}

You run tests with the tag fast but fastTest does not run. What is the most likely reason?

A The test class must be annotated with @Tag for methods to be filtered.

B The @Tag annotation is only for documentation and does not affect test execution.

C The test method name must start with 'test' to run.

D The test runner was not configured to include the 'fast' tag in the filter.

💡 Hint

Think about how test runners select tests by tag.

Tags only affect which tests run if the test runner is told to include or exclude tests by tag. If the runner is not configured to run 'fast' tagged tests, those tests won't run.

❓ framework

expert

Combining @Tag with Test Suites in JUnit 5

You want to create a test suite that runs only tests tagged with critical across multiple test classes. Which approach correctly achieves this in JUnit 5?

A Use <code>@SelectPackages</code> or <code>@SelectClasses</code> with <code>@IncludeTags("critical")</code> on a suite class annotated with <code>@Suite</code>.

B Annotate the suite class with <code>@Tag("critical")</code> and run it normally.

C Manually call each test method with the 'critical' tag inside the suite class.

D Use <code>@RunWith(JUnitPlatform.class)</code> and filter tags in the test methods.

💡 Hint

JUnit 5 suites use specific annotations to select tests and filter tags.

JUnit 5 provides @Suite with @SelectPackages or @SelectClasses to define which tests to run, combined with @IncludeTags to filter by tag. Option A is the correct modern approach.