diff --git a/assertions-examples/src/test/java/org/assertj/examples/ArrayAssertionsExamples.java b/assertions-examples/src/test/java/org/assertj/examples/ArrayAssertionsExamples.java index 25e6196..29a9369 100644 --- a/assertions-examples/src/test/java/org/assertj/examples/ArrayAssertionsExamples.java +++ b/assertions-examples/src/test/java/org/assertj/examples/ArrayAssertionsExamples.java @@ -65,18 +65,21 @@ public void array_assertions_examples() { Movie[] trilogy = array(theFellowshipOfTheRing, theTwoTowers, theReturnOfTheKing); assertThat(elvesRings).isNotEmpty().hasSize(3); - assertThat(elvesRings).hasSameSizeAs(trilogy); - assertThat(elvesRings).hasSameSizeAs(newArrayList(trilogy)); + assertThat(elvesRings) + .hasSameSizeAs(trilogy) + .hasSameSizeAs(newArrayList(trilogy)); assertThat(elvesRings).contains(nenya).doesNotContain(oneRing); - assertThat(elvesRings).containsExactly(vilya, nenya, narya); - assertThat(elvesRings).containsExactlyElementsOf(newArrayList(vilya, nenya, narya)); + assertThat(elvesRings) + .containsExactly(vilya, nenya, narya) + .containsExactlyElementsOf(newArrayList(vilya, nenya, narya)); // you can check element at a given index (we use Index.atIndex(int) synthetic sugar for better readability). assertThat(elvesRings).contains(vilya, atIndex(0)).contains(nenya, atIndex(1)).contains(narya, atIndex(2)); // with containsOnly, all the elements must be present (but the order is not important) - assertThat(elvesRings).containsOnly(nenya, vilya, narya); - assertThat(elvesRings).containsOnlyElementsOf(newArrayList(nenya, vilya, narya)); - assertThat(elvesRings).hasSameElementsAs(newArrayList(nenya, vilya, narya)); + assertThat(elvesRings) + .containsOnly(nenya, vilya, narya) + .containsOnlyElementsOf(newArrayList(nenya, vilya, narya)) + .hasSameElementsAs(newArrayList(nenya, vilya, narya)); assertThat(elvesRings).doesNotContainNull().doesNotHaveDuplicates(); assertThat(elvesRings).doesNotContainAnyElementsOf(newArrayList(oneRing, manRing, dwarfRing)); // special check for null, empty collection or both @@ -371,8 +374,9 @@ public void iterable_assertions_on_extracted_private_fields_values_example() { @Test public void array_assertions_testing_elements_type() throws Exception { Number[] numbers = { 2, 6L, 8.0 }; - assertThat(numbers).hasAtLeastOneElementOfType(Long.class); - assertThat(numbers).hasOnlyElementsOfType(Number.class); + assertThat(numbers) + .hasAtLeastOneElementOfType(Long.class) + .hasOnlyElementsOfType(Number.class); } @Test diff --git a/assertions-examples/src/test/java/org/assertj/examples/BasicAssertionsExamples.java b/assertions-examples/src/test/java/org/assertj/examples/BasicAssertionsExamples.java index cbbfd74..b509ede 100644 --- a/assertions-examples/src/test/java/org/assertj/examples/BasicAssertionsExamples.java +++ b/assertions-examples/src/test/java/org/assertj/examples/BasicAssertionsExamples.java @@ -116,8 +116,9 @@ public void isSame_isNotSame_assertions_examples() { @Test public void isIn_isNotIn_assertions_examples() { - assertThat(frodo).isIn(fellowshipOfTheRing); - assertThat(frodo).isIn(sam, frodo, pippin); + assertThat(frodo) + .isIn(fellowshipOfTheRing) + .isIn(sam, frodo, pippin); assertThat((TolkienCharacter) null).isIn(sam, frodo, pippin, null); assertThat(sauron).isNotIn(fellowshipOfTheRing); assertThat((TolkienCharacter) null).isNotIn(fellowshipOfTheRing); @@ -213,12 +214,13 @@ public void should_be_able_to_extract_primitive_values() { @Test public void has_field_or_property_examples() { assertThat(frodo).hasFieldOrProperty("age"); - // private field are found unless Assertions.setAllowExtractingPrivateFields(false); + // private field is found unless Assertions.setAllowExtractingPrivateFields(false); assertThat(frodo).hasFieldOrProperty("notAccessibleField"); - assertThat(frodo).hasFieldOrPropertyWithValue("age", 33); - assertThat(frodo).hasFieldOrProperty("race.name"); - assertThat(frodo).hasOnlyFields("age", "race", "name", "notAccessibleField"); - assertThat(frodo).hasFieldOrPropertyWithValue("race.name", "Hobbit"); + assertThat(frodo) + .hasFieldOrPropertyWithValue("age", 33) + .hasFieldOrProperty("race.name") + .hasOnlyFields("age", "race", "name", "notAccessibleField") + .hasFieldOrPropertyWithValue("race.name", "Hobbit"); } @Test diff --git a/assertions-examples/src/test/java/org/assertj/examples/IterableAssertionsExamples.java b/assertions-examples/src/test/java/org/assertj/examples/IterableAssertionsExamples.java index f885527..df273ed 100644 --- a/assertions-examples/src/test/java/org/assertj/examples/IterableAssertionsExamples.java +++ b/assertions-examples/src/test/java/org/assertj/examples/IterableAssertionsExamples.java @@ -104,8 +104,9 @@ public void iterable_basic_assertions_examples() { .isSubsetOf(duplicatedElvesRings); try { - assertThat(elvesRings).isSubsetOf(list(vilya, nenya, vilya, oneRing)); - assertThat(elvesRings).containsOnly(nenya, vilya, oneRing); + assertThat(elvesRings) + .isSubsetOf(list(vilya, nenya, vilya, oneRing)) + .containsOnly(nenya, vilya, oneRing); } catch (AssertionError e) { logAssertionErrorMessage("containsOnly", e); } @@ -324,8 +325,9 @@ public void narrow_assertions_type_with_asInstanceOf_example() { @Test public void iterable_is_subset_of_assertion_example() { Collection elvesRings = list(vilya, nenya, narya); - assertThat(elvesRings).isSubsetOf(ringsOfPower); - assertThat(elvesRings).isSubsetOf(vilya, nenya, narya); + assertThat(elvesRings) + .isSubsetOf(ringsOfPower) + .isSubsetOf(vilya, nenya, narya); try { assertThat(elvesRings).isSubsetOf(list(nenya, narya)); } catch (AssertionError e) { @@ -442,26 +444,28 @@ public void iterable_assertion_match_example() { @Test public void iterable_satisfy_assertion_example() { List hobbits = list(frodo, sam, pippin); - assertThat(hobbits).allSatisfy(character -> { - assertThat(character.getRace()).isEqualTo(HOBBIT); - assertThat(character.getName()).isNotEqualTo("Sauron"); - }); - - assertThat(hobbits).anySatisfy(character -> { - assertThat(character.getRace()).isEqualTo(HOBBIT); - assertThat(character.age).isLessThan(30); - }); - - assertThat(hobbits).noneSatisfy(character -> assertThat(character.getRace()).isEqualTo(ELF)); + assertThat(hobbits) + .allSatisfy(character -> { + assertThat(character.getRace()).isEqualTo(HOBBIT); + assertThat(character.getName()).isNotEqualTo("Sauron"); + }) + .anySatisfy(character -> { + assertThat(character.getRace()).isEqualTo(HOBBIT); + assertThat(character.age).isLessThan(30); + }) + .noneSatisfy(character -> assertThat(character.getRace()).isEqualTo(ELF)); // order is important, so frodo must satisfy the first lambda requirements, sam the second and pippin the last - assertThat(hobbits).satisfiesExactly(character -> assertThat(character.getName()).isEqualTo("Frodo"), - character -> assertThat(character.getName()).isEqualTo("Sam"), - character -> assertThat(character.getName()).startsWith("Pip")) - // order is not but all requirements must be met - .satisfiesExactlyInAnyOrder(character -> assertThat(character.getName()).isEqualTo("Sam"), - character -> assertThat(character.getName()).startsWith("Pip"), - character -> assertThat(character.getName()).isEqualTo("Frodo")); + assertThat(hobbits) + .satisfiesExactly( + character -> assertThat(character.getName()).isEqualTo("Frodo"), + character -> assertThat(character.getName()).isEqualTo("Sam"), + character -> assertThat(character.getName()).startsWith("Pip")) + // order is not but all requirements must be met + .satisfiesExactlyInAnyOrder( + character -> assertThat(character.getName()).isEqualTo("Sam"), + character -> assertThat(character.getName()).startsWith("Pip"), + character -> assertThat(character.getName()).isEqualTo("Frodo")); } @Test @@ -599,12 +603,14 @@ public void iterable_assertions_on_flat_extracted_values_examples() throws Excep public void iterable_assertions_testing_elements_type() throws Exception { List numbers = list(1L, 2L); - assertThat(numbers).hasOnlyElementsOfType(Number.class); - assertThat(numbers).hasOnlyElementsOfType(Long.class); + assertThat(numbers) + .hasOnlyElementsOfType(Number.class) + .hasOnlyElementsOfType(Long.class); List mixed = list("string", 1L); - assertThat(mixed).hasAtLeastOneElementOfType(String.class); - assertThat(mixed).hasOnlyElementsOfTypes(Long.class, String.class); + assertThat(mixed) + .hasAtLeastOneElementOfType(String.class) + .hasOnlyElementsOfTypes(Long.class, String.class); } @Test @@ -769,9 +775,10 @@ public void zipStatisfy_example() { public void should_not_produce_warning_for_varargs_parameter() { List> list = new ArrayList<>(); list.add(Pair.of("A", "B")); - assertThat(list).containsAnyOf(Pair.of("A", "B"), Pair.of("C", "D")); - assertThat(list).containsExactly(Pair.of("A", "B")); - assertThat(list).contains(Pair.of("A", "B")); + assertThat(list) + .containsAnyOf(Pair.of("A", "B"), Pair.of("C", "D")) + .containsExactly(Pair.of("A", "B")) + .contains(Pair.of("A", "B")); } @Test diff --git a/assertions-examples/src/test/java/org/assertj/examples/MapAssertionsExamples.java b/assertions-examples/src/test/java/org/assertj/examples/MapAssertionsExamples.java index 0e45804..9a2190f 100644 --- a/assertions-examples/src/test/java/org/assertj/examples/MapAssertionsExamples.java +++ b/assertions-examples/src/test/java/org/assertj/examples/MapAssertionsExamples.java @@ -63,15 +63,17 @@ public void map_assertions_examples() { assertThat(ringBearers).isNotEmpty().hasSize(4); // note the usage of Assertions.entry(key, value) synthetic sugar for better readability (similar to - // MapEntry.entry(key, value)). - assertThat(ringBearers).contains(entry(oneRing, frodo), entry(nenya, galadriel)); - // using java util Map.Entry - assertThat(ringBearers).contains(javaMapEntry(oneRing, frodo), javaMapEntry(nenya, galadriel)); + assertThat(ringBearers) + // MapEntry.entry(key, value)). + .contains(entry(oneRing, frodo), entry(nenya, galadriel)) + // using java util Map.Entry + .contains(javaMapEntry(oneRing, frodo), javaMapEntry(nenya, galadriel)); // same assertion but different way of expressing it : no entry call needed but no varargs support. assertThat(ringBearers).containsEntry(oneRing, frodo).containsEntry(nenya, galadriel); // opposite of contains/containsEntry - assertThat(ringBearers).doesNotContain(entry(oneRing, sauron), entry(nenya, aragorn)); - assertThat(ringBearers).doesNotContainEntry(oneRing, aragorn); + assertThat(ringBearers) + .doesNotContain(entry(oneRing, sauron), entry(nenya, aragorn)) + .doesNotContainEntry(oneRing, aragorn); Map ringBearersInDifferentOrder = new LinkedHashMap<>(); ringBearersInDifferentOrder.put(Ring.oneRing, frodo); @@ -81,12 +83,13 @@ public void map_assertions_examples() { assertThat(ringBearers).containsExactlyInAnyOrderEntriesOf(ringBearersInDifferentOrder); // Assertion on key - assertThat(ringBearers).containsKey(nenya); - assertThat(ringBearers).containsKeys(nenya, narya); - assertThat(ringBearers).containsValues(frodo, galadriel); - assertThat(ringBearers).containsOnlyKeys(nenya, narya, vilya, oneRing); - assertThat(ringBearers).doesNotContainKey(manRing); - assertThat(ringBearers).doesNotContainKeys(manRing, dwarfRing); + assertThat(ringBearers) + .containsKey(nenya) + .containsKeys(nenya, narya) + .containsValues(frodo, galadriel) + .containsOnlyKeys(nenya, narya, vilya, oneRing) + .doesNotContainKey(manRing) + .doesNotContainKeys(manRing, dwarfRing); try { assertThat(ringBearers).containsOnlyKeys(nenya, narya, dwarfRing); @@ -95,13 +98,14 @@ public void map_assertions_examples() { } // Assertion on value - assertThat(ringBearers).containsValue(frodo); - assertThat(ringBearers).doesNotContainValue(sam); - - assertThat(ringBearers).hasSameSizeAs(ringBearers); + assertThat(ringBearers) + .containsValue(frodo) + .doesNotContainValue(sam) + .hasSameSizeAs(ringBearers); ringBearers.clear(); - assertThat(ringBearers).contains(); - assertThat(ringBearers).containsAllEntriesOf(ringBearers); + assertThat(ringBearers) + .contains() + .containsAllEntriesOf(ringBearers); } @Test @@ -222,10 +226,11 @@ public void map_with_condition_examples() { ringBearers.put(frodo, oneRing); ringBearers.put(isildur, oneRing); - assertThat(ringBearers).hasEntrySatisfying(oneRingManBearer); - assertThat(ringBearers).hasEntrySatisfying(isMan, oneRingBearer); - assertThat(ringBearers).hasKeySatisfying(isMan); - assertThat(ringBearers).hasValueSatisfying(oneRingBearer); + assertThat(ringBearers) + .hasEntrySatisfying(oneRingManBearer) + .hasEntrySatisfying(isMan, oneRingBearer) + .hasKeySatisfying(isMan) + .hasValueSatisfying(oneRingBearer); } @Test