如何为JUNIT编写Java程序的异常测试？

Question

package BasicTesting;

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Factorial_of_number {
    public static int factorial(int n)//factorial method
    {
        if (n == 0) {
            return 1;
        } else if (n < 1) {
            return -1;
        } else {
            return n * factorial(n - 1);
        }
    }

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("Enter number to factorize ");
        int n = input.nextInt();
        System.out.println(factorial(n));
    }
}

在这里，当我们给出负数为输入时，它们的处理方式不佳。实际上，该程序应返回我们找不到负数的阶乘。通过使用此程序，我们如何编写JUNIT测试案例以检查该程序是否给出了负数的正确输出？他们没有检查负数，因此在我们测试异常时，系统必须失败，对吗？我也附上了我的Junit Test案例。

package BasicTesting;

import static org.junit.Assert.*;

import java.util.Arrays;
import java.util.Collection;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

@RunWith(Parameterized.class)

public class FactorialTest {

    public FactorialTest(int input, int expected) {
        super();
        this.input = input;
        this.expected = expected;
    }

    Factorial_of_number ob = new Factorial_of_number();
    private int input;
    private int expected;

    @Parameters
    public static Iterable<Object[]> testConditions() {
        return Arrays.asList(new Object[][]{{0, 1}, {1, 1},
                {5, 120}, {-3, -1}, {10, 3628800}, {12, 479001600}});
    }

    @Test
    public void factorial_test() {
        assertEquals(expected, Factorial_of_number.factorial(input));
    }
}

如何检查该例外？我也应该更改我的源程序吗？还请提供编辑的代码。

Answer 1

首先，当您当前返回-1时，您的阶乘方法将有例外，以便您的方法看起来像这样 -

    public static int factorial(int n)//factorial method
{
    if (n == 0) {
        return 1;
    } else if (n < 1) {
        throw new RuntimeException("Negative value, can not get factorial");
    } else {
        return n * factorial(n - 1);
    }
}

然后您可以使用这样的测试用例 -

@RunWith(Enclosed.class)
public class FactorialTest {
@RunWith(Parameterized.class)
public static class GoodTest {
    @Parameters
    public static Iterable<Object[]> goodTestConditions() {
        return Arrays.asList(new Object[][]{{0, 1}, {1, 1},
                {5, 120}, {10, 3628800}, {12, 479001600}});
    }


    public GoodTest(int input, int expected) {
        this.input = input;
        this.expected = expected;
    }

    private final int input;
    private final int expected;


    @Test
    public void factorial_test_good() {
        assertEquals(expected, Factorial_of_number.factorial(input));
    }
}

@RunWith(Parameterized.class)
public static class BadTest {
    @Parameters
    public static Iterable<Object[]> badTestConditions() {
        return Arrays.asList(new Object[][]{{-1}, {-10}});
    }


    public BadTest(int input) {
        this.input = input;
    }

    private final int input;


    @Test(expected = RuntimeException.class)
    public void factorial_test_good() {
        Factorial_of_number.factorial(input);
    }
}
}

Answer 2

首先，您必须在测试方法中声明何时以及哪种类型的异常。

然后，对于Junit4，有3种主张例外的主要方法。

1）非常原始和非时尚的方式：

这是基本方法，但仍然可以使用。

@Test    
public void factorial_test_good() {
   try {
       Factorial_of_number.factorial(input);
   } catch(Exception e) {
       Assert.assertThat(e, Matchers.<Exception>instanceOf(YourException.class));
   }
}

2）快速易于阅读：

最好如果要识别失败的测试，但不需要细节。

@Test(expected = YourException.class)
public void factorial_test_good() {
    Factorial_of_number.factorial(input);
}

3）最复杂的，最适合详细测试

如果要测试特定方案，例如异常消息或原因。
可以有一种方法可以带有不同类型或消息的多个异常 - 那么这是最佳选择。

在测试注释之前初始化：

@Rule
public ExpectedException exceptionRule = ExpectedException.none();

测试本身：

@Test    
public void factorial_test_good() {
   exceptionRule.expect(YourException.class);
   /* 
    * OPTIONAL
    * exceptionRule.expectMessage("Your custom exception message");
    * exceptionRule.expectCause(is(instanceOf(IllegalStateException.class)));
    */
   Factorial_of_number.factorial(input);
}

我想这远远超出了您的问题，但将来可能会方便。