Test additional cases in test/async/drop-cross-task-borrow.wast

Author: lukewagner

test/async/drop-cross-task-borrow.wast

@@ -30,7 +30,8 @@
       (import "" "future.new" (func $future.new (result i64)))
       (import "" "future.read" (func $future.read (param i32 i32) (result i32)))
       (import "" "future.write" (func $future.write (param i32 i32) (result i32)))
-      (import "" "task.return" (func $task.return (param i32)))
+      (import "" "task.return0" (func $task.return0))
+      (import "" "task.return1" (func $task.return1 (param i32)))
       (import "" "R-rep" (func $R-rep (param i32) (result i32)))
       (import "" "R-drop" (func $R-drop (param i32)))
 
@@ -49,7 +50,7 @@
       )
       (func (export "dont-drop-cb") (param i32 i32 i32) (result i32)
         ;; We were resumed by resume-dont-drop
-        (call $task.return (global.get $dont-drop-result))
+        (call $task.return1 (global.get $dont-drop-result))
         (i32.const 0 (; EXIT ;))
       )
       (func (export "drop-handle") (result i32)
@@ -75,10 +76,28 @@
           (then unreachable))
         (call $waitable.join (local.get $futr) (global.get $dont-drop-ws))
       )
+      (func (export "drop-other-and-self") (param $h i32) (result i32)
+        (local $result i32)
+        (local.set $result (call $R-rep (global.get $handle)))
+        (call $R-drop (global.get $handle))
+        (call $R-drop (local.get $h))
+        (call $task.return1 (local.get $result))
+        (i32.const 0 (; EXIT ;))
+      )
+      (func (export "drop-wrong-one") (param $h i32) (result i32)
+        (call $R-drop (global.get $handle))
+        ;; trap b/c $h wasn't dropped
+        (call $task.return0)
+        (i32.const 0 (; EXIT ;))
+      )
+      (func (export "unreachable-cb") (param i32 i32 i32) (result i32)
+        unreachable
+      )
     )
     (type $FT (future))
     (alias export $d "R" (type $R))
-    (canon task.return (result u32) (core func $task.return))
+    (canon task.return (core func $task.return0))
+    (canon task.return (result u32) (core func $task.return1))
     (canon waitable.join (core func $waitable.join))
     (canon waitable-set.new (core func $waitable-set.new))
     (canon future.new $FT (core func $future.new))
