fix(test): 收紧 should_panic 判定

MRNIU · MRNIU · commit 80e6dc2b1aaa · 2026-05-08T16:21:28.000+08:00
R4 第一阶段先修测试可信度问题，避免 QEMU guest 退出码没有传递到宿主时，should_panic 未触发也被 xtask 误判为通过。

- 让 normal/should_panic 测试分别输出 TEST OK 和 SHOULD_PANIC OK success sentinel
- 让 xtask 的 --name 和全量测试路径统一捕获串口输出并校验 sentinel
- 补充 xtask 单测覆盖缺失 sentinel、normal 成功、should_panic 成功和 timeout
- 移除 test_harness 多余 alloc_error_handler feature gate，避免新增 warning
- 更新 R4 audit-progress，记录第一阶段修复、验证结果和下一步低耦合切片

验证：
- docker exec simplekernel-dev sh -lc 'cd /workspace &amp;&amp; cargo fmt --all -- --check'
- docker exec simplekernel-dev sh -lc 'cd /workspace &amp;&amp; cargo test -p xtask'
- docker exec simplekernel-dev sh -lc 'cd /workspace &amp;&amp; cargo xtask check --arch riscv64'
- docker exec simplekernel-dev sh -lc 'cd /workspace &amp;&amp; cargo xtask check --arch aarch64'
- docker exec simplekernel-dev sh -lc 'cd /workspace &amp;&amp; cargo xtask test --arch riscv64 --name device-test --timeout 30'
- docker exec simplekernel-dev sh -lc 'cd /workspace &amp;&amp; cargo xtask test --arch riscv64 --name memory-types-test/align-down-canonical-panic --timeout 30'

Signed-off-by: Niu Zhihong &lt;zhihong@nzhnb.com&gt;
diff --git a/docs/audit/audit-progress.md b/docs/audit/audit-progress.md
@@ -5,18 +5,34 @@
 
 ## 当前状态
 
-**当前 Phase**: R4 — 架构层只读复审已完成，并已将问题原因、可能触发路径、修复方案和验证方向写入 `docs/audit/2026-05-08-r4-architecture-review-findings.md`。本轮未修改实现代码；R4 修复尚未开始。
+**当前 Phase**: R4 — 架构层第一阶段测试可信度修复已完成。`R4-09 should_panic harness/xtask 假阳性`
+已通过串口 success sentinel 和 xtask 输出判定收口，后续 panic 回归不再只依赖 QEMU 宿主退出码。
 **下一个目标**（按优先级）：
-1. **测试可信度优先**：修复 R4-09 `should_panic` harness/xtask 假阳性问题，否则后续 panic 回归可能继续误判通过。
-2. **R4 低耦合修复切片**：R4-03 RISC-V 从核 `gp` 初始化、R4-07 任务栈 16 字节对齐、R4-08 `ArchOps::dtb_addr()` unsafe 边界、R4-10 AArch64 `TCR_EL1.IPS`、R4-15 timer fail-fast。
-3. **R4 时序与跨核协议设计**：R4-01/R4-02 timer 与调度边界、R4-04/R4-12 CPU topology 与 SGI、R4-05 TLB shootdown 协议、R4-11 PLIC context 与启用顺序、R4-13 discovered/online core count、R4-14 timekeeper core。
-4. **R3 遗留设计跟踪**：`PageTable::update_range_flags()` 若进入运行期路径，需要并发写者证明；完整多 bank RAM、真机设备/DMA 语义继续按 `docs/audit/2026-05-07-device-dma-rdrive-tracking.md` 跟踪。
+1. **R4 低耦合修复切片**：R4-03 RISC-V 从核 `gp` 初始化、R4-07 任务栈 16 字节对齐、R4-08 `ArchOps::dtb_addr()` unsafe 边界、R4-10 AArch64 `TCR_EL1.IPS`、R4-15 timer fail-fast。
+2. **R4 时序与跨核协议设计**：R4-01/R4-02 timer 与调度边界、R4-04/R4-12 CPU topology 与 SGI、R4-05 TLB shootdown 协议、R4-11 PLIC context 与启用顺序、R4-13 discovered/online core count、R4-14 timekeeper core。
+3. **R3 遗留设计跟踪**：`PageTable::update_range_flags()` 若进入运行期路径，需要并发写者证明；完整多 bank RAM、真机设备/DMA 语义继续按 `docs/audit/2026-05-07-device-dma-rdrive-tracking.md` 跟踪。
 
 验证计划：后续设计边界改动仍需先补目标回归测试，再按变更面执行
 `cargo fmt --all -- --check`、`cargo xtask check --arch riscv64`、
 `cargo xtask check --arch aarch64`。涉及 QEMU 的命令必须使用 30 秒超时并在
 超时后清理残留 `qemu-system` 进程。
 
