Java ThrowingCallable类代码示例

import org.assertj.core.api.ThrowableAssert.ThrowingCallable; //导入依赖的package包/类
@Test
public void should_mock_final_method() {
    final FinalClass finalClass = Mockito.mock(FinalClass.class);
    
    doNothing().when(finalClass).say(anyString());
    
    Throwable throwable = catchThrowable(new ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            finalClass.say(RandomStringUtils.random(10));
        }
    });
    
    assertThat(throwable)
        .as("Final method is mocked and exception is not thrown")
        .isNull();
    
}
 

import org.assertj.core.api.ThrowableAssert.ThrowingCallable; //导入依赖的package包/类
@Test
public void validation_should_work_everytime_when_no_exception_is_thrown() {
    InterfaceAvecDesMethodes mock = mock(InterfaceAvecDesMethodes.class);
    when(mock.recuperationDesDonnees(anyString())).thenReturn(resultListMock());

    final ServiceInterface service = getInterface(mock);

    Throwable thrownByMethod = catchThrowable(new ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            service.validationDonneesForId("0");
        }
    });

    assertThat(thrownByMethod).isNull();
}
 

import org.assertj.core.api.ThrowableAssert.ThrowingCallable; //导入依赖的package包/类
@Test
public void validation_should_work_everytime_when_sqlexception_is_thrown() throws SQLException {
    InterfaceAvecDesMethodes mock = mock(InterfaceAvecDesMethodes.class);
    when(mock.recuperationDesDonnees(anyString())).thenReturn(resultListMock());

    doThrow(SQLException.class)
            .when(mock)
            .verificationDesDonnees(anyList());

    final ServiceInterface service = getInterface(mock);

    Throwable thrownByMethod = catchThrowable(new ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            service.validationDonneesForId("0");
        }
    });

    assertThat(thrownByMethod).isNull();
}
 

import org.assertj.core.api.ThrowableAssert.ThrowingCallable; //导入依赖的package包/类
@Test
public void should_raise_and_exception_when_querying_for_unknow_object() {

    Throwable thrown = Assertions.catchThrowable(new ThrowingCallable() {

        @Override
        public void call() throws Throwable {
            queryForObject.getIdForUser(4);
            failBecauseExceptionWasNotThrown(EmptyResultDataAccessException.class);
        }
    });

    Assertions.assertThat(thrown)
            .isNotNull()
            .isInstanceOf(EmptyResultDataAccessException.class);
}
 

import org.assertj.core.api.ThrowableAssert.ThrowingCallable; //导入依赖的package包/类
@Test
public void saveOrUpdate_should_raise_and_SQLException() {
    final UserService service = new UserServiceImpl(mock(UserDao.class));

    Throwable throwable = Assertions.catchThrowable(new ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            service.saveOrUpdate(user(1l, "one"));
        }
    });

    Assertions.assertThat(throwable)
            .isNotNull()
            .isInstanceOf(SQLException.class);

}
 

import org.assertj.core.api.ThrowableAssert.ThrowingCallable; //导入依赖的package包/类
@Test
public void delete_should_raise_and_UnsupportedOperationException() {
    final UserService service = new UserServiceImpl(mock(UserDao.class));

    Throwable throwable = Assertions.catchThrowable(new ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            service.delete(user(1l, "one"));
        }
    });

    Assertions.assertThat(throwable)
            .isNotNull()
            .isInstanceOf(UnsupportedOperationException.class);

}
 

import org.assertj.core.api.ThrowableAssert.ThrowingCallable; //导入依赖的package包/类
@Test
public void thisWillFailMiserabily_should_raise_and_UnsupportedOperationException() {
    final UserService service = new UserServiceImpl(mock(UserDao.class));

    Throwable throwable = Assertions.catchThrowable(new ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            service.thisWillFailMiserabily();
        }
    });

    Assertions.assertThat(throwable)
            .isNotNull()
            .isInstanceOf(UnsupportedOperationException.class);

}
 

import org.assertj.core.api.ThrowableAssert.ThrowingCallable; //导入依赖的package包/类
@Test
public void should_catch_any_exception_but_DomainException_and_wrap_it_into_DomainException() {
    final Exception thrown = new Exception();

    assertThatThrownBy(new ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            final ExceptionAutoWrap aspect = new ExceptionAutoWrap();
            aspect.catchLogAndRethrow(thrown);
            failBecauseExceptionWasNotThrown(Exception.class);
        }
    })
            .isNotNull()
            .isInstanceOf(DomainException.class)
            .hasCause(thrown);
}
 

