window-sand-box 0.1.0

//! 进程执行
//!
//! 使用受限令牌创建进程，捕获 stdout/stderr。
//!
//! # Safety
//!
//! `execute_with_token` 是核心 unsafe 函数，调用者必须确保传入的令牌句柄有效。
//! 模块内 helper 函数之间的 unsafe 调用不额外包裹，由调用者统一承担 Safety 责任。

#![allow(unsafe_op_in_unsafe_fn)]

use anyhow::{Result, anyhow};
use std::collections::HashMap;
use std::path::Path;
use std::ptr;
use windows_sys::Win32::Foundation::{
    CloseHandle, GetLastError, HANDLE, HANDLE_FLAG_INHERIT, SetHandleInformation,
};
use windows_sys::Win32::System::Pipes::CreatePipe;
use windows_sys::Win32::System::Threading::{
    CreateProcessAsUserW, GetExitCodeProcess, INFINITE, PROCESS_INFORMATION,
    STARTF_USESTDHANDLES, STARTUPINFOW, TerminateProcess,
    WaitForSingleObject, CREATE_UNICODE_ENVIRONMENT,
};
use windows_sys::Win32::Storage::FileSystem::ReadFile;

use crate::winutil::to_wide;

/// 进程执行结果
#[derive(Debug, Clone)]
pub struct ProcessResult {
    pub exit_code: u32,
    pub stdout: Vec<u8>,
    pub stderr: Vec<u8>,
    pub timed_out: bool,
}

/// 构建环境变量块，排序后以 UTF-16 编码，双 null 结尾
///
/// Windows 环境块格式：`KEY=VALUE\0KEY2=VALUE2\0\0`
/// 使用 `encode_wide` 直接构建，避免先生成带 null 的宽字符串再 pop 的多余操作。
fn make_env_block(env: &HashMap<String, String>) -> Vec<u16> {
    use std::os::windows::ffi::OsStrExt;

    let mut items: Vec<(String, String)> =
        env.iter().map(|(k, v)| (k.clone(), v.clone())).collect();
    items.sort_by(|a, b| {
        a.0.to_uppercase()
            .cmp(&b.0.to_uppercase())
            .then(a.0.cmp(&b.0))
    });
    let mut w: Vec<u16> = Vec::new();
    for (k, v) in &items {
        let entry = format!("{k}={v}");
        w.extend(
            std::ffi::OsStr::new(&entry)
                .encode_wide()
        );
        w.push(0); // 每个条目以 null 结尾
    }
    // Windows 环境块要求双 null 结尾 (\0\0)。
    // 有条目时：最后条目的末尾 null 作为第一个，这里补第二个 null。
    // 无条目时：直接补双 null。
    if items.is_empty() {
        w.push(0);
    }
    w.push(0);
    w
}

/// 将参数列表转为 Windows 命令行格式
///
/// 遵循 `CommandLineToArgvW` 的反向转义规则：
/// - 不含空格/制表符/引号的参数原样输出
/// - 含特殊字符的参数用 `"..."` 包裹
/// - 参数内的 `"` 前加 `\` 转义
/// - 结尾的 `\` 在遇到 closing `"` 前翻倍
/// - 普通 `\` 原样保留
///
/// 参考 MSDN: <https://docs.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-commandlinetoargvw>
fn argv_to_command_line(args: &[String]) -> String {
    args.iter()
        .map(|arg| {
            // 不需要转义的情况
            if !arg.contains(' ') && !arg.contains('\t') && !arg.contains('"') && !arg.ends_with('\\')
            {
                return arg.clone();
            }

            let mut result = String::from("\"");
            let bytes = arg.as_bytes();
            let mut i = 0;
            while i < bytes.len() {
                // 统计连续反斜杠数量
                let mut backslash_count = 0usize;
                while i < bytes.len() && bytes[i] == b'\\' {
                    backslash_count += 1;
                    i += 1;
                }

                if i == bytes.len() {
                    // 结尾反斜杠 → 翻倍后加 closing quote
                    for _ in 0..backslash_count * 2 {
                        result.push('\\');
                    }
                } else if bytes[i] == b'"' {
                    // `"` → 每个反斜杠翻倍 + `\"`
                    for _ in 0..backslash_count * 2 + 1 {
                        result.push('\\');
                    }
                    result.push('"');
                    i += 1;
                } else {
                    // 普通字符 → 反斜杠原样保留
                    for _ in 0..backslash_count {
                        result.push('\\');
                    }
                    result.push(bytes[i] as char);
                    i += 1;
                }
            }
            result.push('"');
            result
        })
        .collect::<Vec<_>>()
        .join(" ")
}

