Gradle项目中JUnit 5测试抛出异常失败问题排查

问题根源 #

你的测试失败是因为目标main方法在捕获FileNotFoundException后，仅打印错误信息并调用System.exit(1)终止JVM，没有重新抛出异常。JUnit无法感知到这种内部处理的异常，自然触发不了断言逻辑。

解决方案1：调整业务代码（推荐，若允许修改） #

修改main方法的catch块，在打印信息后重新抛出异常（用RuntimeException包装，避免改动方法签名），同时可根据需求保留或移除System.exit(1)：

package P1;

import java.io.FileNotFoundException;

public class MainClass {
    public static void main(String[] args) {
        try {
            // 你的文件操作逻辑，示例：主动抛出不存在文件的异常
            throw new FileNotFoundException("/path/to/nonexistent/file.txt");
        } catch (FileNotFoundException e) {
            String errMsg = "文件未找到: " + e.getMessage();
            System.err.println(errMsg);
            // 重新抛出异常，让测试可以捕获
            throw new RuntimeException(errMsg, e);
            // 若不需要终止程序，可删除下面的exit调用
            // System.exit(1);
        }
    }
}

对应的测试方法可正常捕获异常并断言：

import org.junit.jupiter.api.Test;
import P1.MainClass;

import static org.junit.jupiter.api.Assertions.*;

class MainClassTest {
    @Test
    void testMissingFile() {
        String[] args = {"/path/to/nonexistent/file.txt"};
        
        RuntimeException exception = assertThrows(RuntimeException.class, () -> {
            MainClass.main(args);
        });
        
        // 断言底层异常类型为FileNotFoundException
        assertTrue(exception.getCause() instanceof FileNotFoundException);
        // 断言异常消息匹配预期
        assertTrue(exception.getMessage().contains("文件未找到"));
        assertEquals("/path/to/nonexistent/file.txt", ((FileNotFoundException) exception.getCause()).getMessage());
    }
}

解决方案2：不修改业务代码，拦截System.exit与错误输出 #

如果无法改动业务代码，可以通过替换SecurityManager拦截System.exit调用，同时捕获System.err的输出来验证逻辑：

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import P1.MainClass;

import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.security.Permission;

import static org.junit.jupiter.api.Assertions.*;

class MainClassTest {
    private PrintStream originalErr;
    private ByteArrayOutputStream errContent;
    private SecurityManager originalSecurityManager;

    @BeforeEach
    void setUp() {
        // 拦截System.err输出，用于后续断言
        originalErr = System.err;
        errContent = new ByteArrayOutputStream();
        System.setErr(new PrintStream(errContent));
        
        // 替换SecurityManager，拦截System.exit(1)的调用
        originalSecurityManager = System.getSecurityManager();
        System.setSecurityManager(new SecurityManager() {
            @Override
            public void checkExit(int status) {
                if (status == 1) {
                    // 抛出自定义异常中断exit流程，方便测试捕获
                    throw new SecurityException("拦截System.exit(1)");
                }
                super.checkExit(status);
            }
        });
    }

    @AfterEach
    void tearDown() {
        // 恢复系统原有配置，避免影响其他测试
        System.setErr(originalErr);
        System.setSecurityManager(originalSecurityManager);
    }

    @Test
    void testMissingFile() {
        String[] args = {"/path/to/nonexistent/file.txt"};
        
        // 捕获拦截exit时抛出的SecurityException
        assertThrows(SecurityException.class, () -> {
            MainClass.main(args);
        });
        
        // 断言错误输出包含预期的提示信息
        String errOutput = errContent.toString().trim();
        assertTrue(errOutput.contains("文件未找到"));
        // 若知道完整消息，可精确断言
        // assertEquals("文件未找到: /path/to/nonexistent/file.txt", errOutput);
    }
}

方案选择 #

• 若业务代码允许调整，优先选方案1，异常抛出后测试逻辑更直接、符合代码规范。
• 若无法修改业务代码，用方案2通过拦截系统调用和输出来验证异常处理逻辑。

内容的提问来源于stack exchange，提问作者Lucas Hill