如何为Program.cs文件中的Main方法编写XUnit测试？

1. 优先重构Main方法，剥离核心逻辑 #

把Main里的业务代码抽成独立的可测试类/方法，这是最彻底的解决方案——毕竟Main本身就是程序入口，没必要直接测试它，核心业务逻辑才是测试重点。

示例代码（以C#为例）：

// 重构前的Main
static void Main(string[] args)
{
    if (args.Length == 0)
    {
        Console.WriteLine("缺少输入参数");
        Environment.Exit(1);
    }
    var processed = args[0].Replace("foo", "bar");
    Console.WriteLine(processed);
    Environment.Exit(0);
}

// 重构后：核心逻辑抽离到独立类
public static class InputProcessor
{
    public static string Process(string input)
    {
        if (string.IsNullOrEmpty(input))
            throw new ArgumentNullException(nameof(input));
        return input.Replace("foo", "bar");
    }
}

// 简化后的Main，只做入口调度
static void Main(string[] args)
{
    try
    {
        if (args.Length == 0)
            throw new ArgumentNullException(nameof(args), "缺少输入参数");
        
        var result = InputProcessor.Process(args[0]);
        Console.WriteLine(result);
        Environment.Exit(0);
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
        Environment.Exit(1);
    }
}

之后直接测试InputProcessor.Process即可，完全避开Main的进程生命周期问题。

2. 必须测试Main时，解决进程终止问题 #

如果一定要直接测试Main，重点是避免Environment.Exit()终止测试进程。可以通过抽象退出逻辑来实现：

// 抽象退出接口
public interface IApplicationExit
{
    void Exit(int exitCode);
}

// 生产环境实现
public class DefaultApplicationExit : IApplicationExit
{
    public void Exit(int exitCode) => Environment.Exit(exitCode);
}

// 修改Program类，允许替换退出逻辑
public static class Program
{
    public static IApplicationExit ExitHandler { get; set; } = new DefaultApplicationExit();

    static void Main(string[] args)
    {
        try
        {
            if (args.Length == 0)
            {
                Console.WriteLine("缺少输入参数");
                ExitHandler.Exit(1);
                return;
            }
            var result = InputProcessor.Process(args[0]);
            Console.WriteLine(result);
            ExitHandler.Exit(0);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
            ExitHandler.Exit(1);
        }
    }
}

// 单元测试代码
[TestClass]
public class ProgramTests
{
    [TestMethod]
    public void Main_WithEmptyArgs_ExitsWithCode1()
    {
        // 模拟退出逻辑，记录退出状态
        int recordedExitCode = -1;
        Program.ExitHandler = new MockApplicationExit(code => recordedExitCode = code);

        // 调用Main
        Program.Main(Array.Empty<string>());

        // 验证结果
        Assert.AreEqual(1, recordedExitCode);
    }

    // 模拟退出实现
    private class MockApplicationExit : IApplicationExit
    {
        private readonly Action<int> _onExit;
        public MockApplicationExit(Action<int> onExit) => _onExit = onExit;
        public void Exit(int exitCode) => _onExit?.Invoke(exitCode);
    }
}

3. 测试控制台输出（如果需要） #

如果Main有控制台输出，测试时可以重定向输出流捕获内容：

[TestMethod]
public void Main_WithValidInput_WritesCorrectOutput()
{
    var originalOut = Console.Out;
    string output = string.Empty;

    try
    {
        using (var writer = new StringWriter())
        {
            Console.SetOut(writer);
            Program.Main(new[] { "foo test" });
            output = writer.ToString().Trim();
        }
        Assert.AreEqual("bar test", output);
    }
    finally
    {
        // 恢复原有输出流，避免影响其他测试
        Console.SetOut(originalOut);
    }
}

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