@Test
public void should_create_error_message_with_custom_comparison_strategy() {
ErrorMessageFactory factory =
shouldContainExactly(
newArrayList("Yoda", "Han"),
newArrayList("Luke", "Yoda"),
newLinkedHashSet("Luke"),
newLinkedHashSet("Han"),
CASE_INSENSITIVE_COMPARISON_STRATEGY);
String message = factory.create(new TextDescription("Test"), new StandardRepresentation());
assertThat(message)
.isEqualTo(
"[Test] \n"
+ "Expecting:\n"
+ " <[\"Yoda\", \"Han\"]>\n"
+ "to contain exactly (and in same order):\n"
+ " <[\"Luke\", \"Yoda\"]>\n"
+ "but some elements were not found:\n"
+ " <[\"Luke\"]>\n"
+ "and others were not expected:\n"
+ " <[\"Han\"]>\n"
+ "when comparing values using 'CaseInsensitiveStringComparator'");
}
@Test
public void should_create_error_message() {
ErrorMessageFactory factory =
shouldContainAtIndex(newArrayList("Yoda", "Luke"), "Leia", atIndex(1), "Luke");
String message = factory.create(new TextDescription("Test"));
assertEquals(
"[Test] \nExpecting:\n <\"Leia\">\nat index <1> but found:\n <\"Luke\">\nin:\n <[\"Yoda\", \"Luke\"]>\n",
message);
}
@Test
public void should_create_error_message() {
ErrorMessageFactory factory =
shouldNotContain(
newArrayList("Yoda"), newArrayList("Luke", "Yoda"), newLinkedHashSet("Yoda"));
String message = factory.create(new TextDescription("Test"), new StandardRepresentation());
assertEquals(
"[Test] \nExpecting\n <[\"Yoda\"]>\nnot to contain\n <[\"Luke\", \"Yoda\"]>\nbut found\n <[\"Yoda\"]>\n",
message);
}
@Test
public void should_create_error_message() {
ErrorMessageFactory factory =
shouldBeAtIndex(
list("Yoda", "Luke"), new TestCondition<String>("red lightsaber"), atIndex(1), "Luke");
String message = factory.create(new TextDescription("Test"));
assertEquals(
"[Test] expecting:<'Luke'> at index <1> to be:<red lightsaber> in:\n <['Yoda', 'Luke']>\n",
message);
}
@Test
public void should_create_error_message_with_custom_comparison_strategy() {
ErrorMessageFactory factory =
shouldNotContain(
"Yoda",
"od",
new ComparatorBasedComparisonStrategy(CaseInsensitiveStringComparator.instance));
String message = factory.create(new TextDescription("Test"), new StandardRepresentation());
assertEquals(
"[Test] \nExpecting:\n <\"Yoda\">\nnot to contain:\n <\"od\"> when comparing values using 'CaseInsensitiveStringComparator'",
message);
}
@Test
public void should_create_error_message_when_only_elements_order_differs() {
ErrorMessageFactory factory = elementsDifferAtIndex("Luke", "Han", 1);
String message = factory.create(new TextDescription("Test"), new StandardRepresentation());
assertThat(message)
.isEqualTo(
"[Test] \n"
+ "Actual and expected have the same elements but not in the same order, at index 1 actual element was:\n"
+ " <\"Luke\">\n"
+ "whereas expected element was:\n"
+ " <\"Han\">\n");
}
@Test
public void should_create_error_message_with_custom_comparison_strategy() {
ErrorMessageFactory factory =
shouldNotContain(
newArrayList("Yoda"),
newArrayList("Luke", "Yoda"),
newLinkedHashSet("Yoda"),
new ComparatorBasedComparisonStrategy(CaseInsensitiveStringComparator.instance));
String message = factory.create(new TextDescription("Test"), new StandardRepresentation());
assertEquals(
"[Test] \nExpecting\n <[\"Yoda\"]>\nnot to contain\n <[\"Luke\", \"Yoda\"]>\n"
+ "but found\n <[\"Yoda\"]>\naccording to 'CaseInsensitiveStringComparator' comparator",
message);
}
@Test
public void should_create_error_message_with_custom_comparison_strategy() {
ErrorMessageFactory factory =
shouldContainAtIndex(
newArrayList("Yoda", "Luke"),
"Leia",
atIndex(1),
"Luke",
new ComparatorBasedComparisonStrategy(CaseInsensitiveStringComparator.instance));
String message = factory.create(new TextDescription("Test"));
assertEquals(
"[Test] \nExpecting:\n <\"Leia\">\nat index <1> but found:\n <\"Luke\">\nin:\n <[\"Yoda\", \"Luke\"]>\n"
+ "according to 'CaseInsensitiveStringComparator' comparator",
message);
}
@Test
public void should_create_error_message_for_array() {
ErrorMessageFactory factory =
shouldHaveAtLeastOneElementOfType(array("Yoda", "Luke"), Long.class);
String message = factory.create(new TextDescription("Test"), new StandardRepresentation());
assertThat(message)
.isEqualTo(
String.format(
"[Test] %n"
+ "Expecting:%n"
+ " <[\"Yoda\", \"Luke\"]>%n"
+ "to have at least one element of type:%n"
+ " <java.lang.Long>%n"
+ "but had none."));
}
@Test
public void should_create_error_message() {
String message = factory.create(new TextDescription("Test"));
assertEquals(
"[Test] expecting\n" + "<['Yoda', 'Luke']>\n" + " to start with\n" + "<['Han', 'Leia']>\n",
message);
}
@Test
public void should_create_error_message() {
String message = factory.create(new TextDescription("Test"));
assertEquals(
"[Test] expecting elements:\n<['Yoda', 'Luke', 'Obiwan']>\n to have at most 2 times <Jedi power>",
message);
}
@Test
public void should_create_error_message() {
String message = factory.create(new TextDescription("Test"), new StandardRepresentation());
assertEquals(
"[Test] \nExpecting:\n <2011-01-01T00:00:00>\nto be before or equals to:\n <2012-01-01T00:00:00>",
message);
}
@Test
public void should_create_error_message() {
String message = factory.create(new TextDescription("Test"));
assertEquals(
"[Test] expecting elements:\n<['Yoda']>\n of \n<['Darth Vader', 'Leia', 'Yoda']>\n not to be <not a Jedi>",
message);
}
@Test
public void
should_create_error_message_when_only_elements_order_differs_according_to_custom_comparison_strategy() {
ErrorMessageFactory factory =
elementsDifferAtIndex("Luke", "Han", 1, CASE_INSENSITIVE_COMPARISON_STRATEGY);
String message = factory.create(new TextDescription("Test"), new StandardRepresentation());
assertThat(message)
.isEqualTo(
"[Test] \n"
+ "Actual and expected have the same elements but not in the same order, at index 1 actual element was:\n"
+ " <\"Luke\">\nwhereas expected element was:\n"
+ " <\"Han\">\n"
+ "when comparing values using 'CaseInsensitiveStringComparator'");
}
@Test
public void should_create_error_message_when_ignoring_case() {
factory = shouldContainIgnoringCase("Yoda", "Luke");
String message = factory.create(new TextDescription("Test"));
assertEquals(
"[Test] \nExpecting:\n <'Yoda'>\nto contain:\n <'Luke'>\n (ignoring case)", message);
}
@Test
public void should_create_error_message() {
factory = shouldContain("Yoda", "Luke");
String message = factory.create(new TextDescription("Test"), new StandardRepresentation());
assertThat(message)
.isEqualTo(String.format("[Test] %nExpecting:%n <\"Yoda\">%nto contain:%n <\"Luke\"> "));
}
@Test
public void should_create_error_message_with_several_string_values() {
factory = shouldContain("Yoda, Luke", array("Luke", "Vador", "Solo"), newSet("Vador", "Solo"));
String message = factory.create(new TextDescription("Test"));
assertEquals(
"[Test] \nExpecting:\n <'Yoda, Luke'>\nto contain:\n <['Luke', 'Vador', 'Solo']>\nbut could not find:\n <['Vador', 'Solo']>\n ",
message);
}
@Test
public void should_create_error_message() {
String message = factory.create(new TextDescription("Test"), new StandardRepresentation());
assertThat(message)
.isEqualTo(
String.format(
"[Test] %nExpecting:%n <[\"Yoda\", \"Luke\"]>%nto start with:%n <[\"Han\", \"Leia\"]>%n"));
}
@Test
public void should_create_error_message() {
String message = factory.create(new TestDescription("Test"), new StandardRepresentation());
assertThat(message)
.isEqualTo(
String.format(
"[Test] %nExpecting:%n <\"Yoda\">%nnot to be an instance of any of these types:%n <[java.lang.String, java.lang.Object]>"));
}
@Test
public void should_create_error_message() {
String message = factory.create(new TextDescription("Test"), new StandardRepresentation());
assertThat(message)
.isEqualTo(
String.format(
"[Test] %nExpecting elements:%n<[\"Yoda\", \"Luke\", \"Obiwan\"]>%n to be at most 2 times <a Jedi>"));
}
@Test
public void should_create_error_message_ignoring_hours() {
ErrorMessageFactory factory =
shouldBeEqual(
parseDatetimeWithMs("2011-01-01T05:00:00.000"),
parseDatetimeWithMs("2011-01-01T06:05:17.003"),
TimeUnit.HOURS);
String message = factory.create(new TextDescription("Test"), new StandardRepresentation());
assertThat(message)
.isEqualTo(
format(
"[Test] %nExpecting:%n"
+ " <2011-01-01T05:00:00.000>%n"
+ "to have same year, month and day as:%n"
+ " <2011-01-01T06:05:17.003>%n"
+ "but had not."));
}
@Test
public void should_create_error_message_with_several_string_values() {
factory = shouldContain("Yoda, Luke", array("Luke", "Vador", "Solo"), newSet("Vador", "Solo"));
String message = factory.create(new TextDescription("Test"), new StandardRepresentation());
assertThat(message)
.isEqualTo(
String.format(
"[Test] %nExpecting:%n <\"Yoda, Luke\">%nto contain:%n <[\"Luke\", \"Vador\", \"Solo\"]>%nbut could not find:%n <[\"Vador\", \"Solo\"]>%n "));
}
@Test
public void should_not_display_unexpected_elements_when_there_are_none() {
ErrorMessageFactory factory =
shouldContainExactly(
newArrayList("Yoda"), newArrayList("Luke", "Yoda"),
newLinkedHashSet("Luke"), Collections.emptySet());
String message = factory.create(new TextDescription("Test"), new StandardRepresentation());
assertThat(message)
.isEqualTo(
"[Test] \n"
+ "Expecting:\n"
+ " <[\"Yoda\"]>\n"
+ "to contain exactly (and in same order):\n"
+ " <[\"Luke\", \"Yoda\"]>\n"
+ "but could not find the following elements:\n"
+ " <[\"Luke\"]>\n");
}
@Test
public void should_create_error_message_with_custom_comparison_strategy() {
factory =
shouldContain(
"Yoda",
"Luke",
new ComparatorBasedComparisonStrategy(CaseInsensitiveStringComparator.instance));
String message = factory.create(new TextDescription("Test"));
assertEquals(
"[Test] \nExpecting:\n <'Yoda'>\nto contain:\n <'Luke'> according to 'CaseInsensitiveStringComparator' comparator",
message);
}
@Test
public void should_create_error_message_with_custom_comparison_strategy() {
factory =
shouldBeIn(
"Yoda",
array("Luke", "Leia"),
new ComparatorBasedComparisonStrategy(CaseInsensitiveStringComparator.instance));
String message = factory.create(new TextDescription("Test"), new StandardRepresentation());
assertEquals(
"[Test] \nExpecting:\n <\"Yoda\">\nto be in:\n <[\"Luke\", \"Leia\"]>\naccording to 'CaseInsensitiveStringComparator' comparator",
message);
}
@Test
public void should_create_error_message() {
ErrorMessageFactory factory =
shouldContainExactly(
newArrayList("Yoda", "Han"), newArrayList("Luke", "Yoda"),
newLinkedHashSet("Luke"), newLinkedHashSet("Han"));
String message = factory.create(new TextDescription("Test"), new StandardRepresentation());
assertThat(message)
.isEqualTo(
"[Test] \n"
+ "Expecting:\n"
+ " <[\"Yoda\", \"Han\"]>\n"
+ "to contain exactly (and in same order):\n"
+ " <[\"Luke\", \"Yoda\"]>\n"
+ "but some elements were not found:\n"
+ " <[\"Luke\"]>\n"
+ "and others were not "
+ "expected:\n"
+ " <[\"Han\"]>\n");
}
@Test
public void should_create_error_message_with_custom_comparison_strategy() {
factory =
shouldContain(
"Yoda",
"Luke",
new ComparatorBasedComparisonStrategy(CaseInsensitiveStringComparator.instance));
String message = factory.create(new TextDescription("Test"), new StandardRepresentation());
assertThat(message)
.isEqualTo(
String.format(
"[Test] %nExpecting:%n <\"Yoda\">%nto contain:%n <\"Luke\"> when comparing values using 'CaseInsensitiveStringComparator'"));
}
@Test
public void should_create_error_message_with_single_field_difference() {
factory =
shouldBeLenientEqualByAccepting(
new Jedi("Yoda", "green"),
list("lightSaberColor"),
list((Object) "green"),
list("lightSaberColor"));
String message = factory.create(new TextDescription("Test"));
assertEquals(
"[Test] expected value <'green'> in field <'lightSaberColor'> of <Yoda the Jedi>.\n"
+ "Comparison was performed on fields <['lightSaberColor']>",
message);
}
@Test
public void should_create_error_message_with_custom_comparison_strategy() {
factory =
shouldStartWith(
newArrayList("Yoda", "Luke"),
newArrayList("Han", "Leia"),
new ComparatorBasedComparisonStrategy(CaseInsensitiveStringComparator.instance));
String message = factory.create(new TextDescription("Test"), new StandardRepresentation());
assertThat(message)
.isEqualTo(
String.format(
"[Test] %nExpecting:%n <[\"Yoda\", \"Luke\"]>%nto start with:%n <[\"Han\", \"Leia\"]>%n"
+ "when comparing values using 'CaseInsensitiveStringComparator'"));
}
@Test
public void
should_not_display_unexpected_elements_when_there_are_none_with_custom_comparison_strategy() {
ErrorMessageFactory factory =
shouldContainExactly(
newArrayList("Yoda"),
newArrayList("Luke", "Yoda"),
newLinkedHashSet("Luke"),
Collections.emptySet(),
CASE_INSENSITIVE_COMPARISON_STRATEGY);
String message = factory.create(new TextDescription("Test"), new StandardRepresentation());
assertThat(message)
.isEqualTo(
"[Test] \n"
+ "Expecting:\n"
+ " <[\"Yoda\"]>\n"
+ "to contain exactly (and in same order):\n"
+ " <[\"Luke\", \"Yoda\"]>\n"
+ "but could not find the following elements:\n"
+ " <[\"Luke\"]>\n"
+ "when comparing values using 'CaseInsensitiveStringComparator'");
}