import org.assertj.core.api.ThrowableAssert.ThrowingCallable; //导入依赖的package包/类
@Test
public void should_catch_any_RuntimeException_and_wrap_it_into_DomainException() {
    final Exception thrown = new RuntimeException();

    assertThatThrownBy(new ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            final ExceptionAutoWrap aspect = new ExceptionAutoWrap();
            aspect.catchLogAndRethrow(thrown);
            failBecauseExceptionWasNotThrown(Exception.class);
        }
    })
            .isNotNull()
            .isInstanceOf(DomainException.class)
            .hasCause(thrown);
}
 

import org.assertj.core.api.ThrowableAssert.ThrowingCallable; //导入依赖的package包/类
@Test
public void should_not_wrap_DomainException() {
    final Exception thrown = new DomainException("Test message");

    assertThatThrownBy(new ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            final ExceptionAutoWrap aspect = new ExceptionAutoWrap();
            aspect.catchLogAndRethrow(thrown);
            failBecauseExceptionWasNotThrown(DomainException.class);
        }
    })
            .isNotNull()
            .isInstanceOf(DomainException.class)
            .hasNoCause()
            .isEqualTo(thrown);
}
 

import org.assertj.core.api.ThrowableAssert.ThrowingCallable; //导入依赖的package包/类
@Test
public void should_wrap_any_RuntimeException_into_Checked_Exception() {
    final RuntimeException thrown = new DomainException("Test message");

    assertThatThrownBy(new ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            final ExceptionAutoWrap aspect = new ExceptionAutoWrap();
            aspect.wrapIntoNotRuntimeException(thrown);
            failBecauseExceptionWasNotThrown(Exception.class);
        }
    })
            .isNotNull()
            .isInstanceOf(Exception.class)
            .hasCause(thrown);
}
 

import org.assertj.core.api.ThrowableAssert.ThrowingCallable; //导入依赖的package包/类
@Test
public void should_raise_DiceException_when_rolling_dice_with_a_beautiful_test() {
    final MethodsThrowingExceptions method = new MethodsThrowingExceptions(21);

    // la meilleure façon de tester si on est en Java7 avec assertJ 2.X
    Throwable thrownByMethod = Assertions.catchThrowable(new ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            method.rollDice();
            failBecauseExceptionWasNotThrown(DiceException.class);
        }
    });

    assertThat(thrownByMethod)
            .isInstanceOf(RandomException.class)
            .isExactlyInstanceOf(DiceException.class)
            .hasMessageContaining("21 failures yet");
}
 

import org.assertj.core.api.ThrowableAssert.ThrowingCallable; //导入依赖的package包/类
/**
 * Adds {@code "(expected exception)"} to the log message and lower its logging level to
 * {@link Level#DEBUG} if the exception occurred from the {@code shouldRaiseThrowable} matches
 * {@code throwable} and contains {@code message}.
 */
public static AbstractThrowableAssert<?, ? extends Throwable> assertThatThrownByWithExpectedException(
        Class<?> throwable, String message, ThrowingCallable shouldRaiseThrowable) throws Exception {
    requireNonNull(throwable, "throwable");
    requireNonNull(message, "message");
    requireNonNull(shouldRaiseThrowable, "shouldRaiseThrowable");
    exceptionAndMessage.put(throwable.getName(), message);
    try {
        return assertThatThrownBy(shouldRaiseThrowable);
    } finally {
        exceptionAndMessage.remove(throwable.getName());
    }
}
 

import org.assertj.core.api.ThrowableAssert.ThrowingCallable; //导入依赖的package包/类
@Test
public void shouldThrowForNonDataenumClassName() throws Exception {
  assertThatThrownBy(
          new ThrowingCallable() {
            @Override
            public void call() throws Throwable {
              OutputSpecFactory.toOutputClass(ClassName.get("com.spotify", "My"));
            }
          })
      .isInstanceOf(ParserException.class)
      .hasMessageContaining("Bad name");
}
 

import org.assertj.core.api.ThrowableAssert.ThrowingCallable; //导入依赖的package包/类
@Test
public void shouldThrowForNonClassName() throws Exception {
  assertThatThrownBy(
          new ThrowingCallable() {
            @Override
            public void call() throws Throwable {
              OutputSpecFactory.toOutputClass(TypeName.BOOLEAN);
            }
          })
      .isInstanceOf(ClassCastException.class);
}