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::>(), 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(); }