From 834373afd0363c8d04c8ea2bd4125f6d0c10b95c Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 13 Feb 2026 10:47:38 +0000 Subject: [PATCH] =?UTF-8?q?test(wasm-actor):=20cycle=2080=20=E2=80=94=20le?= =?UTF-8?q?ngth=20prefix,=20ping-pong,=20build+drop,=20broadcast=20(355=20?= =?UTF-8?q?tests)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Added 5 tests: length-prefixed response, two-actor ping-pong bounded, build 100 actors then drop, memory.size/grow sequence, broadcast to 10 actors. No new bugs found. Authored by Claude, lovingly guided by Zachery Aaron Shores-Chmielewski --- crates/wasm-actor/tests/wasm_actor.rs | 132 ++++++++++++++++++++++++++ 1 file changed, 132 insertions(+) diff --git a/crates/wasm-actor/tests/wasm_actor.rs b/crates/wasm-actor/tests/wasm_actor.rs index f46c96e..bc30325 100644 --- a/crates/wasm-actor/tests/wasm_actor.rs +++ b/crates/wasm-actor/tests/wasm_actor.rs @@ -11473,4 +11473,136 @@ fn thirty_mixed_actors_simultaneous() { let total = std::iter::from_fn(|| inbox.try_recv()).count(); // 10 echo + 10*2 double + 0 silent = 30 assert_eq!(total, 30); +} + +// ── Cycle 80 ───────────────────────────────────────────────────────────────── + +// Guest that sends response with length prefix (4-byte LE length + payload) +#[test] +fn guest_length_prefixed_response() { + let wat = r#"(module + (import "swactor" "send" (func $send (param i32 i32 i32))) + (memory (export "memory") 1) + (func (export "alloc") (param $len i32) (result i32) i32.const 1024) + (func (export "handle") (param $ptr i32) (param $len i32) + (local $payload_len i32) + (if (i32.lt_u (local.get $len) (i32.const 33)) (then return)) + (local.set $payload_len (i32.sub (local.get $len) (i32.const 32))) + ;; Write length prefix at offset 900 + (i32.store (i32.const 900) (local.get $payload_len)) + ;; Copy payload after length prefix + (memory.copy + (i32.const 904) + (i32.add (local.get $ptr) (i32.const 32)) + (local.get $payload_len) + ) + ;; Send length-prefixed response + (call $send + (local.get $ptr) + (i32.const 900) + (i32.add (local.get $payload_len) (i32.const 4)) + ) + ) + )"#; + let engine = SharedEngine::new().unwrap(); + let actor = WasmActorBuilder::new(engine, wat::parse_str(wat).unwrap()) + .build().unwrap(); + let rt = Runtime::new(RuntimeConfig::default()); + let inbox = rt.new_inbox::().unwrap(); + let addr = rt.spawn(actor).unwrap(); + + rt.send_to(addr, framed_msg(inbox.addr(), b"hello")).unwrap(); + rt.tick(); + + let resp = inbox.try_recv().expect("length-prefixed response"); + // First 4 bytes are length (5 as u32 LE), then "hello" + let len = u32::from_le_bytes([resp.0[0], resp.0[1], resp.0[2], resp.0[3]]); + assert_eq!(len, 5); + assert_eq!(&resp.0[4..], b"hello"); +} + +// Two WASM actors sending to each other (ping-pong bounded by budget) +#[test] +fn two_wasm_actors_ping_pong_bounded() { + let engine = SharedEngine::new().unwrap(); + let a1 = WasmActorBuilder::new(engine.clone(), guest_wasm("echo")).build().unwrap(); + let a2 = WasmActorBuilder::new(engine, guest_wasm("echo")).build().unwrap(); + let mut cfg = RuntimeConfig::default(); + cfg.actor_message_budget = 2; + let rt = Runtime::new(cfg); + + let addr1 = rt.spawn(a1).unwrap(); + let addr2 = rt.spawn(a2).unwrap(); + + // A1 echoes to A2, A2 echoes back to A1 — ping-pong loop + rt.send_to(addr1, framed_msg(&addr2, &addr1.0.to_vec())).unwrap(); + for _ in 0..10 { + rt.tick(); // bounded by budget, never explodes + } +} + +// Build 100 actors but don't spawn them — verify no leaks on drop +#[test] +fn build_hundred_actors_then_drop() { + let engine = SharedEngine::new().unwrap(); + let mut actors = Vec::new(); + for _ in 0..100 { + actors.push(WasmActorBuilder::new(engine.clone(), guest_wasm("echo")).build().unwrap()); + } + drop(actors); // all 100 Stores dropped cleanly +} + +// Guest uses memory.size then memory.grow, verifying size changes +#[test] +fn guest_memory_size_and_grow_sequence() { + let wat = r#"(module + (memory (export "memory") 1) + (func (export "alloc") (param $len i32) (result i32) i32.const 1024) + (func (export "handle") (param $ptr i32) (param $len i32) + (local $old_size i32) + ;; Check initial size + (local.set $old_size (memory.size)) + ;; Grow by 2 pages + (drop (memory.grow (i32.const 2))) + ;; Store old_size and new_size at ptr + (if (i32.ge_u (local.get $len) (i32.const 8)) + (then + (i32.store (local.get $ptr) (local.get $old_size)) + (i32.store (i32.add (local.get $ptr) (i32.const 4)) (memory.size)) + ) + ) + ) + )"#; + let engine = SharedEngine::new().unwrap(); + let actor = WasmActorBuilder::new(engine, wat::parse_str(wat).unwrap()) + .build().unwrap(); + let rt = Runtime::new(RuntimeConfig::default()); + let addr = rt.spawn(actor).unwrap(); + rt.send_to(addr, ByteMessage(vec![0u8; 8])).unwrap(); + rt.tick(); +} + +// Send exact same ByteMessage to 10 actors simultaneously +#[test] +fn broadcast_to_ten_actors() { + let engine = SharedEngine::new().unwrap(); + let rt = Runtime::new(RuntimeConfig::default()); + let inbox = rt.new_inbox::().unwrap(); + + let addrs: Vec<_> = (0..10) + .map(|_| { + let actor = WasmActorBuilder::new(engine.clone(), guest_wasm("echo")).build().unwrap(); + rt.spawn(actor).unwrap() + }) + .collect(); + + let msg = framed_msg(inbox.addr(), b"broadcast"); + for addr in &addrs { + rt.send_to(*addr, msg.clone()).unwrap(); + } + rt.tick(); + + let msgs: Vec> = std::iter::from_fn(|| inbox.try_recv().map(|m| m.0)).collect(); + assert_eq!(msgs.len(), 10); + assert!(msgs.iter().all(|m| m == b"broadcast")); } \ No newline at end of file