Junit测试异常

最新推荐文章于 2024-07-04 15:41:35 发布
转载 最新推荐文章于 2024-07-04 15:41:35 发布 · 926 阅读 · 0

本文详细介绍了在JUnit4中使用try...catch、@Test(expected)和@Rules ExpectedException等方法进行异常测试的最佳实践，提供了简洁明了的测试代码示例，并对比了不同方法在测试异常时提供的反馈差异。

本篇讲述如何在 JUnit 4 下正确测试异常，我会从 try..catch 的方式谈起，然后说到 @Test(expected=Exception.class), 最后论及 @Rules public ExpectedException 的实现方式，最终基本可确定用 @Rules 是最方便的。

我们在用 JUnit 测试方法异常的时候，最容易想到的办法就是用 try...catch 去捕获异常，需要断言以下几个条件：

1. 确实抛出的异常
2. 抛出异常的 Class 类型
3. 抛出异常的具体类型，一般检查异常的 message 属性中包含的字符串的断定

所以常用的代码你可能会这么写：

01
02
03
04
05
06
07
08
09
10
@Test
public void passwordLengthLessThan6LettersThrowsException(){
    try{
        Password.validate("123");
        fail("No exception thrown.");
    }catch(Exception ex){
        assertTrue(ex instanceof InvalidPasswordException);
        assertTrue(ex.getMessage().contains("contains at least 6"));
    }
}

这里被测试的方法是 Password.validate() 方法是否抛出了相应的异常，注意这里别漏 try 中的

fail("No Exception thrown.")

代码行，不然如果被测试的方法如果没有抛出异常的话，这个用例是通过的，而你预期的是要抛出异常的。

上面的土办法对于哪个 JUnit 版本是是适合，可是我们早已步入了 JUnit 4 的时候，大可不必如此这般的去测试方法异常。虽然这样也能测定出是否执行出预期的异常来，但它仍有弊端，接下来会一对比就知道了，try...catch 的方法，JUnit 无法为你提示出详细的断言失败原因。

那么来看看自从 JUnit 4 后可以怎么去测试异常呢？用 @Test(execpted=Exception.class) 注解就行，参考如下代码：

1
2
3
4
@Test(expected = NullPointerException.class)
public void passwordIsNullThrowsException() throws InvalidPasswordException {
    Password.validate(null);
}

如果被测试的方法有抛出 NullPointerException 类型便是断言成功，对了 @Test(expected = NullPointerException.class) 只能判断出异常的类型，并无相应的注解能断言出异常的更具体的信息，即无法判定抛出异常的  message 属性。

那么，有时候我们会在一个方法中多次抛出一种类型的异常，但原因不同，即异常的 message 信息不同，比如出现 InvalidPasswordException 时会有以下两种异常：

new InvalidPasswordException("Password must contains at least 6 letters.")
new InvalidPasswordException("Password length less than 15 letters")

这就要有办法去断言异常的 message 了，针对于此，自 JUnit 4.7 之后又给了我们更完美的选择，就是下面的代码：

1
2
3
4
5
6
7
8
9
@Rule
public ExpectedException expectedEx = ExpectedException.none();
 
@Test
public void passwordIsEmptyThrowsException() throws InvalidPasswordException {
    expectedEx.expect(InvalidPasswordException.class);
    expectedEx.expectMessage("required");
    Password.validate("");
}

上面代码需重点关注几个：

1. @Rule 注解的  ExpectedException 变量声明，它必须为  public
2. @Test 处，不能写成 @Test(expected=InvalidPasswordException.class)，否则不能正确测试，也就是
          @Test(expected=InvalidPasswordException.class) 和测试方法中的 expectedEx.expectXxx() 方法是不能同时并存的
3. expectedEx.expectMessage() 中的参数是 Matcher 或  subString，就是说可用正则表达式判定，或判断是否包含某个子字符串
4. 再就是有一点很重，把被测试方法写在 expectedEx.expectXxx() 方法后面，不然也不能正确测试的异常
5. 最后一个是，只要测试方法直接抛出被测试方法的异常即可，并不影响你所关心的异常

前面说到用 try...catch 的办法也能正确测试到异常，@Test(expected=...) 或 @Rule 与 try...catch 的方法对比有什么好处呢，显然用 JUnit 4 推荐的方法简洁明了。再来看测试失败时 JUnit 会为你提示什么呢？

try...catch 测试异常失败时，得到的提示:

无异常时：

java.lang.AssertionError: No exception thrown.
    at org.junit.Assert.fail(Assert.java:91)
    at cc.unmi.PasswordTest.passwordLengthLessThan6LettersThrowsException(PasswordTest.java:20)

异常类型不对或异常的 message 不对时：

java.lang.AssertionError: 
    at org.junit.Assert.fail(Assert.java:91)
    at org.junit.Assert.assertTrue(Assert.java:43)
    at org.junit.Assert.assertTrue(Assert.java:54)
    at cc.unmi.PasswordTest.passwordLengthLessThan6LettersThrowsException(PasswordTest.java:22)

上面能提供给我们的定位错误的帮助不是特别大

再看 @Test(expected=InvalidPasswordException.class) 时测试失败时的提示：

java.lang.AssertionError: Expected exception: cc.unmi.InvalidPasswordException
    at org.junit.internal.runners.statements.ExpectException.evaluate(ExpectException.java:32)
    at org.junit.rules.ExpectedException$ExpectedExceptionStatement.evaluate(ExpectedException.java:110)

用 @Rules ExpectedException方式来测试异常，失败时的提示：

java.lang.AssertionError: 
Expected: (exception with message a string containing "YES. required" and an instance of java.lang.NullPointerException)
     got: <cc.unmi.InvalidPasswordException: Password is required.>

    at org.junit.Assert.assertThat(Assert.java:778)
    at org.junit.Assert.assertThat(Assert.java:736)
    at org.junit.rules.ExpectedException$ExpectedExceptionStatement.evaluate(ExpectedException.java:114)

特别是 @Rules  ExpectedException 方法时为何测试失败提示的清清楚楚。期望什么异常，异常 message 中含何字符串，实际上确得到什么类型的异常，异常中 message 是什么。有了这，你一看到就知道怎么去修补你的程序。

所以到了这里，我们真的没理由不用 @Test(expected=...) 或  @Rule ExpectedException 的写法了。

末了，还是补上一段代码，开篇的 try...catch 测试异常的代码是为了说明别忽略了 catch 块中的 fail() 代码行才写成那样的，更好点的可以写成：

01
02
03
04
05
06
07
08
09
10
11
12
13
14
@Test
public void passwordLengthMoreThan15LettersThrowsException(){
 
    Throwable t = null;
    try{
        Password.validate("1234567890123456");
    }catch(Exception ex){
        t = ex;
    }
         
    assertNotNull(t);
    assertTrue(t instanceof InvalidPasswordException);
    assertTrue(t.getMessage().contains("less than 15"));
}

不过，总之呢，有了 JUnit 4 呢，不提 try...catch 的实现方式也罢。

最后附上两个我为这篇博文写的测试代码 Password.java 和 PasswordTest.java，点击这两文件名即可下载。这里面有种写法的测试用例，文中的代码也这里面也有，可供参考。

参考：1. JUnit 4.7的新特性：Rule
            2. ExpectedException (JUnit API)
            3. JUnit 4 抢先看
            4. JUnit: Custom ExpectedException rules…rule!
            5. Expected Exception Testing With JUnit

本文链接 http://us.unmi.cc/junit-4-how-to-test-exceptions, 来自 隔叶黄莺 Unmi Blog

[版权声明]本站内文章，如未特别注明，均系原创或翻译之作，本人 Unmi 保留一切权利。本站原创及译作未经本人许可，不得用于商业用途及传统媒体。网络媒体可随意转载，或以此为基础进行演译，但务必以链接形式注明原始出处和作者信息，否则属于侵权行为。另对本站转载他处文章，俱有说明，如有侵权请联系本人，本人将会在第一时间删除侵权文章。及此说明，重之之重。

厚积
关注
Java开发里JUnit的异常测试技巧
AI开发架构师
07-05 874
异常处理是Java编程中不可或缺的部分，而异常测试则是确保代码在异常情况下仍能按预期行为的关键手段。本文旨在为Java开发者提供一套完整的JUnit异常测试方法论，涵盖从基础到高级的各种技巧。文章首先介绍异常测试的基本概念，然后深入JUnit 4和JUnit 5的具体实现方式，接着探讨高级技巧和最佳实践，最后通过实际案例展示如何应用这些技巧。单元测试：对软件中最小可测试单元进行检查和验证异常测试：专门验证代码在异常情况下行为的测试测试覆盖率：衡量测试对源代码覆盖程度的指标断言(Assertion)
测试异常是否正确抛出的4种JUnit测试用例写法
行步至春深
03-16 1194
捕获异常是否正确抛出(含异常类型和异常信息)，可以有以下四种写法
JUnit 4 如何正确测试异常
king841021的专栏
05-07 813
JUnit 4 如何正确测试异常 2012-06-08 — Unmi 本篇讲述如何在 JUnit 4 下正确测试异常，我会从 try..catch 的方式谈起，然后说到 @Test(expected=Exception.class), 最后论及 @Rules public ExpectedException 的实现方式，最终基本可确定用 @Rules 是最方便的。 我们在用 JU
JUnit异常测试
qq_56403015的博客
05-13 2011
JUnit异常测试 在Java语言中，JUnit是一套标准的单元测试方案，它提供了很多验证抛出的异常的机制。你可以测试代码是否它抛出了想要得到的异常。expected 参数和@Timeout一样与@Test 注释一起使用。 Expected测试案例 测试方法一：@Test(expected) 首先我们需要一个可以对其进行测试的类，并且需要其抛出异常，时测试方法可以进行异常测试。以下是一个判断是否及格的代码案例，我们用于测试异常测试。 package test.Expect; public class Er
junit4 测试异常
iteye_15847的博客
05-03 127
在@Test标签后加要测的异常参数就行了。如 @Test(expected= IndexOutOfBoundsException.class)     @Test(expected= IndexOutOfBoundsException.class) public void testSomething(){ ArrayList list = new ArrayList(); li...
幕测平台_使用Junit测试异常,测试NextDay函数
12-20
测试代码使用了JUnit的`ExpectedException`规则来捕获预期的异常，并使用`assertThat`配合`containsString`来验证异常信息。 接下来，我们看到相关的类定义，包括`Year`和`Month`，它们都继承自`CalendarUnit`。`...
单元测试实战-Junit测试
01-27
4. 抛出异常的方法，测试应确保在预期情况下异常被正确抛出。 Junit还支持参数化测试，允许使用不同的输入数据运行同一个测试多次。例如： ```java import org.junit.runner.RunWith; import org.junit.runners....
junit测试_java_JUnit_JUnit测试_
09-28
例如，文件可能会讲解如何设置一个基本的JUnit测试类，通常这个类会继承自`junit.framework.TestCase`（对于较旧的JUnit版本）或者使用注解`@RunWith(JUnit4.class)`（对于JUnit 4及以上版本）。 测试类中的每个...
junit 4中对指定异常的测试
jackyrongvip的专栏
02-19 268
junit 4中，也可以测试指定的异常是否出现了，比如： [code="java"] public class Person { private final String name; private final int age; public Person(String name, int age) { this.name = name; ...
JUnit三（异常测试）
我的博客
11-09 702
JUnit—异常测试 一.概述 异常测试是指可能希望测试代码在给定无效输入时抛出正确的异常，这里有两种方法可以实现，第一种是将预期的Exception添加到@Test注释中，另一种是在将预期的Exception放在try-catch中，下面分别给出两个方法的实现代码。 二.代码示例： 1.将Exception添加到@Test中 public class JUnitDemo1Test { ...
Junit中测试异常的方法
热门推荐
qq_41784749的博客
06-09 1万+
Java中测试异常的方式有很多种，下面介绍几种使用JUnit来测试Java代码中的异常 首先创建一个Person类代码如下： public class Person { private final int age; private final String name; public Person(int age, String name) throws IllegalAgeException { super(); if(age < 0) throw new IllegalAgeExce
JUnit4测试方法异常抛出实例
shirley@paddy的博客
07-21 3047
它用于测试由方法抛出的异常。 import org.junit.*; /** * JUnit Expected Exception Test * @author yiibai * */ public class JunitTest2 { @Test(expected = ArithmeticException.class) public void divisionW
JUnit - 怎么测试异常
u013248470的专栏
05-21 572
代码 public Example(String example) { if (example == null) { throw new NullPointerException(); } } JUnit 测试代码 @Test(expected = NullPointerException.class) public void construct
Junit 单元测试之错误和异常处理
kk_lzvvkpj的博客
07-04 1589
5. 测试的目的：这个测试的目的并不是检查userRepository.findById()本身是否真的会抛出异常，而是检查当它抛出异常时，userService.getUserById()是否会正确地传递这个异常。这种自定义异常，通常在我们希望为特定的错误情况定义更具描述性的异常名时使用，或者当我们想为特定的异常情况添加更多上下文信息时使用，信息越多，测试反馈的效果越好，所以一般使用自定义异常，继承RuntimeException！有时，如果你希望调用者必须处理某个特定的异常，使用检查型异常可能更合适。
(译) 14-JUnit-异常测试
Andy's Blog
03-16 680
JUnit 提供了跟踪代码异常处理的选项。您可以测试代码是否引发所需的异常。预期参数与 @Test 批注一起使用。让我们看看 @Test (预期) 的行动。创建类创建要测试的 java 类, 如 C: \ &gt; JUNIT_WORKSPACE 中的MessageUtil 。在 printMessage () 方法内添加错误条件。/* * This class prints the given ...
JUnit编写异常测试的Testcase
万杨的博客
05-15 3108
项目遇到需要编写单元测试，版本是junit4.10，来测试代码遇到的异常信息（如业务中出现的错误代码）是否准确，JUnit提供了两种不同的测试方法： 1.Expected Exception，主要是使用Test注解中的expected，局限性比较明显：1.只能判断所抛出的异常的类型是否准确；2.测试代码如果有多处抛出同样异常的，testcase都会正常运行，无法来进行有效的单元测试 @Test
junit如何测试异常
最新发布
07-09
<think>首先，用户的问题是关于JUnit如何编写测试用例来验证抛出的异常。用户指定了系统级指令，所以我必须遵守这些规则： 1. 所有行内数学表达式使用$...$格式。 2. 独立公式使用$$...$$并单独成段。 3. LaTeX语法正确。 4. 使用中文回答。 5. 生成相关问题。 6. 在回答中引用的段落末尾自然地添加引用标识，如[^1]。 用户提供了参考引用，这些引用来自站内内容： - 引用[1]: 关于JUnit异常测试，使用@Test(expected)等。 - 引用[2]: JUnit的核心算法步骤。 - 引用[3]: 测试异常抛出的4种写法。 用户说这些引用仅供参考，我应该基于用户的问题来回答。用户的问题是：“我想用户想了解如何使用JUnit测试异常情况 请问JUnit 如何编写测试用例验证抛出的异常”。 所以，我的回答应该专注于如何用JUnit编写测试用例来验证抛出的异常。 结构上，我需要： - 回答结构清晰，逐步解决问题。 - 保证回答真实可靠。 - 在回答中自然地添加引用标识，当引用那些内容时。 现在，规划回答内容： 1. **介绍主题**：简要解释为什么需要测试异常，以及JUnit如何帮助。 2. **方法讲解**：详细描述几种方法来验证异常抛出。 - 基于引用[1]和[3]，有几种方法： - 使用@Test(expected = Exception.class) - 使用try-catch块 - 使用JUnit 5的assertThrows - 其他方法如使用ExpectedException规则（JUnit 4） - 我需要覆盖JUnit 4和JUnit 5的不同方法，因为用户提到JUnit 5。 3. **代码示例**：提供代码片段来展示每种方法。用户示例中有Python代码，但这里是Java，所以用Java代码。 4. **步骤解释**：使结构逐步清晰。 5. **添加引用**：当引用特定方法时，添加引用标识，如[^1]。 6. **生成相关问题**：在末尾添加相关问题。 确保语言是中文。 现在，内容大纲： - **开头**：解释JUnit异常测试的重要性。 - **方法1：使用@Test(expected)**：适用于JUnit 4。 - 代码示例。 - 引用引用[1]。 - **方法2：使用try-catch块**：传统方法。 - 代码示例。 - **方法3：使用JUnit 5的assertThrows**：现代方法。 - 代码示例。 - 引用引用[3]。 - **方法4：使用ExpectedException规则**：JUnit 4的另一种方法。 - 代码示例。 - **总结**：推荐使用的方法。 - **相关问题**：生成2-3个相关问题。 关于数学表达式：用户问题中没有数学内容，但系统指令说所有行内数学表达式必须用$...$。这里可能不需要数学，除非我提到算法复杂度等。但用户问题是关于JUnit测试，所以可能不需要数学。如果引入任何数学，如时间复杂度的讨论，才使用。否则，忽略。 最后，生成相关问题：基于主题，如不同方法的比较、常见错误等。 相关问题示例： 1. JUnit 4和JUnit 5在异常测试上的主要区别是什么？ 2. 如何测试多个异常在同一个测试方法中？ 3. 异常测试的最佳实践有哪些？ 现在，写回答。</think>### 如何使用JUnit编写测试用例验证抛出的异常 在软件开发中，验证代码在异常情况下的行为至关重要。JUnit作为Java的标准单元测试框架，提供了多种机制来测试方法是否抛出了预期的异常。这能确保代码的健壮性和错误处理逻辑的正确性。下面，我将逐步介绍JUnit 4和JUnit 5中的常用方法，每种方法都附有代码示例和解释。回答基于JUnit官方文档和最佳实践[^1][^3]。 #### 1. **使用`@Test(expected)`注解（JUnit 4）** 这是最简洁的方法，适用于JUnit 4。通过在测试方法上添加`@Test(expected = Exception.class)`，JUnit会自动验证测试是否抛出了指定类型的异常。如果未抛出异常或抛出的类型不匹配，测试会失败。 ```java import org.junit.Test; public class ExceptionTest { @Test(expected = IllegalArgumentException.class) public void testExpectedException() { // 模拟会抛出IllegalArgumentException的代码 if (true) { throw new IllegalArgumentException("无效参数"); } } } ``` **步骤说明**： - 定义测试方法，并添加`@Test(expected = 异常类.class)`注解。 - 在方法体内执行可能抛出异常的代码。 - JUnit在运行时会捕获异常，并验证其类型是否匹配[^1]。 优点：简单直观，代码量少。 缺点：无法验证异常消息或其他属性，仅适用于JUnit 4。 #### 2. **使用try-catch块（通用方法，JUnit 4和5兼容）** 这是一种传统方法，通过手动捕获异常并进行断言。它灵活，能验证异常的详细信息，如消息或原因。 ```java import org.junit.Test; import static org.junit.Assert.fail; public class ExceptionTest { @Test public void testTryCatchException() { try { // 模拟会抛出异常的代码 if (true) { throw new NullPointerException("空指针错误"); } fail("未抛出预期异常"); // 如果未抛出异常，测试失败 } catch (NullPointerException e) { // 验证异常属性 assert e.getMessage().equals("空指针错误"); } } } ``` **步骤说明**： - 在测试方法中使用try-catch块包裹可能抛出异常的代码。 - 在catch块中，使用断言（如JUnit的`assert`或`Assert.assertEquals`）验证异常细节。 - 如果代码未抛出异常，调用`fail()`强制测试失败[^2]。 优点：兼容性强，可自定义验证逻辑。 缺点：代码较冗长，易出错。 #### 3. **使用`assertThrows`方法（JUnit 5推荐）** JUnit 5引入了`assertThrows`方法，更现代且灵活。它允许验证异常类型和消息，并支持lambda表达式。 ```java import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertEquals; public class ExceptionTest { @Test public void testAssertThrows() { // 使用lambda表达式执行代码 Exception exception = assertThrows(IllegalArgumentException.class, () -> { if (true) { throw new IllegalArgumentException("参数无效"); } }); // 验证异常消息 assertEquals("参数无效", exception.getMessage()); } } ``` **步骤说明**： - 导入JUnit 5的`assertThrows`和断言类。 - 在测试方法中，调用`assertThrows(异常类.class, Executable)`，其中`Executable`是一个lambda表达式。 - `assertThrows`返回捕获的异常对象，便于进一步断言其属性[^3]。 优点：代码简洁，支持详细验证，是JUnit 5的最佳实践。 注意：JUnit 5中`Executable`接口来自`org.junit.jupiter.api.function.Executable`，如果使用JUnit 4的API，需改用`ThrowingRunnable`[^3]。 #### 4. **使用`ExpectedException`规则（JUnit 4）** 对于JUnit 4，还可以使用`ExpectedException`规则，它提供更灵活的验证，如匹配异常消息。 ```java import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; public class ExceptionTest { @Rule public ExpectedException exceptionRule = ExpectedException.none(); @Test public void testExpectedExceptionRule() { // 设置预期异常类型和消息 exceptionRule.expect(IllegalStateException.class); exceptionRule.expectMessage("状态错误"); // 模拟抛出异常的代码 throw new IllegalStateException("状态错误"); } } ``` **步骤说明**： - 声明`@Rule public ExpectedException`实例。 - 在测试方法中，使用`expect`方法设置预期异常类型和消息。 - 执行代码后，规则会自动验证异常[^1]。 优点：比`@Test(expected)`更强大，支持消息验证。 缺点：仅限JUnit 4，且需额外规则声明。 #### 总结与推荐 - **JUnit 4用户**：优先使用`@Test(expected)`简单场景，或`ExpectedException`规则高级验证。 - **JUnit 5用户**：推荐`assertThrows`方法，它结合了简洁性和灵活性。 - 通用提示：测试异常时，确保覆盖边界条件，例如验证异常消息的准确性，以避免潜在bug。JUnit的核心算法在执行测试时会扫描注解、初始化对象并捕获异常，从而生成可靠报告[^2]。 在实际项目中，选择方法取决于JUnit版本和测试需求。始终确保测试代码独立且可重复，以维护测试套件的可靠性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值