org.assertj.core.api.AbstractBooleanAssert Java Examples

/**
 * Returns an {@code Assert} object that allows performing assertions on boolean value of the {@link String} under test.
 * <p>
 * If actual value after lowercasing is one of the following "true", "false", then it can be parsed to boolean.
 *
 * @throws AssertionError if the actual value is {@code null}.
 * @throws AssertionError if the actual value does not contain a parsable boolean
 */
public AbstractBooleanAssert<?> asBoolean() {
    isNotNull();
    boolean value = false;
    switch (actual.toLowerCase()) {
        case "true":
            value = true;
            break;
        case "false":
            value = false;
            break;
        default:
            throwAssertionError(shouldBeConvertible(actual, "boolean"));
    }

    return AssertionsAdapter.assertThat(value);
}
 

private List<AbstractBooleanAssert<?>> dependencyMatches(Class<?> originClass, Class<?> targetClass) {
    return ImmutableList.of(
            assertThat(dependency(originClass, targetClass).apply(actual))
                    .as("Dependency [%s -> %s] matches [%s -> %s]",
                            actual.getOriginClass().getName(), actual.getTargetClass().getName(),
                            originClass.getName(), targetClass.getName()),
            assertThat(dependency(originClass.getName(), targetClass.getName()).apply(actual))
                    .as("Dependency [%s -> %s] matches [%s -> %s]",
                            actual.getOriginClass().getName(), actual.getTargetClass().getName(),
                            originClass.getName(), targetClass.getName()),
            assertThat(dependency(
                    HasName.Predicates.name(originClass.getName()),
                    HasName.Predicates.name(targetClass.getName())).apply(actual))
                    .as("Dependency [%s -> %s] matches [%s -> %s]",
                            actual.getOriginClass().getName(), actual.getTargetClass().getName(),
                            originClass.getName(), targetClass.getName()));
}
 

private List<AbstractBooleanAssert<?>> dependencyMatchesOrigin(Class<?> originClass) {
    return ImmutableList.of(
            assertThat(dependencyOrigin(originClass).apply(actual))
                    .as("Dependency origin matches '%s.class'", originClass.getSimpleName()),
            assertThat(dependencyOrigin(originClass.getName()).apply(actual))
                    .as("Dependency origin matches '%s.class'", originClass.getSimpleName()),
            assertThat(dependencyOrigin(HasName.Predicates.name(originClass.getName())).apply(actual))
                    .as("Dependency origin matches '%s.class'", originClass.getSimpleName()));
}
 

private List<AbstractBooleanAssert<?>> dependencyMatchesTarget(Class<?> targetClass) {
    return ImmutableList.of(
            assertThat(dependencyTarget(targetClass).apply(actual))
                    .as("Dependency target matches '%s.class'", targetClass.getSimpleName()),
            assertThat(dependencyTarget(targetClass.getName()).apply(actual))
                    .as("Dependency target matches '%s.class'", targetClass.getSimpleName()),
            assertThat(dependencyTarget(HasName.Predicates.name(targetClass.getName())).apply(actual))
                    .as("Dependency target matches '%s.class'", targetClass.getSimpleName()));
}
 

public void isFalse() {
    for (AbstractBooleanAssert<?> assertion : assignableAssertion) {
        assertion.isFalse();
    }
}
 

static AbstractBooleanAssert<?> assertThat(boolean actual) {
    return new BooleanAssert(actual);
}
 

public AbstractBooleanAssert<?> hasBooleanAtPath(String path) {
	return Assertions.assertThat(actual.read(path, Boolean.class));
}
 

private AbstractBooleanAssert<?> assertStrong(Object domainObject) {
  return assertThat(
      permissionEvaluator.hasPermission(authentication, domainObject, "fake permission"));
}
 

private AbstractBooleanAssert<?> assertWeak(Object domainObject) {
  return assertThat(permissionEvaluator.hasPermission(authentication, "fake id",
      domainObject.getClass().getName(), "fake permission"));
}
 

private AbstractBooleanAssert<?> assertReconciled(final PaySelectionId paySelectionId)
{
	final I_C_PaySelection paySelection = paySelectionDAO.getById(paySelectionId).get();
	return assertThat(paySelection.isReconciled())
			.as("Is " + paySelectionId + " reconciled?");
}
 

private AbstractBooleanAssert<?> assertNameMatches(String input, String regex) {
    return assertThat(nameMatching(regex).apply(newHasName(input)))
            .as(input + " =~ " + regex);
}
 

private ImmutableList<? extends AbstractBooleanAssert<?>> contains(JavaMethod method, Class<?> type) {
    return ImmutableList.of(
            assertThat(method.getThrowsClause().containsType(type)).as("throws clause contains " + type.getSimpleName()),
            assertThat(method.getThrowsClause().containsType(type.getName())).as("throws clause contains " + type.getSimpleName()),
            assertThat(method.getThrowsClause().containsType(equivalentTo(type))).as("throws clause contains " + type.getSimpleName()));
}
 

private void assertAllFalse(Iterable<? extends AbstractBooleanAssert<?>> asserts) {
    for (AbstractBooleanAssert<?> anAssert : asserts) {
        anAssert.isFalse();
    }
}
 

private void assertAllTrue(Iterable<? extends AbstractBooleanAssert<?>> asserts) {
    for (AbstractBooleanAssert<?> anAssert : asserts) {
        anAssert.isTrue();
    }
}
 

private AbstractBooleanAssert<?> assertThatPredicateAppliesTo(T value) {
    return assertThat(actual.apply(value)).as("predicate <%s> matches <%s>", actual, value);
}
 

public void isTrue() {
    for (AbstractBooleanAssert<?> assertion : assignableAssertion) {
        assertion.isTrue();
    }
}
 

public void doesntMatchTarget(Class<?> targetClass) {
    for (AbstractBooleanAssert<?> dependencyTargetAssert : dependencyMatchesTarget(targetClass)) {
        dependencyTargetAssert.isFalse();
    }
}
 

public DependencyAssertion matchesTarget(Class<?> targetClass) {
    for (AbstractBooleanAssert<?> dependencyTargetAssert : dependencyMatchesTarget(targetClass)) {
        dependencyTargetAssert.isTrue();
    }
    return this;
}
 

public void doesntMatchOrigin(Class<?> originClass) {
    for (AbstractBooleanAssert<?> dependencyOriginAssert : dependencyMatchesOrigin(originClass)) {
        dependencyOriginAssert.isFalse();
    }
}
 

public DependencyAssertion matchesOrigin(Class<?> originClass) {
    for (AbstractBooleanAssert<?> dependencyOriginAssert : dependencyMatchesOrigin(originClass)) {
        dependencyOriginAssert.isTrue();
    }
    return this;
}
 

public DependencyAssertion doesntMatch(Class<?> originClass, Class<?> targetClass) {
    for (AbstractBooleanAssert<?> dependencyAssert : dependencyMatches(originClass, targetClass)) {
        dependencyAssert.isFalse();
    }
    return this;
}
 

public DependencyAssertion matches(Class<?> originClass, Class<?> targetClass) {
    for (AbstractBooleanAssert<?> dependencyAssert : dependencyMatches(originClass, targetClass)) {
        dependencyAssert.isTrue();
    }
    return this;
}
 

/**
 * A little wrapper over {@code assertThat} that just mention that this what we expect from the test. So if the
 * expectation fails, it's probably the test that is wrong, not the implementation.
 *
 * @param actual actual value
 * @return an AssertJ assertion
 */
protected static AbstractBooleanAssert<?> expect(boolean actual) {
  return assertThat(actual);
}