Question

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

我想检查列表中的下一个值（日期）是否低于上一个值。我能够使用一些for和添加临时列表来做到这一点，但我想知道是否有更简单的解决方案。我在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;
      }
    };
  }

此示例适用于Integer，但您可以轻松地使用Date。

[第二个选项] ，基于OP问题中对contains的引用：您可以创建第二个列表，排序原始列表，而不是使用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

有一个open request for such a matcher，但不幸的是它还没有实现。

我会选择更简单的方法 - 复制列表，对其进行排序，并与原始列表进行比较：

@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));

此处提供更多信息：How to determine if a List is sorted in Java?

Answer 4

对于小型集合，我建议在代码中提供硬编码的预期集合。这是单元测试，不应包含任何逻辑。之后，您可以比较两个集合。（使用hamcrest检查等效物）

Answer 5

我遇到了类似的问题，我只是检查下一个以毫秒为单位的日期值是否大于/小于该列表中的前一个日期值。

/**
 * Test sort by date
 */
@Test
public void findAllMessagesSortByDate() {
    Collection<Message> messages = messageService.getAllMessagesSortedByDate();
    long previousTime = messages.iterator().next().getDate().getTimeInMillis();
    for (Message message : messages) {
        assertTrue(message.getDate.getTimeInMillis() <= previousTime);
        previousTime = message.getMessageFolderTs().getTimeInMillis();
    }
}

Answer 6

您可以在其他主题中查看我的答案，但方法保持不变 - 您应该检查项目是否按预期顺序。

How to check if collection contains items in given order using Hamcrest

这种方法需要＆＃39; Hamcrest＆＃39;要使用的库。

希望这有帮助。

Answer 7

您可以使用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()));
}

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

7 个答案: