JUnit assertThrows中的Executable会发生什么？

Question

I understand that Junit5 Assertions.assertThrows accepts an Executable type object. So for a simple example where a Constructor may not take an empty string as a name parameter:

public Company(String aName, Calendar aFoundingDate)
{
    if (aName == null || aName.length() == 0 || aName.length() > 50) {
        throw new IllegalArgumentException("Invalid name");
    }
    this.name = aName;
    foundingDate = aFoundingDate;
}

I can write a test like this:

// Company constructor test
@Test
void testCompanyConstructor() {
    // Given
    String emptyName = "aabbe";
    Calendar validFoundingDate = Calendar.getInstance();
    validFoundingDate.set(2000, 1, 1);

    // Then
    assertThrows(IllegalArgumentException.class, () -> new Company(emptyName, validFoundingDate));
}

What I wonder is, what happens to the executable, ie the Lambda Expression? Does JUnit call execute() on the Lambda expression and in doing so, the anonymous company Object with the empty name is created and the exception is

Appendix: These versions are equivalent:

// Company constructor test
@Test
void testCompanyConstructor() {
    // Given
    String emptyName = "";
    Calendar validFoundingDate = Calendar.getInstance();
    validFoundingDate.set(2000, 1, 1);

    // Then
    Executable executable = new Executable() {
        public void execute() {
            new Company(emptyName, validFoundingDate);
        }
    };
    assertThrows(IllegalArgumentException.class, executable);
    assertThrows(IllegalArgumentException.class, () -> new Company(emptyName, validFoundingDate));
}

Answer 1

Yes that's precisely what happens. JUnit runs the Executable inside a try { ... } catch (Throwable t) {...} block. If the exception caught is of the specified type, then all is good. If not then it throws an AssertionError.

Answer 2

When inspecting the code of assertThrows we can see that deeply there is such code placed in AssertThrows::assertThrows :

try {
    executable.execute();
}
catch (Throwable actualException)
    if (expectedType.isInstance(actualException)) {
        return (T) actualException;
    }
    else {
        BlacklistedExceptions.rethrowIfBlacklisted(actualException);
        String message = buildPrefix(nullSafeGet(messageOrSupplier))
                + format(expectedType, actualException.getClass(), "Unexpected exception type thrown");
        throw new AssertionFailedError(message, actualException);
    }
}

so it basically invokes Executable and catches Throwable that might be thrown and returns it. If no exception was thrown or the type of exception is different than expected - the assertion fails.