@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'"); }