Java 单元测试：使用 assertThrows 正确验证异常抛出

// Application.java
import java.io.Console; // 假设这里有一个Console工具类，或者使用Scanner

public class Application {
    public static int enterTheAmount() {
        final int LOTTO_PRICE = 1000;
        // 模拟从控制台读取输入，实际测试中会通过System.setIn重定向
        // int amount = Integer.parseInt(Console.readLine()); // 原始代码，这里简化为直接读取

        // 为了方便测试，我们修改为从参数获取，或者在测试中模拟Console.readLine()
        // 这里为了演示，我们假设Console.readLine()返回一个字符串，并转换为int
        // 实际测试时，需要通过System.setIn()来模拟输入流
        String input = readSimulatedInput(); // 假设这是一个模拟读取输入的方法
        int amount = Integer.parseInt(input);

        if (amount % LOTTO_PRICE != 0) {
            throw new IllegalArgumentException("输入的金额必须是 " + LOTTO_PRICE + " 的倍数。");
        }
        return amount / LOTTO_PRICE;
    }

    // 模拟读取输入，在实际测试中会用ByteArrayInputStream替换
    private static String readSimulatedInput() {
        // 这是一个占位符，在实际测试中会被System.setIn(new ByteArrayInputStream(...))替换
        return "1234"; // 默认返回一个无效值
    }
}

import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows; // 提前引入正确的断言

import java.io.ByteArrayInputStream;
import java.io.InputStream;

public class ApplicationTest {

    // 模拟System.in的辅助方法
    private void setSimulatedInput(String input) {
        InputStream in = new ByteArrayInputStream(input.getBytes());
        System.setIn(in);
    }

    @Test
    void validateTheEnteredAmount_IncorrectApproach() {
        setSimulatedInput("1234"); // 设置一个无效输入

        // 这种断言方式是错误的，它会尝试执行enterTheAmount()方法，
        // 如果该方法抛出异常，测试会在assertThat()被调用之前就失败，
        // 而不是捕获异常并检查其类型。
        // try {
        //     assertThat(Application.enterTheAmount()).isInstanceOf(IllegalArgumentException.class);
        //     // 如果代码执行到这里，说明没有抛出异常，测试应该失败
        //     fail("Expected IllegalArgumentException was not thrown.");
        // } catch (IllegalArgumentException e) {
        //     // 捕获到异常，说明抛出了，测试通过
        //     // 但这种方式冗长且不符合断言库的初衷
        //     assertThat(e).isInstanceOf(IllegalArgumentException.class); // 这里的isInstanceOf是多余的，因为已经捕获到了
        // }

        // 上述注释代码是手动捕获异常的演示，但不是AssertJ或JUnit推荐的测试异常方式。
        // 直接使用assertThat(Application.enterTheAmount()).isInstanceOf(...)
        // 会导致测试失败，因为当enterTheAmount()抛出异常时，
        // 异常会在assertThat()方法被调用之前就传播出来，导致测试中断。
        // 因此，这种方式无法达到验证异常的目的。
    }
}

assertThrows(ExpectedExceptionType.class, () -> {
    // 可能会抛出ExpectedExceptionType异常的代码块
});

import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat; // 仍然可以使用AssertJ进行更详细的异常内容断言
import static org.junit.jupiter.api.Assertions.assertThrows;

import java.io.ByteArrayInputStream;
import java.io.InputStream;

public class ApplicationTest {

    // 模拟System.in的辅助方法
    private void setSimulatedInput(String input) {
        InputStream in = new ByteArrayInputStream(input.getBytes());
        System.setIn(in);
    }

    @Test
    void validateTheEnteredAmount_CorrectApproach() {
        setSimulatedInput("1234"); // 设置一个无效输入

        // 使用 assertThrows 验证是否抛出 IllegalArgumentException
        IllegalArgumentException thrown = assertThrows(
            IllegalArgumentException.class,
            () -> Application.enterTheAmount(), // 传递一个Lambda表达式，包含可能抛出异常的代码
            "Expected enterTheAmount() to throw IllegalArgumentException, but it didn't" // 失败时的消息
        );

        // 可以在此基础上进一步断言异常的详细信息，例如异常消息
        assertThat(thrown.getMessage()).contains("输入的金额必须是 1000 的倍数");
    }

    @Test
    void validateTheEnteredAmount_ValidInput() {
        setSimulatedInput("2000"); // 设置一个有效输入
        int result = Application.enterTheAmount();
        assertThat(result).isEqualTo(2); // 验证返回结果
    }
}