import org.assertj.core.internal.Failures; //导入依赖的package包/类
private CompositeQueryFilterAssert anyFilterMatches(@NonNull final Predicate<IQueryFilter> p)
{
	isNotNull();

	@SuppressWarnings("unchecked")
	final List<IQueryFilter> filters = actual.getFilters();
	for (final IQueryFilter filter : filters)
	{
		if (p.test(filter))
		{
			return this;
		}
	}
	throw Failures.instance().failure(info, elementsShouldSatisfyAny(actual));
}
 

import org.assertj.core.internal.Failures; //导入依赖的package包/类
@Before
public void setUp() {
  failures = spy(new Failures());
  doubles = new Doubles();
  doubles.setFailures(failures);
  absValueComparisonStrategy = new ComparatorBasedComparisonStrategy(new AbsValueComparator<Double>());
  doublesWithAbsValueComparisonStrategy = new Doubles(absValueComparisonStrategy);
  doublesWithAbsValueComparisonStrategy.failures = failures;
}
 

import org.assertj.core.internal.Failures; //导入依赖的package包/类
public RelationshipAssert doesNotEndWithNode(Node node) {
  Objects.instance().assertNotNull(info, actual);

  Node actualEndNode = actual.getEndNode();

  checkActualRelationshipNode(actualEndNode, "The actual end node should not be null");
  checkArgumentNode(node, "The end node to look for should not be null");

  if (actualEndNode.equals(node)) {
    throw Failures.instance().failure(info, shouldNotEndWithNode(actual, node));
  }
  return this;
}
 

import org.assertj.core.internal.Failures; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
@CheckReturnValue
public SELF withThreadDumpOnError() {
  Failures.instance().enablePrintThreadDump();
  return myself;
}
 

import org.assertj.core.internal.Failures; //导入依赖的package包/类
@Before
public void setUp() {
  failures = spy(new Failures());
  strings = new Strings();
  strings.failures = failures;
  comparisonStrategy = new ComparatorBasedComparisonStrategy(CaseInsensitiveStringComparator.instance);
  stringsWithCaseInsensitiveComparisonStrategy = new Strings(comparisonStrategy);
  stringsWithCaseInsensitiveComparisonStrategy.failures = failures;
}
 

import org.assertj.core.internal.Failures; //导入依赖的package包/类
@Before
public void setUp() {
  diff = mock(Diff.class);
  failures = spy(new Failures());
  inputStreams = new InputStreams();
  inputStreams.diff = diff;
  inputStreams.failures = failures;
}
 

import org.assertj.core.internal.Failures; //导入依赖的package包/类
@Before
public void setUp() {
  failures = spy(new Failures());
  condition = new TestCondition<>();
  conditions = new Conditions();
  conditions.failures = failures;
}
 

import org.assertj.core.internal.Failures; //导入依赖的package包/类
@Before
public void setUp() {
  failures = spy(new Failures());
  characters = new Characters();
  characters.failures = failures;
  caseInsensitiveComparisonStrategy = new ComparatorBasedComparisonStrategy(CaseInsensitiveCharacterComparator.instance);
  charactersWithCaseInsensitiveComparisonStrategy = new Characters(caseInsensitiveComparisonStrategy);
  charactersWithCaseInsensitiveComparisonStrategy.failures = failures;
}
 

import org.assertj.core.internal.Failures; //导入依赖的package包/类
@Before
public void setUp() {
  failures = spy(new Failures());
  shorts = new Shorts();
  shorts.setFailures(failures);
  absValueComparisonStrategy = new ComparatorBasedComparisonStrategy(new AbsValueComparator<Short>());
  shortsWithAbsValueComparisonStrategy = new Shorts(absValueComparisonStrategy);
  shortsWithAbsValueComparisonStrategy.failures = failures;
}
 

import org.assertj.core.internal.Failures; //导入依赖的package包/类
@Before
public void setUp() {
  failures = spy(new Failures());
  comparables = new Comparables();
  comparables.failures = failures;
  customComparisonStrategy = new ComparatorBasedComparisonStrategy(comparatorForCustomComparisonStrategy());
  comparablesWithCustomComparisonStrategy = new Comparables(customComparisonStrategy);
  comparablesWithCustomComparisonStrategy.failures = failures;
}
 

import org.assertj.core.internal.Failures; //导入依赖的package包/类
@Before
public void setUp() {
  failures = spy(new Failures());
  lists = new Lists();
  lists.failures = failures;
  comparisonStrategy = new ComparatorBasedComparisonStrategy(CaseInsensitiveStringComparator.instance);
  listsWithCaseInsensitiveComparisonStrategy = new Lists(comparisonStrategy);
  listsWithCaseInsensitiveComparisonStrategy.failures = failures;
}
 

import org.assertj.core.internal.Failures; //导入依赖的package包/类
@Test
public void should_not_filter_when_global_remove_option_is_disabled() {
  Failures.instance().setRemoveAssertJRelatedElementsFromStackTrace(false);
  try {
    new CustomAssert("").fail();
  } catch (AssertionError e) {
    assertThat(e.getStackTrace()).areAtLeastOne(elementOf(CustomAssert.class));
  }
}
 

