Question

我正在用Java实现一个单链表。我创建了一个名为 reverseList 的方法，它反转了我的列表，例如：

头 - ＆gt; 1 - ＆gt; 2 - ＆gt; 3 - ＆gt;空
变为：
头 - ＆gt; 3 - ＆gt; 2 - ＆gt; 1 - ＆gt;空

我还创建了一个测试类（使用JUnit），它有一个名为 testReverseList 的方法，用于测试 reverseList 方法。 insert 方法获取数据以及要添加新节点的位置。所有这三种方法似乎都正常工作。

public String reverseList() {
    Node prev = null, current = head, next;
    StringBuilder checkList = new StringBuilder();
    while (current != null) {
        checkList.append(current.getData());
        next = current.getNext();
        current.setNext(prev);
        prev = current; 
        current = next;
    }
    head = prev;
    return checkList.toString(); 
}

@Test
public void testReverseList() {
    LinkedList myList = new LinkedList();
    myList.insert(1, 1);
    myList.insert(2, 2);
    myList.insert(3, 3);
    String normalListOrder = "123";
    assertEquals("Check reverseList, reversing a list with 3 elements.", normalListOrder, myList.reverseList());    
}

我的问题是：我不相信我正在通过使用这种方法附加我的节点的每个数据然后返回它来正确测试我的 reverseList 方法，因为我不真的检查它是否被颠倒了。此外，看起来需要更多的计算资源来完成所有这些工作。而且我认为只是在执行结束时返回一个真值就足够了。那么，我应该不测试它吗？有更好的方法进行测试吗？

答案：谢谢大家。我遵循了Pelocho建议并覆盖了 equals 方法并更改了我的 testReverseList 和 reverseList 方法。我还创建了 testEquals 方法来检查已实现的 equals 。看来这是我想要的最佳方法。所有测试都没问题。

public LinkedList reverseList() {
    Node prev = null, current = head, next;
    while (current != null) {
        next = current.getNext();
        current.setNext(prev);
        prev = current;
        current = next;
    }
    head = prev;
    return this;
}

public boolean equals(LinkedList myList) {
    if (myList == this) {
        return true;
    }
    if (!(myList.getListSize() == this.getListSize())) {
        return false;
    }
    // Starts at 1 because retrieveNode pick the position, not index
    for (int i = 1; i != this.getListSize(); i++) {
        if (myList.retrieveNode(i).getData() != this.retrieveNode(i).getData()) {
            return false;
        }
    }
    return true;
}

@Test
public void testReverseList() {
    LinkedList myList = new LinkedList();
    myList.insert(1, 1);
    LinkedList singleElementList = new LinkedList();
    singleElementList.insert(1, 1);
    assertEquals("Check reverseList, reversing a list with 1 element.", true, myList.reverseList().equals(singleElementList));  
    LinkedList expectedList = new LinkedList();
    myList.insert(2, 2);
    myList.insert(3, 3);
    expectedList.insert(3, 1);
    expectedList.insert(2, 2);
    expectedList.insert(1, 3);
    assertEquals("Check reverseList, reversing a list with 3 elements.", true, myList.reverseList().equals(expectedList));  
}

public void testEquals() {
    LinkedList myList = new LinkedList();
    myList.insert(1, 1);
    assertEquals("Check reverseList, comparing to the same list.", true, myList.reverseList().equals(myList));
    LinkedList myList2 = new LinkedList();
    myList2.insert(1, 1);
    myList2.insert(2, 2);
    assertEquals("Check reverseList, different size list.", false, myList.reverseList().equals(myList2));
}

Answer 1

我可以建议以下更改：

将列表反转与“toString”表示分开，并分别调用方法。

然后，确保您正在测试正确的结果（您想要“321”，对吧？）。

public LinkedList reverseList() {
    Node prev = null, current = head, next;
    while (current != null) {
        next = current.getNext();
        current.setNext(prev);
        prev = current; 
        current = next;
    }
    head = current;
    return this;
}

public String toString() {
    StringBuilder checkList = new StringBuilder();
    Node current = head;
    while (current != null) {
        checkList.append(current.getData());
        current = current.getNext();
    }
    return checkList.toString(); 
}

@Test
public void testReverseList() {
    LinkedList myList = new LinkedList();
    myList.insert(1, 1);
    myList.insert(2, 2);
    myList.insert(3, 3);
    String reverseListOrder = "321";
    assertEquals("Check reverseList, reversing a list with 3 elements.", reverseListOrder, myList.reverseList().toString());    
}

Answer 2

很难理解你的代码。如果您需要代码审查，我可以首先告诉您永远不要使用与API（LinkedList）中的类名相同的类名。然后创建一个单独的类并使用junit进行测试。你的测试失败了？你正在比较“123”应该是什么“321”没有？为什么列表中有一个插入键值对的方法？

Answer 3

我开始建议在撤消时返回新的LinkedList。但这仅仅是为了不变性

无论如何，你想测试你的方法，对吧？

现在你正在改变状态并返回当前状态的表示只是为了测试。请注意，修改生产代码只是为了能够执行测试通常不是一个好习惯。您正在修改其内部状态，以便您需要检查的内容

@Test
public void testReverseList() {
    LinkedList someList = new LinkedList();
    myList.insert(1, 1);
    myList.insert(2, 2);
    myList.insert(3, 3);

    LinkedList expectedList = new LinkedList();
    // You'll probably want to check these lines in order to ensure I'm using it the right way
    expectedList.insert(3, 1);
    expectedList.insert(2, 2);
    expectedList.insert(1, 3);

    for (int i = 0; i < expectedList.size(); i++)
        assertEquals("Checking item with index " + i, myList.get(i), expectedList.get(i));
    assertEquals(myList.size(), expectedList.size());

    // Or even better, implement LinkedList.equals() so you can use
    assertEquals("Check reverseList", myList, expectedList);    
}

通过使用toString()执行检查，您在其实施中过多地转发。让我们假设您有一个对象，其toString()方法返回一个随机字符串（我不确定为什么它可能有用，但让我们假设一分钟）。 assertEquals(myObject.toString(), myObject.toString())可能会失败，但assertEquals(myObject, myObject)不会

使用JUnit测试反转单链表的方法

3 个答案: