Java assertj双容器序列

在比较双精度序列时，如何为assertj指定双精度/浮点公差？这里，

items

是一个

列表

，

ScoredItem

有两个属性

itemId

和

score

assertThat(items).extracting("score").containsSequence(3.0, 2.0, 1.0, 0.35, 0.2);

这是在单元测试期间引发异常

java.lang.AssertionError: 
Expecting:
 <[3.0, 2.0000000298023224, 1.0, 0.3500000052154064, 0.20000000298023224]>
to contain sequence:
 <[3.0, 2.0, 1.0, 0.35, 0.2]>

---

…但是没有运气：（

因为这是从列表中提取的，所以在调用

containsSequence

之前，您必须使用

使用ComparatorForType

调用泛型方法（感谢谁更正了我的颠倒顺序）。然后您可以传入

DoubleComparator

assertThat(items)
   .extracting("score")
   .usingComparatorForType(new DoubleComparator(0.2), Double.class)
   .containsSequence(3.0, 2.0, 1.0, 0.35, 0.2);

如果

items

只是一个

double[]

，那么您只需要使用comparatorwithprecision调用方法

assertThat(items)
    .usingComparatorWithPrecision(0.5)
    .containsSequence(3.0, 2.0, 1.0, 0.35, 0.2);

assertThat(items).extracting("score")
    .containsSequence(new double[]{3.0, 2.0, 1.0, 0.35, 0.2}, withPrecision(0.5));

或者将第二行的
偏移量
替换为
精度

assertThat(items)
    .usingComparatorWithPrecision(0.5)
    .containsSequence(3.0, 2.0, 1.0, 0.35, 0.2);

assertThat(items).extracting("score")
    .containsSequence(new double[]{3.0, 2.0, 1.0, 0.35, 0.2}, withPrecision(0.5));

我已使用以下代码使用AssertJ 3.9.1对此进行了测试：

public class ScoredItem {
    public int itemId;
    public double score;

    public ScoredItem(int i, double s) {
        itemId = i;
        score = s;
    }

    public static void main(String[] args) {
        List<ScoredItem> items = new ArrayList<ScoredItem>();
        items.add(new ScoredItem(1,3.0));
        items.add(new ScoredItem(1,2.0));
        items.add(new ScoredItem(1,1.1));
        items.add(new ScoredItem(1,0.33));
        items.add(new ScoredItem(1,0.22));

        assertThat(items)
            .extracting("score")
            .usingComparatorForType(new DoubleComparator(0.2), Double.class)
            .containsSequence(3.0, 2.0, 1.0, 0.35, 0.2);

    }
}

公共类ScoredItem{
公共int itemId；
公众双倍得分；
公共计分表（整数i，双s）{
itemId=i；
得分=s；
}
公共静态void main（字符串[]args）{
列表项=新建ArrayList（）；
添加（新的ScoredItem（1,3.0））；
添加（新的ScoredItem（1,2.0））；
添加（新的ScoredItem（1,1.1））；
添加（新的ScoredItem（1,0.33））；
添加（新的ScoredItem（1,0.22））；
资产（项目）
.提取（“分数”）
.使用ComparatorForType（新的DoubleComparator（0.2），Double.class）
.容器顺序（3.0,2.0,1.0,0.35,0.2）；
}
}
由于这是从列表中提取的，因此在调用
containsSequence
之前，必须使用
usingComparatorForType
调用泛型方法（感谢谁更正了我的颠倒顺序）。然后您可以传入
双比较器

assertThat(items)
   .extracting("score")
   .usingComparatorForType(new DoubleComparator(0.2), Double.class)
   .containsSequence(3.0, 2.0, 1.0, 0.35, 0.2);

如果
items
只是一个
double[]
，那么您只需要使用comparatorwithprecision调用方法

assertThat(items)
    .usingComparatorWithPrecision(0.5)
    .containsSequence(3.0, 2.0, 1.0, 0.35, 0.2);

assertThat(items).extracting("score")
    .containsSequence(new double[]{3.0, 2.0, 1.0, 0.35, 0.2}, withPrecision(0.5));

或者将第二行的
偏移量
替换为
精度

assertThat(items)
    .usingComparatorWithPrecision(0.5)
    .containsSequence(3.0, 2.0, 1.0, 0.35, 0.2);

assertThat(items).extracting("score")
    .containsSequence(new double[]{3.0, 2.0, 1.0, 0.35, 0.2}, withPrecision(0.5));

