Question

我有这个方法，它将搜索LinkedList（名为ListNode）并检查字符并检查它们是否包含大写字符，然后存储在新的链表中，然后返回。我为它编写了代码，用JUnit测试了它，但它失败了JUNit（On那些蓝盒子）。有谁知道出了什么问题？

这是我的LinkedList方法：

public static ListNode copyUpperCase(ListNode head) {
    ListNode newListNode = mkEmpty();
    if(head == null){
        throw new ListsException("");
    }else{      
        while(head.next != null){
            if(Character.isUpperCase(head.element)){
                newListNode.element = head.element;         
            }
            head = head.next;
        }
    }
    return newListNode;
}

这是ListNode：

public class ListNode {
    public char element;
    public ListNode next;
}

以下是测试方法：

@Test
public void testCopyUpperCase()
{
    // Inject upper case letters randomly in the test strings.
    // Assert equal results when extracting the upper case chars from
    // the corresponding list, as wheen extracting them from the 
    // injected string itself.
    for ( String s : cases ) {
        String uppersAndLowers = randInjectUpper(s);
        // Extract the upper case characters
        StringBuilder uppers = new StringBuilder();
        for ( int i = 0; i < uppersAndLowers.length(); i++ ) {
            final char c = uppersAndLowers.charAt(i);
            if ( Character.isUpperCase(c) )
                uppers.append(c);
        }
        ListNode temp = Lists.toList(uppersAndLowers);
        ListNode lhs = Lists.copyUpperCase(temp);
        assertFalse(hasSharedNodes(temp,lhs));
        ListNode rhs = Lists.toList(uppers.toString());
        assertTrue(Lists.equals(lhs,rhs));
    }
}

测试方法中的失败行是最后一行，即：

assertTrue（Lists.equals（左，右））;

这是什么意思，如果它在那条线上失败了？

PS。这里也是equals方法：

// Two lists are equal if both are empty, or if they have equal lengths
// and contain pairwise equal elements at the same positions.
public static boolean equals(ListNode l1,ListNode l2) {
    if ( isEmpty(l1) && isEmpty(l2) )
        return true;
    else if ( isEmpty(l1) || isEmpty(l2) )
        return false;
    else { // both lists are non-empty
        ListNode p1 = l1.next, p2 = l2.next;
        while ( p1 != null && p2 != null ) {
            char c1 = p1.element, c2 = p2.element;
            if ( p1.element != p2.element )
                return false;
            p1 = p1.next;
            p2 = p2.next;
        }
        return p1 == null && p2 == null;
    }
}

编辑：这是新方法：

public static ListNode copyUpperCase(ListNode head) {

    ListNode newListNode = mkEmpty();
    if(head == null){
        throw new ListsException("Lists: null passed to copyUpperCase");
    }else{
        String cpy = toString(head);
        char[] chry = cpy.toCharArray();
        for(int i = 0; i < chry.length ; i++ )
                if(Character.isUpperCase(chry[i])){
                    newListNode.element = chry[i];      
                }
                newListNode = newListNode.next;
        }           
    return newListNode;
}

Answer 1

你的equals方法似乎没问题。它正确检查两个列表是否为空，然后正确检查，一个是否为空，另一个不是。之后，您同时迭代两个列表，检查每个字符，最后，您希望两个指针都为空。一切都好。

所以问题必须在toList方法或copyUppercase方法中。事实上你copyUppercase方法是错误的。问问自己，只有一个元素的列表会发生什么？然后问问自己，任何提供的列表的最后一个元素会发生什么？你能看到这个地方吗？

while循环条件错误：它必须只是

while (head != null) { ... }

Answer 2

根据Lists.equals中的实现，这意味着lhs不等于rhs

错误似乎是你的copyUpperCase只返回参数中给出的列表中的单个元素，或者你的测试代码将字符串中的所有大写字符添加到rhs（取决于你的意图）。但是您的Lists.Equal方法中也可能出现错误，但未显示。

PS。我建议你不要在JUnit测试中加入随机元素，因为这意味着结果不可重复。

LinkedList方法的JUnit测试失败了，为什么？

2 个答案: