控制检查JUnit中引发的ExpectedException的规则

Question

我的任务是计算给定两个字符串中不匹配（不同字符）的数量。虽然;有两个条件需要满足。

如果给定的两个字符串的长度不相同； 使用适当的消息引发异常。

如果仅提供一个输入String； 使用适当的消息引发异常。

我的解决方案：

class Hamming {
    private final String leftString;
    private final String rightString;

    public Hamming(String leftString, String rightString) {
        this.leftString = leftString;
        this.rightString = rightString;
    }

    public int getHammingDistance() {
        int hammingDistance = 0;
        int secondCharIndex = 0;
        if (leftString.length() == 0 && rightString.length() != 0)
            throw new IllegalArgumentException("left string must not be empty.");
        if (rightString.length() == 0 && leftString.length() != 0)
            throw new IllegalArgumentException("right string must not be empty.");
        if (leftString.length() != rightString.length())
            throw new IllegalArgumentException("left and right string must be of equal length.");
        for (char ch : leftString.toCharArray()) {
            if (ch != rightString.charAt(secondCharIndex)) hammingDistance++;
            secondCharIndex++;
        }
        return hammingDistance;
    }
}

现在，当我直接运行此解决方案时；它按预期工作。您可以找到上述代码here.]的运行示例

当我尝试使用Junit Test Coverage

运行相同的代码时；相同的代码无法通过所有涉及异常的测试用例。以下是我的HammingTest.java

import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThrows;

import org.junit.Ignore;
import org.junit.Test;

public class HammingTest {

    @Test
    public void testNoDistanceBetweenEmptyStrings() {
        assertEquals(0, new Hamming("", "").getHammingDistance());
    }

//    @Ignore("Remove to run test")
    @Test
    public void testNoDistanceBetweenShortIdenticalStrings() {
        assertEquals(0, new Hamming("A", "A").getHammingDistance());
    }

//    @Ignore("Remove to run test")
    @Test
    public void testCompleteDistanceInSingleLetterDifferentStrings() {
        assertEquals(1, new Hamming("G", "T").getHammingDistance());
    }

//    @Ignore("Remove to run test")
    @Test
    public void testDistanceInLongIdenticalStrings() {
        assertEquals(0, new Hamming("GGACTGAAATCTG", "GGACTGAAATCTG").getHammingDistance());
    }

//    @Ignore("Remove to run test")
    @Test
    public void testDistanceInLongDifferentStrings() {
        assertEquals(9, new Hamming("GGACGGATTCTG", "AGGACGGATTCT").getHammingDistance());
    }

//    @Ignore("Remove to run test")
    @Test
    public void testValidatesFirstStringNotLonger() {
        IllegalArgumentException expected =
            assertThrows(
                IllegalArgumentException.class,
                () -> new Hamming("AATG", "AAA"));

        assertThat(expected)
            .hasMessage("left and right string must be of equal length.");
    }

//    @Ignore("Remove to run test")
    @Test
    public void testValidatesSecondStringNotLonger() {
        IllegalArgumentException expected =
            assertThrows(
                IllegalArgumentException.class,
                () -> new Hamming("ATA", "AGTG"));

        assertThat(expected)
            .hasMessage("left and right string must be of equal length.");
    }

//    @Ignore("Remove to run test")
    @Test
    public void testDisallowLeftEmptyString() {
        IllegalArgumentException expected =
            assertThrows(
                IllegalArgumentException.class,
                () -> new Hamming("", "G"));

        assertThat(expected)
            .hasMessage("left string must not be empty.");
    }

//    @Ignore("Remove to run test")
    @Test
    public void testDisallowRightEmptyString() {
        IllegalArgumentException expected =
            assertThrows(
                IllegalArgumentException.class,
                () -> new Hamming("G", ""));

        assertThat(expected)
            .hasMessage("right string must not be empty.");
    }

}
我正在将项目用作渐变项目。

，因此生成的报告显示了以下问题：

什么解决了我的问题：

[长时间工作后；当我最终尝试将异常抛出条件放入构造函数中

时；它解决了我的问题。每个测试用例都通过了。像这样的东西：

public Hamming(String leftString, String rightString) {
        if (leftString.length() == 0 && rightString.length() != 0) {
            throw new IllegalArgumentException("left string must not be empty.");
        } else if (rightString.length() == 0 && leftString.length() != 0) {
            throw new IllegalArgumentException("right string must not be empty.");
        } else if (leftString.length() != rightString.length()) {
            throw new IllegalArgumentException("leftString and rightString must be of equal length.");
        }
        this.leftSting = leftString;
        this.rightString = rightString;
    }
我的疑问是：

1. 为什么将异常引发条件放入构造函数中的解决方案起作用？
2. [当我试图将异常抛出条件置于getHamming()方法中时；为什么测试失败？
3. [当我在没有JUnit的情况下运行与前面提到的相同的Hamming类时；它按预期工作。为什么会这样？

任何帮助都会有所帮助。

我的任务是计算给定两个字符串中不匹配（不同字符）的数量。虽然;有两个条件需要满足。如果给定两个字符串的长度为...

Answer 1

您错过了致电getHammingDistance()的原因，这就是您的测试用例失败的原因。让我们来做一个测试案例，看看为什么。