public void testOrderedVsUnordered() {
        class NumberHolder {
            private final Number number;

            NumberHolder(final Number number) {
                this.number = number;
            }

            public Number getNumber() {
                return number;
            }

            @Override
            public String toString() {
                return number.toString();
            }
        }

        class Foo {
            private final Collection<NumberHolder> holders;

            Foo(Collection<NumberHolder> holders) {
                this.holders = holders;
            }

            Collection<NumberHolder> getOrderedNumberHolders() {
                return holders;
            }
        }

        final RecursiveComparisonConfiguration ignoreDouble =
                RecursiveComparisonConfiguration.builder().withIgnoredFieldsOfTypes(NumberHolder.class).build();
        final Number intValue = Integer.valueOf(12);
        final Double doubleValueA = Double.valueOf(12.34);
        final Double doubleValueB = Double.valueOf(56.78);
        final List<NumberHolder> holdersA = asList(new NumberHolder(intValue), new NumberHolder(doubleValueA));
        final List<NumberHolder> holdersB= asList(new NumberHolder(intValue), new NumberHolder(doubleValueB));

        // Pass
        assertThat(new Foo(List.copyOf(holdersA))).usingRecursiveComparison(ignoreDouble)
                                                  .isEqualTo(new Foo(List.copyOf(holdersB)));

        // Fail, NumberHolder is not ignored
        assertThat(new Foo(Set.copyOf(holdersA))).usingRecursiveComparison(ignoreDouble)
                                                 .isEqualTo(new Foo(Set.copyOf(holdersB)));
    }

        final RecursiveComparisonConfiguration ignoreDouble =
                RecursiveComparisonConfiguration.builder().withEqualsForType((c1, c2) -> true, NumberHolder.class)
                                                .build();