我已使用以下代码使用AssertJ 3.9.1对此进行了测试：

public class ScoredItem {
    public int itemId;
    public double score;

    public ScoredItem(int i, double s) {
        itemId = i;
        score = s;
    }

    public static void main(String[] args) {
        List<ScoredItem> items = new ArrayList<ScoredItem>();
        items.add(new ScoredItem(1,3.0));
        items.add(new ScoredItem(1,2.0));
        items.add(new ScoredItem(1,1.1));
        items.add(new ScoredItem(1,0.33));
        items.add(new ScoredItem(1,0.22));

        assertThat(items)
            .extracting("score")
            .usingComparatorForType(new DoubleComparator(0.2), Double.class)
            .containsSequence(3.0, 2.0, 1.0, 0.35, 0.2);

    }
}

公共类ScoredItem{
公共int itemId；
公众双倍得分；
公共计分表（整数i，双s）{
itemId=i；
得分=s；
}
公共静态void main（字符串[]args）{
列表项=新建ArrayList（）；
添加（新的ScoredItem（1,3.0））；
添加（新的ScoredItem（1,2.0））；
添加（新的ScoredItem（1,1.1））；
添加（新的ScoredItem（1,0.33））；
添加（新的ScoredItem（1,0.22））；
资产（项目）
.提取（“分数”）
.使用ComparatorForType（新的DoubleComparator（0.2），Double.class）
.容器顺序（3.0,2.0,1.0,0.35,0.2）；
}
}
@Magdop是正确的（除了在断言后使用ComparatorWithPrecision调用
）

使用3.10.0，该测试通过：

@Test
public void containsSequence_with_precision() {
  // GIVEN
  double[] scores = { 3.0, 2.0000000298023224, 1.0, 0.3500000052154064, 0.20000000298023224 };
  // THEN
  assertThat(scores).containsSequence(new double[] { 3.0, 2.0, 1.0, 0.35, 0.2 }, withPrecision(0.01));
  assertThat(scores).usingComparatorWithPrecision(0.01).containsSequence(new double[] { 3.0, 2.0, 1.0, 0.35, 0.2 });
  assertThat(scores).usingComparatorWithPrecision(0.01).containsSequence(3.0, 2.0, 1.0, 0.35, 0.2);
  assertThat(scores).usingComparatorWithPrecision(0.0001).containsSequence(3.0, 2.0, 1.0, 0.35, 0.2);
  // fails as expected when uncommented
  // assertThat(scores).usingComparatorWithPrecision(0.0000000001).containsSequence(3.0, 2.0, 1.0, 0.35, 0.2);
}

在断言之前需要调用
usingComparatorWithPrecision
，否则AssertJ将不使用它

withPrecision
是偏移量的别名（IMHO可读性稍高）。
@Magdop是正确的（除了在断言后使用comparatorwithprecision调用
）

使用3.10.0，该测试通过：

@Test
public void containsSequence_with_precision() {
  // GIVEN
  double[] scores = { 3.0, 2.0000000298023224, 1.0, 0.3500000052154064, 0.20000000298023224 };
  // THEN
  assertThat(scores).containsSequence(new double[] { 3.0, 2.0, 1.0, 0.35, 0.2 }, withPrecision(0.01));
  assertThat(scores).usingComparatorWithPrecision(0.01).containsSequence(new double[] { 3.0, 2.0, 1.0, 0.35, 0.2 });
  assertThat(scores).usingComparatorWithPrecision(0.01).containsSequence(3.0, 2.0, 1.0, 0.35, 0.2);
  assertThat(scores).usingComparatorWithPrecision(0.0001).containsSequence(3.0, 2.0, 1.0, 0.35, 0.2);
  // fails as expected when uncommented
  // assertThat(scores).usingComparatorWithPrecision(0.0000000001).containsSequence(3.0, 2.0, 1.0, 0.35, 0.2);
}

在断言之前需要调用
usingComparatorWithPrecision
，否则AssertJ将不使用它

withPrecision
是偏移量的别名（IMHO可读性稍高）。
这两种方法对我都不起作用。首先，我没有看到使用ComparatorWithPrecision的
（assertj版本3.9.1）。第二个解决方案再次抱怨
期望：包含序列：
这两个都不适合我。对于第一个解决方案，我没有看到
使用ComparatorWithPrecision
（assertj版本3.9.1）。第二个解决方案再次抱怨
期望：包含序列：