How to use usingComparatorForElementFieldsWithType method of org.assertj.core.api.AtomicReferenceArrayAssert class

Best Assertj code snippet using org.assertj.core.api.AtomicReferenceArrayAssert.usingComparatorForElementFieldsWithType

Source:AtomicReferenceArrayAssert.java

...1483   * <li>{@link #usingRecursiveFieldByFieldElementComparator}</li>1484   * </ul>1485   * <p>1486   * Comparators specified by this method have precedence over comparators specified by1487   * {@link #usingComparatorForElementFieldsWithType(Comparator, Class) usingComparatorForElementFieldsWithType}.1488   * <p>1489   * Example:1490   * <p>1491   * <pre><code class='java'> public class TolkienCharacter {1492   *   private String name;1493   *   private double height;1494   *   // constructor omitted1495   * }1496   *1497   * TolkienCharacter frodo = new TolkienCharacter(&quot;Frodo&quot;, 1.2);1498   * TolkienCharacter tallerFrodo = new TolkienCharacter(&quot;Frodo&quot;, 1.3);1499   * TolkienCharacter reallyTallFrodo = new TolkienCharacter(&quot;Frodo&quot;, 1.9);1500   *1501   * Comparator&lt;Double&gt; closeEnough = new Comparator&lt;Double&gt;() {1502   *   double precision = 0.5;1503   *   public int compare(Double d1, Double d2) {1504   *     return Math.abs(d1 - d2) &lt;= precision ? 0 : 1;1505   *   }1506   * };1507   *1508   * AtomicReferenceArray&lt;TolkienCharacter&gt; hobbits = new AtomicReferenceArray&lt;&gt;(new TolkienCharacter[]{frodo});1509   *1510   * // assertions will pass1511   * assertThat(hobbits).usingComparatorForElementFieldsWithNames(closeEnough, &quot;height&quot;)1512   *                    .usingFieldByFieldElementComparator()1513   *                    .contains(tallerFrodo);1514   *1515   * assertThat(hobbits).usingComparatorForElementFieldsWithNames(closeEnough, &quot;height&quot;)1516   *                    .usingElementComparatorOnFields(&quot;height&quot;)1517   *                    .contains(tallerFrodo);1518   *1519   * assertThat(hobbits).usingComparatorForElementFieldsWithNames(closeEnough, &quot;height&quot;)1520   *                    .usingElementComparatorIgnoringFields(&quot;name&quot;)1521   *                    .contains(tallerFrodo);1522   *1523   * assertThat(hobbits).usingComparatorForElementFieldsWithNames(closeEnough, &quot;height&quot;)1524   *                    .usingRecursiveFieldByFieldElementComparator()1525   *                    .contains(tallerFrodo);1526   *1527   * // assertion will fail1528   * assertThat(hobbits).usingComparatorForElementFieldsWithNames(closeEnough, &quot;height&quot;)1529   *                    .usingFieldByFieldElementComparator()1530   *                    .containsExactly(reallyTallFrodo);</code></pre>1531   *1532   * @param comparator the {@link java.util.Comparator} to use1533   * @param elementPropertyOrFieldNames the names of the properties and/or fields of the elements the comparator should be used for1534   * @return {@code this} assertions object1535   * @since 2.7.0 / 3.7.01536   */1537  @CheckReturnValue1538  public <C> AtomicReferenceArrayAssert<T> usingComparatorForElementFieldsWithNames(Comparator<C> comparator,1539                                                        String... elementPropertyOrFieldNames) {1540    for (String elementPropertyOrField : elementPropertyOrFieldNames) {1541      comparatorsForElementPropertyOrFieldNames.put(elementPropertyOrField, comparator);1542    }1543    return myself;1544  }1545  /**1546   * Allows to set a specific comparator to compare properties or fields of elements with the given type.1547   * A typical usage is for comparing fields of numeric type at a given precision.1548   * <p>1549   * To be used, comparators need to be specified by this method <b>before</b> calling any of:1550   * <ul>1551   * <li>{@link #usingFieldByFieldElementComparator}</li>1552   * <li>{@link #usingElementComparatorOnFields}</li>1553   * <li>{@link #usingElementComparatorIgnoringFields}</li>1554   * <li>{@link #usingRecursiveFieldByFieldElementComparator}</li>1555   * </ul>1556   * <p>1557   * Comparators specified by {@link #usingComparatorForElementFieldsWithNames(Comparator, String...) usingComparatorForElementFieldsWithNames}1558   * have precedence over comparators specified by this method.1559   * <p>1560   * Example:1561   * <pre><code class='java'> public class TolkienCharacter {1562   *   private String name;1563   *   private double height;1564   *   // constructor omitted1565   * }1566   * TolkienCharacter frodo = new TolkienCharacter(&quot;Frodo&quot;, 1.2);1567   * TolkienCharacter tallerFrodo = new TolkienCharacter(&quot;Frodo&quot;, 1.3);1568   * TolkienCharacter reallyTallFrodo = new TolkienCharacter(&quot;Frodo&quot;, 1.9);1569   *1570   * Comparator&lt;Double&gt; closeEnough = new Comparator&lt;Double&gt;() {1571   *   double precision = 0.5;1572   *   public int compare(Double d1, Double d2) {1573   *     return Math.abs(d1 - d2) &lt;= precision ? 0 : 1;1574   *   }1575   * };1576   *1577   * AtomicReferenceArray&lt;TolkienCharacter&gt; hobbits = new AtomicReferenceArray&lt;&gt;(new TolkienCharacter[]{frodo});1578   *1579   * // assertions will pass1580   * assertThat(hobbits).usingComparatorForElementFieldsWithType(closeEnough, Double.class)1581   *                    .usingFieldByFieldElementComparator()1582   *                    .contains(tallerFrodo);1583   *1584   * assertThat(hobbits).usingComparatorForElementFieldsWithType(closeEnough, Double.class)1585   *                    .usingElementComparatorOnFields(&quot;height&quot;)1586   *                    .contains(tallerFrodo);1587   *1588   * assertThat(hobbits).usingComparatorForElementFieldsWithType(closeEnough, Double.class)1589   *                    .usingElementComparatorIgnoringFields(&quot;name&quot;)1590   *                    .contains(tallerFrodo);1591   *1592   * assertThat(hobbits).usingComparatorForElementFieldsWithType(closeEnough, Double.class)1593   *                    .usingRecursiveFieldByFieldElementComparator()1594   *                    .contains(tallerFrodo);1595   *1596   * // assertion will fail1597   * assertThat(hobbits).usingComparatorForElementFieldsWithType(closeEnough, Double.class)1598   *                    .usingFieldByFieldElementComparator()1599   *                    .contains(reallyTallFrodo);</code></pre>1600   *1601   * If multiple compatible comparators have been registered for a given {@code type}, the closest in the inheritance 1602   * chain to the given {@code type} is chosen in the following order:1603   * <ol>1604   * <li>The comparator for the exact given {@code type}</li>1605   * <li>The comparator of a superclass of the given {@code type}</li>1606   * <li>The comparator of an interface implemented by the given {@code type}</li>1607   * </ol>1608   *1609   * @param comparator the {@link java.util.Comparator} to use1610   * @param type the {@link java.lang.Class} of the type of the element fields the comparator should be used for1611   * @return {@code this} assertions object1612   * @since 2.7.0 / 3.7.01613   */1614  @CheckReturnValue1615  public <C> AtomicReferenceArrayAssert<T> usingComparatorForElementFieldsWithType(Comparator<C> comparator, Class<C> type) {1616    comparatorsForElementPropertyOrFieldTypes.put(type, comparator);1617    return myself;1618  }1619  /**1620   * Allows to set a specific comparator for the given type of elements or their fields.1621   * Extends {@link #usingComparatorForElementFieldsWithType} by applying comparator specified for given type1622   * to elements themselves, not only to their fields.1623   * <p>1624   * Usage of this method affects comparators set by next methods:1625   * <ul>1626   * <li>{@link #usingFieldByFieldElementComparator}</li>1627   * <li>{@link #usingElementComparatorOnFields}</li>1628   * <li>{@link #usingElementComparatorIgnoringFields}</li>1629   * <li>{@link #usingRecursiveFieldByFieldElementComparator}</li>1630   * </ul>1631   * <p>1632   * Example:1633   * <pre><code class='java'> // assertion will pass1634   * assertThat(new AtomicReferenceArray<>(new Object[] { "some", new BigDecimal("4.2") }))1635   *       .usingComparatorForType(BIG_DECIMAL_COMPARATOR, BigDecimal.class)1636   *       .contains(new BigDecimal("4.20"));1637   * </code></pre>1638   * </p>1639   *1640   * @param comparator the {@link java.util.Comparator} to use1641   * @param type the {@link java.lang.Class} of the type of the element or element fields the comparator should be used for1642   * @return {@code this} assertions object1643   * @since 2.9.0 / 3.9.01644   */1645  @CheckReturnValue1646  public <C> AtomicReferenceArrayAssert<T> usingComparatorForType(Comparator<C> comparator, Class<C> type) {1647    if (arrays.getComparator() == null) {1648      usingElementComparator(new ExtendedByTypesComparator(comparatorsByType));1649    }1650    comparatorsForElementPropertyOrFieldTypes.put(type, comparator);1651    comparatorsByType.put(type, comparator);1652    return myself;1653  }1654  /**1655   * Use field/property by field/property comparison (including inherited fields/properties) instead of relying on1656   * actual type A <code>equals</code> method to compare AtomicReferenceArray elements for incoming assertion checks. Private fields1657   * are included but this can be disabled using {@link Assertions#setAllowExtractingPrivateFields(boolean)}.1658   * <p>1659   * This can be handy if <code>equals</code> method of the objects to compare does not suit you.1660   * <p>1661   * You can specify a custom comparator per name or type of element field with1662   * {@link #usingComparatorForElementFieldsWithNames(Comparator, String...)}1663   * and {@link #usingComparatorForElementFieldsWithType(Comparator, Class)}.1664   * <p>1665   * Note that the comparison is <b>not</b> recursive, if one of the fields/properties is an Object, it will be compared1666   * to the other field/property using its <code>equals</code> method.1667   * </p>1668   * Example:1669   * <pre><code class='java'> TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);1670   * TolkienCharacter frodoClone = new TolkienCharacter("Frodo", 33, HOBBIT);1671   *1672   * // Fail if equals has not been overridden in TolkienCharacter as equals default implementation only compares references1673   * assertThat(atomicArray(frodo)).contains(frodoClone);1674   *1675   * // frodo and frodoClone are equals when doing a field by field comparison.1676   * assertThat(atomicArray(frodo)).usingFieldByFieldElementComparator().contains(frodoClone);</code></pre>1677   *1678   * @return {@code this} assertion object.1679   * @since 2.7.0 / 3.7.01680   */1681  @CheckReturnValue1682  public AtomicReferenceArrayAssert<T> usingFieldByFieldElementComparator() {1683    return usingExtendedByTypesElementComparator(new FieldByFieldComparator(comparatorsForElementPropertyOrFieldNames,1684                                                             comparatorsForElementPropertyOrFieldTypes));1685  }1686  /**1687   * Use a recursive field/property by field/property comparison (including inherited fields/properties)1688   * instead of relying on actual type A <code>equals</code> method to compare AtomicReferenceArray elements for incoming1689   * assertion checks. This can be useful if actual's {@code equals} implementation does not suit you.1690   * <p>1691   * The recursive property/field comparison is <b>not</b> applied on fields having a custom {@code equals}1692   * implementation, i.e. the overridden {@code equals} method will be used instead of a field/property by field/property comparison.1693   * <p>1694   * You can specify a custom comparator per (nested) name or type of element field with1695   * {@link #usingComparatorForElementFieldsWithNames(Comparator, String...) usingComparatorForElementFieldsWithNames}1696   * and {@link #usingComparatorForElementFieldsWithType(Comparator, Class) usingComparatorForElementFieldsWithType}.1697   * <p>1698   * The recursive comparison handles cycles.1699   * <p>1700   * The objects to compare can be of different types but must have the same properties/fields. For example if actual object has a1701   * {@code name} String field, the other object must also have one.1702   * <p>1703   * If an object has a field and a property with the same name, the property value will be used over the field.1704   * <p>1705   * Example:1706   *1707   * <pre><code class='java'> TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);1708   * TolkienCharacter pippin = new TolkienCharacter("Pippin", 28, HOBBIT);1709   * frodo.setFriend(pippin);1710   * pippin.setFriend(frodo);1711   *1712   * TolkienCharacter frodoClone = new TolkienCharacter("Frodo", 33, HOBBIT);1713   * TolkienCharacter pippinClone = new TolkienCharacter("Pippin", 28, HOBBIT);1714   * frodoClone.setFriend(pippinClone);1715   * pippinClone.setFriend(frodoClone);1716   *1717   * AtomicReferenceArray&lt;TolkienCharacter&gt; hobbits = new AtomicReferenceArray&lt;&gt;(new TolkienCharacter[] {frodo, pippin});1718   *1719   * // fails if equals has not been overridden in TolkienCharacter as it would compares object references1720   * assertThat(hobbits).contains(frodoClone, pippinClone);1721   *1722   * // frodo/frodoClone and pippin/pippinClone are equals when doing a recursive property/field by property/field comparison1723   * assertThat(hobbits).usingRecursiveFieldByFieldElementComparator()1724   *                    .contains(frodoClone, pippinClone);</code></pre>1725   *1726   * @return {@code this} assertion object.1727   * @since 2.7.0 / 3.7.01728   */1729  @CheckReturnValue1730  public AtomicReferenceArrayAssert<T> usingRecursiveFieldByFieldElementComparator() {1731    return usingExtendedByTypesElementComparator(new RecursiveFieldByFieldComparator(comparatorsForElementPropertyOrFieldNames,1732                                                                      comparatorsForElementPropertyOrFieldTypes));1733  }1734  /**1735   * Use field/property by field/property comparison on the <b>given fields/properties only</b> (including inherited1736   * fields/properties) instead of relying on actual type A <code>equals</code> method to compare AtomicReferenceArray elements for1737   * incoming assertion checks. Private fields are included but this can be disabled using1738   * {@link Assertions#setAllowExtractingPrivateFields(boolean)}.1739   * <p>1740   * This can be handy if <code>equals</code> method of the objects to compare does not suit you.1741   * <p>1742   * You can specify a custom comparator per name or type of element field with1743   * {@link #usingComparatorForElementFieldsWithNames(Comparator, String...)}1744   * and {@link #usingComparatorForElementFieldsWithType(Comparator, Class)}.1745   * <p>1746   * Note that the comparison is <b>not</b> recursive, if one of the fields/properties is an Object, it will be compared1747   * to the other field/property using its <code>equals</code> method.1748   * </p>1749   * Example:1750   * <pre><code class='java'> TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);1751   * TolkienCharacter sam = new TolkienCharacter("Sam", 38, HOBBIT);1752   *1753   * // frodo and sam both are hobbits, so they are equals when comparing only race1754   * assertThat(atomicArray(frodo)).usingElementComparatorOnFields("race").contains(sam); // OK1755   *1756   * // ... but not when comparing both name and race1757   * assertThat(atomicArray(frodo)).usingElementComparatorOnFields("name", "race").contains(sam); // FAIL</code></pre>1758   *1759   * @return {@code this} assertion object.1760   * @since 2.7.0 / 3.7.01761   */1762  @CheckReturnValue1763  public AtomicReferenceArrayAssert<T> usingElementComparatorOnFields(String... fields) {1764    return usingExtendedByTypesElementComparator(new OnFieldsComparator(comparatorsForElementPropertyOrFieldNames,1765                                                         comparatorsForElementPropertyOrFieldTypes, fields));1766  }1767  /**1768   * Use field/property by field/property on all fields/properties <b>except</b> the given ones (including inherited1769   * fields/properties) instead of relying on actual type A <code>equals</code> method to compare AtomicReferenceArray elements for1770   * incoming assertion checks. Private fields are included but this can be disabled using1771   * {@link Assertions#setAllowExtractingPrivateFields(boolean)}.1772   * <p>1773   * This can be handy if <code>equals</code> method of the objects to compare does not suit you.1774   * <p>1775   * You can specify a custom comparator per name or type of element field with1776   * {@link #usingComparatorForElementFieldsWithNames(Comparator, String...)}1777   * and {@link #usingComparatorForElementFieldsWithType(Comparator, Class)}.1778   * <p>1779   * Note that the comparison is <b>not</b> recursive, if one of the fields/properties is an Object, it will be compared1780   * to the other field/property using its <code>equals</code> method.1781   * </p>1782   * Example:1783   * <pre><code class='java'> TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);1784   * TolkienCharacter sam = new TolkienCharacter("Sam", 38, HOBBIT);1785   *1786   * // frodo and sam both are hobbits, so they are equals when comparing only race (i.e. ignoring all other fields)1787   * assertThat(atomicArray(frodo)).usingElementComparatorIgnoringFields("name", "age").contains(sam); // OK1788   *1789   * // ... but not when comparing both name and race1790   * assertThat(atomicArray(frodo)).usingElementComparatorIgnoringFields("age").contains(sam); // FAIL</code></pre>1791   *...

Source:AtomicReferenceArrayAssert_usingElementComparatorIgnoringFields_Test.java

...57    Comparator<String> comparator = (o1, o2) -> o1.compareTo(o2);58    Jedi actual = new Jedi("Yoda", "green");59    Jedi other = new Jedi("Luke", "green");60    assertThat(atomicArrayOf(actual)).usingComparatorForElementFieldsWithNames(ALWAY_EQUALS_STRING, "name")61                                     .usingComparatorForElementFieldsWithType(comparator, String.class)62                                     .usingElementComparatorIgnoringFields("lightSaberColor")63                                     .contains(other);64  }65  @Test66  public void should_be_able_to_use_a_comparator_for_element_fields_with_specified_type_using_element_comparator_ignoring_fields() {67    Jedi actual = new Jedi("Yoda", "green");68    Jedi other = new Jedi("Luke", "blue");69    assertThat(atomicArrayOf(actual)).usingComparatorForElementFieldsWithType(ALWAY_EQUALS_STRING, String.class)70                                     .usingElementComparatorIgnoringFields("name")71                                     .contains(other);72  }73}...

Source:AtomicReferenceArrayAssert_usingElementComparatorOnFields_Test.java

...56    Comparator<String> comparator = (o1, o2) -> o1.compareTo(o2);57    Jedi actual = new Jedi("Yoda", "green");58    Jedi other = new Jedi("Luke", "green");59    assertThat(atomicArrayOf(actual)).usingComparatorForElementFieldsWithNames(ALWAY_EQUALS_STRING, "name")60                                     .usingComparatorForElementFieldsWithType(comparator, String.class)61                                     .usingElementComparatorOnFields("name", "lightSaberColor")62                                     .contains(other);63  }64  @Test65  public void should_be_able_to_use_a_comparator_for_element_fields_with_specified_type_using_element_comparator_on_fields() {66    Jedi actual = new Jedi("Yoda", "green");67    Jedi other = new Jedi("Luke", "blue");68    assertThat(atomicArrayOf(actual)).usingComparatorForElementFieldsWithType(ALWAY_EQUALS_STRING, String.class)69                                     .usingElementComparatorOnFields("name", "lightSaberColor")70                                     .contains(other);71  }72}...