summaryrefslogtreecommitdiffstats
path: root/src/net/udpsock_test.go
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/net/udpsock_test.go666
1 files changed, 666 insertions, 0 deletions
diff --git a/src/net/udpsock_test.go b/src/net/udpsock_test.go
new file mode 100644
index 0000000..0ed2ff9
--- /dev/null
+++ b/src/net/udpsock_test.go
@@ -0,0 +1,666 @@
+// Copyright 2012 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.
+
+//go:build !js
+
+package net
+
+import (
+ "errors"
+ "internal/testenv"
+ "net/netip"
+ "os"
+ "reflect"
+ "runtime"
+ "testing"
+ "time"
+)
+
+func BenchmarkUDP6LinkLocalUnicast(b *testing.B) {
+ testHookUninstaller.Do(uninstallTestHooks)
+
+ if !supportsIPv6() {
+ b.Skip("IPv6 is not supported")
+ }
+ ifi := loopbackInterface()
+ if ifi == nil {
+ b.Skip("loopback interface not found")
+ }
+ lla := ipv6LinkLocalUnicastAddr(ifi)
+ if lla == "" {
+ b.Skip("IPv6 link-local unicast address not found")
+ }
+
+ c1, err := ListenPacket("udp6", JoinHostPort(lla+"%"+ifi.Name, "0"))
+ if err != nil {
+ b.Fatal(err)
+ }
+ defer c1.Close()
+ c2, err := ListenPacket("udp6", JoinHostPort(lla+"%"+ifi.Name, "0"))
+ if err != nil {
+ b.Fatal(err)
+ }
+ defer c2.Close()
+
+ var buf [1]byte
+ for i := 0; i < b.N; i++ {
+ if _, err := c1.WriteTo(buf[:], c2.LocalAddr()); err != nil {
+ b.Fatal(err)
+ }
+ if _, _, err := c2.ReadFrom(buf[:]); err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+type resolveUDPAddrTest struct {
+ network string
+ litAddrOrName string
+ addr *UDPAddr
+ err error
+}
+
+var resolveUDPAddrTests = []resolveUDPAddrTest{
+ {"udp", "127.0.0.1:0", &UDPAddr{IP: IPv4(127, 0, 0, 1), Port: 0}, nil},
+ {"udp4", "127.0.0.1:65535", &UDPAddr{IP: IPv4(127, 0, 0, 1), Port: 65535}, nil},
+
+ {"udp", "[::1]:0", &UDPAddr{IP: ParseIP("::1"), Port: 0}, nil},
+ {"udp6", "[::1]:65535", &UDPAddr{IP: ParseIP("::1"), Port: 65535}, nil},
+
+ {"udp", "[::1%en0]:1", &UDPAddr{IP: ParseIP("::1"), Port: 1, Zone: "en0"}, nil},
+ {"udp6", "[::1%911]:2", &UDPAddr{IP: ParseIP("::1"), Port: 2, Zone: "911"}, nil},
+
+ {"", "127.0.0.1:0", &UDPAddr{IP: IPv4(127, 0, 0, 1), Port: 0}, nil}, // Go 1.0 behavior
+ {"", "[::1]:0", &UDPAddr{IP: ParseIP("::1"), Port: 0}, nil}, // Go 1.0 behavior
+
+ {"udp", ":12345", &UDPAddr{Port: 12345}, nil},
+
+ {"http", "127.0.0.1:0", nil, UnknownNetworkError("http")},
+
+ {"udp", "127.0.0.1:domain", &UDPAddr{IP: ParseIP("127.0.0.1"), Port: 53}, nil},
+ {"udp", "[::ffff:127.0.0.1]:domain", &UDPAddr{IP: ParseIP("::ffff:127.0.0.1"), Port: 53}, nil},
+ {"udp", "[2001:db8::1]:domain", &UDPAddr{IP: ParseIP("2001:db8::1"), Port: 53}, nil},
+ {"udp4", "127.0.0.1:domain", &UDPAddr{IP: ParseIP("127.0.0.1"), Port: 53}, nil},
+ {"udp4", "[::ffff:127.0.0.1]:domain", &UDPAddr{IP: ParseIP("127.0.0.1"), Port: 53}, nil},
+ {"udp6", "[2001:db8::1]:domain", &UDPAddr{IP: ParseIP("2001:db8::1"), Port: 53}, nil},
+
+ {"udp4", "[2001:db8::1]:domain", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "2001:db8::1"}},
+ {"udp6", "127.0.0.1:domain", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "127.0.0.1"}},
+ {"udp6", "[::ffff:127.0.0.1]:domain", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "::ffff:127.0.0.1"}},
+}
+
+func TestResolveUDPAddr(t *testing.T) {
+ origTestHookLookupIP := testHookLookupIP
+ defer func() { testHookLookupIP = origTestHookLookupIP }()
+ testHookLookupIP = lookupLocalhost
+
+ for _, tt := range resolveUDPAddrTests {
+ addr, err := ResolveUDPAddr(tt.network, tt.litAddrOrName)
+ if !reflect.DeepEqual(addr, tt.addr) || !reflect.DeepEqual(err, tt.err) {
+ t.Errorf("ResolveUDPAddr(%q, %q) = %#v, %v, want %#v, %v", tt.network, tt.litAddrOrName, addr, err, tt.addr, tt.err)
+ continue
+ }
+ if err == nil {
+ addr2, err := ResolveUDPAddr(addr.Network(), addr.String())
+ if !reflect.DeepEqual(addr2, tt.addr) || err != tt.err {
+ t.Errorf("(%q, %q): ResolveUDPAddr(%q, %q) = %#v, %v, want %#v, %v", tt.network, tt.litAddrOrName, addr.Network(), addr.String(), addr2, err, tt.addr, tt.err)
+ }
+ }
+ }
+}
+
+func TestWriteToUDP(t *testing.T) {
+ switch runtime.GOOS {
+ case "plan9":
+ t.Skipf("not supported on %s", runtime.GOOS)
+ }
+
+ c, err := ListenPacket("udp", "127.0.0.1:0")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer c.Close()
+
+ testWriteToConn(t, c.LocalAddr().String())
+ testWriteToPacketConn(t, c.LocalAddr().String())
+}
+
+func testWriteToConn(t *testing.T, raddr string) {
+ c, err := Dial("udp", raddr)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer c.Close()
+
+ ra, err := ResolveUDPAddr("udp", raddr)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ b := []byte("CONNECTED-MODE SOCKET")
+ _, err = c.(*UDPConn).WriteToUDP(b, ra)
+ if err == nil {
+ t.Fatal("should fail")
+ }
+ if err != nil && err.(*OpError).Err != ErrWriteToConnected {
+ t.Fatalf("should fail as ErrWriteToConnected: %v", err)
+ }
+ _, err = c.(*UDPConn).WriteTo(b, ra)
+ if err == nil {
+ t.Fatal("should fail")
+ }
+ if err != nil && err.(*OpError).Err != ErrWriteToConnected {
+ t.Fatalf("should fail as ErrWriteToConnected: %v", err)
+ }
+ _, err = c.Write(b)
+ if err != nil {
+ t.Fatal(err)
+ }
+ _, _, err = c.(*UDPConn).WriteMsgUDP(b, nil, ra)
+ if err == nil {
+ t.Fatal("should fail")
+ }
+ if err != nil && err.(*OpError).Err != ErrWriteToConnected {
+ t.Fatalf("should fail as ErrWriteToConnected: %v", err)
+ }
+ _, _, err = c.(*UDPConn).WriteMsgUDP(b, nil, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+}
+
+func testWriteToPacketConn(t *testing.T, raddr string) {
+ c, err := ListenPacket("udp", "127.0.0.1:0")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer c.Close()
+
+ ra, err := ResolveUDPAddr("udp", raddr)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ b := []byte("UNCONNECTED-MODE SOCKET")
+ _, err = c.(*UDPConn).WriteToUDP(b, ra)
+ if err != nil {
+ t.Fatal(err)
+ }
+ _, err = c.WriteTo(b, ra)
+ if err != nil {
+ t.Fatal(err)
+ }
+ _, err = c.(*UDPConn).Write(b)
+ if err == nil {
+ t.Fatal("should fail")
+ }
+ _, _, err = c.(*UDPConn).WriteMsgUDP(b, nil, nil)
+ if err == nil {
+ t.Fatal("should fail")
+ }
+ if err != nil && err.(*OpError).Err != errMissingAddress {
+ t.Fatalf("should fail as errMissingAddress: %v", err)
+ }
+ _, _, err = c.(*UDPConn).WriteMsgUDP(b, nil, ra)
+ if err != nil {
+ t.Fatal(err)
+ }
+}
+
+var udpConnLocalNameTests = []struct {
+ net string
+ laddr *UDPAddr
+}{
+ {"udp4", &UDPAddr{IP: IPv4(127, 0, 0, 1)}},
+ {"udp4", &UDPAddr{}},
+ {"udp4", nil},
+}
+
+func TestUDPConnLocalName(t *testing.T) {
+ testenv.MustHaveExternalNetwork(t)
+
+ for _, tt := range udpConnLocalNameTests {
+ c, err := ListenUDP(tt.net, tt.laddr)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer c.Close()
+ la := c.LocalAddr()
+ if a, ok := la.(*UDPAddr); !ok || a.Port == 0 {
+ t.Fatalf("got %v; expected a proper address with non-zero port number", la)
+ }
+ }
+}
+
+func TestUDPConnLocalAndRemoteNames(t *testing.T) {
+ for _, laddr := range []string{"", "127.0.0.1:0"} {
+ c1, err := ListenPacket("udp", "127.0.0.1:0")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer c1.Close()
+
+ var la *UDPAddr
+ if laddr != "" {
+ var err error
+ if la, err = ResolveUDPAddr("udp", laddr); err != nil {
+ t.Fatal(err)
+ }
+ }
+ c2, err := DialUDP("udp", la, c1.LocalAddr().(*UDPAddr))
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer c2.Close()
+
+ var connAddrs = [4]struct {
+ got Addr
+ ok bool
+ }{
+ {c1.LocalAddr(), true},
+ {c1.(*UDPConn).RemoteAddr(), false},
+ {c2.LocalAddr(), true},
+ {c2.RemoteAddr(), true},
+ }
+ for _, ca := range connAddrs {
+ if a, ok := ca.got.(*UDPAddr); ok != ca.ok || ok && a.Port == 0 {
+ t.Fatalf("got %v; expected a proper address with non-zero port number", ca.got)
+ }
+ }
+ }
+}
+
+func TestIPv6LinkLocalUnicastUDP(t *testing.T) {
+ testenv.MustHaveExternalNetwork(t)
+
+ if !supportsIPv6() {
+ t.Skip("IPv6 is not supported")
+ }
+
+ for i, tt := range ipv6LinkLocalUnicastUDPTests {
+ c1, err := ListenPacket(tt.network, tt.address)
+ if err != nil {
+ // It might return "LookupHost returned no
+ // suitable address" error on some platforms.
+ t.Log(err)
+ continue
+ }
+ ls := (&packetListener{PacketConn: c1}).newLocalServer()
+ defer ls.teardown()
+ ch := make(chan error, 1)
+ handler := func(ls *localPacketServer, c PacketConn) { packetTransponder(c, ch) }
+ if err := ls.buildup(handler); err != nil {
+ t.Fatal(err)
+ }
+ if la, ok := c1.LocalAddr().(*UDPAddr); !ok || !tt.nameLookup && la.Zone == "" {
+ t.Fatalf("got %v; expected a proper address with zone identifier", la)
+ }
+
+ c2, err := Dial(tt.network, ls.PacketConn.LocalAddr().String())
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer c2.Close()
+ if la, ok := c2.LocalAddr().(*UDPAddr); !ok || !tt.nameLookup && la.Zone == "" {
+ t.Fatalf("got %v; expected a proper address with zone identifier", la)
+ }
+ if ra, ok := c2.RemoteAddr().(*UDPAddr); !ok || !tt.nameLookup && ra.Zone == "" {
+ t.Fatalf("got %v; expected a proper address with zone identifier", ra)
+ }
+
+ if _, err := c2.Write([]byte("UDP OVER IPV6 LINKLOCAL TEST")); err != nil {
+ t.Fatal(err)
+ }
+ b := make([]byte, 32)
+ if _, err := c2.Read(b); err != nil {
+ t.Fatal(err)
+ }
+
+ for err := range ch {
+ t.Errorf("#%d: %v", i, err)
+ }
+ }
+}
+
+func TestUDPZeroBytePayload(t *testing.T) {
+ switch runtime.GOOS {
+ case "plan9":
+ t.Skipf("not supported on %s", runtime.GOOS)
+ case "darwin", "ios":
+ testenv.SkipFlaky(t, 29225)
+ }
+
+ c := newLocalPacketListener(t, "udp")
+ defer c.Close()
+
+ for _, genericRead := range []bool{false, true} {
+ n, err := c.WriteTo(nil, c.LocalAddr())
+ if err != nil {
+ t.Fatal(err)
+ }
+ if n != 0 {
+ t.Errorf("got %d; want 0", n)
+ }
+ c.SetReadDeadline(time.Now().Add(30 * time.Second))
+ var b [1]byte
+ var name string
+ if genericRead {
+ _, err = c.(Conn).Read(b[:])
+ name = "Read"
+ } else {
+ _, _, err = c.ReadFrom(b[:])
+ name = "ReadFrom"
+ }
+ if err != nil {
+ t.Errorf("%s of zero byte packet failed: %v", name, err)
+ }
+ }
+}
+
+func TestUDPZeroByteBuffer(t *testing.T) {
+ switch runtime.GOOS {
+ case "plan9":
+ t.Skipf("not supported on %s", runtime.GOOS)
+ }
+
+ c := newLocalPacketListener(t, "udp")
+ defer c.Close()
+
+ b := []byte("UDP ZERO BYTE BUFFER TEST")
+ for _, genericRead := range []bool{false, true} {
+ n, err := c.WriteTo(b, c.LocalAddr())
+ if err != nil {
+ t.Fatal(err)
+ }
+ if n != len(b) {
+ t.Errorf("got %d; want %d", n, len(b))
+ }
+ c.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
+ if genericRead {
+ _, err = c.(Conn).Read(nil)
+ } else {
+ _, _, err = c.ReadFrom(nil)
+ }
+ switch err {
+ case nil: // ReadFrom succeeds
+ default: // Read may timeout, it depends on the platform
+ if nerr, ok := err.(Error); (!ok || !nerr.Timeout()) && runtime.GOOS != "windows" { // Windows returns WSAEMSGSIZE
+ t.Fatal(err)
+ }
+ }
+ }
+}
+
+func TestUDPReadSizeError(t *testing.T) {
+ switch runtime.GOOS {
+ case "plan9":
+ t.Skipf("not supported on %s", runtime.GOOS)
+ }
+
+ c1 := newLocalPacketListener(t, "udp")
+ defer c1.Close()
+
+ c2, err := Dial("udp", c1.LocalAddr().String())
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer c2.Close()
+
+ b1 := []byte("READ SIZE ERROR TEST")
+ for _, genericRead := range []bool{false, true} {
+ n, err := c2.Write(b1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if n != len(b1) {
+ t.Errorf("got %d; want %d", n, len(b1))
+ }
+ b2 := make([]byte, len(b1)-1)
+ if genericRead {
+ n, err = c1.(Conn).Read(b2)
+ } else {
+ n, _, err = c1.ReadFrom(b2)
+ }
+ if err != nil && runtime.GOOS != "windows" { // Windows returns WSAEMSGSIZE
+ t.Fatal(err)
+ }
+ if n != len(b1)-1 {
+ t.Fatalf("got %d; want %d", n, len(b1)-1)
+ }
+ }
+}
+
+// TestUDPReadTimeout verifies that ReadFromUDP with timeout returns an error
+// without data or an address.
+func TestUDPReadTimeout(t *testing.T) {
+ la, err := ResolveUDPAddr("udp4", "127.0.0.1:0")
+ if err != nil {
+ t.Fatal(err)
+ }
+ c, err := ListenUDP("udp4", la)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer c.Close()
+
+ c.SetDeadline(time.Now())
+ b := make([]byte, 1)
+ n, addr, err := c.ReadFromUDP(b)
+ if !errors.Is(err, os.ErrDeadlineExceeded) {
+ t.Errorf("ReadFromUDP got err %v want os.ErrDeadlineExceeded", err)
+ }
+ if n != 0 {
+ t.Errorf("ReadFromUDP got n %d want 0", n)
+ }
+ if addr != nil {
+ t.Errorf("ReadFromUDP got addr %+#v want nil", addr)
+ }
+}
+
+func TestAllocs(t *testing.T) {
+ switch runtime.GOOS {
+ case "plan9":
+ // Plan9 wasn't optimized.
+ t.Skipf("skipping on %v", runtime.GOOS)
+ }
+ // Optimizations are required to remove the allocs.
+ testenv.SkipIfOptimizationOff(t)
+
+ conn, err := ListenUDP("udp4", &UDPAddr{IP: IPv4(127, 0, 0, 1)})
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer conn.Close()
+ addr := conn.LocalAddr()
+ addrPort := addr.(*UDPAddr).AddrPort()
+ buf := make([]byte, 8)
+
+ allocs := testing.AllocsPerRun(1000, func() {
+ _, _, err := conn.WriteMsgUDPAddrPort(buf, nil, addrPort)
+ if err != nil {
+ t.Fatal(err)
+ }
+ _, _, _, _, err = conn.ReadMsgUDPAddrPort(buf, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ })
+ if got := int(allocs); got != 0 {
+ t.Errorf("WriteMsgUDPAddrPort/ReadMsgUDPAddrPort allocated %d objects", got)
+ }
+
+ allocs = testing.AllocsPerRun(1000, func() {
+ _, err := conn.WriteToUDPAddrPort(buf, addrPort)
+ if err != nil {
+ t.Fatal(err)
+ }
+ _, _, err = conn.ReadFromUDPAddrPort(buf)
+ if err != nil {
+ t.Fatal(err)
+ }
+ })
+ if got := int(allocs); got != 0 {
+ t.Errorf("WriteToUDPAddrPort/ReadFromUDPAddrPort allocated %d objects", got)
+ }
+
+ allocs = testing.AllocsPerRun(1000, func() {
+ _, err := conn.WriteTo(buf, addr)
+ if err != nil {
+ t.Fatal(err)
+ }
+ _, _, err = conn.ReadFromUDP(buf)
+ if err != nil {
+ t.Fatal(err)
+ }
+ })
+ if got := int(allocs); got != 1 {
+ t.Errorf("WriteTo/ReadFromUDP allocated %d objects", got)
+ }
+}
+
+func BenchmarkReadWriteMsgUDPAddrPort(b *testing.B) {
+ conn, err := ListenUDP("udp4", &UDPAddr{IP: IPv4(127, 0, 0, 1)})
+ if err != nil {
+ b.Fatal(err)
+ }
+ defer conn.Close()
+ addr := conn.LocalAddr().(*UDPAddr).AddrPort()
+ buf := make([]byte, 8)
+ b.ResetTimer()
+ b.ReportAllocs()
+ for i := 0; i < b.N; i++ {
+ _, _, err := conn.WriteMsgUDPAddrPort(buf, nil, addr)
+ if err != nil {
+ b.Fatal(err)
+ }
+ _, _, _, _, err = conn.ReadMsgUDPAddrPort(buf, nil)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+func BenchmarkWriteToReadFromUDP(b *testing.B) {
+ conn, err := ListenUDP("udp4", &UDPAddr{IP: IPv4(127, 0, 0, 1)})
+ if err != nil {
+ b.Fatal(err)
+ }
+ defer conn.Close()
+ addr := conn.LocalAddr()
+ buf := make([]byte, 8)
+ b.ResetTimer()
+ b.ReportAllocs()
+ for i := 0; i < b.N; i++ {
+ _, err := conn.WriteTo(buf, addr)
+ if err != nil {
+ b.Fatal(err)
+ }
+ _, _, err = conn.ReadFromUDP(buf)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+func BenchmarkWriteToReadFromUDPAddrPort(b *testing.B) {
+ conn, err := ListenUDP("udp4", &UDPAddr{IP: IPv4(127, 0, 0, 1)})
+ if err != nil {
+ b.Fatal(err)
+ }
+ defer conn.Close()
+ addr := conn.LocalAddr().(*UDPAddr).AddrPort()
+ buf := make([]byte, 8)
+ b.ResetTimer()
+ b.ReportAllocs()
+ for i := 0; i < b.N; i++ {
+ _, err := conn.WriteToUDPAddrPort(buf, addr)
+ if err != nil {
+ b.Fatal(err)
+ }
+ _, _, err = conn.ReadFromUDPAddrPort(buf)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+func TestUDPIPVersionReadMsg(t *testing.T) {
+ switch runtime.GOOS {
+ case "plan9":
+ t.Skipf("skipping on %v", runtime.GOOS)
+ }
+ conn, err := ListenUDP("udp4", &UDPAddr{IP: IPv4(127, 0, 0, 1)})
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer conn.Close()
+ daddr := conn.LocalAddr().(*UDPAddr).AddrPort()
+ buf := make([]byte, 8)
+ _, err = conn.WriteToUDPAddrPort(buf, daddr)
+ if err != nil {
+ t.Fatal(err)
+ }
+ _, _, _, saddr, err := conn.ReadMsgUDPAddrPort(buf, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !saddr.Addr().Is4() {
+ t.Error("returned AddrPort is not IPv4")
+ }
+ _, err = conn.WriteToUDPAddrPort(buf, daddr)
+ if err != nil {
+ t.Fatal(err)
+ }
+ _, _, _, soldaddr, err := conn.ReadMsgUDP(buf, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(soldaddr.IP) != 4 {
+ t.Error("returned UDPAddr is not IPv4")
+ }
+}
+
+// TestIPv6WriteMsgUDPAddrPortTargetAddrIPVersion verifies that
+// WriteMsgUDPAddrPort accepts IPv4, IPv4-mapped IPv6, and IPv6 target addresses
+// on a UDPConn listening on "::".
+func TestIPv6WriteMsgUDPAddrPortTargetAddrIPVersion(t *testing.T) {
+ if !supportsIPv6() {
+ t.Skip("IPv6 is not supported")
+ }
+
+ switch runtime.GOOS {
+ case "dragonfly", "openbsd":
+ // DragonflyBSD's IPv6 sockets are always IPv6-only, according to the man page:
+ // https://www.dragonflybsd.org/cgi/web-man?command=ip6 (search for IPV6_V6ONLY).
+ // OpenBSD's IPv6 sockets are always IPv6-only, according to the man page:
+ // https://man.openbsd.org/ip6#IPV6_V6ONLY
+ t.Skipf("skipping on %v", runtime.GOOS)
+ }
+
+ conn, err := ListenUDP("udp", nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer conn.Close()
+
+ daddr4 := netip.AddrPortFrom(netip.MustParseAddr("127.0.0.1"), 12345)
+ daddr4in6 := netip.AddrPortFrom(netip.MustParseAddr("::ffff:127.0.0.1"), 12345)
+ daddr6 := netip.AddrPortFrom(netip.MustParseAddr("::1"), 12345)
+ buf := make([]byte, 8)
+
+ _, _, err = conn.WriteMsgUDPAddrPort(buf, nil, daddr4)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ _, _, err = conn.WriteMsgUDPAddrPort(buf, nil, daddr4in6)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ _, _, err = conn.WriteMsgUDPAddrPort(buf, nil, daddr6)
+ if err != nil {
+ t.Fatal(err)
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-28 10:34:15 +0000