Update wast tests for thread index changes (#605)

Numbers in tests were updated to account for #600

Author: alexcrichton

test/async/async-calls-sync.wast

@@ -1,7 +1,7 @@
 ;; This test contains 3 components, $AsyncInner, $SyncMiddle and $AsyncOuter,
 ;; where there are two instances of $SyncMiddle that import a single instance
 ;; of $AsyncInner, and $AsyncOuter imports all 3 preceding instances.
-;; 
+;;
 ;; $AsyncOuter.run asynchronously calls $SyncMiddle.sync-func twice concurrently
 ;; in each instance (4 total calls), hitting the synchronous backpressure case
 ;; in 2 of the 4 calls.
@@ -19,7 +19,7 @@
 
       (memory 1)
       (global $blocked (mut i32) (i32.const 1))
-      (global $counter (mut i32) (i32.const 3))
+      (global $counter (mut i32) (i32.const 2))
 
       ;; 'blocking-call' cooperatively "spin-waits" until $blocked is 0.
       (func $blocking-call (export "blocking-call") (result i32)
@@ -136,24 +136,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 0x31 (; STARTED=1 | (subtask=3 << 4) ;)) (local.get $ret))
+        (if (i32.ne (i32.const 0x21 (; STARTED=1 | (subtask=2 << 4) ;)) (local.get $ret))
           (then unreachable))
-        (call $waitable.join (i32.const 3) (global.get $ws))
+        (call $waitable.join (i32.const 2) (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))
+        (if (i32.ne (i32.const 0x31 (; STARTED=1 | (subtask=3 << 4) ;)) (local.get $ret))
           (then unreachable))
-        (call $waitable.join (i32.const 4) (global.get $ws))
+        (call $waitable.join (i32.const 3) (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 0x50 (; STARTING=0 | (subtask=5 << 4) ;)) (local.get $ret))
+        (if (i32.ne (i32.const 0x40 (; STARTING=0 | (subtask=4 << 4) ;)) (local.get $ret))
           (then unreachable))
-        (call $waitable.join (i32.const 5) (global.get $ws))
+        (call $waitable.join (i32.const 4) (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))
+        (if (i32.ne (i32.const 0x50 (; STARTING=0 | (subtask=5 << 4) ;)) (local.get $ret))
           (then unreachable))
-        (call $waitable.join (i32.const 6) (global.get $ws))
+        (call $waitable.join (i32.const 5) (global.get $ws))
 
         ;; unblock all the tasks and start waiting to complete
         (call $unblock)
@@ -167,21 +167,21 @@
           (then unreachable))
 
         ;; if we receive a SUBTASK STARTED event, it should only be for the 3rd or
-        ;; 4th subtask (at indices 5/6, resp), so keep waiting for completion
+        ;; 4th subtask (at indices 4/5, 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 5))
-                (i32.ne (local.get $index) (i32.const 6)))
+                (i32.ne (local.get $index) (i32.const 4))
+                (i32.ne (local.get $index) (i32.const 5)))
             (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 3, the
-        ;; first subtask index. The address of the return buffer is the index-1*4.
+        ;; 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.
         (if (i32.ne (local.get $payload) (i32.const 2 (; RETURNED ;)))
           (then unreachable))
-        (if (i32.ne (local.get $index) (i32.load (i32.mul (i32.sub (local.get $index) (i32.const 1)) (i32.const 4))))
+        (if (i32.ne (local.get $index) (i32.load (i32.mul (local.get $index) (i32.const 4))))
           (then unreachable))
 
         ;; decrement $remain and exit if 0

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 2) (local.get $sr))
+        (if (i32.ne (i32.const 1) (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 2) (local.get $sr))
+        (if (i32.ne (i32.const 1) (local.get $sr))
           (then unreachable))
 
         ;; start outstanding write in $C, read 4 of it, then call back into $C

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 2) (local.get $sr))
+        (if (i32.ne (i32.const 1) (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 2) (local.get $sr))
+        (if (i32.ne (i32.const 1) (local.get $sr))
           (then unreachable))
 
         ;; start a blocking write and partially read from it

test/async/drop-waitable-set.wast

@@ -11,7 +11,7 @@
       (global $ws (mut i32) (i32.const 0))
       (func $start (global.set $ws (call $waitable-set.new)))
       (start $start)
-      
+
       (func $wait-on-set (export "wait-on-set") (result i32)
         ;; wait on $ws
         (i32.or (i32.const 2 (; WAIT ;)) (i32.shl (global.get $ws) (i32.const 4)))
@@ -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 0x21) (local.get $ret))
+        (if (i32.ne (i32.const 0x11) (local.get $ret))
           (then unreachable))
 
         ;; this call will try to drop the same waitable-set, which should trap.

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 4) (global.get $futr))
+        (if (i32.ne (i32.const 2) (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 5) (local.get $futw))
+        (if (i32.ne (i32.const 3) (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 3) (local.get $subtask))
+        (if (i32.ne (i32.const 2) (local.get $subtask))
           (then unreachable))
 
         ;; call 'unblocker' to unblock 'blocker'; it should complete eagerly

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 2) (local.get $fr))
+        (if (i32.ne (i32.const 1) (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 2) (local.get $fr))
+        (if (i32.ne (i32.const 1) (local.get $fr))
           (then unreachable))
 
         ;; boom

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 3) (global.get $insr))
+        (if (i32.ne (i32.const 2) (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 4) (local.get $outsr))
+        (if (i32.ne (i32.const 3) (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 5) (global.get $outsw))
+        (if (i32.ne (i32.const 4) (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 2) (local.get $insr))
+        (if (i32.ne (i32.const 1) (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 3) (local.get $insw))
+        (if (i32.ne (i32.const 2) (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 2) (local.get $outsr))
+        (if (i32.ne (i32.const 1) (local.get $outsr))
           (then unreachable))
 
         ;; multiple write calls succeed until 12-byte buffer is filled
@@ -183,7 +183,7 @@
         (local.set $ret (call $stream.write (local.get $insw) (i32.const 16) (i32.const 12)))
         (if (i32.ne (i32.const -1 (; BLOCKED ;)) (local.get $ret))
           (then unreachable))
-        
+
         ;; wait for transform to read our write and drop all the streams
         (local.set $ws (call $waitable-set.new))
         (call $waitable.join (local.get $insw) (local.get $ws))

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 2))
+        (if (i32.ne (local.get $rs) (i32.const 1))
           (then unreachable))
 
         ;; read only 1 (of the 2 pending) elements, which won't block
@@ -143,7 +143,7 @@
         ;; drop the stream and then let $C run and assert stuff
         (call $stream.drop-readable (local.get $rs))
         (call $cancel-write)
-        
+
         (i32.const 42)
       )
     )
@@ -173,4 +173,4 @@
   (func (export "fail-accessing-res1") (alias export $producer "fail-accessing-res1"))
 )
 (assert_return (invoke "run") (u32.const 42))
-(assert_trap (invoke "fail-accessing-res1") "index is not a resource")
+(assert_trap (invoke "fail-accessing-res1") "unknown handle index 3")

test/resources/multiple-resources.wast

@@ -107,16 +107,16 @@
 
         ;; create 4 resources
         (local.set $h1 (call $make-R1))
-        (if (i32.ne (i32.const 2) (local.get $h1))
+        (if (i32.ne (i32.const 1) (local.get $h1))
           (then unreachable))
         (local.set $h2 (call $make-R2))
-        (if (i32.ne (i32.const 3) (local.get $h2))
+        (if (i32.ne (i32.const 2) (local.get $h2))
           (then unreachable))
         (local.set $h3 (call $make-R1))
-        (if (i32.ne (i32.const 4) (local.get $h3))
+        (if (i32.ne (i32.const 3) (local.get $h3))
           (then unreachable))
         (local.set $h4 (call $make-R2))
-        (if (i32.ne (i32.const 5) (local.get $h4))
+        (if (i32.ne (i32.const 4) (local.get $h4))
           (then unreachable))
         (if (i32.ne (i32.const 4) (call $num-live))
           (then unreachable))