Update tests for coop threading (#570)

TartanLlama · web-flow · commit 3508d139e3c7 · 2025-10-23T11:07:18.000+02:00
diff --git a/test/async/async-calls-sync.wast b/test/async/async-calls-sync.wast
@@ -19,7 +19,7 @@
 
       (memory 1)
       (global $blocked (mut i32) (i32.const 1))
-      (global $counter (mut i32) (i32.const 2))
+      (global $counter (mut i32) (i32.const 3))
 
       ;; 'blocking-call' cooperatively "spin-waits" until $blocked is 0.
       (func $blocking-call (export "blocking-call") (result i32)
@@ -135,24 +135,24 @@
         ;; (on $AsyncInner.blocking-call). because 'sync-func1/2' are in different instances,
         ;; both calls will reach the STARTED state.
         (local.set $ret (call $sync-func1 (i32.const 8)))
-        (if (i32.ne (i32.const 0x21 (; STARTED=1 | (subtask=2 << 4) ;)) (local.get $ret))
-          (then unreachable))
-        (call $waitable.join (i32.const 2) (global.get $ws))
-        (local.set $ret (call $sync-func2 (i32.const 12)))
         (if (i32.ne (i32.const 0x31 (; STARTED=1 | (subtask=3 << 4) ;)) (local.get $ret))
           (then unreachable))
         (call $waitable.join (i32.const 3) (global.get $ws))
+        (local.set $ret (call $sync-func2 (i32.const 12)))
+        (if (i32.ne (i32.const 0x41 (; STARTED=1 | (subtask=4 << 4) ;)) (local.get $ret))
+          (then unreachable))
+        (call $waitable.join (i32.const 4) (global.get $ws))
 
         ;; now start another pair of 'sync-func1/2' calls, both of which should see auto
         ;; backpressure and get stuck in the STARTING state.
         (local.set $ret (call $sync-func1 (i32.const 16)))
-        (if (i32.ne (i32.const 0x40 (; STARTING=0 | (subtask=4 << 4) ;)) (local.get $ret))
-          (then unreachable))
-        (call $waitable.join (i32.const 4) (global.get $ws))
-        (local.set $ret (call $sync-func2 (i32.const 20)))
         (if (i32.ne (i32.const 0x50 (; STARTING=0 | (subtask=5 << 4) ;)) (local.get $ret))
           (then unreachable))
         (call $waitable.join (i32.const 5) (global.get $ws))
+        (local.set $ret (call $sync-func2 (i32.const 20)))
+        (if (i32.ne (i32.const 0x60 (; STARTING=0 | (subtask=6 << 4) ;)) (local.get $ret))
+          (then unreachable))
+        (call $waitable.join (i32.const 6) (global.get $ws))
 
         ;; this POLL should return that nothing is ready
         (i32.or (i32.const 3 (; POLL ;)) (i32.shl (global.get $ws) (i32.const 4)))
@@ -175,21 +175,21 @@
           (then unreachable))
 
         ;; if we receive a SUBTASK STARTED event, it should only be for the 3rd or
-        ;; 4th subtask (at indices 4/5, resp), so keep waiting for completion
+        ;; 4th subtask (at indices 5/6, resp), so keep waiting for completion
         (if (i32.eq (local.get $payload) (i32.const 1 (; STARTED ;))) (then
           (if (i32.and
-                (i32.ne (local.get $index) (i32.const 4))
-                (i32.ne (local.get $index) (i32.const 5)))
+                (i32.ne (local.get $index) (i32.const 5))
+                (i32.ne (local.get $index) (i32.const 6)))
             (then unreachable))
           (return (i32.or (i32.const 2 (; WAIT ;)) (i32.shl (global.get $ws) (i32.const 4))))
         ))
 
         ;; when we receive a SUBTASK RETURNED event, check the return value is equal to the
