assertThat - hamcrest - 检查列表是否已排序

Question

好的,我认为这将是一个简短的问题.我有一个按日期排序的ArrayList,当然我看到它有效,但我也想为它编写一个测试.

我想检查列表中的下一个值(日期)是否低于上一个值.我能够使用一些fors并添加临时列表来做到这一点,但我想知道是否有更简单的解决方案.我在hamrest文档中读到,有一些contains想法(hamrest contains)迭代一个对象(列表,地图等),但我仍然不知道下一步该做什么.

Answer 1

[第一选项]:您可以编写自己的匹配器.像(免责声明:这只是一个示例代码,它没有经过测试,可能并不完美):

@Test
  public void theArrayIsInDescendingOrder() throws Exception
  {
    List<Integer> orderedList = new ArrayList<Integer>();
    orderedList.add(10);
    orderedList.add(5);
    orderedList.add(1);
    assertThat(orderedList, isInDescendingOrdering());
  }

  private Matcher<? super List<Integer>> isInDescendingOrdering()
  {
    return new TypeSafeMatcher<List<Integer>>()
    {
      @Override
      public void describeTo (Description description)
      {
        description.appendText("describe the error has you like more");
      }

      @Override
      protected boolean matchesSafely (List<Integer> item)
      {
        for(int i = 0 ; i < item.size() -1; i++) {
          if(item.get(i) <= item.get(i+1)) return false;
        }
        return true;
      }
    };
  }

这个例子是Integers,但你可以Date很容易地做到.

[第二个选项],基于containsOP问题中的引用:您可以创建第二个列表,订购原始列表,而不是使用assertThat(origin, contains(ordered)).这样就可以更精确地描述最终的错误,因为如果一个元素不是预期的顺序,那么就会指出它.例如,这段代码

@Test
  public void testName() throws Exception
  {
    List<Integer> actual = new ArrayList<Integer>();
    actual.add(1);
    actual.add(5);
    actual.add(3);
    List<Integer> expected = new ArrayList<Integer>(actual);
    Collections.sort(expected);
    assertThat(actual, contains(expected.toArray()));
  }

将生成描述

java.lang.AssertionError: 
Expected: iterable containing [<1>, <3>, <5>]
     but: item 1: was <5>
    at org.hamcrest.MatcherAssert.assertThat(MatcherAssert.java:20)
    at org.junit.Assert.assertThat(Assert.java:865)
    at org.junit.Assert.assertThat(Assert.java:832)
    ...

Answer 2

对这样的匹配器有一个开放的请求,但不幸的是它还没有实现.

我会选择更简单的东西 - 复制列表,对其进行排序,并与原始列表进行比较:

@Test
public void testListOrder() {
    ArrayList<SomeObject> original = ...;
    ArrayList<SomeObject> sorted = new ArrayList<SomeObject>(original);
    Collections.sort(sorted);
    Assert.assertEquals ("List is not sorted", sorted, original);
}

编辑:
@dsncode在评论中有一个很好的观点 - 虽然(相对)优雅,但这个解决方案并没有考虑任何性能.如果列表不是太大就应该没问题,但是如果列表很大,那么对它进行排序可能会很昂贵.如果列表很大,最好直接迭代它,如果遇到小于前一个元素的元素,则测试失败.例如:

assertTrue(() -> {
    Iterator<SomeClass> iter = list.iterator();

    SomeClass prev = null;
    if (iter.hasNext()) {
        prev = iter.next();
    }

    SomeClass curr = null;
    while (iter.hasNext()) {
        curr = iter.next();
        if (curr.compareTo(prev) < 0) {
            return false;
        }
        prev = curr;
    }

    return true;
});

Answer 3

还可以使用GUAVA进行检查:

import com.google.common.collect.Ordering;

...

assertTrue(Ordering.natural().isOrdered(list));

更多信息:如何确定List是否按Java排序？

Answer 4

您可以使用hamcrest-more-matchers（可在Maven Central上找到）。它有两种实用方法来验证排序集合：（softOrdered允许相等的顺序项）和strictOrdered（不允许相等的项）。使用示例：

import com.github.seregamorph.hamcrest.OrderMatchers.*;

@Test
public void softOrderedEqualShouldSuccess() {
    // success
    assertThat(Arrays.asList(1, 1, 2), softOrdered());
    // fails with diagnostics
    // java.lang.AssertionError: 
    // Expected: Strictly ordered by natural comparator
    //     but: Found equal elements 1 and 1
    assertThat(Arrays.asList(1, 1, 2), strictOrdered());
}

或者它可以嵌套：

@Test
public void nestedCollectionShouldMatchOrderedItem() {
    List<Iterable<Integer>> nested = Arrays.asList(
            Arrays.asList(3, 2, 1),
            Arrays.asList(1, 2, 3)
    );

    // success
    assertThat(nested, hasItem(strictOrdered()));
    // fails with diagnostics
    // java.lang.AssertionError:
    // Expected: every item is Softly ordered by natural comparator
    //     but: an item Found unordered elements 3 and 2
    assertThat(nested, everyItem(softOrdered()));
}

默认情况下使用自然比较器，但也可以自定义：

import static java.util.Comparator.comparing;

@Test
public void stringsShouldMatchOrderByLength() {
    List<String> list = Arrays.asList("abc", "ab", "a");

    assertThat(list, strictOrdered(comparing(String::length).reversed()));
}