/// 创建管道
unsafe fn create_pipes() -> Result<((HANDLE, HANDLE), (HANDLE, HANDLE), (HANDLE, HANDLE))> {
    let mut in_r: HANDLE = 0;
    let mut in_w: HANDLE = 0;
    let mut out_r: HANDLE = 0;
    let mut out_w: HANDLE = 0;
    let mut err_r: HANDLE = 0;
    let mut err_w: HANDLE = 0;

    if CreatePipe(&mut in_r, &mut in_w, ptr::null_mut(), 0) == 0 {
        return Err(anyhow!("CreatePipe stdin failed: {}", GetLastError()));
    }
    if CreatePipe(&mut out_r, &mut out_w, ptr::null_mut(), 0) == 0 {
        CloseHandle(in_r); CloseHandle(in_w);
        return Err(anyhow!("CreatePipe stdout failed: {}", GetLastError()));
    }
    if CreatePipe(&mut err_r, &mut err_w, ptr::null_mut(), 0) == 0 {
        CloseHandle(in_r); CloseHandle(in_w);
        CloseHandle(out_r); CloseHandle(out_w);
        return Err(anyhow!("CreatePipe stderr failed: {}", GetLastError()));
    }

    Ok(((in_r, in_w), (out_r, out_w), (err_r, err_w)))
}

