import org.assertj.core.internal.ComparisonStrategy; //导入依赖的package包/类
@Test
public void should_create_AssertionError_with_message_differentiating_expected_and_actual_persons_even_if_a_comparator_based_comparison_strategy_is_used() {
  Person actual = new Person("Jake", 43);
  Person expected = new Person("Jake", 47);
  ComparisonStrategy ageComparisonStrategy = new ComparatorBasedComparisonStrategy(new PersonComparator());
  shouldBeEqual = (ShouldBeEqual) shouldBeEqual(actual, expected, ageComparisonStrategy,
                                                new StandardRepresentation());
  shouldBeEqual.descriptionFormatter = mock(DescriptionFormatter.class);
  when(shouldBeEqual.descriptionFormatter.format(description)).thenReturn(formattedDescription);

  AssertionError error = shouldBeEqual.newAssertionError(description, new StandardRepresentation());

  assertThat(error).isInstanceOf(AssertionFailedError.class)
                   .hasMessage("[my test] %n" +
                               "Expecting:%n" +
                               " <\"Person[name=Jake] ([email protected]%s)\">%n" +
                               "to be equal to:%n" +
                               " <\"Person[name=Jake] ([email protected]%s)\">%n" +
                               "when comparing values using PersonComparator%n" +
                               "but was not.", toHexString(actual.hashCode()), toHexString(expected.hashCode()));
}
 

import org.assertj.core.internal.ComparisonStrategy; //导入依赖的package包/类
/**
 * Creates a new <code>{@link ShouldNotContainCharSequence}</code>.
 * @param actual the actual value in the failed assertion.
 * @param sequence the charsequence expected not to be in {@code actual}.
 * @param comparisonStrategy the {@link ComparisonStrategy} used to evaluate assertion.
 * @return the created {@code ErrorMessageFactory}.
 */
public static ErrorMessageFactory shouldNotContain(CharSequence actual, CharSequence sequence,
                                                   ComparisonStrategy comparisonStrategy) {
  return new ShouldNotContainCharSequence("%n" +
                                          "Expecting:%n" +
                                          " <%s>%n" +
                                          "not to contain:%n" +
                                          " <%s>%n" +
                                          "%s",
                                          actual, sequence, comparisonStrategy);
}
 

import org.assertj.core.internal.ComparisonStrategy; //导入依赖的package包/类
private ShouldContainAnyOf(Object actual, Object expected, ComparisonStrategy comparisonStrategy) {
  super("%nExpecting:%n" +
        "  <%s>%n" +
        "to contain at least one of the following elements:%n" +
        "  <%s>%n" +
        "but none were found %s",
        actual, expected, comparisonStrategy);
}
 

import org.assertj.core.internal.ComparisonStrategy; //导入依赖的package包/类
@VisibleForTesting
ShouldBeEqual(Object actual, Object expected, ComparisonStrategy comparisonStrategy, Representation representation) {
  this.actual = actual;
  this.expected = expected;
  this.comparisonStrategy = comparisonStrategy;
  this.representation = representation;
}
 

import org.assertj.core.internal.ComparisonStrategy; //导入依赖的package包/类
private ShouldContainOnlyKeys(Object actual, Object expected, Object notFound, Object notExpected,
                            ComparisonStrategy comparisonStrategy) {
super("%n" +
      "Expecting:%n" +
      "  <%s>%n" +
      "to contain only following keys:%n" +
      "  <%s>%n" +
      "keys not found:%n" +
      "  <%s>%n" +
      "and keys not expected:%n" +
      "  <%s>%n%s", actual,
      expected, notFound, notExpected, comparisonStrategy);
 }
 

import org.assertj.core.internal.ComparisonStrategy; //导入依赖的package包/类
/**
 * Creates a new <code>{@link ShouldContainExactly}</code>.
 *
 * @param actual the actual value in the failed assertion.
 * @param expected values expected to be contained in {@code actual}.
 * @param notFound values in {@code expected} not found in {@code actual}.
 * @param notExpected values in {@code actual} that were not in {@code expected}.
 * @param comparisonStrategy the {@link ComparisonStrategy} used to evaluate assertion.
 * @return the created {@code ErrorMessageFactory}.
 * 
 */
public static ErrorMessageFactory shouldContainExactly(Object actual, Iterable<?> expected,
                                                       Iterable<?> notFound, Iterable<?> notExpected,
                                                       ComparisonStrategy comparisonStrategy) {
  if (isNullOrEmpty(notExpected)) {
    return new ShouldContainExactly(actual, expected, notFound, comparisonStrategy);
  }
  if (isNullOrEmpty(notFound)) {
    return new ShouldContainExactly(actual, expected, comparisonStrategy, notExpected);
  }
  return new ShouldContainExactly(actual, expected, notFound, notExpected, comparisonStrategy);
}
 

import org.assertj.core.internal.ComparisonStrategy; //导入依赖的package包/类
private ShouldContainExactly(Object actual, Object expected, Object notFound, Object notExpected,
                             ComparisonStrategy comparisonStrategy) {
  super("%n" +
        "Expecting:%n" +
        "  <%s>%n" +
        "to contain exactly (and in same order):%n" +
        "  <%s>%n" +
        "but some elements were not found:%n" +
        "  <%s>%n" +
        "and others were not expected:%n" +
        "  <%s>%n%s",
        actual, expected, notFound, notExpected, comparisonStrategy);
}
 