@@ -87,7 +106,8 @@
     (canon lower (func $d "R-rep") (core func $R-rep))
     (canon resource.drop $R (core func $R-drop))
     (core instance $dm (instantiate $DM (with "" (instance
-      (export "task.return" (func $task.return))
+      (export "task.return0" (func $task.return0))
+      (export "task.return1" (func $task.return1))
       (export "waitable.join" (func $waitable.join))
       (export "waitable-set.new" (func $waitable-set.new))
       (export "future.new" (func $future.new))
@@ -105,6 +125,12 @@
     (func (export "resume-dont-drop")
       (canon lift (core func $dm "resume-dont-drop"))
     )
+    (func (export "drop-other-and-self") (param "self" (borrow $R)) (result u32)
+      (canon lift (core func $dm "drop-other-and-self") async (callback (func $dm "unreachable-cb")))
+    )
+    (func (export "drop-wrong-one") (param "self" (borrow $R))
+      (canon lift (core func $dm "drop-wrong-one") async (callback (func $dm "unreachable-cb")))
+    )
   )
 
   (component $E
@@ -117,6 +143,8 @@
       (export "dont-drop" (func async (param "self" (borrow $R)) (result u32)))
       (export "drop-handle" (func (result u32)))
       (export "resume-dont-drop" (func))
+      (export "drop-other-and-self" (func (param "self" (borrow $R)) (result u32)))
+      (export "drop-wrong-one" (func (param "self" (borrow $R))))
     ))
     (core module $Memory (memory (export "mem") 1))
     (core instance $memory (instantiate $Memory))
@@ -129,15 +157,17 @@
       (import "" "dont-drop" (func $dont-drop (param i32 i32) (result i32)))
       (import "" "drop-handle" (func $drop-handle (result i32)))
       (import "" "resume-dont-drop" (func $resume-dont-drop))
-      (func (export "do-it-right") (result i32)
+      (import "" "drop-other-and-self" (func $drop-other-and-self (param i32) (result i32)))
+      (import "" "drop-wrong-one" (func $drop-wrong-one (param i32)))
+      (func (export "drop-other-no-self") (result i32)
         (local $ret i32)
         (local $retp i32) (local $retp2 i32)
         (local $handle i32)
         (local $subtask i32)
         (local $magic i32)
         (local $ws i32) (local $event_code i32)
 
-        ;; Create a resource storign $magic as it's rep
+        ;; Create a resource storing $magic as it's rep
         (local.set $magic (i32.const 10))
         (local.set $handle (call $R-new (local.get $magic)))
 
@@ -174,6 +204,69 @@
 
         i32.const 42
       )
+      (func (export "drop-other-and-self") (result i32)
+        (local $ret i32)
+        (local $retp i32) (local $retp2 i32)
+        (local $handle i32)
+        (local $subtask i32)
+        (local $magic i32)
+        (local $ws i32) (local $event_code i32)
+
+        ;; Create a resource storing $magic as it's rep
+        (local.set $magic (i32.const 11))
+        (local.set $handle (call $R-new (local.get $magic)))
+
+        ;; Kick off a call to dont-drop that will block
+        (local.set $retp (i32.const 16))
+        (local.set $ret (call $dont-drop (local.get $handle) (local.get $retp)))
+        (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)))
+
+        ;; This will drop dont-drop's *and* its own borrowed handle
+        (local.set $ret (call $drop-other-and-self (local.get $handle)))
+        (if (i32.ne (local.get $magic) (local.get $ret))
+          (then unreachable))
+
+        ;; this unblocks $subtask
+        (call $resume-dont-drop)
+
+        ;; now wait for $subtask to return, so that it can run before the test is over
+        (local.set $ws (call $waitable-set.new))
+        (call $waitable.join (local.get $subtask) (local.get $ws))
+        (local.set $retp2 (i32.const 32))
+        (local.set $event_code (call $waitable-set.wait (local.get $ws) (local.get $retp2)))
+        (if (i32.ne (i32.const 1 (; SUBTASK ;)) (local.get $event_code))
+          (then unreachable))
+        (if (i32.ne (local.get $subtask) (i32.load (local.get $retp2)))
+          (then unreachable))
+        (if (i32.ne (i32.const 2 (; RETURNED=2 | (0<<4) ;)) (i32.load offset=4 (local.get $retp2)))
+          (then unreachable))
+
+        ;; $subtask should return the rep passed to $R-new.
+        (if (i32.ne (local.get $magic) (i32.load (local.get $retp)))
+          (then unreachable))
+
+        i32.const 43
+      )
+      (func (export "drop-other-miss-self")
+        (local $ret i32)
+        (local $retp i32)
+        (local $handle i32)
+        (local $subtask i32)
+
+        (local.set $handle (call $R-new (i32.const 42)))
+
+        ;; Kick off a call to dont-drop that will block
+        (local.set $retp (i32.const 16))
+        (local.set $ret (call $dont-drop (local.get $handle) (local.get $retp)))
+        (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)))
+
+        ;; Call drop-wrong-one which will drop the above call's borrow, but not its own and trap
+        (call $drop-wrong-one (local.get $handle))
+      )
     )
     (canon waitable.join (core func $waitable.join))
     (canon waitable-set.new (core func $waitable-set.new))
@@ -182,6 +275,8 @@
     (canon lower (func $d "dont-drop") async (memory $memory "mem") (core func $dont-drop))
     (canon lower (func $d "drop-handle") (core func $drop-handle))
     (canon lower (func $d "resume-dont-drop") (core func $resume-dont-drop))
+    (canon lower (func $d "drop-other-and-self") (core func $drop-other-and-self))
+    (canon lower (func $d "drop-wrong-one") (core func $drop-wrong-one))
     (core instance $em (instantiate $EM (with "" (instance
       (export "mem" (memory $memory "mem"))
       (export "waitable.join" (func $waitable.join))
@@ -191,14 +286,24 @@
       (export "dont-drop" (func $dont-drop))
       (export "drop-handle" (func $drop-handle))
       (export "resume-dont-drop" (func $resume-dont-drop))
+      (export "drop-other-and-self" (func $drop-other-and-self))
+      (export "drop-wrong-one" (func $drop-wrong-one))
     ))))
-    (func (export "do-it-right") async (result u32) (canon lift (core func $em "do-it-right")))
+    (func (export "drop-other-no-self") async (result u32) (canon lift (core func $em "drop-other-no-self")))
+    (func (export "drop-other-and-self") async (result u32) (canon lift (core func $em "drop-other-and-self")))
+    (func (export "drop-other-miss-self") async (canon lift (core func $em "drop-other-miss-self")))
   )
   (instance $c (instantiate $C))
   (instance $d (instantiate $D (with "c" (instance $c))))
   (instance $e (instantiate $E (with "c" (instance $c)) (with "d" (instance $d))))
-  (func (export "do-it-right") (alias export $e "do-it-right"))
+  (func (export "drop-other-no-self") (alias export $e "drop-other-no-self"))
+  (func (export "drop-other-and-self") (alias export $e "drop-other-and-self"))
+  (func (export "drop-other-miss-self") (alias export $e "drop-other-miss-self"))
 )
 
 (component instance $i $Test)
-(assert_return (invoke "do-it-right") (u32.const 42))
+(assert_return (invoke "drop-other-no-self") (u32.const 42))
+(component instance $i $Test)
+(assert_return (invoke "drop-other-and-self") (u32.const 43))
+(component instance $i $Test)
+(assert_trap (invoke "drop-other-miss-self") "borrow handles still remain at the end of the call")