Search in sources :

Example 1 with SoftAssertionError

use of org.assertj.core.api.SoftAssertionError in project assertj-core by joel-costigliola.

the class AutoClosableSoftAssertionsLineNumberTest method should_print_line_numbers_of_failed_assertions.

@Test
public void should_print_line_numbers_of_failed_assertions() {
    try {
        AutoCloseableSoftAssertions softly = new AutoCloseableSoftAssertions();
        softly.assertThat(1).isLessThan(0).isLessThan(1);
        softly.close();
        fail("Should not reach here");
    } catch (SoftAssertionError e) {
        assertThat(e).hasMessageContaining(format("1) %n" + "Expecting:%n" + " <1>%n" + "to be less than:%n" + " <0> %n" + "at AutoClosableSoftAssertionsLineNumberTest.should_print_line_numbers_of_failed_assertions(AutoClosableSoftAssertionsLineNumberTest.java:34)%n" + "2) %n" + "Expecting:%n" + " <1>%n" + "to be less than:%n" + " <1> %n" + "at AutoClosableSoftAssertionsLineNumberTest.should_print_line_numbers_of_failed_assertions(AutoClosableSoftAssertionsLineNumberTest.java:35)"));
    }
}
Also used : AutoCloseableSoftAssertions(org.assertj.core.api.AutoCloseableSoftAssertions) SoftAssertionError(org.assertj.core.api.SoftAssertionError) Test(org.junit.Test)

Example 2 with SoftAssertionError

use of org.assertj.core.api.SoftAssertionError in project assertj-core by joel-costigliola.

the class SoftAssertionsPerfTest method should_be_able_to_catch_exceptions_thrown_by_all_proxied_methods.

@SuppressWarnings("unchecked")
@Test
public void should_be_able_to_catch_exceptions_thrown_by_all_proxied_methods() throws URISyntaxException {
    try {
        softly.assertThat(BigDecimal.ZERO).isEqualTo(BigDecimal.ONE);
        softly.assertThat(Boolean.FALSE).isTrue();
        softly.assertThat(false).isTrue();
        softly.assertThat(new boolean[] { false }).isEqualTo(new boolean[] { true });
        softly.assertThat(new Byte((byte) 0)).isEqualTo((byte) 1);
        softly.assertThat((byte) 2).inHexadecimal().isEqualTo((byte) 3);
        softly.assertThat(new byte[] { 4 }).isEqualTo(new byte[] { 5 });
        softly.assertThat(new Character((char) 65)).isEqualTo(new Character((char) 66));
        softly.assertThat((char) 67).isEqualTo((char) 68);
        softly.assertThat(new char[] { 69 }).isEqualTo(new char[] { 70 });
        softly.assertThat(new StringBuilder("a")).isEqualTo(new StringBuilder("b"));
        softly.assertThat(Object.class).isEqualTo(String.class);
        softly.assertThat(parseDatetime("1999-12-31T23:59:59")).isEqualTo(parseDatetime("2000-01-01T00:00:01"));
        softly.assertThat(new Double(6.0d)).isEqualTo(new Double(7.0d));
        softly.assertThat(8.0d).isEqualTo(9.0d);
        softly.assertThat(new double[] { 10.0d }).isEqualTo(new double[] { 11.0d });
        softly.assertThat(new File("a")).overridingErrorMessage("expected:<File(b)> but was:<File(a)>").isEqualTo(new File("b"));
        softly.assertThat(new Float(12f)).isEqualTo(new Float(13f));
        softly.assertThat(14f).isEqualTo(15f);
        softly.assertThat(new float[] { 16f }).isEqualTo(new float[] { 17f });
        softly.assertThat(new ByteArrayInputStream(new byte[] { (byte) 65 })).hasSameContentAs(new ByteArrayInputStream(new byte[] { (byte) 66 }));
        softly.assertThat(new Integer(20)).isEqualTo(new Integer(21));
        softly.assertThat(22).isEqualTo(23);
        softly.assertThat(new int[] { 24 }).isEqualTo(new int[] { 25 });
        softly.assertThat((Iterable<String>) Lists.newArrayList("26")).isEqualTo(Lists.newArrayList("27"));
        softly.assertThat(Lists.newArrayList("28").iterator()).contains("29");
        softly.assertThat(Lists.newArrayList("30")).isEqualTo(Lists.newArrayList("31"));
        softly.assertThat(new Long(32L)).isEqualTo(new Long(33L));
        softly.assertThat(34L).isEqualTo(35L);
        softly.assertThat(new long[] { 36L }).isEqualTo(new long[] { 37L });
        softly.assertThat(mapOf(MapEntry.entry("38", "39"))).isEqualTo(mapOf(MapEntry.entry("40", "41")));
        softly.assertThat(new Short((short) 42)).isEqualTo(new Short((short) 43));
        softly.assertThat((short) 44).isEqualTo((short) 45);
        softly.assertThat(new short[] { (short) 46 }).isEqualTo(new short[] { (short) 47 });
        softly.assertThat("48").isEqualTo("49");
        softly.assertThat(new Object() {

            @Override
            public String toString() {
                return "50";
            }
        }).isEqualTo(new Object() {

            @Override
            public String toString() {
                return "51";
            }
        });
        softly.assertThat(new Object[] { new Object() {

            @Override
            public String toString() {
                return "52";
            }
        } }).isEqualTo(new Object[] { new Object() {

            @Override
            public String toString() {
                return "53";
            }
        } });
        final IllegalArgumentException illegalArgumentException = new IllegalArgumentException("IllegalArgumentException message");
        softly.assertThat(illegalArgumentException).hasMessage("NullPointerException message");
        softly.assertThatThrownBy(new ThrowingCallable() {

            @Override
            public void call() throws Exception {
                throw new Exception("something was wrong");
            }
        }).hasMessage("something was good");
        softly.assertThat(mapOf(MapEntry.entry("54", "55"))).contains(MapEntry.entry("1", "2"));
        softly.assertThat(LocalTime.of(12, 00)).isEqualTo(LocalTime.of(13, 00));
        softly.assertThat(OffsetTime.of(12, 0, 0, 0, ZoneOffset.UTC)).isEqualTo(OffsetTime.of(13, 0, 0, 0, ZoneOffset.UTC));
        softly.assertThat(Optional.of("not empty")).isEqualTo("empty");
        softly.assertThat(OptionalInt.of(0)).isEqualTo(1);
        softly.assertThat(OptionalDouble.of(0.0)).isEqualTo(1.0);
        softly.assertThat(OptionalLong.of(0L)).isEqualTo(1L);
        softly.assertThat(new URI("http://assertj.org")).hasPort(8888);
        softly.assertThat(CompletableFuture.completedFuture("done")).hasFailed();
        softly.assertThat((Predicate<String>) s -> s.equals("something")).accepts("something else");
        softly.assertThat((IntPredicate) s -> s == 1).accepts(2);
        softly.assertThat((LongPredicate) s -> s == 1).accepts(2);
        softly.assertThat((DoublePredicate) s -> s == 1).accepts(2);
        softly.assertAll();
        fail("Should not reach here");
    } catch (SoftAssertionError e) {
        List<String> errors = e.getErrors();
        assertThat(errors).hasSize(52);
        assertThat(errors.get(0)).startsWith("expected:<[1]> but was:<[0]>");
        assertThat(errors.get(1)).startsWith("expected:<[tru]e> but was:<[fals]e>");
        assertThat(errors.get(2)).startsWith("expected:<[tru]e> but was:<[fals]e>");
        assertThat(errors.get(3)).startsWith("expected:<[[tru]e]> but was:<[[fals]e]>");
        assertThat(errors.get(4)).startsWith("expected:<[1]> but was:<[0]>");
        assertThat(errors.get(5)).startsWith("expected:<0x0[3]> but was:<0x0[2]>");
        assertThat(errors.get(6)).startsWith("expected:<[[5]]> but was:<[[4]]>");
        assertThat(errors.get(7)).startsWith("expected:<'[B]'> but was:<'[A]'>");
        assertThat(errors.get(8)).startsWith("expected:<'[D]'> but was:<'[C]'>");
        assertThat(errors.get(9)).startsWith("expected:<['[F]']> but was:<['[E]']>");
        assertThat(errors.get(10)).startsWith("expected:<[b]> but was:<[a]>");
        assertThat(errors.get(11)).startsWith("expected:<java.lang.[String]> but was:<java.lang.[Object]>");
        assertThat(errors.get(12)).startsWith("expected:<[2000-01-01T00:00:01].000> but was:<[1999-12-31T23:59:59].000>");
        assertThat(errors.get(13)).startsWith("expected:<[7].0> but was:<[6].0>");
        assertThat(errors.get(14)).startsWith("expected:<[9].0> but was:<[8].0>");
        assertThat(errors.get(15)).startsWith("expected:<[1[1].0]> but was:<[1[0].0]>");
        assertThat(errors.get(16)).startsWith("expected:<File(b)> but was:<File(a)>");
        assertThat(errors.get(17)).startsWith("expected:<1[3].0f> but was:<1[2].0f>");
        assertThat(errors.get(18)).startsWith("expected:<1[5].0f> but was:<1[4].0f>");
        assertThat(errors.get(19)).startsWith("expected:<[1[7].0f]> but was:<[1[6].0f]>");
        assertThat(errors.get(20)).startsWith(format("%nInputStreams do not have same content:%n%n" + "Changed content at line 1:%n" + "expecting:%n" + "  [\"B\"]%n" + "but was:%n" + "  [\"A\"]%n"));
        assertThat(errors.get(21)).startsWith("expected:<2[1]> but was:<2[0]>");
        assertThat(errors.get(22)).startsWith("expected:<2[3]> but was:<2[2]>");
        assertThat(errors.get(23)).startsWith("expected:<[2[5]]> but was:<[2[4]]>");
        assertThat(errors.get(24)).startsWith("expected:<[\"2[7]\"]> but was:<[\"2[6]\"]>");
        assertThat(errors.get(25)).startsWith(format("%nExpecting:%n" + " <[\"28\"]>%n" + "to contain:%n" + " <[\"29\"]>%n" + "but could not find:%n" + " <[\"29\"]>%n"));
        assertThat(errors.get(26)).startsWith("expected:<[\"3[1]\"]> but was:<[\"3[0]\"]>");
        assertThat(errors.get(27)).startsWith("expected:<3[3]L> but was:<3[2]L>");
        assertThat(errors.get(28)).startsWith("expected:<3[5]L> but was:<3[4]L>");
        assertThat(errors.get(29)).startsWith("expected:<[3[7]L]> but was:<[3[6]L]>");
        assertThat(errors.get(30)).startsWith("expected:<{\"[40\"=\"41]\"}> but was:<{\"[38\"=\"39]\"}>");
        assertThat(errors.get(31)).startsWith("expected:<4[3]> but was:<4[2]>");
        assertThat(errors.get(32)).startsWith("expected:<4[5]> but was:<4[4]>");
        assertThat(errors.get(33)).startsWith("expected:<[4[7]]> but was:<[4[6]]>");
        assertThat(errors.get(34)).startsWith("expected:<\"4[9]\"> but was:<\"4[8]\">");
        assertThat(errors.get(35)).startsWith("expected:<5[1]> but was:<5[0]>");
        assertThat(errors.get(36)).startsWith("expected:<[5[3]]> but was:<[5[2]]>");
        assertThat(errors.get(37)).startsWith(format("%nExpecting message:%n" + " <\"NullPointerException message\">%n" + "but was:%n" + " <\"IllegalArgumentException message\">"));
        assertThat(errors.get(38)).startsWith(format("%nExpecting message:%n" + " <\"something was good\">%n" + "but was:%n" + " <\"something was wrong\">"));
        assertThat(errors.get(39)).startsWith(format("%nExpecting:%n" + " <{\"54\"=\"55\"}>%n" + "to contain:%n" + " <[MapEntry[key=\"1\", value=\"2\"]]>%n" + "but could not find:%n" + " <[MapEntry[key=\"1\", value=\"2\"]]>%n"));
        assertThat(errors.get(40)).startsWith("expected:<1[3]:00> but was:<1[2]:00>");
        assertThat(errors.get(41)).startsWith("expected:<1[3]:00Z> but was:<1[2]:00Z>");
        assertThat(errors.get(42)).startsWith("expected:<[\"empty\"]> but was:<[Optional[not empty]]>");
        assertThat(errors.get(43)).startsWith("expected:<[1]> but was:<[OptionalInt[0]]>");
        assertThat(errors.get(44)).startsWith("expected:<[1.0]> but was:<[OptionalDouble[0.0]]>");
        assertThat(errors.get(45)).startsWith("expected:<[1L]> but was:<[OptionalLong[0]]>");
        assertThat(errors.get(46)).contains("Expecting port of");
        assertThat(errors.get(47)).contains("to have failed");
        assertThat(errors.get(48)).startsWith(format("%nExpecting:%n  <given predicate>%n" + "to accept <\"something else\"> but it did not."));
        assertThat(errors.get(49)).startsWith(format("%nExpecting:%n  <given predicate>%n" + "to accept <2> but it did not."));
        assertThat(errors.get(50)).startsWith(format("%nExpecting:%n  <given predicate>%n" + "to accept <2L> but it did not."));
        assertThat(errors.get(51)).startsWith(format("%nExpecting:%n  <given predicate>%n" + "to accept <2.0> but it did not."));
    }
}
Also used : CartoonCharacter(org.assertj.core.test.CartoonCharacter) IntPredicate(java.util.function.IntPredicate) DoublePredicate(java.util.function.DoublePredicate) OptionalDouble(java.util.OptionalDouble) URI(java.net.URI) LongPredicate(java.util.function.LongPredicate) URISyntaxException(java.net.URISyntaxException) IntPredicate(java.util.function.IntPredicate) LongPredicate(java.util.function.LongPredicate) Predicate(java.util.function.Predicate) DoublePredicate(java.util.function.DoublePredicate) ByteArrayInputStream(java.io.ByteArrayInputStream) ThrowingCallable(org.assertj.core.api.ThrowableAssert.ThrowingCallable) OptionalLong(java.util.OptionalLong) Arrays.asList(java.util.Arrays.asList) List(java.util.List) File(java.io.File) SoftAssertionError(org.assertj.core.api.SoftAssertionError) BaseAssertionsTest(org.assertj.core.api.BaseAssertionsTest) Test(org.junit.Test)