+验证结果（2026-05-08 R4 第一阶段测试可信度修复）：容器 `simplekernel-dev`
+内 `cargo fmt --all -- --check`、`cargo test -p xtask`、`cargo xtask check --arch riscv64`、
+`cargo xtask check --arch aarch64` 通过（保留既有 warning）。新增 xtask 单测覆盖：
+QEMU 进程状态成功但缺少 success sentinel 时必须失败、normal `TEST OK` 成功、
+`should_panic` 的 `SHOULD_PANIC OK` 成功、timeout 即使带 success sentinel 也失败。
+RISC-V QEMU 30 秒超时下定点验证通过：`memory-types-test/codec`、
+`memory-types-test/align-down-canonical-panic`、`panic-test`、`device-test`。
+随后运行 `cargo xtask test --arch riscv64 --timeout 30`，30 个独立测试全部通过
+（30 passed, 0 failed, 0 timed out）。另用 AArch64 目标构建 `device-test` 和
+`memory-types-test/align-down-canonical-panic`，确认 test harness normal / should_panic
+路径在 AArch64 也能编译。第一次全量 RISC-V 回归曾暴露 `device-test` 的裸串口
+`TEST OK` 被从核日志穿插打碎，最终改为通过 `log` 后端输出 success sentinel，
+由 console lock 保证单条 sentinel 不被并发日志破坏。提交前复查 warning 时，
+清理了 `tests/test_harness` 中新触发的 `unused feature: alloc_error_handler`；
+复跑验证后，本轮改动文件不再产生新的编译 warning，剩余 warning 均来自既有内核路径。
+
 验证结果（2026-05-08 R4 复审文档化）：本轮只新增审计文档并更新进度文件，
 未修改实现代码，未运行构建或 QEMU 系统测试。R4 问题详情见
 `docs/audit/2026-05-08-r4-architecture-review-findings.md`。
@@ -49,6 +65,35 @@ frame allocator 后端已在 hard IRQ 上下文分配/释放时 fail-fast。
 
 ## 上次对话摘要
 
+**日期**：2026-05-08（R4 第一阶段测试可信度修复）
+
+### 已完成
+
+本轮按 `docs/audit/2026-05-08-r4-architecture-review-findings.md` 的处理顺序，
+先修复 R4-09 `should_panic` harness/xtask 假阳性问题：
+
+1. normal `test_main!` 测试成功后输出 `TEST OK` sentinel。
+2. should_panic 和手写 `panic-test` 的成功路径统一输出 `SHOULD_PANIC OK` sentinel。
+3. `cargo xtask test --name` 与全量测试均改用捕获输出路径，并由 xtask 同时检查 QEMU 进程状态、
+   timeout、失败 sentinel 和 success sentinel。
+4. success sentinel 改用 `log` 后端输出，避免 SMP 从核日志与裸串口 sentinel 交错导致误判。
+
+### 关键结论
+
+| # | 结论 | 状态 | ADR |
+|---|------|------|-----|
+| R4-09 `should_panic` harness 假阳性 | 已通过统一 success sentinel + xtask 输出判定修复 | 已修复 | — |
+| QEMU guest `exit_qemu(code)` 仍不应作为唯一可信信号 | xtask 现在要求串口 success sentinel；缺失即失败 | 已收口 | — |
+| SMP 日志可打碎裸串口 sentinel | success sentinel 必须走日志锁或等价原子输出路径 | 已修复 | — |
+| R4-03/R4-07/R4-08/R4-10/R4-15 | 下一组低耦合修复切片 | 待修复 | 部分待定 |
+
+### 下一步
+
+进入 R4 低耦合修复切片：优先处理 R4-03 RISC-V 从核 `gp` 初始化、R4-07 任务栈 16 字节对齐、
+R4-08 `ArchOps::dtb_addr()` unsafe 边界、R4-10 AArch64 `TCR_EL1.IPS`、R4-15 timer fail-fast。
+
+---
+
 **日期**：2026-05-08（R4 架构层复审文档化）
 
 ### 已完成
