fix(wasix): de-flake udp-large-recv and stream-tcp-writev-partial tests by Arshia001 · Pull Request #6789 · wasmerio/wasmer

Arshia001 · 2026-07-09T08:57:06Z

Summary

Fixes the two flaky socket integration tests reported in #6785. Both flaked under nextest (worse on macOS and under concurrent load) — no runtime code is changed, only the tests.

`udp-large-recv`

The test sent a single 20480-byte UDP datagram over loopback and did one blocking recvfrom. UDP is best-effort: a dropped datagram left recvfrom to wait out the socket's default 30s read timeout and return -1 (ETIMEDOUT) — the "gets stuck ~1 min then fails" symptom. This is common on macOS (default net.inet.udp.maxdgram is 9216, and loopback drops large datagrams under load) and under nextest's concurrent-process load.

Now it:

retries the send/receive a few times, each bounded by poll(POLLIN, 1s) (wasix-libc doesn't wire SO_RCVTIMEO, so poll() is used, matching the udp-readiness test);
treats a failed sendto (e.g. macOS EMSGSIZE on oversized datagrams) as a dropped attempt;
skips (exit 0) if no datagram is ever delivered — a drop is not the behaviour under test;
fails only when a datagram is delivered but has the wrong length or payload (truncation / sharding / corruption), which is the real invariant.

`stream-tcp-writev-partial`

The test relied on the peer's RST landing in the tiny window between the two back-to-back internal send() calls of a single writev. That transition is an asynchronous RST round-trip, so depending on timing the syscall returned the first-iovec length (pass), the full length, or -1 — inherently racy. Virtual SO_SNDBUF/SO_RCVBUF tuning is a no-op on host sockets, so the buffer can't be shrunk to make the boundary controllable either.

Rewritten to exercise the same fd_write contract — "return bytes already transferred instead of failing the whole syscall" — via a deterministic short write: client is non-blocking, server never reads, and writev([5 bytes, 64 MB]) sends the small iovec in full and short-writes the oversized one, so the loop returns a partial total. A whole-syscall failure (the regression) would surface as -1 and fail the assertion.

Caveat: this guards the local_sent != buf.len() => break branch rather than the exact Err(_) if sent > 0 => break arm the original regression fixed — same user-visible contract, different line. Deterministically hitting the error arm from guest code isn't possible (it needs an async error mid-syscall); guarding that specific line would require a runtime-side unit test against a mock VirtualTcpSocket.

Testing

udp-large-recv: happy path passes; forced persistent drops skip in ~8s (exit 0, no 30s hang); forced short delivery fails as expected. Verified on default and v2026-05-12.1 libc (cranelift).
stream-tcp-writev-partial: 6/6 deterministic passes on both libc variants; confirmed it produces a genuine multi-MB partial.

Closes #6785

🤖 Generated with Claude Code

Both socket integration tests were flaky under nextest (issue #6785), timing out / returning wrong values under load, primarily on macOS. udp-large-recv relied on reliable delivery of a single 20480-byte UDP datagram over loopback. UDP is best-effort, so a dropped datagram left the blocking recvfrom to wait out the socket's 30s read timeout and return -1. Retry the exchange a few times with a poll()-bounded wait (wasix-libc does not wire SO_RCVTIMEO), skip (exit 0) if no datagram is ever delivered, and only fail on truncation/sharding/corruption when a datagram does arrive. stream-tcp-writev-partial relied on the peer's RST landing in the window between two back-to-back internal send() calls of a single writev, which is inherently racy (returns first-iovec len, full len, or -1 depending on timing). Rewrite it to exercise the same "return bytes already transferred" fd_write contract via a deterministic short write: a tiny first iovec followed by an oversized second iovec that can never fully fit the send buffer. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Copilot

Pull request overview

This PR updates two WASIX socket integration tests to reduce flakiness under nextest/concurrent load, without changing runtime behavior. It aims to avoid long hangs on dropped UDP datagrams and to make the TCP writev partial-write assertion deterministic.

Changes:

udp-large-recv: retry send/receive attempts with poll()-bounded waits and skip when no datagram is ever delivered.
stream-tcp-writev-partial: rework the test to provoke a partial writev() via non-blocking I/O and an oversized second iovec instead of racing a peer close/RST.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 3 comments.

File	Description
lib/wasix/tests/wasm_tests/socket/udp-large-recv/main.c	Adds bounded polling + retry/skip behavior to avoid hangs on dropped large UDP datagrams.
lib/wasix/tests/wasm_tests/socket/stream-tcp-writev-partial/main.c	Rewrites the test to target a deterministic short write path for `writev` partial-success behavior.

+    int pr = poll(&pfd, 1, RECV_TIMEOUT_MS);
+    if (pr <= 0 || (pfd.revents & POLLIN) == 0) {
+      // Timed out waiting for the datagram (dropped in transit); retry.
+      fprintf(stderr, "attempt %d: poll timed out (pr=%d revents=0x%x)\n",
+              attempt, pr, pfd.revents);
+      continue;
+    }


+    ssize_t nread = recvfrom(receiver, recvbuf, sizeof(recvbuf), 0, NULL, NULL);
+    if (nread < 0) {
+      fprintf(stderr, "attempt %d: recvfrom failed (errno %d: %s)\n", attempt,
+              errno, strerror(errno));
+      continue;
+    }


+  if (written <= (ssize_t)FIRST_IOV_LEN ||
+      written >= (ssize_t)(FIRST_IOV_LEN + (size_t)SECOND_IOV_LEN)) {
    fprintf(stderr,
-            "expected writev to return %d bytes after peer close, got %zd "
-            "errno=%d (%s)\n",
-            FIRST_IOV_LEN, written, errno, strerror(errno));
+            "expected partial writev in (%d, %zu), got %zd errno=%d (%s)\n",
+            FIRST_IOV_LEN, FIRST_IOV_LEN + (size_t)SECOND_IOV_LEN, written,


The stream-tcp-writev-partial rewrite exercises fd_write's partial-return contract through the short-write branch, but not the exact `Err(_) if sent > 0 => break` arm the original regression fixed. That arm requires a later per-iovec send() to error after an earlier iovec already succeeded, which cannot be triggered deterministically over real host sockets (it races an asynchronous RST landing between two back-to-back sends of one writev). Add a test-only mock VirtualNetworking whose TCP socket succeeds on the first send() and returns ECONNRESET afterwards, and drive a small C guest (connect + writev of two iovecs) against it via the existing runtime-config test harness. writev must return the first iovec length. Verified it fails (returns -1) when the partial-return arm is removed. No application code is changed; async-trait is added as a dev-dependency for the mock impl. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Arshia001 · 2026-07-09T09:37:00Z

Added a follow-up commit that closes the coverage gap noted above.

stream-tcp-writev-partial (the short-write rewrite) guards the local_sent != buf.len() => break branch of fd_write, but not the exact Err(_) if sent > 0 => break arm the original regression fixed. That arm needs a later per-iovec send() to error after an earlier iovec already succeeded, which can't be triggered deterministically over real host sockets (it races an async RST landing between two back-to-back sends of one writev).

The new wasm/writev_partial_send_error test drives it against a test-only mock VirtualNetworking (tests/wasm_tests/mock_net.rs) whose TCP socket succeeds on the first send() and returns ECONNRESET afterwards. A small C guest connects and writevs two iovecs; fd_write must return the first iovec length. It runs through the existing runtime-config harness path (mirroring the dynamic_runtime_hooks smoke test) and the C driver carries an Ignored directive so the auto-collected real-networking run is skipped.

No application code changed; async-trait added as a dev-dependency for the mock impl.
Verified the test fails (writev returns -1) when the Err(_) if sent > 0 => break arm is removed, and passes with it intact.

…ull writev Incorporate PR review feedback so the de-flaked tests can still catch regressions instead of masking them: - udp-large-recv: distinguish a dropped datagram (poll() timeout, pr==0) from a genuine error. Retry on EINTR, treat pr==0 as a drop, but fail hard on any other poll() error or unexpected revents, and on a recvfrom() error after POLLIN (readiness reported then recv fails is a real bug, not a drop). - stream-tcp-writev-partial: if the host's socket buffers accept the whole oversized write, we cannot force a short write; treat that as an environment limitation and skip rather than false-fail. Still fail on written < 0 (the regression). Drop the ExpectedStdout directive since the skip path no longer prints it; assert via exit code. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Arshia001 · 2026-07-09T11:19:46Z

Thanks — addressed all three review points in bc1cf3f:

udp-large-recv poll() errors — now only pr == 0 (timeout) is treated as a dropped datagram. EINTR retries; any other poll() error or unexpected revents (POLLERR/POLLHUP/…) fails hard instead of skipping, and the misleading "timed out" message is gone.
udp-large-recv recvfrom() after POLLIN — a recvfrom failure once the socket is reported readable now fails the test (except EINTR), rather than retrying/skipping, so a "readiness reported then recv errors" regression can't be masked.
writev 64 MiB full-write — if the host accepts the whole write (buffers ≥ 64 MiB), the test now skips ("environment can't force a short write") instead of false-failing; it still fails on written < 0 (the regression). Dropped the ExpectedStdout directive since the skip path no longer prints it and assert via exit code.

Re-verified: happy paths pass on both libc variants, the udp skip path still exits 0 (~8s) on forced drops, and the writev mock test still fails when the Err(_) if sent > 0 => break arm is removed.

Copilot

Pull request overview

Copilot reviewed 6 out of 6 changed files in this pull request and generated 2 comments.

+    ssize_t nsent = sendto(sender, sendbuf, PAYLOAD_SIZE, 0,
+                           (struct sockaddr*)&addr, sizeof(addr));
+    if (nsent != PAYLOAD_SIZE) {
+      // e.g. macOS rejects datagrams larger than net.inet.udp.maxdgram with
+      // EMSGSIZE. That is not the behaviour under test, so treat it as a
+      // dropped attempt.
+      fprintf(stderr, "attempt %d: sendto returned %zd (errno %d: %s)\n",
+              attempt, nsent, errno, strerror(errno));
+      continue;
+    }


+  char* big = malloc(SECOND_IOV_LEN);
+  if (big == NULL) {
+    fprintf(stderr, "malloc failed\n");
    close(client);
+    close(server);
    return 1;
  }
+  memset(big, 'w', SECOND_IOV_LEN);


- udp-large-recv: only treat expected best-effort/oversize/transient sendto() failures (EMSGSIZE/ENOBUFS/EAGAIN/EWOULDBLOCK/EINTR) as a dropped attempt; any other errno now fails the test instead of being skipped, so a real sendto regression (EBADF/EINVAL/...) cannot be masked. A short non-negative datagram send is also treated as a bug. - stream-tcp-writev-partial: skip (exit 0) if the 64 MiB allocation fails rather than hard-failing, so constrained environments don't reintroduce flakiness; drop the memset since only the returned byte count is asserted. - Apply clang-format (Google style) to satisfy the Code lint CI job. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Arshia001 · 2026-07-09T12:13:10Z

Addressed the re-review in 2bf9566 (also fixed the clang-format CI failure in the same commit):

sendto masking real regressions — the retry loop now only treats expected best-effort/oversize/transient failures (EMSGSIZE/ENOBUFS/EAGAIN/EWOULDBLOCK/EINTR) as a dropped attempt. Any other errno (e.g. EBADF/EINVAL) fails the test instead of eventually skipping, and a short non-negative datagram send is treated as a bug too.
64 MiB allocation — malloc failure now skips (exit 0) instead of hard-failing, so constrained environments don't reintroduce flakiness; dropped the memset since only the returned byte count is asserted.

Re-verified all three tests pass on both libc variants and the udp skip path still exits 0 (~8s) under forced drops. clang-format (Google style) now passes locally.

marxin · 2026-07-09T13:43:03Z

        }
    }));

