Java ThrowableAssert.ThrowingCallable方法代码示例

import org.assertj.core.api.ThrowableAssert; //导入方法依赖的package包/类
@Test
public void shouldKeepDescriptionInErrorMessage() {
    //given
    final String DESCRIPTION = "minimum range closer than 100";
    //when
    ts.findNumberOfShipsInRangeByCriteria(searchCriteria);
    //then
    ThrowableAssert.ThrowingCallable verifyLambda = () -> {
        verify(ts).findNumberOfShipsInRangeByCriteria(argLambda(c -> c.getMinimumRange() < 100, DESCRIPTION));
    };
    assertThatThrownBy(verifyLambda)
            .isInstanceOf(AssertionError.class)
            .hasMessageContaining("Argument(s) are different! Wanted:\n" +
                    "ts.findNumberOfShipsInRangeByCriteria(\n" +
                    "    " + DESCRIPTION + "\n" +
                    ");")
            .hasMessageContaining("Actual invocation has different arguments:\n" +
                    "ts.findNumberOfShipsInRangeByCriteria(\n" +
                    "    ShipSearchCriteria{minimumRange=1000, numberOfPhasers=4}\n" +
                    ");");

}
 

import org.assertj.core.api.ThrowableAssert; //导入方法依赖的package包/类
@Test
public void shouldHaveMeaningfulErrorMessage() {
    //when
    ts.findNumberOfShipsInRangeByCriteria(searchCriteria);
    //then
    ThrowableAssert.ThrowingCallable verifyLambda = () -> {
        verify(ts).findNumberOfShipsInRangeByCriteria(assertArg(sc -> assertThat(sc.getMinimumRange()).isLessThan(50)));
    };
    assertThatThrownBy(verifyLambda)
            .isInstanceOf(AssertionError.class)
            .hasMessageContaining("Argument(s) are different! Wanted:\n" +
                    "ts.findNumberOfShipsInRangeByCriteria(\n" +
                    "    AssertionMatcher reported: \n" +
                    "Expecting:\n" +
                    " <1000>\n" +
                    "to be less than:\n" +
                    " <50> ")
            .hasMessageContaining("Actual invocation has different arguments:\n" +
                    "ts.findNumberOfShipsInRangeByCriteria(\n" +
                    "    ShipSearchCriteria{minimumRange=1000, numberOfPhasers=4}\n" +
                    ");");
}
 

import org.assertj.core.api.ThrowableAssert; //导入方法依赖的package包/类
@Test
public void shouldFailOnInvalidSelectKeyword() {
    // given
    String query = "selectx * from cars";

    // when
    ThrowableAssert.ThrowingCallable when = () -> sqlParser.parse(query);

    // then
    assertThatThrownBy(when).isInstanceOf(InvalidQueryException.class);
}
 

import org.assertj.core.api.ThrowableAssert; //导入方法依赖的package包/类
private void verifyUnsupportedOperation(ThrowableAssert.ThrowingCallable operation) {
    // when
    Throwable ex = catchThrowable(operation);

    // then
    assertThat(ex).isInstanceOf(UnsupportedOperationException.class);
}
 

import org.assertj.core.api.ThrowableAssert; //导入方法依赖的package包/类
/**
 * Convenience method to catch a {@link GAWrapperException} and cast the return value to that type.
 * <b>Only use this when you're expecting the enclosed code to throw that exception.</b>
 * If the enclosed code doesn't throw the expected {@link GAWrapperException}, this method calls
 * {@link org.assertj.core.api.StrictAssertions#fail(String)} to cause the enclosing test to fail
 * and log the stack trace.
 * @param thisShouldThrow the {@link Callable} we're calling, which should throw {@link GAWrapperException}
 * @return the {@link Throwable} thrown in the execution of the {@link Callable}
 */
public static GAWrapperException catchGAWrapperException(ThrowableAssert.ThrowingCallable
                                                                 thisShouldThrow) {
    final GAWrapperException maybeAnException =
            (GAWrapperException)catchThrowable(thisShouldThrow);
    if (maybeAnException == null) {
        // we were expecting an exception and didn't get one.  log it as a failure.
        fail("Expected but did not receive GAWrapperException");
    }
    return maybeAnException;
}
 

import org.assertj.core.api.ThrowableAssert; //导入方法依赖的package包/类
private static void assertCodeException(Code expectedCode, ThrowableAssert.ThrowingCallable call) {
    CoapCodeException ex = (CoapCodeException) catchThrowable(call);
    assertEquals(expectedCode, ex.getCode());
}
 