import org.assertj.core.internal.Failures; //导入依赖的package包/类
@Before
public void setUp() {
  Failures.instance().setRemoveAssertJRelatedElementsFromStackTrace(false);
  description = new TestDescription("Jedi");
  factory = (ShouldBeEqual) shouldBeEqual("Luke", "Yoda", new StandardRepresentation());
  constructorInvoker = mock(ConstructorInvoker.class);
  factory.constructorInvoker = constructorInvoker;
}
 

import org.assertj.core.internal.Failures; //导入依赖的package包/类
@Before
public void setUp() {
  failures = spy(new Failures());
  integers = new Integers();
  integers.setFailures(failures);
  absValueComparisonStrategy = new ComparatorBasedComparisonStrategy(new AbsValueComparator<Integer>());
  integersWithAbsValueComparisonStrategy = new Integers(absValueComparisonStrategy);
  integersWithAbsValueComparisonStrategy.failures = failures;
}
 

import org.assertj.core.internal.Failures; //导入依赖的package包/类
@Before
public void setUp() {
  actual = newArrayList("Luke", "Yoda", "Leia");
  failures = spy(new Failures());
  iterables = new Iterables();
  iterables.failures = failures;
  comparisonStrategy = new ComparatorBasedComparisonStrategy(CaseInsensitiveStringComparator.instance);
  iterablesWithCaseInsensitiveComparisonStrategy = new Iterables(comparisonStrategy);
  iterablesWithCaseInsensitiveComparisonStrategy.failures = failures;
  info = someInfo();
}
 

import org.assertj.core.internal.Failures; //导入依赖的package包/类
@Before
public void setUp() {
  failures = spy(new Failures());
  longs = new Longs();
  longs.setFailures(failures);
  absValueComparisonStrategy = new ComparatorBasedComparisonStrategy(new AbsValueComparator<Long>());
  longsWithAbsValueComparisonStrategy = new Longs(absValueComparisonStrategy);
  longsWithAbsValueComparisonStrategy.failures = failures;
}
 

import org.assertj.core.internal.Failures; //导入依赖的package包/类
public void hasHeader(String headerName, String expectedHeaderValue) {
    response.getHeaders().stream().filter(th -> th.getName().equals(headerName)).findFirst()
            .map(TusHeader::getValue)
            .map(value -> assertThat(value).isEqualTo(expectedHeaderValue))
            .orElseThrow(() -> Failures.instance().failure(headerName + " header not present in response"));
}
 

import org.assertj.core.internal.Failures; //导入依赖的package包/类
public void hasHeaderEndingWith(String headerName, String expectedHeaderValue) {
    response.getHeaders().stream().filter(th -> th.getName().equals(headerName)).findFirst()
            .map(TusHeader::getValue)
            .map(value -> assertThat(value).endsWith(expectedHeaderValue))
            .orElseThrow(() -> Failures.instance().failure(headerName + " header not present in response"));
}
 

import org.assertj.core.internal.Failures; //导入依赖的package包/类
/**
 * Creates an <code>{@link AssertionError}</code> indicating that an assertion that verifies that two objects are
 * equal failed.<br>
 * The <code>{@link AssertionError}</code> message is built so that it differentiates {@link #actual} and
 * {@link #expected} description in case their string representation are the same (like 42 float and 42 double).
 * <p>
 * If JUnit 4 is in the classpath and the description is standard (no comparator was used and {@link #actual} and
 * {@link #expected} string representation were different), this method will instead create a
 * org.junit.ComparisonFailure that highlights the difference(s) between the expected and actual objects.
 * </p>
 * <p>
 *   If opentest4j is on the classpath then {@code org.opentest4j.AssertionFailedError} would be used.
 * </p>
 * {@link AssertionError} stack trace won't show AssertJ related elements if {@link Failures} is configured to filter
 * them (see {@link Failures#setRemoveAssertJRelatedElementsFromStackTrace(boolean)}).
 *
 * @param description the description of the failed assertion.
 * @param representation the {@link Representation} used to format values.
 * @return the created {@code AssertionError}.
 */
@Override
public AssertionError newAssertionError(Description description, Representation representation) {
  // only use JUnit error message if the comparison strategy used was standard, otherwise we need to mention
  // comparison strategy in the assertion error message to make it clear to the user it was used.
  if (comparisonStrategy.isStandard() && !actualAndExpectedHaveSameStringRepresentation()) {
    // comparison strategy is standard -> try to build a JUnit ComparisonFailure that is nicely displayed in IDEs.
    AssertionError error = comparisonFailure(description);
    // error != null means that JUnit 4 was in the classpath and we were to build a ComparisonFailure.
    if (error != null) return error;
  }
  String message = smartErrorMessage(description, representation);
  AssertionError assertionFailedError = assertionFailedError(message);
  if (assertionFailedError != null) return assertionFailedError;
  // No JUnit in the classpath => fall back to default error message
  return Failures.instance().failure(message);
}
 

import org.assertj.core.internal.Failures; //导入依赖的package包/类
private AssertionError actualDoesNotStartWithSequence(AssertionInfo info, Object[] sequence) {
  return Failures.instance()
                 .failure(info, shouldStartWith("Stream under test", sequence, iterables.getComparisonStrategy()));
}