+    tests.push(libtest_mimic::Trial::test(


Don't like this (apparently second one) special-case. If have have a special need from the harness, we should introduce a new directive and annotate the corresponding expectations in the test-case.

marxin · 2026-07-09T13:46:43Z

@@ -0,0 +1,175 @@
+//! A mock networking backend used by the `writev_partial_send_error` test.
+//!
+//! It hands out a TCP socket whose first `try_send` succeeds in full and whose


Well, this only covers one particular scenario - it's not any generic mocking harness. How much do we benefit from the specific scenario?

marxin · 2026-07-16T09:15:44Z

For unblocking of the CI on main, I temporarily disabled the test in 503f53f.
Please enable it again as part of this PR.

Copilot AI review requested due to automatic review settings July 9, 2026 08:57

Copilot started reviewing on behalf of Arshia001 July 9, 2026 09:00 View session

Copilot AI reviewed Jul 9, 2026

View reviewed changes

Arshia001 requested a review from marxin July 9, 2026 09:24

Arshia001 requested a review from Copilot July 9, 2026 12:06

Copilot started reviewing on behalf of Arshia001 July 9, 2026 12:07 View session

Copilot AI reviewed Jul 9, 2026

View reviewed changes

marxin requested changes Jul 9, 2026

View reviewed changes

marxin added the macos label Jul 9, 2026

marxin mentioned this pull request Jul 15, 2026

fix(macOS): respect MTU on macOS in udp-large-recv test-case #6786

Closed

Navigation Menu

Uh oh!

fix(wasix): de-flake udp-large-recv and stream-tcp-writev-partial tests - #6789

fix(wasix): de-flake udp-large-recv and stream-tcp-writev-partial tests#6789
Arshia001 wants to merge 4 commits into
mainfrom
fix/flaky-udp-tcp-socket-tests

Arshia001 commented Jul 9, 2026

Uh oh!

Copilot AI left a comment

Uh oh!

Arshia001 commented Jul 9, 2026

Uh oh!

Arshia001 commented Jul 9, 2026

Uh oh!

Copilot AI left a comment

Uh oh!

Arshia001 commented Jul 9, 2026

Uh oh!

marxin Jul 9, 2026

Uh oh!

marxin Jul 9, 2026

Uh oh!

marxin commented Jul 16, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Uh oh!

Conversation

Arshia001 commented Jul 9, 2026

Summary

udp-large-recv

stream-tcp-writev-partial

Testing

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Arshia001 commented Jul 9, 2026

Uh oh!

Arshia001 commented Jul 9, 2026

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Arshia001 commented Jul 9, 2026

Uh oh!

marxin Jul 9, 2026

Choose a reason for hiding this comment

Uh oh!

marxin Jul 9, 2026

Choose a reason for hiding this comment

Uh oh!

marxin commented Jul 16, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

`udp-large-recv`

`stream-tcp-writev-partial`