/// 以受限令牌创建进程并等待完成
///
/// # Safety
/// h_token 必须是有效的受限令牌句柄
///
/// # 参数
/// - `process_handle_out`: 如果提供，创建进程后将 `pi.hProcess` 存入其中。
///   调用者可通过它从外部终止进程。此时本函数**不会**关闭 `pi.hProcess`，
///   调用者须在 `SandboxTask` 的 drop 或 kill 方法中关闭。
pub unsafe fn execute_with_token(
    h_token: HANDLE,
    command: &[String],
    cwd: &Path,
    env_map: &HashMap<String, String>,
    timeout_ms: Option<u64>,
    desktop_name: Option<&str>,
    process_handle_out: Option<&std::sync::Arc<std::sync::Mutex<Option<HANDLE>>>>,
) -> Result<ProcessResult> {
    if command.is_empty() {
        return Err(anyhow!("Empty command"));
    }

    // 1. 创建管道
    let ((in_r, in_w), (out_r, out_w), (err_r, err_w)) = create_pipes()?;

    // 2. 构建命令行
    let cmdline_str = argv_to_command_line(command);
    let mut cmdline = to_wide(&cmdline_str);

    // 3. 构建环境变量块（始终非空，受限令牌需要有效环境块）
    let env_block = if env_map.is_empty() {
        let current_env: HashMap<String, String> = std::env::vars().collect();
        make_env_block(&current_env)
    } else {
        make_env_block(env_map)
    };

    // 4. 工作目录
    let cwd_wide = to_wide(cwd);

    // 5. 设置 STARTUPINFOW
    let desktop_str = desktop_name.unwrap_or("Winsta0\\Default");
    let desktop_name_wide = to_wide(desktop_str);
    let mut si: STARTUPINFOW = std::mem::zeroed();
    si.cb = std::mem::size_of::<STARTUPINFOW>() as u32;
    si.lpDesktop = desktop_name_wide.as_ptr() as *mut u16; // 受限令牌必须设置桌面
    si.dwFlags = STARTF_USESTDHANDLES;
    si.hStdInput = in_r;
    si.hStdOutput = out_w;
    si.hStdError = err_w;

    // 确保管道句柄可继承
    for &handle in &[in_r, out_w, err_w] {
        if SetHandleInformation(handle, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT) == 0 {
            CloseHandle(in_r); CloseHandle(in_w);
            CloseHandle(out_r); CloseHandle(out_w);
            CloseHandle(err_r); CloseHandle(err_w);
            return Err(anyhow!("SetHandleInformation failed: {}", GetLastError()));
        }
    }

    // 6. 创建进程
    let mut pi: PROCESS_INFORMATION = std::mem::zeroed();

    let ok = CreateProcessAsUserW(
        h_token,
        ptr::null(),                             // 使用命令行解析 exe
        cmdline.as_mut_ptr(),
        ptr::null_mut(),                         // 进程安全属性
        ptr::null_mut(),                         // 线程安全属性
        1,                                       // bInheritHandles = TRUE
        CREATE_UNICODE_ENVIRONMENT,
        env_block.as_ptr() as *mut _,
        cwd_wide.as_ptr(),
        &si,
        &mut pi,
    );

    // 关闭父进程不需要的管道端
    CloseHandle(in_r);
    CloseHandle(in_w);
    CloseHandle(out_w);
    CloseHandle(err_w);

    if ok == 0 {
        let err = GetLastError();
        CloseHandle(out_r);
        CloseHandle(err_r);

        // 为常见错误提供友好提示
        let hint = match err {
            2 => {
                let first_cmd = command.first().map(|s| s.as_str()).unwrap_or("");
                format!(
                    "\n  💡 提示: '{first_cmd}' 不是可执行文件（cmd 内部命令需要用 cmd /c 前缀）\n  \
                     正确用法: wsbx exec cmd /c \"{}\"",
                    command.iter().map(|s| {
                        if s.contains(' ') { format!("\"{}\"", s) } else { s.clone() }
                    }).collect::<Vec<_>>().join(" ")
                )
            }
            87 => "\n  💡 提示: 参数错误，检查命令格式".to_string(),
            _ => String::new(),
        };

        return Err(anyhow!(
            "CreateProcessAsUserW failed: {err} (cmd: {cmdline_str}){hint}"
        ));
    }

    // 如果提供了 process_handle_out，存储进程句柄供外部中断使用
    if let Some(ph_out) = process_handle_out {
        *ph_out.lock().unwrap() = Some(pi.hProcess);
    }

    // 7. 读取子进程输出（使用独立线程避免管道死锁）
    //
    // 注意：Windows 管道需要同时读取 stdout 和 stderr，否则当其中一个
    // 管道缓冲区满时子进程会被阻塞。使用两个独立线程并发读取。
    //
    // ⚠ 死锁防护：进程退出后，如果孙进程继承管道句柄，ReadFile 会永久阻塞。
    // 使用带超时的线程 Join + 强制关闭管道的兜底策略。
    let (tx_out, rx_out) = std::sync::mpsc::channel::<Vec<u8>>();
    let (tx_err, rx_err) = std::sync::mpsc::channel::<Vec<u8>>();

    // 保留管道读端副本，用于在读取线程卡死时强制解除阻塞
    let cancel_out_r = out_r;
    let cancel_err_r = err_r;

    let t_out = std::thread::spawn(move || {
        let mut buf = Vec::new();
        let mut tmp = [0u8; 8192];
        loop {
            let mut read_bytes: u32 = 0;
            let ok = ReadFile(
                out_r,
                tmp.as_mut_ptr() as *mut _,
                tmp.len() as u32,
                &mut read_bytes,
                ptr::null_mut(),
            );
            if ok == 0 || read_bytes == 0 {
                break;
            }
            buf.extend_from_slice(&tmp[..read_bytes as usize]);
        }
        let _ = tx_out.send(buf);
    });

    let t_err = std::thread::spawn(move || {
        let mut buf = Vec::new();
        let mut tmp = [0u8; 8192];
        loop {
            let mut read_bytes: u32 = 0;
            let ok = ReadFile(
                err_r,
                tmp.as_mut_ptr() as *mut _,
                tmp.len() as u32,
                &mut read_bytes,
                ptr::null_mut(),
            );
            if ok == 0 || read_bytes == 0 {
                break;
            }
            buf.extend_from_slice(&tmp[..read_bytes as usize]);
        }
        let _ = tx_err.send(buf);
    });

    // 8. 等待进程完成或超时
    let timed_out = if let Some(timeout) = timeout_ms {
        let res = WaitForSingleObject(pi.hProcess, timeout as u32);
        if res == 0x0000_0102 {
            TerminateProcess(pi.hProcess, 1);
            true
        } else {
            false
        }
    } else {
        WaitForSingleObject(pi.hProcess, INFINITE);
        false
    };

    // 9. 获取退出码
    let mut exit_code: u32 = 1;
    if !timed_out {
        GetExitCodeProcess(pi.hProcess, &mut exit_code);
    }

    // 10. 清理进程句柄
    //
    // 如果外部持有进程句柄（来自 process_handle_out），由调用者负责关闭。
    // 否则在此关闭。
    if process_handle_out.is_none() {
        CloseHandle(pi.hProcess);
    }
    CloseHandle(pi.hThread);

    // 11. 等待读取线程完成（带超时防止死锁）
    //
    // 正常情况下子进程退出后管道关闭，线程在几毫秒内完成。
    // 异常情况下孙进程持有管道句柄导致 ReadFile 阻塞。
    // 使用 5 秒超时 + 强制关闭管道的兜底策略。
    fn join_reader(
        thread: std::thread::JoinHandle<()>,
        cancel_handle: HANDLE,
        label: &str,
    ) {
        // 先尝试短暂等待（正常情况线程几乎立即完成）
        if thread.is_finished() {
            let _ = thread.join();
            return;
        }
        // 线程仍在运行 → 等待最多 5 秒
        let start = std::time::Instant::now();
        while start.elapsed() < std::time::Duration::from_secs(5) {
            if thread.is_finished() {
                let _ = thread.join();
                return;
            }
            std::thread::sleep(std::time::Duration::from_millis(100));
        }
        // 超时 → 强制关闭管道解除 ReadFile 阻塞
        eprintln!("⚠ 读取线程 '{label}' 超时（孙进程可能持有管道），强制关闭管道");
        unsafe {
            CloseHandle(cancel_handle);
        }
        let _ = thread.join();
    }

    join_reader(t_out, cancel_out_r, "stdout");
    join_reader(t_err, cancel_err_r, "stderr");

    let stdout = rx_out.recv().unwrap_or_default();
    let stderr = rx_err.recv().unwrap_or_default();

    Ok(ProcessResult {
        exit_code,
        stdout,
        stderr,
        timed_out,
    })
}

