Intrepid/Prometeu/Runtime/pipeline/head There was a failure building this commit
Coordinate bounded native publication progress during frame advance while preserving watchdogs, guest budgets and resource ownership. Add controlled and packaged reopen regressions, clarify the runtime specs, and retain qualification evidence.
413 lines
16 KiB
Rust
413 lines
16 KiB
Rust
use super::*;
|
|
use prometeu_test_support::memcard_fixture::{MemcardFixture, memcard_program};
|
|
|
|
fn card(kind: MemcardFixture, version: &str) -> TempDir {
|
|
let dir = TempDir::new();
|
|
fs::write(dir.0.join("program.pbx"), memcard_program(kind)).unwrap();
|
|
fs::write(
|
|
dir.0.join("manifest.json"),
|
|
serde_json::to_vec(&json!({
|
|
"magic":"PMTU","cartridge_version":1,"app_id":4294967295u32,
|
|
"title":"Neutral persistence","app_version":version,"app_mode":"Game",
|
|
"capabilities":["memcard"],"memcard_slots":1
|
|
}))
|
|
.unwrap(),
|
|
)
|
|
.unwrap();
|
|
dir
|
|
}
|
|
fn start_at(binary: &Path) -> Client {
|
|
let mut c = Client::spawn(binary, &["headless", "--stdio"], Some(&std::env::temp_dir()));
|
|
c.ok(
|
|
"initialize",
|
|
json!({"protocolVersion":{"major":1,"minor":1},"requiredCapabilities":["memcard"]}),
|
|
);
|
|
c
|
|
}
|
|
fn start() -> Client {
|
|
start_at(Path::new(env!("CARGO_BIN_EXE_prometeu")))
|
|
}
|
|
fn mount(c: &mut Client, path: &Path, action: &str, access: &str) -> Value {
|
|
c.ok("memcard_mount", json!({"path":path,"action":action,"access":access}))
|
|
}
|
|
fn launch(c: &mut Client, dir: &TempDir, choice: &str) {
|
|
c.ok("boot", json!({"path":dir.0,"memcardChoice":choice}));
|
|
}
|
|
fn oracle(c: &mut Client, expected: i64) {
|
|
let deadline = Instant::now() + Duration::from_secs(5);
|
|
loop {
|
|
let advance = c.ok("advance", json!({"frames":1}));
|
|
assert_eq!(
|
|
advance["stop"],
|
|
"completed",
|
|
"{advance}; state={}; mem={}; fault={}",
|
|
c.ok("get_state", json!({})),
|
|
c.ok("get_memcard_state", json!({})),
|
|
c.ok("get_fault", json!({}))
|
|
);
|
|
let state = c.ok("get_state", json!({}));
|
|
let top = state["stackTop"].as_array().unwrap();
|
|
if top.last().and_then(|v| v["value"].as_str()) == Some(&expected.to_string()) {
|
|
return;
|
|
}
|
|
assert!(Instant::now() < deadline, "oracle {expected} not reached: {state}");
|
|
}
|
|
}
|
|
fn reason(c: &mut Client, command: &str, params: Value, expected: &str) -> Value {
|
|
let error = c.call(command, params)["error"].clone();
|
|
assert_eq!(error["code"], "memcard_error", "{error}");
|
|
assert_eq!(error["details"]["reason"], expected, "{error}");
|
|
error["details"]["state"].clone()
|
|
}
|
|
fn persistence(binary: &Path) {
|
|
let root = TempDir::new();
|
|
let image = root.0.join("save.pmc");
|
|
let write = card(MemcardFixture::Write, "1");
|
|
let mut first = start_at(binary);
|
|
let mounted = mount(&mut first, &image, "create", "read_write");
|
|
assert_eq!(mounted["media"]["cardId"].as_str().unwrap().len(), 32);
|
|
launch(&mut first, &write, "persistent");
|
|
oracle(&mut first, 101);
|
|
let saved = first.ok("get_memcard_state", json!({}));
|
|
assert_eq!(saved["request"]["state"], "success");
|
|
assert_eq!(saved["request"]["retained"], true);
|
|
assert_eq!(saved["dirty"], false);
|
|
assert_eq!(saved["io"]["active"], false);
|
|
first.close();
|
|
let bytes = fs::read(&image).unwrap();
|
|
for version in ["1", "2"] {
|
|
let read = card(MemcardFixture::Read, version);
|
|
let mut next = start_at(binary);
|
|
mount(&mut next, &image, "open", "read_write");
|
|
launch(&mut next, &read, "persistent");
|
|
oracle(&mut next, 201);
|
|
assert_eq!(next.ok("get_state", json!({}))["appId"], 4294967295u32);
|
|
assert_eq!(
|
|
next.ok("get_memcard_state", json!({}))["request"],
|
|
Value::Null,
|
|
"reader must not submit a save"
|
|
);
|
|
next.close();
|
|
assert!(fs::read(&image).unwrap() == bytes, "readback must not rewrite the image");
|
|
}
|
|
let read = card(MemcardFixture::Read, "2");
|
|
let mut memory = start_at(binary);
|
|
mount(&mut memory, &image, "open", "read_only");
|
|
reason(&mut memory, "boot", json!({"path":read.0,"memcardChoice":"persistent"}), "read_only");
|
|
memory.ok("reset", json!({}));
|
|
launch(&mut memory, &read, "memory_existing");
|
|
oracle(&mut memory, 201);
|
|
assert_eq!(memory.ok("get_memcard_state", json!({}))["session"]["mode"], "memory_only");
|
|
memory.close();
|
|
assert!(fs::read(&image).unwrap() == bytes);
|
|
}
|
|
|
|
pub(super) fn presentation_reopen(binary: &Path) {
|
|
let root = TempDir::new();
|
|
let image = root.0.join("presentation-reopen.pmc");
|
|
let write = card(MemcardFixture::Write, "1");
|
|
let mut writer = start_at(binary);
|
|
mount(&mut writer, &image, "create", "read_write");
|
|
launch(&mut writer, &write, "persistent");
|
|
oracle(&mut writer, 101);
|
|
assert_eq!(writer.ok("get_memcard_state", json!({}))["dirty"], false);
|
|
writer.close();
|
|
|
|
for version in ["1", "2"] {
|
|
let read = card(MemcardFixture::ReadWithPresentation, version);
|
|
let mut reader = start_at(binary);
|
|
mount(&mut reader, &image, "open", "read_write");
|
|
launch(&mut reader, &read, "persistent");
|
|
let booted = reader.ok("get_state", json!({}));
|
|
assert_eq!(booted["pc"], 0);
|
|
assert_eq!(booted["tickIndex"], 0);
|
|
assert_eq!(booted["logicalFrameIndex"], 0);
|
|
// Exactly one command owns the first frame; there is no oracle retry.
|
|
let advanced = reader.ok("advance", json!({"frames":1}));
|
|
assert_eq!(advanced, json!({"requested":1,"completed":1,"stop":"completed"}));
|
|
let state = reader.ok("get_state", json!({}));
|
|
assert_eq!(state["logicalFrameIndex"], 1);
|
|
assert_eq!(state["tickIndex"], 2);
|
|
assert_eq!(state["status"], "paused");
|
|
assert_eq!(state["appId"], 4294967295u32);
|
|
assert_eq!(state["stackTop"].as_array().unwrap().last().unwrap()["value"], "201");
|
|
assert_eq!(reader.ok("get_fault", json!({})), Value::Null);
|
|
let media = reader.ok("get_memcard_state", json!({}));
|
|
assert_eq!(
|
|
media["request"],
|
|
Value::Null,
|
|
"presentation must finish without a payload save"
|
|
);
|
|
assert_eq!(media["io"]["active"], false);
|
|
assert_eq!(media["dirty"], false);
|
|
assert_eq!(reader.ok("capture", json!({}))["logicalFrameIndex"], 1);
|
|
reader.close();
|
|
}
|
|
// Preserve the original reader's independent read-without-writing oracle.
|
|
let bytes = fs::read(&image).unwrap();
|
|
let read = card(MemcardFixture::Read, "2");
|
|
let mut reader = start_at(binary);
|
|
mount(&mut reader, &image, "open", "read_write");
|
|
launch(&mut reader, &read, "persistent");
|
|
oracle(&mut reader, 201);
|
|
reader.close();
|
|
assert_eq!(fs::read(&image).unwrap(), bytes);
|
|
}
|
|
|
|
#[test]
|
|
fn memcard_reopen_presentation_completes_exactly_one_first_frame() {
|
|
presentation_reopen(Path::new(env!("CARGO_BIN_EXE_prometeu")));
|
|
}
|
|
|
|
#[test]
|
|
fn memcard_public_distinct_process_save_readback_and_version_identity() {
|
|
persistence(Path::new(env!("CARGO_BIN_EXE_prometeu")));
|
|
}
|
|
#[test]
|
|
#[ignore = "requires PROMETEU_PROTOCOL_TEST_INSTALL pointing to an extracted dist archive"]
|
|
fn packaged_memcard_process_persistence() {
|
|
let installation = PathBuf::from(
|
|
std::env::var_os("PROMETEU_PROTOCOL_TEST_INSTALL").expect("extracted distribution"),
|
|
);
|
|
persistence(&installation.join("prometeu"));
|
|
}
|
|
#[test]
|
|
fn memcard_dirty_refusal_retains_channel_and_explicit_ram_has_no_save() {
|
|
let dirty = card(MemcardFixture::Dirty, "1");
|
|
let mut c = start();
|
|
launch(&mut c, &dirty, "memory_fresh");
|
|
oracle(&mut c, 301);
|
|
for command in ["shutdown", "reset"] {
|
|
let state = reason(&mut c, command, json!({}), "unsaved_changes");
|
|
assert_eq!(state["dirty"], true);
|
|
assert_eq!(state["session"]["resident"], true);
|
|
assert_eq!(c.ok("get_state", json!({}))["appId"], 4294967295u32);
|
|
}
|
|
let reset = c.ok("reset", json!({"discardUnsaved":true,"pendingWrites":"cancel"}));
|
|
assert_eq!(reset["memcard"]["dirty"], false);
|
|
let write = card(MemcardFixture::Write, "1");
|
|
launch(&mut c, &write, "memory_fresh");
|
|
oracle(&mut c, 104);
|
|
let state = c.ok("get_memcard_state", json!({}));
|
|
assert_eq!(state["request"]["state"], "memory_only");
|
|
assert_eq!(state["dirty"], true);
|
|
assert_eq!(state["io"]["active"], false);
|
|
assert_eq!(state["media"]["path"], Value::Null);
|
|
c.ok("shutdown", json!({"discardUnsaved":true}));
|
|
c.wait_exit();
|
|
}
|
|
#[test]
|
|
fn memcard_media_errors_and_negotiation_never_select_a_fallback() {
|
|
let root = TempDir::new();
|
|
let missing = root.0.join("missing.pmc");
|
|
let mut old = Client::new(&["--stdio"]);
|
|
old.initialize();
|
|
assert_eq!(
|
|
old.call("memcard_mount", json!({"path":missing,"action":"create","access":"read_write"}))
|
|
["error"]["code"],
|
|
"unsupported_capability"
|
|
);
|
|
assert!(!missing.exists());
|
|
old.close();
|
|
let mut c = Client::new(&["--stdio"]);
|
|
assert_eq!(
|
|
c.call(
|
|
"initialize",
|
|
json!({"protocolVersion":{"major":1,"minor":0},"requiredCapabilities":["memcard"]})
|
|
)["error"]["code"],
|
|
"incompatible_version"
|
|
);
|
|
c.ok(
|
|
"initialize",
|
|
json!({"protocolVersion":{"major":1,"minor":1},"requiredCapabilities":["memcard"]}),
|
|
);
|
|
reason(
|
|
&mut c,
|
|
"memcard_mount",
|
|
json!({"path":missing,"action":"open","access":"read_write"}),
|
|
"unavailable",
|
|
);
|
|
assert!(!missing.exists());
|
|
let cart = card(MemcardFixture::Write, "1");
|
|
reason(&mut c, "boot", json!({"path":cart.0}), "choice_required");
|
|
assert_eq!(c.ok("get_state", json!({}))["logicalFrameIndex"], 0);
|
|
c.ok("reset", json!({}));
|
|
let corrupt = root.0.join("corrupt.pmc");
|
|
let mut bytes = vec![0; 5_259_264];
|
|
bytes[..8].copy_from_slice(b"PMCARD1\0");
|
|
bytes[8] = 1;
|
|
fs::write(&corrupt, &bytes).unwrap();
|
|
reason(
|
|
&mut c,
|
|
"memcard_mount",
|
|
json!({"path":corrupt,"action":"open","access":"read_write"}),
|
|
"corrupt",
|
|
);
|
|
assert!(fs::read(&corrupt).unwrap() == bytes);
|
|
assert_eq!(c.ok("get_memcard_state", json!({}))["session"]["mode"], Value::Null);
|
|
c.close();
|
|
}
|
|
#[cfg(unix)]
|
|
#[test]
|
|
fn memcard_process_ownership_covers_aliases_readers_and_release() {
|
|
let root = TempDir::new();
|
|
let image = root.0.join("save.pmc");
|
|
let hard = root.0.join("hard.pmc");
|
|
let sym = root.0.join("sym.pmc");
|
|
let mut owner = start();
|
|
mount(&mut owner, &image, "create", "read_write");
|
|
fs::hard_link(&image, &hard).unwrap();
|
|
std::os::unix::fs::symlink(&image, &sym).unwrap();
|
|
let bytes = fs::read(&image).unwrap();
|
|
let mut contender = start();
|
|
for path in [&image, &hard, &sym] {
|
|
for access in ["read_only", "read_write"] {
|
|
reason(
|
|
&mut contender,
|
|
"memcard_mount",
|
|
json!({"path":path,"action":"open","access":access}),
|
|
"busy",
|
|
);
|
|
}
|
|
}
|
|
reason(
|
|
&mut contender,
|
|
"memcard_mount",
|
|
json!({"path":image,"action":"create","access":"read_write"}),
|
|
"already_exists",
|
|
);
|
|
assert!(fs::read(&image).unwrap() == bytes);
|
|
owner.ok("memcard_unmount", json!({}));
|
|
mount(&mut contender, &image, "open", "read_only");
|
|
reason(
|
|
&mut owner,
|
|
"memcard_mount",
|
|
json!({"path":image,"action":"open","access":"read_only"}),
|
|
"busy",
|
|
);
|
|
contender.close();
|
|
mount(&mut owner, &image, "open", "read_write");
|
|
owner.close();
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
#[test]
|
|
fn memcard_creation_race_and_process_death_release_real_ownership() {
|
|
let root = TempDir::new();
|
|
let image = root.0.join("race.pmc");
|
|
// Kill the actual storage-owning process rather than its dispatcher parent.
|
|
let mut a = Client::new(&["--stdio"]);
|
|
let mut b = Client::new(&["--stdio"]);
|
|
for c in [&mut a, &mut b] {
|
|
c.ok(
|
|
"initialize",
|
|
json!({"protocolVersion":{"major":1,"minor":1},"requiredCapabilities":["memcard"]}),
|
|
);
|
|
}
|
|
let params = json!({"path":image,"action":"create","access":"read_write"});
|
|
let aid = a.send("memcard_mount", params.clone());
|
|
let bid = b.send("memcard_mount", params);
|
|
let ar = a.response(&aid);
|
|
let br = b.response(&bid);
|
|
assert_ne!(
|
|
ar.get("result").is_some(),
|
|
br.get("result").is_some(),
|
|
"exactly one creator must win"
|
|
);
|
|
let (winner, loser, error) =
|
|
if ar.get("result").is_some() { (&mut a, &mut b, br) } else { (&mut b, &mut a, ar) };
|
|
assert_eq!(error["error"]["details"]["reason"], "already_exists");
|
|
let before = fs::read(&image).unwrap();
|
|
winner.child.kill().unwrap();
|
|
winner.child.wait().unwrap();
|
|
mount(loser, &image, "open", "read_write");
|
|
loser.close();
|
|
assert!(fs::read(&image).unwrap() == before);
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
#[test]
|
|
fn memcard_access_denial_is_typed_and_does_not_create_or_modify_media() {
|
|
use std::os::unix::fs::PermissionsExt;
|
|
let root = TempDir::new();
|
|
let image = root.0.join("denied.pmc");
|
|
let mut creator = start();
|
|
mount(&mut creator, &image, "create", "read_write");
|
|
creator.close();
|
|
let before = fs::read(&image).unwrap();
|
|
fs::set_permissions(&image, fs::Permissions::from_mode(0o0)).unwrap();
|
|
let mut c = start();
|
|
reason(
|
|
&mut c,
|
|
"memcard_mount",
|
|
json!({"path":image,"action":"open","access":"read_write"}),
|
|
"access_denied",
|
|
);
|
|
c.close();
|
|
fs::set_permissions(&image, fs::Permissions::from_mode(0o600)).unwrap();
|
|
assert!(fs::read(&image).unwrap() == before);
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
#[test]
|
|
fn desktop_dispatch_forwards_explicit_media_without_interpreting_player_policy() {
|
|
use std::os::unix::fs::PermissionsExt;
|
|
let installation = TempDir::new();
|
|
let dispatcher = installation.0.join("prometeu");
|
|
fs::copy(env!("CARGO_BIN_EXE_prometeu"), &dispatcher).unwrap();
|
|
let runtime = installation.0.join("prometeu-runtime");
|
|
fs::write(&runtime, "#!/bin/sh\nprintf '%s\\n' \"$@\"\n").unwrap();
|
|
fs::set_permissions(&runtime, fs::Permissions::from_mode(0o755)).unwrap();
|
|
for command in ["run", "debug"] {
|
|
let output = Command::new(&dispatcher)
|
|
.args([command, "cartridge", "--memcard", "image with spaces.pmc", "--create-memcard"])
|
|
.output()
|
|
.unwrap();
|
|
assert!(output.status.success());
|
|
let actual = String::from_utf8(output.stdout).unwrap();
|
|
let mut expected = vec![format!("--{command}"), "cartridge".into()];
|
|
if command == "debug" {
|
|
expected.extend(["--port".into(), "7777".into()]);
|
|
}
|
|
expected.extend([
|
|
"--memcard".into(),
|
|
"image with spaces.pmc".into(),
|
|
"--create-memcard".into(),
|
|
]);
|
|
assert_eq!(actual.lines().collect::<Vec<_>>(), expected);
|
|
}
|
|
assert!(
|
|
!Command::new(&dispatcher)
|
|
.args(["run", "cartridge", "--create-memcard"])
|
|
.output()
|
|
.unwrap()
|
|
.status
|
|
.success()
|
|
);
|
|
}
|
|
#[test]
|
|
fn memcard_idle_observation_never_advances_guest_counters() {
|
|
let root = TempDir::new();
|
|
let image = root.0.join("save.pmc");
|
|
let cart = card(MemcardFixture::Write, "1");
|
|
let mut c = start();
|
|
mount(&mut c, &image, "create", "read_write");
|
|
launch(&mut c, &cart, "persistent");
|
|
c.ok("advance", json!({"frames":1}));
|
|
let before = c.ok("get_state", json!({}));
|
|
let deadline = Instant::now() + Duration::from_secs(3);
|
|
loop {
|
|
let state = c.ok("get_memcard_state", json!({}));
|
|
if !state["io"]["active"].as_bool().unwrap() {
|
|
assert_eq!(state["request"]["state"], "success");
|
|
break;
|
|
}
|
|
assert!(Instant::now() < deadline);
|
|
}
|
|
let after = c.ok("get_state", json!({}));
|
|
for field in ["pc", "logicalFrameIndex", "tickIndex", "stackTop"] {
|
|
assert_eq!(before[field], after[field], "{field}");
|
|
}
|
|
c.close();
|
|
}
|