import org.assertj.core.internal.ComparisonStrategy; //导入依赖的package包/类
/**
 * Creates a new <code>{@link ShouldContainSubsequenceOfCharSequence}</code>.
 * 
 * @param actual the actual value in the failed assertion.
 * @param strings the sequence of values expected to be in {@code actual}.
 * @param badOrderIndex index failing the subsequence.
 * @param comparisonStrategy the {@link ComparisonStrategy} used to evaluate assertion.
 * @return the created {@code ErrorMessageFactory}.
 */
public static ErrorMessageFactory shouldContainSubsequence(CharSequence actual, CharSequence[] strings,
                                                           int badOrderIndex, ComparisonStrategy comparisonStrategy) {

  return new ShouldContainSubsequenceOfCharSequence("%nExpecting:%n" +
                                                    "  <%s>%n" +
                                                    "to contain the following CharSequences in this order:%n" +
                                                    "  <%s>%n" +
                                                    "but <%s> was found before <%s>%n%s",
                                                    actual, strings, strings[badOrderIndex + 1],
                                                    strings[badOrderIndex],
                                                    comparisonStrategy);
}
 

import org.assertj.core.internal.ComparisonStrategy; //导入依赖的package包/类
private ShouldContainsOnlyOnce(Object actual, Object expected, Set<?> notFound, Set<?> notOnlyOnce,
    ComparisonStrategy comparisonStrategy) {
  super("%nExpecting:%n <%s>%nto contain only once:%n <%s>%n"
      + "but some elements were not found:%n <%s>%n"
      + "and others were found more than once:%n <%s>%n%s",
        actual, expected, notFound, notOnlyOnce, comparisonStrategy);
}
 

import org.assertj.core.internal.ComparisonStrategy; //导入依赖的package包/类
private ShouldContainOnly(Object actual, Object expected, Iterable<?> notFound, Iterable<?> notExpected,
                          ComparisonStrategy comparisonStrategy) {
  super("%n" +
        "Expecting:%n" +
        "  <%s>%n" +
        "to contain only:%n" +
        "  <%s>%n" +
        "elements not found:%n" +
        "  <%s>%n" +
        "and elements not expected:%n" +
        "  <%s>%n%s", actual,
        expected, notFound, notExpected, comparisonStrategy);
}
 

import org.assertj.core.internal.ComparisonStrategy; //导入依赖的package包/类
public FDatesAssertions(final ComparisonStrategy comparisonStrategy) {
    super(comparisonStrategy);
    this.comparisonStrategy = comparisonStrategy;
}
 

import org.assertj.core.internal.ComparisonStrategy; //导入依赖的package包/类
private ShouldBeAfterOrEqualsTo(Object actual, Object other, ComparisonStrategy comparisonStrategy) {
   super("%nExpecting:%n  <%s>%nto be after or equals to:%n  <%s>%n%s", actual, other, comparisonStrategy);
}
 

import org.assertj.core.internal.ComparisonStrategy; //导入依赖的package包/类
private ShouldBeBefore(Object actual, Object other, ComparisonStrategy comparisonStrategy) {
  super("%nExpecting:%n  <%s>%nto be strictly before:%n  <%s>%n%s", actual, other, comparisonStrategy);
}
 

import org.assertj.core.internal.ComparisonStrategy; //导入依赖的package包/类
private ShouldBeAfter(Object actual, Object other, ComparisonStrategy comparisonStrategy) {
  super("%nExpecting:%n  <%s>%nto be strictly after:%n  <%s>%n%s", actual, other, comparisonStrategy);
}
 

import org.assertj.core.internal.ComparisonStrategy; //导入依赖的package包/类
private ShouldBeBeforeOrEqualsTo(Object actual, Object other, ComparisonStrategy comparisonStrategy) {
  super("%nExpecting:%n  <%s>%nto be before or equals to:%n  <%s>%n%s", actual, other, comparisonStrategy);
}
 

import org.assertj.core.internal.ComparisonStrategy; //导入依赖的package包/类
private ShouldNotEndWith(Object actual, Object expected, ComparisonStrategy comparisonStrategy) {
  super("%nExpecting:%n  <%s>%nnot to end with:%n  <%s>%n%s", actual, expected, comparisonStrategy);
}
 

import org.assertj.core.internal.ComparisonStrategy; //导入依赖的package包/类
private ShouldNotContainCharSequence(String format, CharSequence actual, CharSequence sequence,
                                     ComparisonStrategy comparisonStrategy) {
  super(format, actual, sequence, comparisonStrategy);
}
 

import org.assertj.core.internal.ComparisonStrategy; //导入依赖的package包/类
public static ErrorMessageFactory shouldContainAnyOf(Object actual, Object expected,
                                                     ComparisonStrategy comparisonStrategy) {
  return new ShouldContainAnyOf(actual, expected, comparisonStrategy);
}
 

import org.assertj.core.internal.ComparisonStrategy; //导入依赖的package包/类
private ShouldBeBeforeYear(Date actual, int year, ComparisonStrategy comparisonStrategy) {
  super("%nExpecting year of:%n <%s>%nto be strictly before year:%n <%s>%s", actual, year, comparisonStrategy);
}
 

import org.assertj.core.internal.ComparisonStrategy; //导入依赖的package包/类
private ShouldNotStartWith(Object actual, Object expected, ComparisonStrategy comparisonStrategy) {
  super("%nExpecting:%n  <%s>%nnot to start with:%n  <%s>%n%s", actual, expected, comparisonStrategy);
}