Example 3 with SoftAssertionError

use of org.assertj.core.api.SoftAssertionError in project assertj-core by joel-costigliola.

the class BDDSoftAssertionsLineNumberTest method should_print_line_numbers_of_failed_assertions.

@Test
public void should_print_line_numbers_of_failed_assertions() {
    BDDSoftAssertions softly = new BDDSoftAssertions();
    try {
        softly.then(1).isLessThan(0).isLessThan(1);
        softly.assertAll();
        fail("Should not reach here");
    } catch (SoftAssertionError e) {
        assertThat(e).hasMessageContaining(format("1) %n" + "Expecting:%n" + " <1>%n" + "to be less than:%n" + " <0> %n" + "at BDDSoftAssertionsLineNumberTest.should_print_line_numbers_of_failed_assertions(BDDSoftAssertionsLineNumberTest.java:34)%n" + "2) %n" + "Expecting:%n" + " <1>%n" + "to be less than:%n" + " <1> %n" + "at BDDSoftAssertionsLineNumberTest.should_print_line_numbers_of_failed_assertions(BDDSoftAssertionsLineNumberTest.java:35)"));
    }
}
Also used : BDDSoftAssertions(org.assertj.core.api.BDDSoftAssertions) SoftAssertionError(org.assertj.core.api.SoftAssertionError) Test(org.junit.Test)

