tests/wasitest: add end-to-end wasip1 TCP echo test

Mirrors upstream Go's src/internal/runtime/wasitest/tcpecho_test.go.
A host-side go test compiles the tcpecho_wasip1 guest with
tinygo build -target=wasip1, spawns wasmtime with -Stcplisten=host:port
so the guest sees a pre-opened TCP listener on fd 3, dials in,
exchanges a payload, and asserts the echo.

Gated behind TINYGO_WASITEST_TCP=1 because the port-probe race is
unavoidable: the host picks a port by binding port 0 then closing the
listener, then asks wasmtime to re-bind that same port. Another
process can win the race in between. Upstream Go gates the same way
(GOWASIENABLERACYTEST=1).

Skips cleanly when tinygo or wasmtime aren't on PATH. TINYGO env var
overrides which tinygo binary is used so CI can point at a
freshly-built one.

Exercises the cooperative scheduler's poll_oneoff idle-path
integration (PR tinygo-org#5386) together with this branch's io.EOF
translation fix in internal/poll.FD.sockRecv — without that fix
io.Copy(c, c) in the guest spins on (0, nil) reads when the host
half-closes.

Author: achille-roussel

tests/wasitest/tcpecho_test.go

@@ -0,0 +1,119 @@
+package wasitest
+
+import (
+	"bytes"
+	"fmt"
+	"math/rand"
+	"net"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+// TestTCPEchoWasip1 spawns a TinyGo-compiled wasip1 module that accepts a
+// single TCP connection on a host pre-opened socket and echoes the payload
+// back. The runtime is wasmtime, invoked with -Stcplisten=host:port.
+//
+// Like the upstream Go src/internal/runtime/wasitest/tcpecho_test.go, the
+// port-probe is racy (the host releases the listener, then asks the
+// runtime to re-bind the same port; another process could win in
+// between). Test is gated behind TINYGO_WASITEST_TCP=1 so normal CI runs
+// don't see flakes.
+func TestTCPEchoWasip1(t *testing.T) {
+	if os.Getenv("TINYGO_WASITEST_TCP") != "1" {
+		t.Skip("set TINYGO_WASITEST_TCP=1 to run wasip1 TCP echo test (racy port probe)")
+	}
+
+	tinygo := os.Getenv("TINYGO")
+	if tinygo == "" {
+		if p, err := exec.LookPath("tinygo"); err == nil {
+			tinygo = p
+		} else {
+			t.Skip("tinygo not found in PATH; set TINYGO to override")
+		}
+	}
+	wasmtime, err := exec.LookPath("wasmtime")
+	if err != nil {
+		t.Skip("wasmtime not found in PATH")
+	}
+
+	tmp := t.TempDir()
+	wasm := filepath.Join(tmp, "tcpecho_wasip1.wasm")
+	src := filepath.Join("testdata", "tcpecho_wasip1.go")
+
+	build := exec.Command(tinygo, "build", "-target=wasip1", "-o", wasm, src)
+	build.Stderr = os.Stderr
+	build.Stdout = os.Stderr
+	if err := build.Run(); err != nil {
+		t.Fatalf("tinygo build: %v", err)
+	}
+
+	host, err := probeFreePort()
+	if err != nil {
+		t.Fatalf("probe port: %v", err)
+	}
+
+	run := exec.Command(wasmtime, "run", "-Spreview2=false", "-Stcplisten="+host, wasm)
+	var out bytes.Buffer
+	run.Stdout = &out
+	run.Stderr = &out
+	if err := run.Start(); err != nil {
+		t.Fatalf("wasmtime start: %v", err)
+	}
+	defer func() {
+		_ = run.Process.Kill()
+		_ = run.Wait()
+		if t.Failed() {
+			t.Logf("wasmtime output:\n%s", out.String())
+		}
+	}()
+
+	var conn net.Conn
+	deadline := time.Now().Add(10 * time.Second)
+	for {
+		conn, err = net.Dial("tcp", host)
+		if err == nil {
+			break
+		}
+		if time.Now().After(deadline) {
+			t.Fatalf("dial %s: %v\nwasmtime output:\n%s", host, err, out.String())
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+	defer conn.Close()
+
+	if err := conn.SetDeadline(time.Now().Add(5 * time.Second)); err != nil {
+		t.Fatal(err)
+	}
+
+	payload := []byte("foobar")
+	if _, err := conn.Write(payload); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	if err := conn.(*net.TCPConn).CloseWrite(); err != nil {
+		t.Fatalf("CloseWrite: %v", err)
+	}
+	var got bytes.Buffer
+	if _, err := got.ReadFrom(conn); err != nil {
+		t.Fatalf("read: %v", err)
+	}
+	if !bytes.Equal(got.Bytes(), payload) {
+		t.Errorf("payload mismatch: sent %q, got %q", payload, got.Bytes())
+	}
+}
+
+func probeFreePort() (string, error) {
+	port := rand.Intn(10000) + 40000
+	for range 20 {
+		host := fmt.Sprintf("127.0.0.1:%d", port)
+		l, err := net.Listen("tcp", host)
+		if err == nil {
+			l.Close()
+			return host, nil
+		}
+		port++
+	}
+	return "", fmt.Errorf("could not find free port")
+}

tests/wasitest/testdata/tcpecho_wasip1.go

@@ -0,0 +1,70 @@
+//go:build wasip1
+
+// tcpecho_wasip1 is a guest program for TestTCPEchoWasip1. It accepts a
+// single TCP connection on a wasi-pre-opened socket fd, echoes the
+// payload back, half-closes its write side, and exits.
+package main
+
+import (
+	"errors"
+	"net"
+	"os"
+	"syscall"
+)
+
+func main() {
+	if err := run(); err != nil {
+		println(err.Error())
+		os.Exit(1)
+	}
+}
+
+func run() error {
+	l, err := findListener()
+	if err != nil {
+		return err
+	}
+	if l == nil {
+		return errors.New("no pre-opened sockets available")
+	}
+	defer l.Close()
+
+	c, err := l.Accept()
+	if err != nil {
+		return err
+	}
+	defer c.Close()
+
+	var buf [256]byte
+	n, err := c.Read(buf[:])
+	if err != nil {
+		return err
+	}
+	if _, err := c.Write(buf[:n]); err != nil {
+		return err
+	}
+	return c.(*net.TCPConn).CloseWrite()
+}
+
+// findListener walks pre-opened fds starting at 3 (0/1/2 are stdio),
+// returning a TCPListener for the first one that is a socket. wasip1
+// host runtimes hand pre-opened TCP listeners as raw fds with no
+// in-band metadata, so probing via net.FileListener is the only path.
+func findListener() (net.Listener, error) {
+	for preopenFd := uintptr(3); ; preopenFd++ {
+		f := os.NewFile(preopenFd, "")
+		l, err := net.FileListener(f)
+		f.Close()
+
+		var se syscall.Errno
+		if errors.As(err, &se) {
+			switch se {
+			case syscall.ENOTSOCK:
+				continue
+			case syscall.EBADF:
+				return nil, nil
+			}
+		}
+		return l, err
+	}
+}