/// 以受限令牌创建进程，支持实时流式输出回调
///
/// 与 [`execute_with_token`] 功能相同，但每读取到一个输出块就立即通过回调通知，
/// 而非等待进程结束才返回全部输出。适合需要实时显示执行进度的场景。
///
/// # Safety
/// h_token 必须是有效的受限令牌句柄
pub unsafe fn execute_with_token_stream(
    h_token: HANDLE,
    command: &[String],
    cwd: &Path,
    env_map: &HashMap<String, String>,
    timeout_ms: Option<u64>,
    desktop_name: Option<&str>,
    on_stdout: impl FnMut(&[u8]) + Send + 'static,
    on_stderr: impl FnMut(&[u8]) + Send + 'static,
) -> Result<ProcessResult> {
    if command.is_empty() {
        return Err(anyhow!("Empty command"));
    }

    // 1. 创建管道
    let ((in_r, in_w), (out_r, out_w), (err_r, err_w)) = create_pipes()?;

    // 2. 构建命令行
    let cmdline_str = argv_to_command_line(command);
    let mut cmdline = to_wide(&cmdline_str);

    // 3. 构建环境变量块
    let env_block = if env_map.is_empty() {
        let current_env: HashMap<String, String> = std::env::vars().collect();
        make_env_block(&current_env)
    } else {
        make_env_block(env_map)
    };

    // 4. 工作目录
    let cwd_wide = to_wide(cwd);

    // 5. 设置 STARTUPINFOW
    let desktop_str = desktop_name.unwrap_or("Winsta0\\Default");
    let desktop_name_wide = to_wide(desktop_str);
    let mut si: STARTUPINFOW = std::mem::zeroed();
    si.cb = std::mem::size_of::<STARTUPINFOW>() as u32;
    si.lpDesktop = desktop_name_wide.as_ptr() as *mut u16;
    si.dwFlags = STARTF_USESTDHANDLES;
    si.hStdInput = in_r;
    si.hStdOutput = out_w;
    si.hStdError = err_w;

    for &handle in &[in_r, out_w, err_w] {
        if SetHandleInformation(handle, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT) == 0 {
            CloseHandle(in_r); CloseHandle(in_w);
            CloseHandle(out_r); CloseHandle(out_w);
            CloseHandle(err_r); CloseHandle(err_w);
            return Err(anyhow!("SetHandleInformation failed: {}", GetLastError()));
        }
    }

    // 6. 创建进程
    let mut pi: PROCESS_INFORMATION = std::mem::zeroed();
    let ok = CreateProcessAsUserW(
        h_token,
        ptr::null(),
        cmdline.as_mut_ptr(),
        ptr::null_mut(),
        ptr::null_mut(),
        1,
        CREATE_UNICODE_ENVIRONMENT,
        env_block.as_ptr() as *mut _,
        cwd_wide.as_ptr(),
        &si,
        &mut pi,
    );

    CloseHandle(in_r);
    CloseHandle(in_w);
    CloseHandle(out_w);
    CloseHandle(err_w);

    if ok == 0 {
        let err = GetLastError();
        CloseHandle(out_r);
        CloseHandle(err_r);
        let hint = match err {
            2 => {
                let first_cmd = command.first().map(|s| s.as_str()).unwrap_or("");
                format!(
                    "\n  💡 提示: '{first_cmd}' 不是可执行文件（cmd 内部命令需要用 cmd /c 前缀）\n  \
                     正确用法: wsbx exec cmd /c \"{}\"",
                    command.iter().map(|s| {
                        if s.contains(' ') { format!("\"{}\"", s) } else { s.clone() }
                    }).collect::<Vec<_>>().join(" ")
                )
            }
            _ => String::new(),
        };
        return Err(anyhow!(
            "CreateProcessAsUserW failed: {err} (cmd: {cmdline_str}){hint}"
        ));
    }

    // 7. 流式读取输出（每读到一个块就回调，同时累积到缓冲区）
    //
    // ⚠ 死锁风险：如果子进程衍生孙进程并继承管道句柄，即使子进程退出，
    // 管道写端也不会关闭，导致 ReadFile 永久阻塞。
    // 
    // 解决方案：进程结束后等待 5 秒让读取线程排空剩余数据。如果超时，
    // 说明被孙进程阻塞，强制关闭管道读端以解除 ReadFile 阻塞。
    let (tx_out, rx_out) = std::sync::mpsc::channel::<(Vec<u8>, Vec<u8>)>();
    let (tx_done, rx_done) = std::sync::mpsc::channel::<()>();

    let mut on_stdout = on_stdout;
    let mut on_stderr = on_stderr;

    // 保留管道读端副本，用于在读取线程卡死时强制解除阻塞
    let cancel_out_r = out_r;
    let cancel_err_r = err_r;

    let t_reader = std::thread::spawn(move || {
        let mut buf_out = Vec::new();
        let mut buf_err = Vec::new();
        let mut tmp = [0u8; 8192];

        loop {
            let mut any_read = false;

            // 尝试读 stdout
            let mut read_bytes: u32 = 0;
            let ok = ReadFile(
                out_r,
                tmp.as_mut_ptr() as *mut _,
                tmp.len() as u32,
                &mut read_bytes,
                ptr::null_mut(),
            );
            if ok != 0 && read_bytes > 0 {
                let chunk = &tmp[..read_bytes as usize];
                buf_out.extend_from_slice(chunk);
                on_stdout(chunk);
                any_read = true;
            }

            // 尝试读 stderr
            let mut read_bytes: u32 = 0;
            let ok = ReadFile(
                err_r,
                tmp.as_mut_ptr() as *mut _,
                tmp.len() as u32,
                &mut read_bytes,
                ptr::null_mut(),
            );
            if ok != 0 && read_bytes > 0 {
                let chunk = &tmp[..read_bytes as usize];
                buf_err.extend_from_slice(chunk);
                on_stderr(chunk);
                any_read = true;
            }

            // 两个管道都关闭了（ReadFile 返回 0 或 read_bytes == 0）
            if !any_read {
                let mut eof_out = false;
                let mut read_bytes: u32 = 0;
                if ReadFile(
                    out_r,
                    tmp.as_mut_ptr() as *mut _,
                    tmp.len() as u32,
                    &mut read_bytes,
                    ptr::null_mut(),
                ) == 0 || read_bytes == 0 {
                    eof_out = true;
                } else if read_bytes > 0 {
                    let chunk = &tmp[..read_bytes as usize];
                    buf_out.extend_from_slice(chunk);
                    on_stdout(chunk);
                    continue;
                }

                let mut eof_err = false;
                let mut read_bytes: u32 = 0;
                if ReadFile(
                    err_r,
                    tmp.as_mut_ptr() as *mut _,
                    tmp.len() as u32,
                    &mut read_bytes,
                    ptr::null_mut(),
                ) == 0 || read_bytes == 0 {
                    eof_err = true;
                } else if read_bytes > 0 {
                    let chunk = &tmp[..read_bytes as usize];
                    buf_err.extend_from_slice(chunk);
                    on_stderr(chunk);
                    continue;
                }

                if eof_out && eof_err {
                    break;
                }
            }
        }

        let _ = tx_out.send((buf_out, buf_err));
        let _ = tx_done.send(());
    });

    // 8. 等待进程完成或超时
    let timed_out = if let Some(timeout) = timeout_ms {
        let res = WaitForSingleObject(pi.hProcess, timeout as u32);
        if res == 0x0000_0102 {
            TerminateProcess(pi.hProcess, 1);
            true
        } else {
            false
        }
    } else {
        WaitForSingleObject(pi.hProcess, INFINITE);
        false
    };

    // 9. 获取退出码
    let mut exit_code: u32 = 1;
    if !timed_out {
        GetExitCodeProcess(pi.hProcess, &mut exit_code);
    }

    // 10. 清理进程句柄
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);

    // 11. 等待读取线程完成（最多 5 秒防止死锁）
    //
    // 正常情况下，子进程退出后管道写端关闭，ReadFile 返回 EOF，
    // 读取线程在几毫秒内完成。
    //
    // 异常情况：子进程的孙进程继承了管道句柄且未退出，
    // 管道写端未关闭 → ReadFile 永久阻塞。
    // 
    // 此时强制关闭管道读端，ReadFile 会收到错误并退出循环。
    match rx_done.recv_timeout(std::time::Duration::from_secs(5)) {
        Ok(_) => {
            let _ = t_reader.join();
        }
        Err(_) => {
            // 读取线程卡死 → 强制关闭管道读端解除 ReadFile 阻塞
            eprintln!("⚠ 读取线程超时（孙进程可能持有管道句柄），强制关闭管道");
            unsafe {
                CloseHandle(cancel_out_r);
                CloseHandle(cancel_err_r);
            }
            let _ = t_reader.join();
        }
    }
    let (stdout, stderr) = rx_out.recv().unwrap_or_default();

    Ok(ProcessResult {
        exit_code,
        stdout,
        stderr,
        timed_out,
    })
}