Example 4 with SoftAssertionError

use of org.assertj.core.api.SoftAssertionError in project assertj-core by joel-costigliola.

the class SoftAssertionsLineNumberTest method should_print_line_numbers_of_failed_assertions.

@Test
public void should_print_line_numbers_of_failed_assertions() {
    SoftAssertions softly = new SoftAssertions();
    try {
        softly.assertThat(1).isLessThan(0).isLessThan(1);
        softly.assertAll();
        fail("Should not reach here");
    } catch (SoftAssertionError e) {
        assertThat(e).hasMessageContaining(format("1) %n" + "Expecting:%n" + " <1>%n" + "to be less than:%n" + " <0> %n" + "at SoftAssertionsLineNumberTest.should_print_line_numbers_of_failed_assertions(SoftAssertionsLineNumberTest.java:37)%n" + "2) %n" + "Expecting:%n" + " <1>%n" + "to be less than:%n" + " <1> %n" + "at SoftAssertionsLineNumberTest.should_print_line_numbers_of_failed_assertions(SoftAssertionsLineNumberTest.java:38)"));
    }
}
Also used : SoftAssertions(org.assertj.core.api.SoftAssertions) SoftAssertionError(org.assertj.core.api.SoftAssertionError) Test(org.junit.Test)

Example 5 with SoftAssertionError

