Java - TestNG：为什么我的Assertion总是在try-catch块中写入时通过

Question

我正在尝试使用org.testng.Assert的简单代码来断言2个用例。 在第一个用例中，我声明了2个不正确的值，它们正确地Fail 。

但是在第二个用例中，当我在try-catch块中断言2个不相等的值时，结果总是作为Pass返回

我的代码如下：

package demo;
import org.testng.Assert;
import org.testng.annotations.Test;
public class Q43710035 
{

    @Test
    public void test1() 
    {
        System.out.println("Within test1");
        int a = 12;
        int b =20;
        Assert.assertEquals(a, b);

    }

    @Test
    public void test2() 
    {
        System.out.println("Within test2");
        int a = 12;
        int b =20;

        try 
        {
            Assert.assertEquals(a, b);
        }catch(Throwable t)
        {
            System.out.println("Exception Occurred");
        }
    }
}

我得到的结果是：

Within test1
Within test2
Exception Occurred
PASSED: test2
FAILED: test1
java.lang.AssertionError: expected [20] but found [12]
at org.testng.Assert.fail(Assert.java:94)

我的问题是：

1. 在test2（）中虽然Assertion失败了，为什么执行不会出现在这个Test ？
2. 在test2（）中，似乎try块失败，因此执行到达catch块并且Exception Occurred被打印。 当断言代码执行时，为什么try阻塞失败呢？

Answer 1

如果你看一下assertEquals方法的源代码，你会发现它都归结为fail方法（和许多其他的断言一样）。

public static void fail(String message) {
    if(message == null) {
        throw new AssertionError();
    } else {
        throw new AssertionError(message);
    }
}

正如我们所看到的，它会抛出AssertionError ，你在catch(Throwable t)中catch(Throwable t) 。 所以JUnit无法告诉测试失败 ，因此声明它已通过。

如果捕获异常是测试的一部分（您期望异常），我建议您查看JUnit文档： 异常测试

Answer 2

如果你查看junit4的源代码，请访问https://github.com/junit-team/junit4/blob/master/src/main/java/junit/framework/Assert.java#L71

你会明白test1失败的原因

第1部分：

 /** * Asserts that two objects are equal. If they are not * an AssertionFailedError is thrown with the given message. */ 

static public void assertEquals(String message, Object expected, Object actual) {
    if (expected == null && actual == null) {
        return;
    }
    if (expected != null && expected.equals(actual)) {
        return;
    }
    failNotEquals(message, expected, actual); //It calls Part#2
}

第2部分：

static public void failNotEquals(String message, Object expected, Object actual) {
    fail(format(message, expected, actual)); //It calls Part#3 format(...) method
}

第3：

public static String format(String message, Object expected, Object actual) {
    String formatted = "";
    if (message != null && message.length() > 0) {
        formatted = message + " ";
    }
    return formatted + "expected:<" + expected + "> but was:<" + actual + ">";
}

所以你得到了Part＃3的回复信息

java.lang.AssertionError：expected [20]但发现[12]

有关异常JUnit规则的完整阶段理解，请完成以下教程 ：

期待JUnit规则的异常

为了断言使用JUnit抛出异常，使用try / fail / catch惯用法或@Test注释的期望元素是相当常见的。 尽管比前者更简洁，但有一种观点认为使用预期并不支持您可能想要测试的所有情况。 示例是在异常之后执行附加测试或针对实际异常消息进行测试。

JUnit 4.7引入了下一个进程，一个提供两全其美的@Rule。 本文重点介绍了每种方法的优缺点，并仔细研究了每种方法的语法。 尝试/失败/捕获成语

典型的模式是捕获异常，如果从未抛出则显式失败。

@Test
public void example1() {
    try {
        find("something");
        fail();
    } catch (NotFoundException e) {
        assertThat(e.getMessage(), containsString("could not find something"));
    }
    // ... could have more assertions here
}

这会以下列方式强调失败。

java.lang.AssertionError: expected an exception
    at org.junit.Assert.fail(Assert.java:91)
    at bad.roboot.example.ExceptionTest.example1(ExceptionTest.java:20)
    ...

这个成语具有潜在的优势，因为它提供了对实际例外进行断言以及在期望之后执行额外工作的机会。 除了噪音之外，主要的缺点是它很容易忘记包括失败呼叫。 如果真的首先进行测试，我们总是在测试中运行红色，这不会是一个问题，但是经常会出现问题。 在实践中，我看到太多的例子，失败的失败给出了误报。

@Test（expected = Exception.class）

使用期望的元素，我们可以如下重写测试。

@Test (expected = NotFoundException.class)
public void example2() throws NotFoundException {
    find("something");
    // ... this line will never be reached when the test is passing
}

这将导致以下失败。

java.lang.AssertionError: Expected exception: bad.robot.example.NotFoundException

资源链接： 断言列表时assertEquals究竟检查了什么？

Answer 3

你的第二个案例充满了问题，这就是为什么它表现得如此奇怪。 查看以数字标记的行：

    try 
    {
        Assert.assertEquals(a, b); // 1
    }catch(Throwable t) // 2
    {
        System.out.println("Exception Occurred"); // 3
    }

1 - 'assert *'方法调用不应该被try-catch块包装。 它们旨在通过抛出错误（！）来检查数据并处理它的无效性。

2 - 你试图抓住一切可以在试试部分抛出。 常见情况下应用程序的业务逻辑使用异常，而不是错误。 例外情况表明出现了一些可以恢复的问题。 错误主要表现出一些严重的问题，如（硬盘故障等），你只需要在应用程序停止之前处理应用程序的数据。 异常和错误是从Throwable继承的。 'assert *'方法设计的方式是抛出错误，特别是不被'catch'块捕获。

3 - 通过不处理捕获的异常，你只是忽略它。 这就是为什么你的方法总是会成功完成的原因。

要纠正第二次测试，您可以：a）从方法体中删除try-catch部分b）将't'参数的类型从Throwable更改为Exception c）在'catch'块的末尾添加'throw t'

Answer 4

我也遇到过类似的问题，后来在理解Java的时候，当调用方法想知道它的被调用方法中的异常时，被调用的方法应该包含'throw exception;' Catch块中的语句。

通过这种方式，

@Test
public void test2() 
{
    System.out.println("Within test2");
    int a = 12;
    int b =20;

    try 
    {
        Assert.assertEquals(a, b);
    }catch(Exception e)
    {
        System.out.println("Exception Occurred");
        throw e;
    }
}

TestNG会知道，抛出异常。 然后，TestNG将失败该方法。
请注意，e.printStackTrace（）; 也不会失败你的测试用例。