From d1de863760485ce970427e1f043b71ab9b64f8b7 Mon Sep 17 00:00:00 2001
From: Claude <claude@swactor.dev>
Date: Fri, 13 Feb 2026 10:36:22 +0000
Subject: [PATCH] =?UTF-8?q?test(wasm-actor):=20cycle=2073=20=E2=80=94=20co?=
 =?UTF-8?q?nditional=20trap,=203=20runtimes,=201000=20actors=20(324=20test?=
 =?UTF-8?q?s)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Added 5 tests: trap on specific byte, three runtimes share engine, spawn with no
messages, multiply/divide operations, 1000 actors from same engine stress test.
No new bugs found.

Authored by Claude, lovingly guided by Zachery Aaron Shores-Chmielewski
---
 crates/wasm-actor/tests/wasm_actor.rs | 115 ++++++++++++++++++++++++++
 1 file changed, 115 insertions(+)

diff --git a/crates/wasm-actor/tests/wasm_actor.rs b/crates/wasm-actor/tests/wasm_actor.rs
index 7557412..947f84c 100644
--- a/crates/wasm-actor/tests/wasm_actor.rs
+++ b/crates/wasm-actor/tests/wasm_actor.rs
@@ -10634,4 +10634,119 @@ fn guest_comparison_operations() {
     let addr = rt.spawn(actor).unwrap();
     rt.send_to(addr, ByteMessage(vec![0u8; 4])).unwrap();
     rt.tick();
+}
+
+// ── Cycle 73 ─────────────────────────────────────────────────────────────────
+
+// Guest that traps on specific payload content (trap-on-0xFF)
+#[test]
+fn guest_traps_on_specific_byte_survives_others() {
+    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)
+            ;; If first byte is 0xFF, trap
+            (if (i32.and
+                    (i32.gt_u (local.get $len) (i32.const 0))
+                    (i32.eq (i32.load8_u (local.get $ptr)) (i32.const 0xFF)))
+                (then unreachable)
+            )
+        )
+    )"#;
+    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();
+
+    // Normal message — survives
+    rt.send_to(addr, ByteMessage(vec![0x42])).unwrap();
+    rt.tick();
+
+    // Trap-triggering message — actor survives trap
+    rt.send_to(addr, ByteMessage(vec![0xFF])).unwrap();
+    rt.tick();
+
+    // Another normal message — still alive
+    rt.send_to(addr, ByteMessage(vec![0x00])).unwrap();
+    rt.tick();
+}
+
+// Multiple runtimes share one engine, all operate correctly
+#[test]
+fn three_runtimes_share_one_engine() {
+    let engine = SharedEngine::new().unwrap();
+    let mut rts = Vec::new();
+    let mut inboxes = Vec::new();
+
+    for _ in 0..3 {
+        let rt = Runtime::new(RuntimeConfig::default());
+        let inbox = rt.new_inbox::<ByteMessage>().unwrap();
+        let actor = WasmActorBuilder::new(engine.clone(), guest_wasm("echo")).build().unwrap();
+        let addr = rt.spawn(actor).unwrap();
+        rt.send_to(addr, framed_msg(inbox.addr(), b"shared-engine")).unwrap();
+        inboxes.push(inbox);
+        rts.push(rt);
+    }
+
+    for rt in &rts {
+        rt.tick();
+    }
+
+    for inbox in &inboxes {
+        let resp = inbox.try_recv().expect("each runtime should echo");
+        assert_eq!(resp.0, b"shared-engine");
+    }
+}
+
+// Spawn actor, never send any message, stop — clean lifecycle
+#[test]
+fn spawn_no_messages_then_stop() {
+    let engine = SharedEngine::new().unwrap();
+    let actor = WasmActorBuilder::new(engine, guest_wasm("echo")).build().unwrap();
+    let rt = Runtime::new(RuntimeConfig::default());
+    let addr = rt.spawn(actor).unwrap();
+    rt.tick(); // idle tick
+    rt.stop_actor(addr);
+    rt.tick(); // cleanup
+    rt.tick(); // verify
+}
+
+// Guest with i32.mul and i32.div_u
+#[test]
+fn guest_multiply_and_divide() {
+    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)
+            ;; Multiply len by 3, divide by 2, store at ptr
+            (i32.store (local.get $ptr)
+                (i32.div_u
+                    (i32.mul (local.get $len) (i32.const 3))
+                    (i32.const 2)
+                )
+            )
+        )
+    )"#;
+    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; 10])).unwrap();
+    rt.tick(); // 10*3/2 = 15
+}
+
+// 1000 actors from same engine — stress test engine sharing
+#[test]
+fn thousand_actors_from_same_engine() {
+    let engine = SharedEngine::new().unwrap();
+    let rt = Runtime::new(RuntimeConfig::default());
+
+    for _ in 0..1000 {
+        let actor = WasmActorBuilder::new(engine.clone(), guest_wasm("silent"))
+            .build().unwrap();
+        rt.spawn(actor).unwrap();
+    }
+    rt.tick();
 }
\ No newline at end of file