Failure notification setup in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

JUnit Failure Notification Behavior

What will be the output when this JUnit test class runs?

JUnit

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class NotificationTest {
    @Test
    void testFailureNotification() {
        assertEquals(5, 2 + 2, "Sum should be 5");
    }
}

A Test passes silently

B Test fails with message: 'Sum should be 5'

C Test fails with message: 'expected: <4> but was: <5>'

D Test throws a compilation error

💡 Hint

Check the assertion and the expected vs actual values.

The assertion expects 5 but the actual sum is 4, so the test fails with the provided message.

❓ assertion

intermediate

Correct Assertion for Failure Notification

Which assertion will cause a failure notification if the method getUserCount() returns 10?

JUnit

public int getUserCount() {
    return 10;
}

A assertEquals(5, getUserCount())

B assertEquals(10, getUserCount())

C assertTrue(getUserCount() == 10)

D assertFalse(getUserCount() == 5)

💡 Hint

Failure occurs when expected and actual values differ.

Only option A expects 5 but the method returns 10, causing a failure notification.

❓ framework

advanced

JUnit Failure Notification Listener Setup

Which code snippet correctly sets up a JUnit 5 TestExecutionListener to notify on test failures?

A

public class FailureListener implements TestExecutionListener {
    @Override
    public void executionFinished(TestIdentifier testIdentifier, TestExecutionResult testExecutionResult) {
        if (testExecutionResult.getStatus() == TestExecutionResult.Status.FAILED) {
            System.out.println("Test failed: " + testIdentifier.getDisplayName());
        }
    }
}

B

public class FailureListener implements TestExecutionListener {
    public void onTestFailure(TestIdentifier testIdentifier) {
        System.out.println("Test failed: " + testIdentifier.getDisplayName());
    }
}

C

public class FailureListener implements TestExecutionListener {
    @Override
    public void executionStarted(TestIdentifier testIdentifier) {
        System.out.println("Test started: " + testIdentifier.getDisplayName());
    }
}

D

public class FailureListener {
    public void executionFinished(TestIdentifier testIdentifier, TestExecutionResult testExecutionResult) {
        if (testExecutionResult.getStatus() == TestExecutionResult.Status.SUCCESSFUL) {
            System.out.println("Test failed: " + testIdentifier.getDisplayName());
        }
    }
}

💡 Hint

Look for the correct interface method and failure status check.

Option A correctly overrides executionFinished and checks for FAILED status to notify failure.

🔧 Debug

advanced

Debugging Missing Failure Notification

A JUnit test fails but no failure notification is sent. Which is the most likely cause?

A The assertion uses assertEquals with correct expected and actual values.

B The test method is annotated with @Test.

C The test class extends from a base test class.

D The failure listener is not registered with the test framework.

💡 Hint

Think about how listeners are connected to the test run.

If the listener is not registered, it will not receive failure events to notify.

🧠 Conceptual

expert

Best Practice for Failure Notification in CI Pipelines

Which practice ensures reliable failure notifications in automated CI pipelines?

A Use print statements inside tests to indicate failures.

B Disable failure notifications to reduce noise in CI logs.

C Configure the test framework to output failure details to standard error and integrate with CI notification tools.

D Only run tests locally and manually check results before pushing code.

💡 Hint

Consider automation and integration with CI tools.

Automated failure notifications integrated with CI tools ensure developers are promptly informed.

Practice

1. What is the primary purpose of setting up failure notification in JUnit tests?

easy

A. To get alerts immediately when a test fails

B. To speed up test execution

C. To automatically fix failed tests

D. To skip tests that might fail

Solution

1. Step 1: Understand failure notification purpose

   Failure notification is designed to alert developers right when a test fails so they can act quickly.

2. Step 2: Eliminate unrelated options

   Speeding tests, auto-fixing, or skipping tests are not related to failure notifications.

3. Final Answer:

   To get alerts immediately when a test fails -> Option A

4. Quick Check:

   Failure notification = Immediate alerts [OK]

Hint: Failure notification means alerts on test failure [OK]

Common Mistakes:

• Thinking it speeds up tests
• Assuming it fixes tests automatically
• Believing it skips tests

2. Which JUnit feature is commonly used to detect test failures and trigger notifications?

easy

A. TestRule

B. TestSuite

C. TestWatcher

D. TestRunner

Solution

1. Step 1: Identify JUnit classes for failure detection

   TestWatcher is a JUnit rule designed to watch test execution and detect failures.

2. Step 2: Compare with other options

   TestRule is a general interface, TestSuite groups tests, TestRunner runs tests but does not notify failures.

3. Final Answer:

   TestWatcher -> Option C

4. Quick Check:

   Failure detection = TestWatcher [OK]

Hint: TestWatcher watches tests and detects failures [OK]

Common Mistakes:

• Confusing TestRule interface with TestWatcher
• Thinking TestSuite handles failure notifications
• Assuming TestRunner sends alerts

3. Given the following JUnit snippet, what will happen when the test fails?

public class MyTest {
  @Rule
  public TestWatcher watcher = new TestWatcher() {
    @Override
    protected void failed(Throwable e, Description d) {
      System.out.println("Test failed: " + d.getMethodName());
    }
  };

  @Test
  public void testFail() {
    assertEquals(1, 2);
  }
}

medium

A. Sends an email automatically

B. Test passes silently without output

C. Throws a runtime exception and stops tests

D. Prints 'Test failed: testFail' to the console

Solution

1. Step 1: Understand TestWatcher failed() method

   The failed() method runs when a test fails and prints the method name.

2. Step 2: Analyze the testFail() method

   assertEquals(1, 2) fails, triggering failed() to print the message.

3. Final Answer:

   Prints 'Test failed: testFail' to the console -> Option D

4. Quick Check:

   Failed test triggers failed() print [OK]

Hint: Failed test triggers failed() print message [OK]

Common Mistakes:

• Thinking test passes silently
• Expecting automatic email without code
• Assuming runtime exception stops all tests

4. Identify the error in this JUnit failure notification setup:

public class NotifyTest {
  @Rule
  public TestWatcher watcher = new TestWatcher() {
    @Override
    protected void failed() {
      System.out.println("Failure detected");
    }
  };

  @Test
  public void testExample() {
    fail();
  }
}

medium

A. Missing parameters in failed() method override

B. @Rule annotation is misplaced

C. fail() method is undefined

D. TestWatcher cannot be used with @Rule

Solution

1. Step 1: Check failed() method signature

   TestWatcher.failed() requires parameters (Throwable, Description) to override correctly.

2. Step 2: Verify other parts

   @Rule is correctly placed, fail() is a JUnit method, TestWatcher works with @Rule.

3. Final Answer:

   Missing parameters in failed() method override -> Option A

4. Quick Check:

   Override failed() with correct parameters [OK]

Hint: Override failed(Throwable, Description) exactly [OK]

Common Mistakes:

• Omitting parameters in failed() override
• Misplacing @Rule annotation
• Confusing fail() method usage

5. You want to send an email alert whenever a JUnit test fails. Which approach correctly integrates this using TestWatcher?

public class EmailAlertTest {
  @Rule
  public TestWatcher watcher = new TestWatcher() {
    @Override
    protected void failed(Throwable e, Description d) {
      // What should go here?
    }
  };

  @Test
  public void testEmail() {
    assertTrue(false);
  }
}

hard

A. Use @After annotation to send email after all tests

B. Call a method to send email inside failed(), passing e and d

C. Throw a new exception inside failed() to trigger email

D. Print stack trace only; email sending is automatic

Solution

1. Step 1: Understand TestWatcher failed() role

   failed() runs on test failure; it is the right place to trigger email sending.

2. Step 2: Choose correct action inside failed()

   Calling a method to send email with failure details is correct; throwing exceptions or relying on @After is incorrect.

3. Final Answer:

   Call a method to send email inside failed(), passing e and d -> Option B

4. Quick Check:

   Send email in failed() method [OK]

Hint: Send email inside failed() override [OK]

Common Mistakes:

• Throwing exceptions to send email
• Using @After for failure alerts
• Assuming email sends automatically without code