Fix async tests with latest wasip3 changes (#1301)

alexcrichton · web-flow · commit 5141578ee28f · 2025-05-27T16:25:07.000Z
This involved deleting one test in Rust due to #1300 meaning that the previous behavior cannot be modeled in Rust at this time. Note though that this is still modeled in C which suffices for testing.
diff --git a/tests/runtime-async/async/cancel-import/test.c b/tests/runtime-async/async/cancel-import/test.c
@@ -35,7 +35,7 @@ test_callback_code_t exports_test_async_pending_import_callback(test_event_t *ev
   } else {
     assert(event->event == TEST_EVENT_FUTURE_READ);
     assert(event->waitable == task->future);
-    assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_COMPLETED);
+    assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_CLOSED);
     assert(TEST_WAITABLE_COUNT(event->code) == 1);
     exports_test_async_pending_import_return();
   }
diff --git a/tests/runtime-async/async/future-cancel-write/runner.c b/tests/runtime-async/async/future-cancel-write/runner.c
@@ -53,7 +53,7 @@ int main() {
     assert(status2 == RUNNER_SUBTASK_RETURNED);
 
     status = test_future_string_cancel_write(writer);
-    assert(RUNNER_WAITABLE_STATE(status) == RUNNER_WAITABLE_COMPLETED);
+    assert(RUNNER_WAITABLE_STATE(status) == RUNNER_WAITABLE_CLOSED);
     assert(RUNNER_WAITABLE_COUNT(status) == 1);
 
     test_future_string_close_writable(writer);
diff --git a/tests/runtime-async/async/future-cancel-write/test.c b/tests/runtime-async/async/future-cancel-write/test.c
@@ -10,7 +10,7 @@ void exports_test_take_then_close(exports_test_future_string_t x) {
 test_callback_code_t exports_test_async_read_and_drop(exports_test_future_string_t x) {
   test_string_t string;
   test_waitable_status_t status = exports_test_future_string_read(x, &string);
-  assert(TEST_WAITABLE_STATE(status) == TEST_WAITABLE_COMPLETED);
+  assert(TEST_WAITABLE_STATE(status) == TEST_WAITABLE_CLOSED);
   assert(TEST_WAITABLE_COUNT(status) == 1);
 
   exports_test_future_string_close_readable(x);
diff --git a/tests/runtime-async/async/pending-import/runner.c b/tests/runtime-async/async/pending-import/runner.c
@@ -13,7 +13,7 @@ int main() {
   assert(subtask != 0);
 
   runner_waitable_status_t status2 = test_future_void_write(writer);
-  assert(RUNNER_WAITABLE_STATE(status2) == RUNNER_WAITABLE_COMPLETED);
+  assert(RUNNER_WAITABLE_STATE(status2) == RUNNER_WAITABLE_CLOSED);
   assert(RUNNER_WAITABLE_COUNT(status2) == 1);
   test_future_void_close_writable(writer);
 
diff --git a/tests/runtime-async/async/pending-import/test.c b/tests/runtime-async/async/pending-import/test.c
@@ -26,7 +26,7 @@ test_callback_code_t exports_test_async_pending_import_callback(test_event_t *ev
   struct my_task *task = test_context_get();
   assert(event->event == TEST_EVENT_FUTURE_READ);
   assert(event->waitable == task->future);
-  assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_COMPLETED);
+  assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_CLOSED);
   assert(TEST_WAITABLE_COUNT(event->code) == 1);
   exports_test_async_pending_import_return();
 
diff --git a/tests/runtime-async/async/ping-pong/runner.c b/tests/runtime-async/async/ping-pong/runner.c
@@ -21,7 +21,7 @@ int main() {
   runner_string_t string_tmp;
   runner_string_set(&string_tmp, "hello");
   runner_waitable_status_t status2 = test_future_string_write(writer, &string_tmp);
-  assert(RUNNER_WAITABLE_STATE(status2) == RUNNER_WAITABLE_COMPLETED);
+  assert(RUNNER_WAITABLE_STATE(status2) == RUNNER_WAITABLE_CLOSED);
   assert(RUNNER_WAITABLE_COUNT(status2) == 1);
   test_future_string_close_writable(writer);
 
@@ -39,7 +39,7 @@ int main() {
 
   // Read the result from our future
   status2 = test_future_string_read(ping_result, &string_tmp);
-  assert(RUNNER_WAITABLE_STATE(status2) == RUNNER_WAITABLE_COMPLETED);
+  assert(RUNNER_WAITABLE_STATE(status2) == RUNNER_WAITABLE_CLOSED);
   assert(RUNNER_WAITABLE_COUNT(status2) == 1);
   assert(memcmp(string_tmp.ptr, "helloworld", string_tmp.len) == 0);
   test_future_string_close_readable(ping_result);
@@ -53,7 +53,7 @@ int main() {
 
   // Write our string to the "pong" subtask
   status2 = test_future_string_write(writer, &string_tmp);
-  assert(RUNNER_WAITABLE_STATE(status2) == RUNNER_WAITABLE_COMPLETED);
+  assert(RUNNER_WAITABLE_STATE(status2) == RUNNER_WAITABLE_CLOSED);
   assert(RUNNER_WAITABLE_COUNT(status2) == 1);
   runner_string_free(&string_tmp);
   test_future_string_close_writable(writer);
diff --git a/tests/runtime-async/async/ping-pong/test.c b/tests/runtime-async/async/ping-pong/test.c
@@ -45,7 +45,7 @@ test_callback_code_t exports_test_async_ping_callback(test_event_t *event) {
       // future.
       assert(event->event == TEST_EVENT_FUTURE_READ);
       assert(event->waitable == task->future);
-      assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_COMPLETED);
+      assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_CLOSED);
       assert(TEST_WAITABLE_COUNT(event->code) == 1);
       test_waitable_join(task->future, 0);
       exports_test_future_string_close_readable(task->future);
@@ -83,7 +83,7 @@ test_callback_code_t exports_test_async_ping_callback(test_event_t *event) {
       // of the future.
       assert(event->event == TEST_EVENT_FUTURE_WRITE);
       assert(event->waitable == task->writer);
-      assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_COMPLETED);
+      assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_CLOSED);
       assert(TEST_WAITABLE_COUNT(event->code) == 1);
       test_waitable_join(task->writer, 0);
       exports_test_future_string_close_writable(task->writer);
@@ -134,7 +134,7 @@ test_callback_code_t exports_test_async_pong_callback(test_event_t *event) {
   // assert this event is a future read completion
   assert(event->event == TEST_EVENT_FUTURE_READ);
   assert(event->waitable == task->future);
-  assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_COMPLETED);
+  assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_CLOSED);
   assert(TEST_WAITABLE_COUNT(event->code) == 1);
 
   // deallocate/destroy our future
diff --git a/tests/runtime-async/async/simple-future/runner.c b/tests/runtime-async/async/simple-future/runner.c
@@ -37,7 +37,7 @@ int main() {
     runner_waitable_set_wait(set, &event);
     assert(event.event == RUNNER_EVENT_FUTURE_WRITE);
     assert(event.waitable == writer);
-    assert(RUNNER_WAITABLE_STATE(event.code) == RUNNER_WAITABLE_COMPLETED);
+    assert(RUNNER_WAITABLE_STATE(event.code) == RUNNER_WAITABLE_CLOSED);
     assert(RUNNER_WAITABLE_COUNT(event.code) == 1);
 
     test_future_void_close_writable(writer);
diff --git a/tests/runtime-async/async/simple-future/test.c b/tests/runtime-async/async/simple-future/test.c
@@ -5,7 +5,7 @@
 
 test_subtask_status_t exports_test_async_read_future(exports_test_future_void_t future) {
   test_waitable_status_t status = exports_test_future_void_read(future);
-  assert(TEST_WAITABLE_STATE(status) == TEST_WAITABLE_COMPLETED);
+  assert(TEST_WAITABLE_STATE(status) == TEST_WAITABLE_CLOSED);
   assert(TEST_WAITABLE_COUNT(status) == 1);
   exports_test_future_void_close_readable(future);
   exports_test_async_read_future_return();
diff --git a/tests/runtime-async/async/simple-stream-payload/runner.c b/tests/runtime-async/async/simple-stream-payload/runner.c
@@ -44,12 +44,7 @@ int main() {
   assert(event.event == RUNNER_EVENT_STREAM_WRITE);
   assert(event.waitable == writer);
   assert(RUNNER_WAITABLE_STATE(event.code) == RUNNER_WAITABLE_COMPLETED);
-  assert(RUNNER_WAITABLE_COUNT(event.code) == 1);
-
-  // write the second item
-  status = test_stream_u8_write(writer, buf + 1, 1);
-  assert(RUNNER_WAITABLE_STATE(status) == RUNNER_WAITABLE_COMPLETED);
-  assert(RUNNER_WAITABLE_COUNT(status) == 1);
+  assert(RUNNER_WAITABLE_COUNT(event.code) == 2);
 
   // clean up the writer
   runner_waitable_join(writer, 0);
diff --git a/tests/runtime-async/async/simple-stream-payload/runner.rs b/tests/runtime-async/async/simple-stream-payload/runner.rs
@@ -19,12 +19,7 @@ fn main() {
 
             // write 1/2 items again
             let (result, ret) = tx.write(vec![3, 4]).await;
-            assert_eq!(result, StreamResult::Complete(1));
-            assert_eq!(ret.remaining(), 1);
-
-            // resume the write
-            let (result, ret) = tx.write_buf(ret).await;
-            assert_eq!(result, StreamResult::Complete(1));
+            assert_eq!(result, StreamResult::Complete(2));
             assert_eq!(ret.remaining(), 0);
 
             // write to a closed stream
diff --git a/tests/runtime-async/async/simple-stream-payload/test.c b/tests/runtime-async/async/simple-stream-payload/test.c
@@ -6,7 +6,6 @@
 static test_waitable_set_t SET = 0;
 static exports_test_stream_u8_t STREAM = 0;
 static uint8_t BUF[2];
-static uint8_t STATE = 0;
 
 test_subtask_status_t exports_test_async_read_stream(exports_test_stream_u8_t stream) {
   test_waitable_status_t status = exports_test_stream_u8_read(stream, BUF, 1);
@@ -25,46 +24,32 @@ test_subtask_status_t exports_test_async_read_stream(exports_test_stream_u8_t st
 }
 
 test_subtask_status_t exports_test_async_read_stream_callback(test_event_t *event) {
-  switch (STATE++) {
-    case 0:
-      assert(event->event == TEST_EVENT_STREAM_READ);
-      assert(event->waitable == STREAM);
-      assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_COMPLETED);
-      assert(TEST_WAITABLE_COUNT(event->code) == 2);
+  assert(event->event == TEST_EVENT_STREAM_READ);
+  assert(event->waitable == STREAM);
+  assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_COMPLETED);
+  assert(TEST_WAITABLE_COUNT(event->code) == 2);
 
-      assert(BUF[0] == 1);
-      assert(BUF[1] == 2);
+  assert(BUF[0] == 1);
+  assert(BUF[1] == 2);
 
-      // read 1/2 items
-      test_waitable_status_t status = exports_test_stream_u8_read(STREAM, BUF, 1);
-      assert(TEST_WAITABLE_STATE(status) == TEST_WAITABLE_COMPLETED);
-      assert(TEST_WAITABLE_COUNT(status) == 1);
-      assert(BUF[0] == 3);
-
-      // start the read of item 2/2
-      status = exports_test_stream_u8_read(STREAM, BUF + 1, 1);
-      assert(status == TEST_WAITABLE_STATUS_BLOCKED);
-
-      return TEST_CALLBACK_CODE_WAIT(SET);
-
-    case 1:
-      // complete the read of item 2/2
-      assert(event->event == TEST_EVENT_STREAM_READ);
-      assert(event->waitable == STREAM);
-      assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_COMPLETED);
-      assert(TEST_WAITABLE_COUNT(event->code) == 1);
-      assert(BUF[1] == 4);
+  // read 1/2 items
+  test_waitable_status_t status = exports_test_stream_u8_read(STREAM, BUF, 1);
+  assert(TEST_WAITABLE_STATE(status) == TEST_WAITABLE_COMPLETED);
+  assert(TEST_WAITABLE_COUNT(status) == 1);
+  assert(BUF[0] == 3);
 
-      // clean up resources
-      test_waitable_join(STREAM, 0);
-      exports_test_stream_u8_close_readable(STREAM);
+  // start the read of item 2/2
+  status = exports_test_stream_u8_read(STREAM, BUF + 1, 1);
+  assert(TEST_WAITABLE_STATE(status) == TEST_WAITABLE_COMPLETED);
+  assert(TEST_WAITABLE_COUNT(status) == 1);
+  assert(BUF[1] == 4);
 
-      test_waitable_set_drop(SET);
+  // clean up resources
+  test_waitable_join(STREAM, 0);
+  exports_test_stream_u8_close_readable(STREAM);
 
-      exports_test_async_read_stream_return();
-      return TEST_CALLBACK_CODE_EXIT;
+  test_waitable_set_drop(SET);
 
-    default:
-      assert(0);
-  }
+  exports_test_async_read_stream_return();
+  return TEST_CALLBACK_CODE_EXIT;
 }
diff --git a/tests/runtime-async/async/simple-stream/test.rs b/tests/runtime-async/async/simple-stream/test.rs

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ test_callback_code_t exports_test_async_pending_import_callback(test_event_t *ev`
`35`	`35`	`} else {`
`36`	`36`	`assert(event->event == TEST_EVENT_FUTURE_READ);`
`37`	`37`	`assert(event->waitable == task->future);`
`38`		`- assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_COMPLETED);`
	`38`	`+ assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_CLOSED);`
`39`	`39`	`assert(TEST_WAITABLE_COUNT(event->code) == 1);`
`40`	`40`	`exports_test_async_pending_import_return();`
`41`	`41`	`}`