Java 在assertj中使用ComparatorForType似乎不适用于作为对象属性的对象属性

我想测试两个对象的相等性，但对它们的某些嵌套属性上存在的

double

值的精度有一定的判断权。似乎是一个合适的解决方案，但如果我的

Foo

对象具有类型为

Bar

的属性，其中

Bar.baz

是一个

double

的对象，则它似乎不起作用，我希望对其应用此精度判断。没有完全解决我要测试的情况

一些示例代码

import static org.assertj.core.api.Assertions.assertThat;

import java.util.Comparator;
import java.util.Objects;

import org.junit.Test;

public class ComparatorForTypeTest {

  private static final Comparator<Double> DOUBLE_COMPARATOR = new Comparator<Double>() {
    @Override
    public int compare(Double d1, Double d2) {
      return Math.abs(d1 - d2) <= 0.1 ? 0 : 1;
    }
  };

  class Foo {
    private int id;
    private double baz;
    private Bar bar;

    public Foo(int id, double baz, Bar bar) {
      this.id = id;
      this.baz = baz;
      this.bar = bar;
    }

    public Foo withBar(Bar bar) {
      Foo that = this;
      that.bar = bar;
      return that;
    }

    @Override
    public int hashCode() {
      return Objects.hash(id, baz, bar);
    }

    @Override
    public boolean equals(Object obj) {
      if (this == obj) {
        return true;
      } else if (obj == null || obj.getClass() != Foo.class) {
        return false;
      }

      Foo that = (Foo) obj;
      return Objects.equals(this.id, that.id)
          && Objects.equals(this.baz, that.baz)
          && Objects.equals(this.bar, that.bar);
    }

    @Override
    public String toString() {
      return String.format("Foo[id=%d, score=%f, bar=%s]", id, baz, bar == null ? null : bar.toString());
    }
  }

  class Bar {
    private int id;
    private double baz;

    public Bar(int id, double baz) {
      this.id = id;
      this.baz = baz;
    }

    @Override
    public int hashCode() {
      return Objects.hash(id, baz);
    }

    @Override
    public boolean equals(Object obj) {
      if (this == obj) {
        return true;
      } else if (obj == null || obj.getClass() != Bar.class) {
        return false;
      }

      Bar that = (Bar) obj;
      return Objects.equals(this.id, that.id)
          && Objects.equals(this.baz, that.baz);
    }

    @Override
    public String toString() {
      return String.format("Bar[id=%d, score=%f]", id, baz);
    }
  }

  @Test
  public void itComparesBars() {
    Bar a = new Bar(1, 1.4);
    Bar b = new Bar(1, 1.45);
    Bar c = new Bar(2, 1.4);

    assertThat(a).isNotEqualTo(b);
    assertThat(b).isNotEqualTo(c);
    assertThat(a).isNotEqualTo(c);

    assertThat(a).usingComparatorForType(DOUBLE_COMPARATOR, Double.class).isEqualToComparingFieldByField(b);
  }

  @Test
  public void itComparesFoos() {
    Foo a = new Foo(1, 1.4, null);
    Foo b = new Foo(1, 1.45, null);
    Foo c = new Foo(2, 1.4, null);

    assertThat(a).isNotEqualTo(b);
    assertThat(b).isNotEqualTo(c);
    assertThat(a).isNotEqualTo(c);

    assertThat(a).usingComparatorForType(DOUBLE_COMPARATOR, Double.class).isEqualToComparingFieldByField(b);

    Bar barA = new Bar(1, 1.4);
    Bar barB = new Bar(1, 1.45);

    assertThat(a.withBar(barA)).usingComparatorForType(DOUBLE_COMPARATOR, Double.class).isEqualToComparingFieldByFieldRecursively(b.withBar(barA));
    assertThat(a.withBar(barA)).usingComparatorForType(DOUBLE_COMPARATOR, Double.class).isEqualToComparingFieldByFieldRecursively(b.withBar(barB));
  }
}

import static org.assertj.core.api.Assertions.assertThat；
导入java.util.Comparator；
导入java.util.Objects；
导入org.junit.Test；
类型测试的公共类比较器{
专用静态最终比较器双_比较器=新比较器（）{
@凌驾
公共整数比较（双d1，双d2）{
return Math.abs（d1-d2）这里的问题是
Bar
有一个重写的
equals
方法，用于比较
Bar
实例，这在中提到过（但我知道javadoc并不总是发现API的最佳方式）：

递归属性/字段比较不应用于具有自定义equals实现的字段，即将使用重写的equals方法，而不是逐字段比较

是一个修改递归比较api的工具，它将提供一个选项来强制递归比较，即使
equals
被重写（可能）。
更好地使用递归比较，它将一个字段一个字段地比较对象，默认情况下忽略任何重写的equals请参见-now