// ==================== 单元测试 ====================

#[cfg(test)]
mod tests {
    use super::*;

    // ---- argv_to_command_line ----

    #[test]
    fn test_argv_simple_no_quoting() {
        let args = vec!["hello".to_string(), "world".to_string()];
        let cmd = argv_to_command_line(&args);
        assert_eq!(cmd, "hello world");
    }

    #[test]
    fn test_argv_with_space_adds_quotes() {
        let args = vec!["hello world".to_string(), "test".to_string()];
        let cmd = argv_to_command_line(&args);
        assert_eq!(cmd, "\"hello world\" test");
    }

    #[test]
    fn test_argv_with_embedded_quote() {
        let args = vec!["it's\"done\"".to_string()];
        let cmd = argv_to_command_line(&args);
        assert_eq!(cmd, "\"it's\\\"done\\\"\"");
    }

    #[test]
    fn test_argv_with_trailing_backslash() {
        let args = vec!["path\\".to_string(), "end".to_string()];
        let cmd = argv_to_command_line(&args);
        // 结尾反斜杠在引号前需要翻倍
        assert_eq!(cmd, "\"path\\\\\" end");
    }

    #[test]
    fn test_argv_with_trailing_backslashes_and_quote() {
        // 输入: a\\"b (a + 2反斜杠 + 引号 + b)
        // 2个反斜杠 + 引号 → 2*2+1=5个反斜杠 + 引号
        let args = vec!["a\\\\\"b".to_string()];
        let cmd = argv_to_command_line(&args);
        // 预期: "a" + 5个反斜杠 + 引号 + "b" + "
        let mut expected = String::from("\"a");
        expected.push_str(&"\\".repeat(5)); // 5个反斜杠
        expected.push_str("\"b\"");
        assert_eq!(cmd, expected);
    }