diff --git a/tests/panic_test/src/main.rs b/tests/panic_test/src/main.rs
@@ -95,14 +95,14 @@ fn exit_qemu(code: u32) -> ! {
 #[panic_handler]
 fn panic(_info: &PanicInfo<'_>) -> ! {
     // 打印触发标记——测试运行器通过此字符串判断测试通过
-    simplekernel::logging::raw_put("PANIC_TEST_TRIGGERED\n");
+    log::info!("SHOULD_PANIC OK: PANIC_TEST_TRIGGERED");
     // 成功退出——触发 panic 就是期望行为
     exit_qemu(0);
 }
 
 #[alloc_error_handler]
 fn alloc_error(layout: Layout) -> ! {
-    simplekernel::logging::raw_put("PANIC_TEST: alloc error\n");
+    simplekernel::logging::raw_put("TEST PANIC: alloc error\n");
     let _ = layout;
     exit_qemu(1);
 }
diff --git a/tests/test_harness/src/lib.rs b/tests/test_harness/src/lib.rs
@@ -4,7 +4,6 @@
 //! （`_start`、`panic_handler`、`exit_qemu`、`kernel_thread_bootstrap`）。
 
 #![no_std]
-#![feature(alloc_error_handler)]
 
 extern crate alloc;
 
@@ -86,6 +85,7 @@ macro_rules! test_main {
                     simplekernel::boot::kernel_init(argc, argv, $level);
                 }
                 $test_fn();
+                log::info!("TEST OK");
                 $crate::exit_qemu(0);
             } else {
                 // SAFETY: 从核入口，汇编已设置栈和寄存器
@@ -149,21 +149,16 @@ macro_rules! test_main {
 
         #[panic_handler]
         fn panic(info: &core::panic::PanicInfo<'_>) -> ! {
-            // 打印 panic 信息供 xtask 检查
-            simplekernel::logging::raw_put("\x1b[32mSHOULD_PANIC OK\x1b[0m: ");
             if let Some(loc) = info.location() {
-                let mut buf = heapless::String::<256>::new();
-                let _ = core::fmt::Write::write_fmt(
-                    &mut buf,
-                    format_args!("{}:{}", loc.file(), loc.line()),
+                log::info!(
+                    "SHOULD_PANIC OK: {}:{}: {}",
+                    loc.file(),
+                    loc.line(),
+                    info.message()
                 );
-                simplekernel::logging::raw_put(buf.as_str());
+            } else {
+                log::info!("SHOULD_PANIC OK: <unknown>: {}", info.message());
             }
-            simplekernel::logging::raw_put(": ");
-            let mut msg_buf = heapless::String::<256>::new();
-            let _ = core::fmt::Write::write_fmt(&mut msg_buf, format_args!("{}", info.message()));
-            simplekernel::logging::raw_put(msg_buf.as_str());
-            simplekernel::logging::raw_put("\n");
             // panic 发生 = should_panic 测试成功
             $crate::exit_qemu(0);
         }
diff --git a/xtask/src/test.rs b/xtask/src/test.rs
@@ -45,6 +45,69 @@ pub struct TestBinary {
     pub display_name: String,
 }
 
+/// 根据 QEMU 进程状态和串口 sentinel 得出的测试判定。
+struct TestVerdict {
+    passed: bool,
+    status: &'static str,
+    failure_reason: Option<String>,
+}
+
+const SUCCESS_SENTINELS: [&str; 2] = ["TEST OK", "SHOULD_PANIC OK"];
+
+const FAILURE_SENTINELS: [&str; 3] = [
+    "SHOULD_PANIC test returned without panic",
+    "TEST PANIC:",
+    "PANIC_TEST: alloc error",
+];
+
+/// QEMU 的宿主退出码不一定携带 guest `exit_qemu(code)`，因此测试必须以串口
+/// sentinel 作为最终成功条件。
+fn evaluate_qemu_test_result(result: &qemu::QemuTestResult) -> TestVerdict {
+    if result.timed_out {
+        return TestVerdict {
+            passed: false,
+            status: "TIMEOUT",
+            failure_reason: Some("QEMU 运行超时".to_string()),
+        };
+    }
+
+    if !result.success {
+        return TestVerdict {
+            passed: false,
+            status: "FAIL",
+            failure_reason: Some("QEMU 进程非零退出".to_string()),
+        };
+    }
+
+    if let Some(marker) = FAILURE_SENTINELS
+        .iter()
+        .find(|marker| result.output.contains(**marker))
+    {
+        return TestVerdict {
+            passed: false,
+            status: "FAIL",
+            failure_reason: Some(format!("串口输出包含失败标记 `{marker}`")),
+        };
+    }
+
+    if SUCCESS_SENTINELS
+        .iter()
+        .any(|marker| result.output.contains(marker))
+    {
+        return TestVerdict {
+            passed: true,
+            status: "PASS",
+            failure_reason: None,
+        };
+    }
+
+    TestVerdict {
+        passed: false,
+        status: "FAIL",
+        failure_reason: Some("串口输出缺少 `TEST OK` 或 `SHOULD_PANIC OK` 成功标记".to_string()),
+    }
+}
+
 /// 运行指定测试
 #[expect(
     clippy::too_many_arguments,
@@ -79,21 +142,26 @@ pub fn run_test(
         "[xtask] Running test '{}' (timeout: {}s)...",
         display_name, timeout_secs
     );
-    let result = qemu::launch_qemu(
-        sh,
+    let result = qemu::launch_qemu_captured(
         arch,
         project_root,
         &env.boot_dir,
         &kernel_elf_path,
         &env.rootfs_path,
-        false,
-        Some(timeout_secs),
+        timeout_secs,
     );
 
     match result {
-        Ok(()) => {
-            println!("[xtask] Test '{}' completed", display_name);
-            Ok(true)
+        Ok(qemu_result) => {
+            let verdict = evaluate_qemu_test_result(&qemu_result);
+            println!("[xtask] Test '{}' {}", display_name, verdict.status);
+            if let Some(reason) = verdict.failure_reason {
+                eprintln!("[xtask] Test '{}' failed: {}", display_name, reason);
+                println!("---------- {} output ----------", display_name);
+                println!("{}", qemu_result.output);
+                println!("---------- end {} ----------", display_name);
+            }
+            Ok(verdict.passed)
         }
         Err(e) => {
             eprintln!("[xtask] Test '{}' failed: {}", display_name, e);
@@ -212,6 +280,7 @@ struct TestResult {
     timed_out: bool,
     duration: std::time::Duration,
     output: String,
+    failure_reason: Option<String>,
 }
 
 /// 运行所有测试：构建全部二进制，顺序执行并捕获输出，打印汇总。
@@ -277,24 +346,20 @@ pub fn run_all_tests(
         )?;
 
         let duration = start.elapsed();
-        let status = if qemu_result.timed_out {
-            "TIMEOUT"
-        } else if qemu_result.success {
-            "PASS"
-        } else {
-            "FAIL"
-        };
+        let verdict = evaluate_qemu_test_result(&qemu_result);
         println!(
-            "[xtask]   {name}: {status} ({:.1}s)",
+            "[xtask]   {name}: {} ({:.1}s)",
+            verdict.status,
             duration.as_secs_f64()
         );
 
         results.push(TestResult {
             name: name.clone(),
-            passed: qemu_result.success,
+            passed: verdict.passed,
             timed_out: qemu_result.timed_out,
             duration,
             output: qemu_result.output,
+            failure_reason: verdict.failure_reason,
         });
     }
 
@@ -333,10 +398,62 @@ pub fn run_all_tests(
         if !r.passed {
             println!();
             println!("---------- {} output ----------", r.name);
+            if let Some(reason) = &r.failure_reason {
+                println!("failure reason: {reason}");
+            }
             println!("{}", r.output);
             println!("---------- end {} ----------", r.name);
         }
     }
 
     Ok(failed == 0 && timed_out == 0)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn qemu_result(success: bool, timed_out: bool, output: &str) -> qemu::QemuTestResult {
+        qemu::QemuTestResult {
+            success,
+            timed_out,
+            output: output.to_string(),
+        }
+    }
+
+    #[test]
+    fn missing_success_sentinel_fails_even_when_qemu_status_is_success() {
+        let result = qemu_result(true, false, "SHOULD_PANIC test returned without panic\n");
+
+        let verdict = evaluate_qemu_test_result(&result);
+
+        assert!(!verdict.passed);
+    }
+
+    #[test]
+    fn normal_success_sentinel_passes() {
+        let result = qemu_result(true, false, "boot log\nTEST OK\n");
+
+        let verdict = evaluate_qemu_test_result(&result);
+
+        assert!(verdict.passed);
+    }
+
+    #[test]
+    fn should_panic_success_sentinel_passes() {
+        let result = qemu_result(true, false, "\u{1b}[32mSHOULD_PANIC OK\u{1b}[0m: panic\n");
+
+        let verdict = evaluate_qemu_test_result(&result);
+
+        assert!(verdict.passed);
+    }
+
+    #[test]
+    fn timeout_fails_even_with_success_sentinel() {
+        let result = qemu_result(false, true, "TEST OK\n[TIMEOUT after 30s]");
+
+        let verdict = evaluate_qemu_test_result(&result);
+
+        assert!(!verdict.passed);
+    }
+}
