import org.assertj.core.api.AbstractBooleanAssert; //导入依赖的package包/类
private AbstractBooleanAssert<?> assertValue(CheckMode mode, CharSequence value) {
	return assertThat(validator(mode).isValid(value, context()))
			.describedAs("%s(%s)"
					, mode.toString()
					, value == null ? "null" : value.toString()
			);
}
 

import org.assertj.core.api.AbstractBooleanAssert; //导入依赖的package包/类
private List<AbstractBooleanAssert<?>> dependencyMatches(Class<?> originClass, Class<?> targetClass) {
    return ImmutableList.of(
            assertThat(dependency(originClass, targetClass).apply(input))
                    .as("Dependency matches '%s.class' -> '%s.class'", originClass.getSimpleName(), targetClass.getSimpleName()),
            assertThat(dependency(originClass.getName(), targetClass.getName()).apply(input))
                    .as("Dependency matches '%s.class' -> '%s.class'", originClass.getSimpleName(), targetClass.getSimpleName()),
            assertThat(dependency(
                    HasName.Predicates.name(originClass.getName()),
                    HasName.Predicates.name(targetClass.getName())).apply(input))
                    .as("Dependency matches '%s.class' -> '%s.class'", originClass.getSimpleName(), targetClass.getSimpleName()));
}
 

import org.assertj.core.api.AbstractBooleanAssert; //导入依赖的package包/类
private List<AbstractBooleanAssert<?>> dependencyMatchesOrigin(Class<?> originClass) {
    return ImmutableList.of(
            assertThat(dependencyOrigin(originClass).apply(input))
                    .as("Dependency origin matches '%s.class'", originClass.getSimpleName()),
            assertThat(dependencyOrigin(originClass.getName()).apply(input))
                    .as("Dependency origin matches '%s.class'", originClass.getSimpleName()),
            assertThat(dependencyOrigin(HasName.Predicates.name(originClass.getName())).apply(input))
                    .as("Dependency origin matches '%s.class'", originClass.getSimpleName()));
}
 

import org.assertj.core.api.AbstractBooleanAssert; //导入依赖的package包/类
private List<AbstractBooleanAssert<?>> dependencyMatchesTarget(Class<?> targetClass) {
    return ImmutableList.of(
            assertThat(dependencyTarget(targetClass).apply(input))
                    .as("Dependency target matches '%s.class'", targetClass.getSimpleName()),
            assertThat(dependencyTarget(targetClass.getName()).apply(input))
                    .as("Dependency target matches '%s.class'", targetClass.getSimpleName()),
            assertThat(dependencyTarget(HasName.Predicates.name(targetClass.getName())).apply(input))
                    .as("Dependency target matches '%s.class'", targetClass.getSimpleName()));
}
 

import org.assertj.core.api.AbstractBooleanAssert; //导入依赖的package包/类
private AbstractBooleanAssert<?> assertValue(CharSequence value) {
	return assertThat(validator().isValid(value, context()))
			.describedAs("%s"
					, value == null ? "null" : value.toString()
			);
}
 

import org.assertj.core.api.AbstractBooleanAssert; //导入依赖的package包/类
public void isTrue() {
    for (AbstractBooleanAssert<?> assertion : assignableAssertion) {
        assertion.isTrue();
    }
}
 

import org.assertj.core.api.AbstractBooleanAssert; //导入依赖的package包/类
public void isFalse() {
    for (AbstractBooleanAssert<?> assertion : assignableAssertion) {
        assertion.isFalse();
    }
}
 

import org.assertj.core.api.AbstractBooleanAssert; //导入依赖的package包/类
private AbstractBooleanAssert assertMatches(String input, String regex) {
    return assertThat(nameMatching(regex).apply(newHasName(input)))
            .as(input + " =~ " + regex);
}
 

import org.assertj.core.api.AbstractBooleanAssert; //导入依赖的package包/类
DependencyAssertion matches(Class<?> originClass, Class<?> targetClass) {
    for (AbstractBooleanAssert<?> dependencyAssert : dependencyMatches(originClass, targetClass)) {
        dependencyAssert.isTrue();
    }
    return this;
}
 

import org.assertj.core.api.AbstractBooleanAssert; //导入依赖的package包/类
DependencyAssertion doesntMatch(Class<?> originClass, Class<?> targetClass) {
    for (AbstractBooleanAssert<?> dependencyAssert : dependencyMatches(originClass, targetClass)) {
        dependencyAssert.isFalse();
    }
    return this;
}
 

import org.assertj.core.api.AbstractBooleanAssert; //导入依赖的package包/类
DependencyAssertion matchesOrigin(Class<?> originClass) {
    for (AbstractBooleanAssert<?> dependencyOriginAssert : dependencyMatchesOrigin(originClass)) {
        dependencyOriginAssert.isTrue();
    }
    return this;
}
 

import org.assertj.core.api.AbstractBooleanAssert; //导入依赖的package包/类
void doesntMatchOrigin(Class<?> originClass) {
    for (AbstractBooleanAssert<?> dependencyOriginAssert : dependencyMatchesOrigin(originClass)) {
        dependencyOriginAssert.isFalse();
    }
}
 

import org.assertj.core.api.AbstractBooleanAssert; //导入依赖的package包/类
DependencyAssertion matchesTarget(Class<?> targetClass) {
    for (AbstractBooleanAssert<?> dependencyTargetAssert : dependencyMatchesTarget(targetClass)) {
        dependencyTargetAssert.isTrue();
    }
    return this;
}
 

import org.assertj.core.api.AbstractBooleanAssert; //导入依赖的package包/类
void doesntMatchTarget(Class<?> targetClass) {
    for (AbstractBooleanAssert<?> dependencyTargetAssert : dependencyMatchesTarget(targetClass)) {
        dependencyTargetAssert.isFalse();
    }
}
 

import org.assertj.core.api.AbstractBooleanAssert; //导入依赖的package包/类
public static AbstractBooleanAssert<?> resultOf(CheckedBooleanSupplier whenStep) {
    return assertThat(result(whenStep));
}
 

import org.assertj.core.api.AbstractBooleanAssert; //导入依赖的package包/类
private AbstractBooleanAssert<?> assertWeak(Object domainObject) {
  return assertThat(permissionEvaluator.hasPermission(authentication, "fake id",
      domainObject.getClass().getName(), "fake permission"));
}
 

import org.assertj.core.api.AbstractBooleanAssert; //导入依赖的package包/类
private AbstractBooleanAssert<?> assertStrong(Object domainObject) {
  return assertThat(
      permissionEvaluator.hasPermission(authentication, domainObject, "fake permission"));
}
 

import org.assertj.core.api.AbstractBooleanAssert; //导入依赖的package包/类
/**
 * Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Boolean)}
 */
default AbstractBooleanAssert<?> then(Boolean actual) {
	fluentBdd().verification.recordThen(this);
	return DELEGATE.assertThat(actual);
}
 

import org.assertj.core.api.AbstractBooleanAssert; //导入依赖的package包/类
/**
 * Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Boolean)}
 */
default AbstractBooleanAssert<?> and(Boolean actual) {
	fluentBdd().verification.recordThen(this);
	return DELEGATE.assertThat(actual);
}
 

import org.assertj.core.api.AbstractBooleanAssert; //导入依赖的package包/类
public AbstractBooleanAssert<?> internal() {
  isNotNull();
  return assertThat(actual.getGeneratedBy() == MATERIALIZER).as(description("internal"));
}