    #[test]
    fn test_argv_mixed_complex() {
        let args = vec![
            "simple".to_string(),
            "with space".to_string(),
            "trail\\".to_string(),
            "quote\"here".to_string(),
        ];
        let cmd = argv_to_command_line(&args);
        // 算法验证:
        //   trail\ → 1 个结尾反斜杠 → 翻倍为 2 个 → "trail\\"
        //   quote"here → 0 个反斜杠后跟 " → \" → "quote\"here"
        assert_eq!(cmd, "simple \"with space\" \"trail\\\\\" \"quote\\\"here\"");
    }

    #[test]
    fn test_argv_trailing_backslashes_and_quote_combined() {
        let args = vec!["a\\\"b".to_string()];
        let cmd = argv_to_command_line(&args);
        // 输入 a\"b → 字符: a, \, ", b
        // 遇到 \ → backslash_count=1
        // 遇到 " → 1*2+1=3 反斜杠 + " → 然后 b
        // 结果: "a\\\"b" (a + 3反斜杠 + " + b, 外包装配引号)
        let mut expected = String::from("\"a");
        expected.push_str(&"\\".repeat(3)); // 3个反斜杠
        expected.push_str("\"b\"");
        assert_eq!(cmd, expected);
    }

    #[test]
    fn test_argv_empty_arg() {
        let args = vec!["".to_string()];
        let cmd = argv_to_command_line(&args);
        // 空字符串不含特殊字符，原样返回空串（无需引号包裹）
        assert_eq!(cmd, "");
    }

