单元测试中如何捕获私有函数输出的消息？AssertionError方案无效

你之前用AssertionError的方案无效，核心原因是你的compare方法并没有抛出异常，只是通过println输出消息，所以断言方法调用会抛出AssertionError自然不会生效。下面给两种可行的实现方式：

方式一：重定向标准输出流捕获内容 #

通过临时替换System.out的输出目标，把打印内容存到内存流中，之后取出字符串做断言：

import org.junit.jupiter.api.Test;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class DataCompareTest {
    @Test
    void testCompareWithDifferentRanks() {
        // 保存原标准输出流，测试后恢复
        PrintStream originalOut = System.out;
        ByteArrayOutputStream outContent = new ByteArrayOutputStream();
        System.setOut(new PrintStream(outContent));

        try {
            // 初始化测试用的Rule实例
            Rule rule1 = new Rule(1);
            Rule rule2 = new Rule(2);
            DataCompare dataCompare = new DataCompare();
            
            // 调用测试方法
            dataCompare.compare(rule1, rule2);
            
            // 提取并处理输出内容
            String output = outContent.toString().trim();
            // 断言输出符合预期（注意换行符的存在）
            assertEquals("The ranks are not in order\nrules are same", output);
        } finally {
            // 恢复原输出流，避免影响其他测试用例
            System.setOut(originalOut);
        }
    }
}

方式二：重构代码解耦打印逻辑 #

更优雅的做法是把打印依赖抽离，通过构造方法注入输出流，测试时传入自定义流来捕获内容：

重构后的业务代码 #

import java.io.PrintStream;

public class DataCompare {
    private final PrintStream outputStream;

    // 对外提供的默认构造，使用System.out
    public DataCompare() {
        this(System.out);
    }

    // 测试专用构造，注入自定义输出流
    public DataCompare(PrintStream outputStream) {
        this.outputStream = outputStream;
    }

    public void compare(Rule rule1, Rule rule2) {
        compareRuleRanks(rule1, rule2);
    }

    private void compareRuleRanks(Rule rule1, Rule rule2) {
        if (rule1.rank != rule2.rank) {
            outputStream.println("The ranks are not in order");
        }
        outputStream.println("rules are same");
    }
}

// 假设的Rule类
class Rule {
    int rank;
    public Rule(int rank) {
        this.rank = rank;
    }
}

对应的测试代码 #

import org.junit.jupiter.api.Test;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class DataCompareTest {
    @Test
    void testCompareWithSameRanks() {
        ByteArrayOutputStream outContent = new ByteArrayOutputStream();
        PrintStream testStream = new PrintStream(outContent);
        DataCompare dataCompare = new DataCompare(testStream);

        Rule rule1 = new Rule(1);
        Rule rule2 = new Rule(1);
        dataCompare.compare(rule1, rule2);

        String output = outContent.toString().trim();
        assertEquals("rules are same", output);
    }
}

这种方式避免了修改全局的System.out状态，代码耦合度更低，也更符合测试最佳实践。

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