import org.assertj.core.api.ThrowableAssert; //导入方法依赖的package包/类
private void shouldThrowExceptionWhenSessionIsInvalidated(ThrowableAssert.ThrowingCallable op) {
    when(session.isDestroyed()).thenReturn(true);
    assertThatExceptionOfType(IllegalStateException.class).isThrownBy(op);
}
 

import org.assertj.core.api.ThrowableAssert; //导入方法依赖的package包/类
private AbstractThrowableAssert<?, ?> assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable) {
    return org.assertj.core.api.Assertions.assertThatThrownBy(shouldRaiseThrowable)
            .isInstanceOf(AssertionError.class);
}
 

import org.assertj.core.api.ThrowableAssert; //导入方法依赖的package包/类
private static AWSThrowableAssert assertSNSThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable) {
    return assertThatThrownBy(shouldRaiseThrowable)
            .hasRequestId()
            .hasServiceName("AmazonSNS")
            .hasErrorType(Client);
}
 

import org.assertj.core.api.ThrowableAssert; //导入方法依赖的package包/类
private static AWSThrowableAssert assertSNSParamThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable) {
    return assertSNSThrownBy(shouldRaiseThrowable)
            .isInstanceOf(InvalidParameterException.class)
            .hasErrorCode("InvalidParameter")
            .hasStatusCode(400);
}
 

import org.assertj.core.api.ThrowableAssert; //导入方法依赖的package包/类
private void assertTimeoutOccurred(ThrowableAssert.ThrowingCallable throwingCallable) {
  assertThatExceptionOfType(StoreAccessException.class)
    .isThrownBy(throwingCallable)
    .withCauseInstanceOf(TimeoutException.class);
}
 

import org.assertj.core.api.ThrowableAssert; //导入方法依赖的package包/类
/**
 * Delegate call to public static org.assertj.core.api.AbstractThrowableAssert<?, ? extends java.lang.Throwable> org.assertj.core.api.Assertions.assertThatCode(org.assertj.core.api.ThrowableAssert$ThrowingCallable)
 * {@link org.assertj.core.api.Assertions#assertThatCode(org.assertj.core.api.ThrowableAssert$ThrowingCallable)}
 */
default AbstractThrowableAssert<?, ? extends Throwable> assertThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable) {
    return Assertions.assertThatCode(shouldRaiseOrNotThrowable);
}
 

import org.assertj.core.api.ThrowableAssert; //导入方法依赖的package包/类
/**
 * Delegate call to public static org.assertj.core.api.AbstractThrowableAssert<?, ? extends java.lang.Throwable> org.assertj.core.api.Assertions.assertThatThrownBy(org.assertj.core.api.ThrowableAssert$ThrowingCallable)
 * {@link org.assertj.core.api.Assertions#assertThatThrownBy(org.assertj.core.api.ThrowableAssert$ThrowingCallable)}
 */
default AbstractThrowableAssert<?, ? extends Throwable> assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable) {
    return Assertions.assertThatThrownBy(shouldRaiseThrowable);
}
 

import org.assertj.core.api.ThrowableAssert; //导入方法依赖的package包/类
/**
 * Delegate call to public static java.lang.Throwable org.assertj.core.api.Assertions.catchThrowable(org.assertj.core.api.ThrowableAssert$ThrowingCallable)
 * {@link org.assertj.core.api.Assertions#catchThrowable(org.assertj.core.api.ThrowableAssert$ThrowingCallable)}
 */
default Throwable catchThrowable(ThrowableAssert.ThrowingCallable shouldRaiseThrowable) {
    return Assertions.catchThrowable(shouldRaiseThrowable);
}
 

import org.assertj.core.api.ThrowableAssert; //导入方法依赖的package包/类
/**
 * Delegate call to public static <THROWABLE> THROWABLE org.assertj.core.api.Assertions.catchThrowableOfType(org.assertj.core.api.ThrowableAssert$ThrowingCallable,java.lang.Class<THROWABLE>)
 * {@link org.assertj.core.api.Assertions#catchThrowableOfType(org.assertj.core.api.ThrowableAssert$ThrowingCallable,java.lang.Class)}
 */
default <THROWABLE extends Throwable> THROWABLE catchThrowableOfType(ThrowableAssert.ThrowingCallable shouldRaiseThrowable, Class<THROWABLE> type) {
    return Assertions.catchThrowableOfType(shouldRaiseThrowable, type);
}