use of org.assertj.core.api.SoftAssertionError in project assertj-core by joel-costigliola.

the class SoftAssertionsLineNumberTest method should_print_line_numbers_of_failed_assertions_even_if_it_came_from_nested_calls.

@Test
public void should_print_line_numbers_of_failed_assertions_even_if_it_came_from_nested_calls() {
    SoftAssertions softly = new SoftAssertions();
    try {
        softly.assertThat(Optional.empty()).contains("Foo");
        // nested proxied call to isNotNull
        softly.assertThat((Predicate<String>) null).accepts("a", "b", "c");
        Predicate<String> lowercasePredicate = s -> s.equals(s.toLowerCase());
        // check line number
        softly.assertThat(lowercasePredicate).accepts("a", "b", "C");
        softly.assertAll();
        fail("Should not reach here");
    } catch (SoftAssertionError e) {
        assertThat(e).hasMessageContaining(format("1) %n" + "Expecting Optional to contain:%n" + "  <\"Foo\">%n" + "but was empty.%n" + "at SoftAssertionsLineNumberTest.should_print_line_numbers_of_failed_assertions_even_if_it_came_from_nested_calls(SoftAssertionsLineNumberTest.java:61)%n" + "2) %n" + "Expecting actual not to be null%n" + "at SoftAssertionsLineNumberTest.should_print_line_numbers_of_failed_assertions_even_if_it_came_from_nested_calls(SoftAssertionsLineNumberTest.java:63)%n" + "3) %n" + "Expecting all elements of:%n" + "  <[\"a\", \"b\", \"C\"]>%n" + "to match given predicate but this element did not:%n" + "  <\"C\">%n" + "at SoftAssertionsLineNumberTest.should_print_line_numbers_of_failed_assertions_even_if_it_came_from_nested_calls(SoftAssertionsLineNumberTest.java:66)"));
    }
}
Also used : Assertions.fail(org.assertj.core.api.Assertions.fail) SoftAssertionError(org.assertj.core.api.SoftAssertionError) SoftAssertions(org.assertj.core.api.SoftAssertions) Predicate(java.util.function.Predicate) Assertions.assertThat(org.assertj.core.api.Assertions.assertThat) Optional(java.util.Optional) Test(org.junit.Test) String.format(java.lang.String.format) SoftAssertions(org.assertj.core.api.SoftAssertions) SoftAssertionError(org.assertj.core.api.SoftAssertionError) Predicate(java.util.function.Predicate) Test(org.junit.Test)

Aggregations

SoftAssertionError (org.assertj.core.api.SoftAssertionError)5 Test (org.junit.Test)5 Predicate (java.util.function.Predicate)2 SoftAssertions (org.assertj.core.api.SoftAssertions)2 ByteArrayInputStream (java.io.ByteArrayInputStream)1 File (java.io.File)1 String.format (java.lang.String.format)1 URI (java.net.URI)1 URISyntaxException (java.net.URISyntaxException)1 Arrays.asList (java.util.Arrays.asList)1 List (java.util.List)1 Optional (java.util.Optional)1 OptionalDouble (java.util.OptionalDouble)1 OptionalLong (java.util.OptionalLong)1 DoublePredicate (java.util.function.DoublePredicate)1 IntPredicate (java.util.function.IntPredicate)1 LongPredicate (java.util.function.LongPredicate)1 Assertions.assertThat (org.assertj.core.api.Assertions.assertThat)1 Assertions.fail (org.assertj.core.api.Assertions.fail)1 AutoCloseableSoftAssertions (org.assertj.core.api.AutoCloseableSoftAssertions)1