703a515b16
Same class as the joule_core batch: one redundant clone on a value with no later use, and two test fixtures that build with cargo and genuinely want to block, so they say so with a scoped allow rather than leaving the gate red for everyone. Co-Authored-By: Claude Opus 5 <[email protected]>
79 lines
3.3 KiB
Rust
79 lines
3.3 KiB
Rust
//! The stateful DAP client, end-to-end against a real `lldb-dap`. `#[ignore]`d
|
|
//! because it needs the adapter installed + OS debugging permission; run with:
|
|
//! cargo test -p joule_coded --test dap_step -- --ignored
|
|
|
|
use joule_coded::dap::{find_adapter, DapSession};
|
|
|
|
#[test]
|
|
#[ignore = "needs lldb-dap + OS debugging permission"]
|
|
fn dap_session_walks_execution_and_watches_a_value_change() {
|
|
let Some(adapter) = find_adapter() else {
|
|
eprintln!("no lldb-dap adapter; skipping");
|
|
return;
|
|
};
|
|
|
|
let root = std::env::temp_dir().join(format!("jc-dap-{}", std::process::id()));
|
|
let src = root.join("src");
|
|
std::fs::create_dir_all(&src).unwrap();
|
|
std::fs::write(
|
|
root.join("Cargo.toml"),
|
|
"[package]\nname = \"loopy\"\nversion = \"0.0.0\"\nedition = \"2021\"\n\
|
|
[[bin]]\nname = \"loopy\"\npath = \"src/main.rs\"\n[profile.dev]\ndebug = true\n",
|
|
)
|
|
.unwrap();
|
|
// `total` evolves 0 → 1 → 3 across the breakpoint on line 4.
|
|
std::fs::write(
|
|
src.join("main.rs"),
|
|
"fn main() {\n\
|
|
\x20 let mut total = 0i32;\n\
|
|
\x20 for i in 1..=3 {\n\
|
|
\x20 total += i;\n\
|
|
\x20 }\n\
|
|
\x20 println!(\"{}\", total);\n\
|
|
}\n",
|
|
)
|
|
.unwrap();
|
|
|
|
// Blocking is the point: this test cannot proceed until the fixture is
|
|
// built, and there is no event loop here for it to stall.
|
|
#[allow(clippy::disallowed_methods)]
|
|
let built = std::process::Command::new("cargo")
|
|
.arg("build")
|
|
.current_dir(&root)
|
|
.status()
|
|
.map(|status| status.success())
|
|
.unwrap_or(false);
|
|
assert!(built, "cargo build of the loop fixture");
|
|
|
|
let binary = root.join("target/debug/loopy");
|
|
let source = root.join("src/main.rs");
|
|
// Run-to-stop is adapter-dependent (some macOS lldb-dap builds won't launch the
|
|
// debuggee under the adapter). The session times out cleanly rather than hanging;
|
|
// treat that as "adapter can't drive here" and skip, not a client bug.
|
|
let (mut session, first) = match DapSession::launch(&adapter, &binary, &root, &source, &[4]) {
|
|
Ok(result) => result,
|
|
Err(error) => {
|
|
eprintln!("lldb-dap did not stop at the breakpoint ({error}); skipping the walk assertions");
|
|
std::fs::remove_dir_all(&root).ok();
|
|
return;
|
|
}
|
|
};
|
|
|
|
let total_at = |stop: &joule_coded::dap::Stop| -> Option<i64> {
|
|
stop.variables.iter().find(|variable| variable.name == "total").and_then(|variable| variable.value.parse().ok())
|
|
};
|
|
|
|
// First hit: the loop body hasn't added yet, total == 0.
|
|
assert_eq!(first.reason, "breakpoint");
|
|
let first_total = total_at(&first).expect("captured `total` at the first stop");
|
|
assert_eq!(first_total, 0, "total is 0 on the first iteration");
|
|
|
|
// Continue to the next iteration: total must have advanced — we WATCHED it change
|
|
// by walking execution, not by reading the source.
|
|
let second = session.continue_run().expect("continue to the next breakpoint");
|
|
let second_total = total_at(&second).expect("captured `total` at the second stop");
|
|
assert!(second_total > first_total, "total advanced across iterations: {first_total} -> {second_total}");
|
|
|
|
session.terminate();
|
|
std::fs::remove_dir_all(&root).ok();
|
|
}
|