    #[test]
    fn test_argv_only_backslashes() {
        let args = vec!["\\\\".to_string()];
        let cmd = argv_to_command_line(&args);
        // 2个结尾反斜杠 → 翻倍到4个
        assert_eq!(cmd, "\"\\\\\\\\\"");
    }

    #[test]
    fn test_argv_multiple_args_roundtrip() {
        // 验证基本组合：一个简单参数 + 一个带空格的参数
        let args = vec!["hello".to_string(), "foo bar".to_string(), "end".to_string()];
        let cmd = argv_to_command_line(&args);
        assert_eq!(cmd, "hello \"foo bar\" end");
    }

    // ---- make_env_block ----

    #[test]
    fn test_env_block_single_entry() {
        let mut env = HashMap::new();
        env.insert("PATH".to_string(), "C:\\bin".to_string());
        let block = make_env_block(&env);
        // 格式: "PATH=C:\bin\0\0"
        assert!(block.len() >= 2, "至少应有 2 个 null: {:?}", block);
        assert_eq!(block[block.len() - 1], 0, "应以双 null 结尾");
        assert_eq!(block[block.len() - 2], 0, "倒数第二个也应为 null");
    }

    #[test]
    fn test_env_block_double_null_terminated() {
        let mut env = HashMap::new();
        env.insert("A".to_string(), "1".to_string());
        let block = make_env_block(&env);
        assert!(block.ends_with(&[0, 0]), "环境块应以双 null 终止");
    }

    #[test]
    fn test_env_block_multiple_entries() {
        let mut env = HashMap::new();
        env.insert("B".to_string(), "2".to_string());
        env.insert("A".to_string(), "1".to_string());
        let block = make_env_block(&env);
        // 应排序"B"在"A"后，所以 "A=1\0B=2\0\0"
        assert!(block.ends_with(&[0, 0]));
    }

    #[test]
    fn test_env_block_empty_env_produces_only_double_null() {
        let env = HashMap::new();
        let block = make_env_block(&env);
        assert_eq!(block, vec![0, 0], "空环境块应只有双 null");
    }
}