| // Copyright 2026 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package nettest_test |
| |
| import ( |
| "bytes" |
| "errors" |
| "internal/nettest" |
| "io" |
| "net" |
| "net/netip" |
| "os" |
| "testing" |
| "testing/synctest" |
| "time" |
| ) |
| |
| func TestPacketConnListenConflict(t *testing.T) { |
| synctest.Test(t, func(t *testing.T) { |
| addr := net.UDPAddrFromAddrPort(netip.MustParseAddrPort("10.0.0.1:1000")) |
| pnet := nettest.NewPacketNet() |
| conn, err := pnet.NewConn(addr) |
| if err != nil { |
| t.Fatalf("with no existing listener, pnet.NewConn(%v) = %v; want success", addr, err) |
| } |
| _, err = pnet.NewConn(addr) |
| if err == nil { |
| t.Fatalf("with existing listener, pnet.NewConn(%v) = nil; want error", addr) |
| } |
| conn.Close() |
| _, err = pnet.NewConn(addr) |
| if err != nil { |
| t.Fatalf("after closing existing listener, pnet.NewConn(%v) = %v; want success", addr, err) |
| } |
| }) |
| } |
| |
| func TestPacketConnReadWrite(t *testing.T) { |
| synctest.Test(t, func(t *testing.T) { |
| pnet := nettest.NewPacketNet() |
| c1 := mustNewPacketConn(t, pnet, "10.0.0.1:1000") |
| c2 := mustNewPacketConn(t, pnet, "10.0.0.2:2000") |
| c3 := mustNewPacketConn(t, pnet, "10.0.0.3:3000") |
| |
| wantPacketConnWriteTo(t, c1, []byte("1->3"), c3.LocalAddr()) |
| wantPacketConnWriteTo(t, c2, []byte("2->3"), c3.LocalAddr()) |
| wantPacketConnWriteTo(t, c3, []byte("3->1"), c1.LocalAddr()) |
| |
| wantPacketConnReadBytes(t, c1, []byte("3->1"), c3.LocalAddr()) |
| wantPacketConnReadBytes(t, c3, []byte("1->3"), c1.LocalAddr()) |
| wantPacketConnReadBytes(t, c3, []byte("2->3"), c2.LocalAddr()) |
| wantPacketConnReadBlocked(t, c1) |
| wantPacketConnReadBlocked(t, c2) |
| wantPacketConnReadBlocked(t, c3) |
| |
| // Write a packet into the void (no listener on this address). |
| wantPacketConnWriteTo(t, c1, []byte("1->lost"), net.UDPAddrFromAddrPort(netip.MustParseAddrPort("10.0.0.100:1000"))) |
| }) |
| } |
| |
| func TestPacketConnWriteAddressErrors(t *testing.T) { |
| t.Skip("TODO: figure out if these should be errors") |
| |
| synctest.Test(t, func(t *testing.T) { |
| pnet := nettest.NewPacketNet() |
| c4 := mustNewPacketConn(t, pnet, "10.0.0.1:1000") |
| c6 := mustNewPacketConn(t, pnet, "[::1]:1000") |
| |
| wantPacketConnWriteErr(t, c4, c6.LocalAddr(), anyError) // IPv4 -> IPv6 |
| wantPacketConnWriteErr(t, c6, c4.LocalAddr(), anyError) // IPv6 -> IPv4 |
| |
| // Not a *net.UDPAddr. |
| wantPacketConnWriteErr(t, c4, net.UDPAddrFromAddrPort(netip.MustParseAddrPort("10.0.0.1:1000")), anyError) |
| }) |
| } |
| |
| func TestPacketConnClose(t *testing.T) { |
| synctest.Test(t, func(t *testing.T) { |
| pnet := nettest.NewPacketNet() |
| pconn := mustNewPacketConn(t, pnet, "10.0.0.1:1000") |
| |
| wantPacketConnWriteTo(t, pconn, []byte("hello"), pconn.LocalAddr()) |
| |
| if err := pconn.Close(); err != nil { |
| t.Errorf("pconn.Close() = %v, want success", err) |
| } |
| if err := pconn.Close(); !isOpError(err, net.ErrClosed) { |
| t.Errorf("pconn.Close() = %v, want ErrClosed", err) |
| } |
| |
| wantPacketConnReadErr(t, pconn, net.ErrClosed) |
| wantPacketConnWriteErr(t, pconn, pconn.LocalAddr(), net.ErrClosed) |
| }) |
| } |
| |
| func TestPacketConnReadDeadline(t *testing.T) { |
| for _, setDeadline := range []struct { |
| name string |
| f func(*nettest.PacketConn, time.Time) error |
| }{{ |
| name: "SetDeadline", |
| f: (*nettest.PacketConn).SetDeadline, |
| }, { |
| name: "SetReadDeadline", |
| f: (*nettest.PacketConn).SetReadDeadline, |
| }} { |
| t.Run(setDeadline.name, func(t *testing.T) { |
| testDeadline(t, func() deadlineTest { |
| pnet := nettest.NewPacketNet() |
| rconn := mustNewPacketConn(t, pnet, "10.0.0.1:1000") |
| wconn := mustNewPacketConn(t, pnet, "10.0.0.2:2000") |
| return deadlineTest{ |
| what: "ReadFrom()", |
| block: func() error { |
| _, _, err := rconn.ReadFrom(make([]byte, 1)) |
| return err |
| }, |
| unblock: func() { |
| wconn.WriteTo([]byte("x"), rconn.LocalAddr()) |
| }, |
| setDeadline: func(d time.Duration) { |
| setDeadline.f(rconn, time.Now().Add(d)) |
| }, |
| } |
| }) |
| }) |
| } |
| } |
| |
| func TestPacketConnWriteDeadline(t *testing.T) { |
| synctest.Test(t, func(t *testing.T) { |
| pnet := nettest.NewPacketNet() |
| rconn := mustNewPacketConn(t, pnet, "10.0.0.1:1000") |
| wconn := mustNewPacketConn(t, pnet, "10.0.0.2:2000") |
| |
| // This does nothing, even though the deadline has expired. |
| wconn.SetWriteDeadline(time.Now().Add(-1 * time.Second)) |
| |
| wantPacketConnWriteTo(t, wconn, []byte("data"), rconn.LocalAddr()) |
| wantPacketConnReadBytes(t, rconn, []byte("data"), wconn.LocalAddr()) |
| }) |
| } |
| |
| func TestPacketConnSetReadError(t *testing.T) { |
| synctest.Test(t, func(t *testing.T) { |
| wantErr := errors.New("error") |
| pnet := nettest.NewPacketNet() |
| rconn := mustNewPacketConn(t, pnet, "10.0.0.1:1000") |
| wconn := mustNewPacketConn(t, pnet, "10.0.0.2:2000") |
| rconn.SetReadError(wantErr) |
| |
| // Consume buffer before returning error. |
| wantPacketConnWriteTo(t, wconn, []byte("one"), rconn.LocalAddr()) |
| wantPacketConnReadBytes(t, rconn, []byte("one"), wconn.LocalAddr()) |
| wantPacketConnReadErr(t, rconn, wantErr) |
| |
| // Write more, suppressing error until buffer drains again. |
| wantPacketConnWriteTo(t, wconn, []byte("two"), rconn.LocalAddr()) |
| wantPacketConnReadBytes(t, rconn, []byte("two"), wconn.LocalAddr()) |
| wantPacketConnReadErr(t, rconn, wantErr) |
| |
| // Error may be cleared. |
| rconn.SetReadError(nil) |
| wantPacketConnReadBlocked(t, rconn) |
| |
| // ErrClosed takes precedence over read error. |
| rconn.SetReadError(wantErr) |
| rconn.Close() |
| wantPacketConnReadErr(t, rconn, net.ErrClosed) |
| }) |
| } |
| |
| func TestPacketConnSetWriteError(t *testing.T) { |
| synctest.Test(t, func(t *testing.T) { |
| wantErr := errors.New("error") |
| pnet := nettest.NewPacketNet() |
| rconn := mustNewPacketConn(t, pnet, "10.0.0.1:1000") |
| wconn := mustNewPacketConn(t, pnet, "10.0.0.2:2000") |
| wconn.SetWriteError(wantErr) |
| |
| // Error blocks writes. |
| wantPacketConnWriteErr(t, wconn, rconn.LocalAddr(), wantErr) |
| wantPacketConnReadBlocked(t, rconn) |
| |
| // Error may be cleared. |
| wconn.SetWriteError(nil) |
| wantPacketConnWriteTo(t, wconn, []byte("one"), rconn.LocalAddr()) |
| |
| // Restoring error does not prevent reading buffered data. |
| wconn.SetWriteError(wantErr) |
| wantPacketConnWriteErr(t, wconn, rconn.LocalAddr(), wantErr) |
| wantPacketConnReadBytes(t, rconn, []byte("one"), wconn.LocalAddr()) |
| |
| // Error does not interfere with closing the conn. |
| wconn.Close() |
| wantPacketConnWriteErr(t, wconn, rconn.LocalAddr(), net.ErrClosed) |
| }) |
| } |
| |
| func TestPacketConnSetCloseError(t *testing.T) { |
| synctest.Test(t, func(t *testing.T) { |
| wantErr := errors.New("error") |
| pnet := nettest.NewPacketNet() |
| rconn := mustNewPacketConn(t, pnet, "10.0.0.1:1000") |
| wconn := mustNewPacketConn(t, pnet, "10.0.0.2:2000") |
| wconn.SetCloseError(wantErr) |
| |
| wantPacketConnWriteTo(t, wconn, []byte("one"), rconn.LocalAddr()) |
| if err := wconn.Close(); !isOpError(err, wantErr) { |
| t.Fatalf("wconn.Close = %v, want OpError{Err: %v}", err, wantErr) |
| } |
| if err := wconn.Close(); !isOpError(err, net.ErrClosed) { |
| t.Fatalf("wconn.Close = %v, want OpError{Err: net.ErrClosed}", err) |
| } |
| wantPacketConnReadBytes(t, rconn, []byte("one"), wconn.LocalAddr()) |
| }) |
| } |
| |
| func TestPacketConnCanRead(t *testing.T) { |
| synctest.Test(t, func(t *testing.T) { |
| pnet := nettest.NewPacketNet() |
| rconn := mustNewPacketConn(t, pnet, "10.0.0.1:1000") |
| wconn := mustNewPacketConn(t, pnet, "10.0.0.2:2000") |
| if got, want := rconn.CanRead(), false; got != want { |
| t.Fatalf("before writing data: rconn.CanRead() = %v, want %v", got, want) |
| } |
| wconn.WriteTo([]byte("a"), rconn.LocalAddr()) |
| if got, want := rconn.CanRead(), true; got != want { |
| t.Fatalf("after writing data: rconn.CanRead() = %v, want %v", got, want) |
| } |
| rconn.ReadFrom(make([]byte, 1)) |
| if got, want := rconn.CanRead(), false; got != want { |
| t.Fatalf("after reading data: rconn.CanRead() = %v, want %v", got, want) |
| } |
| }) |
| } |
| |
| func TestPacketConnIsClosed(t *testing.T) { |
| synctest.Test(t, func(t *testing.T) { |
| pnet := nettest.NewPacketNet() |
| conn := mustNewPacketConn(t, pnet, "10.0.0.1:1000") |
| if got, want := conn.IsClosed(), false; got != want { |
| t.Fatalf("before closing: conn.IsClosed() = %v, want %v", got, want) |
| } |
| conn.Close() |
| if got, want := conn.IsClosed(), true; got != want { |
| t.Fatalf("after closing: conn.IsClosed() = %v, want %v", got, want) |
| } |
| }) |
| } |
| |
| func mustNewPacketConn(t *testing.T, pnet *nettest.PacketNet, addr string) *nettest.PacketConn { |
| t.Helper() |
| c, err := pnet.NewConn(net.UDPAddrFromAddrPort(netip.MustParseAddrPort(addr))) |
| if err != nil { |
| t.Fatal(err) |
| } |
| return c |
| } |
| |
| func wantPacketConnWriteTo(t *testing.T, c *nettest.PacketConn, b []byte, dst net.Addr) { |
| t.Helper() |
| if n, err := c.WriteTo(b, dst); n != len(b) || err != nil { |
| t.Fatalf("conn.WriteTo(%q, %v) = %v, %v; want %v, nil", b, dst, n, err, len(b)) |
| } |
| } |
| |
| func wantPacketConnWriteErr(t *testing.T, c *nettest.PacketConn, dst net.Addr, want error) { |
| t.Helper() |
| n, err := c.WriteTo(make([]byte, 1), dst) |
| if n != 0 || !isOpError(err, want) { |
| t.Fatalf("c.WriteTo() = %v, %v; want 0, OpError{Err: %q}", n, err, want) |
| } |
| } |
| |
| func wantPacketConnReadBytes(t *testing.T, c *nettest.PacketConn, want []byte, wantAddr net.Addr) { |
| t.Helper() |
| udpWantAddr, ok := wantAddr.(*net.UDPAddr) |
| if !ok { |
| t.Fatalf("wantAddr is %T, should be *net.UDPAddr", wantAddr) |
| } |
| got := make([]byte, len(want)+1) |
| n, addr, err := c.ReadFrom(got) |
| got = got[:n] |
| udpAddr, addrOK := addr.(*net.UDPAddr) |
| if n != len(want) || !addrOK || udpAddr.AddrPort() != udpWantAddr.AddrPort() { |
| t.Fatalf("conn.ReadFrom() = %v, %v, %v; want %v, %v, nil", n, addr, err, len(want), wantAddr) |
| } |
| if !bytes.Equal(got, want) { |
| t.Fatalf("conn.ReadFrom() read %q, want %q", got, want) |
| } |
| } |
| |
| func wantPacketConnReadErr(t *testing.T, c *nettest.PacketConn, want error) { |
| t.Helper() |
| n, addr, err := c.ReadFrom(make([]byte, 1)) |
| if want == io.EOF { |
| if n != 0 || err != io.EOF { |
| t.Fatalf("c.ReadFrom() = %v, %v, %v; want 0, nil, io.EOF", n, addr, err) |
| } |
| } else { |
| if n != 0 || !isOpError(err, want) { |
| t.Fatalf("c.ReadFrom() = %v, %v, %v; want 0, nil, OpError{Err: %q}", n, addr, err, want) |
| } |
| } |
| } |
| |
| func wantPacketConnReadBlocked(t *testing.T, c *nettest.PacketConn) { |
| done := false |
| go func() { |
| n, addr, err := c.ReadFrom(make([]byte, 1)) |
| if n != 0 || !errors.Is(err, os.ErrDeadlineExceeded) { |
| t.Errorf("c.Read() = %v, %v, %v; want 0, nil, ErrDeadlineExceeded", n, addr, err) |
| } |
| done = true |
| }() |
| synctest.Wait() |
| if done { |
| t.Fatalf("ReadFrom unexpectedly returned before setting deadline") |
| } |
| c.SetReadDeadline(time.Now().Add(-1 * time.Second)) |
| synctest.Wait() |
| c.SetReadDeadline(time.Time{}) |
| if !done { |
| t.Fatalf("ReadFrom unexpectedly did not return after setting deadline") |
| } |
| } |
