File Manager

X7ROOT File Manager

Current Path: /opt/golang/1.17.2/src/net

📁 ..
📄 addrselect.go(9.59 KB)
📄 addrselect_test.go(6.28 KB)
📄 cgo_aix.go(603 B)
📄 cgo_android.go(293 B)
📄 cgo_bsd.go(419 B)
📄 cgo_linux.go(672 B)
📄 cgo_netbsd.go(297 B)
📄 cgo_openbsd.go(297 B)
📄 cgo_resnew.go(668 B)
📄 cgo_resold.go(654 B)
📄 cgo_socknew.go(816 B)
📄 cgo_sockold.go(937 B)
📄 cgo_solaris.go(364 B)
📄 cgo_stub.go(1.08 KB)
📄 cgo_unix.go(9.65 KB)
📄 cgo_unix_test.go(2.01 KB)
📄 cgo_windows.go(423 B)
📄 conf.go(8.78 KB)
📄 conf_netcgo.go(387 B)
📄 conf_test.go(9.76 KB)
📄 conn_test.go(1.79 KB)
📄 dial.go(22.72 KB)
📄 dial_test.go(26.02 KB)
📄 dial_unix_test.go(2.83 KB)
📄 dnsclient.go(5.73 KB)
📄 dnsclient_test.go(1.51 KB)
📄 dnsclient_unix.go(22.12 KB)
📄 dnsclient_unix_test.go(54.46 KB)
📄 dnsconfig_unix.go(5.56 KB)
📄 dnsconfig_unix_test.go(6.83 KB)
📄 dnsname_test.go(1.99 KB)
📄 error_plan9.go(224 B)
📄 error_plan9_test.go(398 B)
📄 error_posix.go(700 B)
📄 error_posix_test.go(998 B)
📄 error_test.go(19.59 KB)
📄 error_unix.go(517 B)
📄 error_unix_test.go(702 B)
📄 error_windows.go(355 B)
📄 error_windows_test.go(483 B)
📄 example_test.go(3.88 KB)
📄 external_test.go(4.08 KB)
📄 fcntl_libc_test.go(400 B)
📄 fcntl_syscall_test.go(545 B)
📄 fd_plan9.go(3.56 KB)
📄 fd_posix.go(2.58 KB)
📄 fd_unix.go(5.54 KB)
📄 fd_windows.go(4.62 KB)
📄 file.go(1.69 KB)
📄 file_plan9.go(2.68 KB)
📄 file_stub.go(507 B)
📄 file_test.go(6.55 KB)
📄 file_unix.go(2.6 KB)
📄 file_windows.go(521 B)
📄 hook.go(628 B)
📄 hook_plan9.go(283 B)
📄 hook_unix.go(840 B)
📄 hook_windows.go(875 B)
📄 hosts.go(3.1 KB)
📄 hosts_test.go(4.59 KB)
📁 http
📄 interface.go(7.17 KB)
📄 interface_aix.go(4.41 KB)
📄 interface_bsd.go(2.8 KB)
📄 interface_bsd_test.go(1.48 KB)
📄 interface_bsdvar.go(753 B)
📄 interface_darwin.go(1.29 KB)
📄 interface_freebsd.go(1.42 KB)
📄 interface_linux.go(6.9 KB)
📄 interface_linux_test.go(3.65 KB)
📄 interface_plan9.go(4.68 KB)
📄 interface_solaris.go(2.07 KB)
📄 interface_stub.go(830 B)
📄 interface_test.go(9.68 KB)
📄 interface_unix_test.go(4.79 KB)
📄 interface_windows.go(5.41 KB)
📁 internal
📄 ip.go(17.66 KB)
📄 ip_test.go(25.33 KB)
📄 iprawsock.go(7.08 KB)
📄 iprawsock_plan9.go(874 B)
📄 iprawsock_posix.go(3.56 KB)
📄 iprawsock_test.go(5.63 KB)
📄 ipsock.go(8.97 KB)
📄 ipsock_plan9.go(7.5 KB)
📄 ipsock_plan9_test.go(645 B)
📄 ipsock_posix.go(6.28 KB)
📄 ipsock_test.go(6.81 KB)
📄 listen_test.go(21.34 KB)
📄 lookup.go(21.33 KB)
📄 lookup_fake.go(1.66 KB)
📄 lookup_plan9.go(7.68 KB)
📄 lookup_test.go(31.13 KB)
📄 lookup_unix.go(8.89 KB)
📄 lookup_windows.go(11.72 KB)
📄 lookup_windows_test.go(8.02 KB)
📄 mac.go(1.88 KB)
📄 mac_test.go(3.26 KB)
📁 mail
📄 main_cloexec_test.go(750 B)
📄 main_conf_test.go(952 B)
📄 main_noconf_test.go(537 B)
📄 main_plan9_test.go(392 B)
📄 main_posix_test.go(1.4 KB)
📄 main_test.go(7.13 KB)
📄 main_unix_test.go(1.33 KB)
📄 main_windows_test.go(1.08 KB)
📄 mockserver_test.go(11.39 KB)
📄 net.go(22.37 KB)
📄 net_fake.go(5.37 KB)
📄 net_test.go(13.88 KB)
📄 net_windows_test.go(15.94 KB)
📄 netgo_unix_test.go(741 B)
📄 nss.go(3.8 KB)
📄 nss_test.go(3.42 KB)
📄 packetconn_test.go(3.57 KB)
📄 parse.go(7.33 KB)
📄 parse_test.go(2.14 KB)
📄 pipe.go(5.43 KB)
📄 pipe_test.go(1.2 KB)
📄 platform_test.go(4.57 KB)
📄 port.go(1.46 KB)
📄 port_test.go(1.34 KB)
📄 port_unix.go(1.39 KB)
📄 protoconn_test.go(7.24 KB)
📄 rawconn.go(1.89 KB)
📄 rawconn_stub_test.go(655 B)
📄 rawconn_test.go(4.45 KB)
📄 rawconn_unix_test.go(3.1 KB)
📄 rawconn_windows_test.go(3.12 KB)
📁 rpc
📄 sendfile_linux.go(1.1 KB)
📄 sendfile_stub.go(391 B)
📄 sendfile_test.go(6.91 KB)
📄 sendfile_unix_alt.go(2.02 KB)
📄 sendfile_windows.go(1.02 KB)
📄 server_test.go(11.11 KB)
📁 smtp
📄 sock_bsd.go(968 B)
📄 sock_cloexec.go(1.53 KB)
📄 sock_linux.go(1.53 KB)
📄 sock_linux_test.go(545 B)
📄 sock_plan9.go(262 B)
📄 sock_posix.go(6.92 KB)
📄 sock_stub.go(420 B)
📄 sock_windows.go(1.16 KB)
📄 sockaddr_posix.go(1.05 KB)
📄 sockopt_aix.go(1.43 KB)
📄 sockopt_bsd.go(2.26 KB)
📄 sockopt_linux.go(1.25 KB)
📄 sockopt_plan9.go(406 B)
📄 sockopt_posix.go(2.76 KB)
📄 sockopt_solaris.go(1.25 KB)
📄 sockopt_stub.go(760 B)
📄 sockopt_windows.go(1.51 KB)
📄 sockoptip_bsdvar.go(929 B)
📄 sockoptip_linux.go(735 B)
📄 sockoptip_posix.go(1.53 KB)
📄 sockoptip_stub.go(971 B)
📄 sockoptip_windows.go(819 B)
📄 splice_linux.go(1.09 KB)
📄 splice_stub.go(304 B)
📄 splice_test.go(10.51 KB)
📄 sys_cloexec.go(1 KB)
📄 tcpsock.go(9.88 KB)
📄 tcpsock_plan9.go(2.13 KB)
📄 tcpsock_posix.go(5.39 KB)
📄 tcpsock_test.go(17.53 KB)
📄 tcpsock_unix_test.go(2.41 KB)
📄 tcpsockopt_darwin.go(770 B)
📄 tcpsockopt_dragonfly.go(698 B)
📄 tcpsockopt_openbsd.go(365 B)
📄 tcpsockopt_plan9.go(525 B)
📄 tcpsockopt_posix.go(592 B)
📄 tcpsockopt_solaris.go(1.15 KB)
📄 tcpsockopt_stub.go(415 B)
📄 tcpsockopt_unix.go(757 B)
📄 tcpsockopt_windows.go(741 B)
📁 testdata
📁 textproto
📄 timeout_test.go(23.39 KB)
📄 udpsock.go(9.19 KB)
📄 udpsock_plan9.go(3.79 KB)
📄 udpsock_plan9_test.go(1.31 KB)
📄 udpsock_posix.go(4.27 KB)
📄 udpsock_test.go(12.27 KB)
📄 unixsock.go(10.17 KB)
📄 unixsock_linux_test.go(2.29 KB)
📄 unixsock_plan9.go(1.24 KB)
📄 unixsock_posix.go(6.03 KB)
📄 unixsock_readmsg_cloexec.go(691 B)
📄 unixsock_readmsg_cmsg_cloexec.go(373 B)
📄 unixsock_readmsg_other.go(301 B)
📄 unixsock_readmsg_test.go(2.62 KB)
📄 unixsock_test.go(10.56 KB)
📄 unixsock_windows_test.go(2.09 KB)
📁 url
📄 write_unix_test.go(1.67 KB)
📄 writev_test.go(5.02 KB)
📄 writev_unix.go(797 B)

Editing: udpsock_test.go

// 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
// +build !js

package net

import (
	"errors"
	"internal/testenv"
	"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, err := (&packetListener{PacketConn: c1}).newLocalServer()
		if err != nil {
			t.Fatal(err)
		}
		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, err := newLocalPacketListener("udp")
	if err != nil {
		t.Fatal(err)
	}
	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, err := newLocalPacketListener("udp")
	if err != nil {
		t.Fatal(err)
	}
	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, err := newLocalPacketListener("udp")
	if err != nil {
		t.Fatal(err)
	}
	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))
		}
		c1.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
		b2 := make([]byte, len(b1)-1)
		if genericRead {
			n, err = c1.(Conn).Read(b2)
		} else {
			n, _, err = c1.ReadFrom(b2)
		}
		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)
			}
		}
		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 BenchmarkWriteToReadFromUDP(b *testing.B) {
	conn, err := ListenUDP("udp4", &UDPAddr{IP: IPv4(127, 0, 0, 1)})
	if err != nil {
		b.Fatal(err)
	}
	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)
		}
	}
}

X7ROOT File Manager

Editing: udpsock_test.go

Upload File

Create Folder