-        ;; subtask index (which we've ensured by having $AsyncInner.$counter start at 2, the
-        ;; first subtask index. The address of the return buffer is the index*4.
+        ;; subtask index (which we've ensured by having $AsyncInner.$counter start at 3, the
+        ;; first subtask index. The address of the return buffer is the index-1*4.
         (if (i32.ne (local.get $payload) (i32.const 2 (; RETURNED ;)))
           (then unreachable))
-        (if (i32.ne (local.get $index) (i32.load (i32.mul (local.get $index) (i32.const 4))))
+        (if (i32.ne (local.get $index) (i32.load (i32.mul (i32.sub (local.get $index) (i32.const 1)) (i32.const 4))))
           (then unreachable))
 
         ;; decrement $remain and exit if 0
diff --git a/test/async/cancel-stream.wast b/test/async/cancel-stream.wast
@@ -116,7 +116,7 @@
 
         ;; call 'start-stream' to get the stream we'll be working with
         (local.set $sr (call $start-stream))
-        (if (i32.ne (i32.const 1) (local.get $sr))
+        (if (i32.ne (i32.const 2) (local.get $sr))
           (then unreachable))
 
         ;; start read that will block
@@ -155,7 +155,7 @@
 
         ;; get a new $sr
         (local.set $sr (call $start-stream))
-        (if (i32.ne (i32.const 1) (local.get $sr))
+        (if (i32.ne (i32.const 2) (local.get $sr))
           (then unreachable))
 
         ;; start outstanding write in $C, read 4 of it, then call back into $C
diff --git a/test/async/drop-stream.wast b/test/async/drop-stream.wast
@@ -89,7 +89,7 @@
 
         ;; call 'start-stream' to get the stream we'll be working with
         (local.set $sr (call $start-stream))
-        (if (i32.ne (i32.const 1) (local.get $sr))
+        (if (i32.ne (i32.const 2) (local.get $sr))
           (then unreachable))
 
         ;; start a blocking read
@@ -111,7 +111,7 @@
 
         ;; call 'start-stream' to get the stream we'll be working with
         (local.set $sr (call $start-stream))
-        (if (i32.ne (i32.const 1) (local.get $sr))
+        (if (i32.ne (i32.const 2) (local.get $sr))
           (then unreachable))
 
         ;; start a blocking write and partially read from it
diff --git a/test/async/drop-waitable-set.wast b/test/async/drop-waitable-set.wast
@@ -59,7 +59,7 @@
         ;; start an async call to 'wait-on-set' which blocks, waiting on a
         ;; waitable-set.
         (local.set $ret (call $wait-on-set))
-        (if (i32.ne (i32.const 0x11) (local.get $ret))
+        (if (i32.ne (i32.const 0x21) (local.get $ret))
           (then unreachable))
 
         ;; this call will try to drop the same waitable-set, which should trap.
diff --git a/test/async/empty-wait.wast b/test/async/empty-wait.wast
@@ -53,10 +53,10 @@
         ;; create a future that will be used to unblock 'blocker', storing r/w ends in $futr/$futw
         (local.set $ret64 (call $future.new))
         (global.set $futr (i32.wrap_i64 (local.get $ret64)))
-        (if (i32.ne (i32.const 2) (global.get $futr))
+        (if (i32.ne (i32.const 4) (global.get $futr))
           (then unreachable))
         (local.set $futw (i32.wrap_i64 (i64.shr_u (local.get $ret64) (i64.const 32))))
-        (if (i32.ne (i32.const 3) (local.get $futw))
+        (if (i32.ne (i32.const 5) (local.get $futw))
           (then unreachable))
 
         ;; perform a future.read which will block, and add this future to the waitable-set
@@ -144,7 +144,7 @@
         (if (i32.ne (i32.const 1 (; STARTED ;)) (i32.and (local.get $ret) (i32.const 0xf)))
           (then unreachable))
         (local.set $subtask (i32.shr_u (local.get $ret) (i32.const 4)))
-        (if (i32.ne (i32.const 2 (; RETURNED=2 | (0<<4) ;)) (local.get $subtask))
+        (if (i32.ne (i32.const 3) (local.get $subtask))
           (then unreachable))
 
         ;; call 'unblocker' to unblock 'blocker'; it should complete eagerly
diff --git a/test/async/futures-must-write.wast b/test/async/futures-must-write.wast
@@ -71,7 +71,7 @@
         ;; call 'start-future' to get the future we'll be working with
         (local $fr i32)
         (local.set $fr (call $start-future))
-        (if (i32.ne (i32.const 1) (local.get $fr))
+        (if (i32.ne (i32.const 2) (local.get $fr))
           (then unreachable))
 
         ;; ok to immediately drop the readable end
@@ -84,7 +84,7 @@
         ;; call 'start-future' to get the future we'll be working with
         (local $fr i32)
         (local.set $fr (call $start-future))
-        (if (i32.ne (i32.const 1) (local.get $fr))
+        (if (i32.ne (i32.const 2) (local.get $fr))
           (then unreachable))
 
         ;; boom
diff --git a/test/async/partial-stream-copies.wast b/test/async/partial-stream-copies.wast
@@ -35,16 +35,16 @@
 
         ;; check the incoming readable stream end
         (global.set $insr (local.get 0))
-        (if (i32.ne (i32.const 2) (global.get $insr))
+        (if (i32.ne (i32.const 3) (global.get $insr))
           (then unreachable))
 
         ;; create a new stream r/w pair $outsr/$outsw
         (local.set $ret64 (call $stream.new))
         (local.set $outsr (i32.wrap_i64 (local.get $ret64)))
-        (if (i32.ne (i32.const 3) (local.get $outsr))
+        (if (i32.ne (i32.const 4) (local.get $outsr))
           (then unreachable))
         (global.set $outsw (i32.wrap_i64 (i64.shr_u (local.get $ret64) (i64.const 32))))
-        (if (i32.ne (i32.const 4) (global.get $outsw))
+        (if (i32.ne (i32.const 5) (global.get $outsw))
           (then unreachable))
 
         ;; start async read on $insr which will block
@@ -153,10 +153,10 @@
         ;; create a new stream r/w pair $insr/$insw
         (local.set $ret64 (call $stream.new))
         (local.set $insr (i32.wrap_i64 (local.get $ret64)))
-        (if (i32.ne (i32.const 1) (local.get $insr))
+        (if (i32.ne (i32.const 2) (local.get $insr))
           (then unreachable))
         (local.set $insw (i32.wrap_i64 (i64.shr_u (local.get $ret64) (i64.const 32))))
-        (if (i32.ne (i32.const 2) (local.get $insw))
+        (if (i32.ne (i32.const 3) (local.get $insw))
           (then unreachable))
 
         ;; call 'transform' which will return a readable stream $outsr eagerly
@@ -165,7 +165,7 @@
         (if (i32.ne (i32.const 2 (; RETURNED=2 | (0<<4) ;)) (local.get $ret))
           (then unreachable))
         (local.set $outsr (i32.load (local.get $retp)))
-        (if (i32.ne (i32.const 1) (local.get $outsr))
+        (if (i32.ne (i32.const 2) (local.get $outsr))
           (then unreachable))
 
         ;; multiple write calls succeed until 12-byte buffer is filled
diff --git a/test/async/passing-resources.wast b/test/async/passing-resources.wast
@@ -121,7 +121,7 @@
 
         ;; get the readable end of a stream which has a pending write
         (local.set $rs (call $start-stream))
-        (if (i32.ne (local.get $rs) (i32.const 1))
+        (if (i32.ne (local.get $rs) (i32.const 2))
           (then unreachable))
 
         ;; read only 1 (of the 2 pending) elements, which won't block
diff --git a/test/resources/multiple-resources.wast b/test/resources/multiple-resources.wast
@@ -107,16 +107,16 @@
 
         ;; create 4 resources
         (local.set $h1 (call $make-R1))
-        (if (i32.ne (i32.const 1) (local.get $h1))
+        (if (i32.ne (i32.const 2) (local.get $h1))
           (then unreachable))
         (local.set $h2 (call $make-R2))
-        (if (i32.ne (i32.const 2) (local.get $h2))
+        (if (i32.ne (i32.const 3) (local.get $h2))
           (then unreachable))
         (local.set $h3 (call $make-R1))
-        (if (i32.ne (i32.const 3) (local.get $h3))
+        (if (i32.ne (i32.const 4) (local.get $h3))
           (then unreachable))
         (local.set $h4 (call $make-R2))
-        (if (i32.ne (i32.const 4) (local.get $h4))
+        (if (i32.ne (i32.const 5) (local.get $h4))
           (then unreachable))
         (if (i32.ne (i32.const 4) (call $num-live))
           (then unreachable))
