How to Print JUnit Assertion Results

The standard practice in testing is to rely on test case results, which may pass or fail. However, sometimes we also need to print assertion results. This helps in several cases:

• Debugging complex test scenarios
• Monitoring test execution in CI/CD pipelines
• Creating detailed test reports based on logs

In this article, we’ll review a few approaches to printing assertion results into logs.

The most straightforward and accurate approach is to use well-built assertion messages with post-assertion logic. Let’s create a TestService that we’ll use in our test cases:

public class TestService {
    public boolean successfulCall() {
        return true;
    }

    public boolean failedCall() {
        return false;
    }

    public boolean exceptionCall() {
        throw new RuntimeException("Service error");
    }
}

In this service, we have methods to test passing cases, failing cases, and cases that verify exception-throwing behavior. Now, let’s create TestServiceTest, where we’ll verify TestService. The first test case we create should verify the successful call:

class TestServiceTest {
    private static final Logger logger = LoggerFactory.getLogger(TestServiceTest.class);

    TestService service = new TestService();

    @Test
    void whenSuccessfulCall_thenSuccessMessagePrintedIntoLog() {
        logger.info("Testing successful call...");
        assertTrue(service.successfulCall(), "Service should return true for successful call");
        logger.info("✓ Successful call assertion passed");
    }
}

In this test case, we add info logs before and after the assertion to indicate the assertion passing process. We also add a clear description message in case the assertion fails. After the test passes, we can see the following messages in the logs:

16:21:50.072 [main] INFO com.baeldung.printassertionresults.TestServiceTest -- Testing successful call...
16:21:50.076 [main] INFO com.baeldung.printassertionresults.TestServiceTest -- ✓ Successful call assertion passed

Now, let’s add a test case that will fail:

@Test
void whenFailedCall_thenFailureMessagePrintedIntoLog() {
    logger.info("Testing failed call...");
    assertTrue(service.failedCall(), "Service should return true for failed call");
}

Here, we add logging before the assertion and expect the failure message to appear in the logs.
As expected, the test case does not pass, and here is the log output:

16:26:14.007 [main] INFO com.baeldung.printassertionresults.TestServiceTest -- Testing failed call...
org.opentest4j.AssertionFailedError: Service should return true for failed call

Another approach is to catch the assertion exception and build custom logging around both passing and failing assertions. Let’s start with the creation of an Assertion interface, which we’ll use to wrap our base assertions:

public interface Assertion {
    void doAssert() throws AssertionError;
}

Next, let’s create the AssertionWithMessage class:

public class AssertionWithMessage {
    private final Assertion assertion;
    private final String message;

    public AssertionWithMessage(Assertion assertion, String message) {
        this.assertion = assertion;
        this.message = message;
    }

    public void doAssert() {
        assertion.doAssert();
    }

    public String getMessage() {
        return message;
    }
}

In the doAssert() method, we proxy the call to the real assertion logic. Additionally, we handle the message we want to log during the assertion. Now, let’s create the LoggingAssertions class:

public class LoggingAssertions {
    private static final Logger logger = LoggerFactory.getLogger(LoggingAssertions.class);

    public static void assertAll(AssertionWithMessage... assertions) {
        boolean failed = false;
        for (AssertionWithMessage assertion : assertions) {
            try {
                assertion.doAssert();
                logger.info("✓ {}", assertion.getMessage());
            } catch (AssertionError e) {
                failed = true;
                logger.error("✗ {} - {}", assertion.getMessage(), e.getMessage());
            }
        }

        if (failed) {
            /*
            * Critical: Re-throw to maintain test failure behavior
            * */
            throw new AssertionError("One of the assertions was failed. See logs for details");
        }
    }
}

In the assertAll() method, we run each assertion one by one. If an assertion passes, we log the message with a successful prefix. If an AssertionError occurs, we log the same assertion message with a failing prefix and include the error description. It’s critically important to rethrow the AssertionError if any assertion fails; otherwise, the testing pipeline won’t correctly identify the test cases that need to be fixed.

Now, let’s create the test case where we’ll verify all TestService methods using our LoggingAssertions class:

@Test
void whenRunMultipleAssertionsWithLogging_thenAllTheLogsShouldBePrintedAndFailureExceptionsRethrown() {
    LoggingAssertions.assertAll(
      new AssertionWithMessage(
        () -> assertTrue(service.successfulCall()),
        "Successful call should return true"),
      new AssertionWithMessage(
        () -> assertTrue(service.failedCall()),
        "Failed call should return true"),
      new AssertionWithMessage(
        () -> assertThrows(RuntimeException.class, service::exceptionCall),
        "Exception call should throw RuntimeException")
    );
}

Here, we check all assertions in one shot. As a result, the test case will fail, and the log messages will show the assertion results:

16:44:26.184 [main] INFO com.baeldung.printassertionresults.LoggingAssertions -- ✓ Successful call should return true
16:44:26.187 [main] ERROR com.baeldung.printassertionresults.LoggingAssertions -- ✗ Failed call should return true - expected: <true> but was: <false>
16:44:26.188 [main] INFO com.baeldung.printassertionresults.LoggingAssertions -- ✓ Exception call should throw RuntimeException
java.lang.AssertionError: One of the assertions was failed. See logs for details

We can also utilize JUnit 5 extensions to log whether test cases passed or failed. This provides a centralized implementation for test assertion logging. However, this logging works at a higher level than individual assertions. By designing our test cases with one assertion per test, we can still achieve our goal. Let’s create a TestResultLogger class:

public class TestResultLogger implements TestWatcher, BeforeEachCallback {
    private static final Logger logger = LoggerFactory.getLogger(TestResultLogger.class);

    @Override
    public void beforeEach(ExtensionContext context) throws Exception {
        logger.info("Testing {}", context.getDisplayName());
    }

    @Override
    public void testSuccessful(ExtensionContext context) {
        logger.info("✓ {} assertion passed", context.getDisplayName());
    }

    @Override
    public void testFailed(ExtensionContext context, Throwable cause) {
        logger.error("✗ {} assertion didn't pass", context.getDisplayName());
    }
}

Here, we’ve implemented TestWatcher and added logging logic in the testSuccessful and testFailed methods. Additionally, we implemented the BeforeEachCallback interface to add logging before each test. Now, let’s create TestServiceWithTestWatcherTest with the attached TestResultLogger extension:

@ExtendWith(TestResultLogger.class)
class TestServiceWithTestWatcherTest {

    TestService service = new TestService();

    @Test
    void whenSuccessfulCall_thenTrueShouldBeReturned() {
        assertTrue(service.successfulCall());
    }

    @Test
    void whenExceptionCall_thenExpectedExceptionShouldBeThrown() {
        assertThrows(RuntimeException.class, service::exceptionCall);
    }

    @Test
    void whenFailedCall_thenTrueShouldBeReturned() {
        assertTrue(service.failedCall());
    }
}

Here, we’ve implemented multiple test cases, each with a specific assertion to cover all TestService functionality. Here is how the log output looks after the tests are executed:

11:52:53.004 [main] INFO com.baeldung.printassertionresults.TestResultLogger -- Testing whenExceptionCall_thenExpectedExceptionShouldBeThrown()
11:52:53.026 [main] INFO com.baeldung.printassertionresults.TestResultLogger -- ✓ whenExceptionCall_thenExpectedExceptionShouldBeThrown() assertion passed
11:52:53.029 [main] INFO com.baeldung.printassertionresults.TestResultLogger -- Testing whenFailedCall_thenTrueShouldBeReturned()
11:52:53.038 [main] ERROR com.baeldung.printassertionresults.TestResultLogger -- ✗ whenFailedCall_thenTrueShouldBeReturned() assertion didn't pass

org.opentest4j.AssertionFailedError: 
Expected :true
Actual   :false
...
11:52:53.054 [main] INFO com.baeldung.printassertionresults.TestResultLogger -- ✓ whenSuccessfulCall_thenTrueShouldBeReturned() assertion passed

In this article, we’ve reviewed multiple approaches to printing assertion results. We can choose what works best for us. As a baseline, it’s recommended to use clear assertion messages, which cover most cases. For more complex assertion logic, we can build utilities around assertion exception rethrowing. For centralized and easy-to-attach behavior, we can choose to implement logging extensions.

As always, the code is available over on GitHub.