[thirdparty/gcc.git] / libgo / go / net / 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.

// +build !js

package net

import (
	"internal/testenv"
	"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":
		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)
		}
	}
}
Commit	Line	Data
22b955cc	1	// Copyright 2012 The Go Authors. All rights reserved.
9af4cb95 ILT	2	// Use of this source code is governed by a BSD-style
	3	// license that can be found in the LICENSE file.
	4
dd931d9b ILT	5	// +build !js
dd931d9b ILT	6
9af4cb95 ILT	7	package net
	8
	9	import (
22b955cc	10	"internal/testenv"
a42a906c	11	"reflect"
9af4cb95 ILT	12	"runtime"
9af4cb95 ILT	13	"testing"
f8d9fa9e	14	"time"
9af4cb95 ILT	15	)
9af4cb95 ILT	16
22b955cc ILT	17	func BenchmarkUDP6LinkLocalUnicast(b *testing.B) {
	18	testHookUninstaller.Do(uninstallTestHooks)
	19
bc998d03	20	if !supportsIPv6() {
22b955cc ILT	21	b.Skip("IPv6 is not supported")
	22	}
	23	ifi := loopbackInterface()
	24	if ifi == nil {
	25	b.Skip("loopback interface not found")
	26	}
	27	lla := ipv6LinkLocalUnicastAddr(ifi)
	28	if lla == "" {
	29	b.Skip("IPv6 link-local unicast address not found")
	30	}
	31
	32	c1, err := ListenPacket("udp6", JoinHostPort(lla+"%"+ifi.Name, "0"))
	33	if err != nil {
	34	b.Fatal(err)
	35	}
	36	defer c1.Close()
	37	c2, err := ListenPacket("udp6", JoinHostPort(lla+"%"+ifi.Name, "0"))
	38	if err != nil {
	39	b.Fatal(err)
	40	}
	41	defer c2.Close()
	42
	43	var buf [1]byte
	44	for i := 0; i < b.N; i++ {
	45	if _, err := c1.WriteTo(buf[:], c2.LocalAddr()); err != nil {
	46	b.Fatal(err)
	47	}
	48	if _, _, err := c2.ReadFrom(buf[:]); err != nil {
	49	b.Fatal(err)
	50	}
	51	}
	52	}
	53
af146490 ILT	54	type resolveUDPAddrTest struct {
	55	network string
	56	litAddrOrName string
	57	addr *UDPAddr
	58	err error
a42a906c ILT	59	}
a42a906c ILT	60
af146490 ILT	61	var resolveUDPAddrTests = []resolveUDPAddrTest{
	62	{"udp", "127.0.0.1:0", &UDPAddr{IP: IPv4(127, 0, 0, 1), Port: 0}, nil},
	63	{"udp4", "127.0.0.1:65535", &UDPAddr{IP: IPv4(127, 0, 0, 1), Port: 65535}, nil},
f8d9fa9e	64
af146490 ILT	65	{"udp", "[::1]:0", &UDPAddr{IP: ParseIP("::1"), Port: 0}, nil},
af146490 ILT	66	{"udp6", "[::1]:65535", &UDPAddr{IP: ParseIP("::1"), Port: 65535}, nil},
f8d9fa9e	67
af146490 ILT	68	{"udp", "[::1%en0]:1", &UDPAddr{IP: ParseIP("::1"), Port: 1, Zone: "en0"}, nil},
af146490 ILT	69	{"udp6", "[::1%911]:2", &UDPAddr{IP: ParseIP("::1"), Port: 2, Zone: "911"}, nil},
f8d9fa9e	70
af146490 ILT	71	{"", "127.0.0.1:0", &UDPAddr{IP: IPv4(127, 0, 0, 1), Port: 0}, nil}, // Go 1.0 behavior
af146490 ILT	72	{"", "[::1]:0", &UDPAddr{IP: ParseIP("::1"), Port: 0}, nil}, // Go 1.0 behavior
f8d9fa9e	73
af146490	74	{"udp", ":12345", &UDPAddr{Port: 12345}, nil},
f8d9fa9e	75
af146490	76	{"http", "127.0.0.1:0", nil, UnknownNetworkError("http")},
c2047754 ILT	77
	78	{"udp", "127.0.0.1:domain", &UDPAddr{IP: ParseIP("127.0.0.1"), Port: 53}, nil},
	79	{"udp", "[::ffff:127.0.0.1]:domain", &UDPAddr{IP: ParseIP("::ffff:127.0.0.1"), Port: 53}, nil},
	80	{"udp", "[2001:db8::1]:domain", &UDPAddr{IP: ParseIP("2001:db8::1"), Port: 53}, nil},
	81	{"udp4", "127.0.0.1:domain", &UDPAddr{IP: ParseIP("127.0.0.1"), Port: 53}, nil},
	82	{"udp4", "[::ffff:127.0.0.1]:domain", &UDPAddr{IP: ParseIP("127.0.0.1"), Port: 53}, nil},
	83	{"udp6", "[2001:db8::1]:domain", &UDPAddr{IP: ParseIP("2001:db8::1"), Port: 53}, nil},
	84
	85	{"udp4", "[2001:db8::1]:domain", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "2001:db8::1"}},
	86	{"udp6", "127.0.0.1:domain", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "127.0.0.1"}},
	87	{"udp6", "[::ffff:127.0.0.1]:domain", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "::ffff:127.0.0.1"}},
af146490 ILT	88	}
	89
	90	func TestResolveUDPAddr(t *testing.T) {
	91	origTestHookLookupIP := testHookLookupIP
	92	defer func() { testHookLookupIP = origTestHookLookupIP }()
	93	testHookLookupIP = lookupLocalhost
	94
c2047754	95	for _, tt := range resolveUDPAddrTests {
af146490	96	addr, err := ResolveUDPAddr(tt.network, tt.litAddrOrName)
c2047754 ILT	97	if !reflect.DeepEqual(addr, tt.addr) \|\| !reflect.DeepEqual(err, tt.err) {
c2047754 ILT	98	t.Errorf("ResolveUDPAddr(%q, %q) = %#v, %v, want %#v, %v", tt.network, tt.litAddrOrName, addr, err, tt.addr, tt.err)
af146490 ILT	99	continue
af146490 ILT	100	}
c2047754 ILT	101	if err == nil {
	102	addr2, err := ResolveUDPAddr(addr.Network(), addr.String())
	103	if !reflect.DeepEqual(addr2, tt.addr) \|\| err != tt.err {
	104	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)
	105	}
af146490	106	}
f8d9fa9e ILT	107	}
	108	}
	109
9af4cb95	110	func TestWriteToUDP(t *testing.T) {
456fba26 ILT	111	switch runtime.GOOS {
456fba26 ILT	112	case "plan9":
af146490	113	t.Skipf("not supported on %s", runtime.GOOS)
9af4cb95 ILT	114	}
9af4cb95 ILT	115
af146490	116	c, err := ListenPacket("udp", "127.0.0.1:0")
9af4cb95	117	if err != nil {
af146490	118	t.Fatal(err)
9af4cb95	119	}
af146490	120	defer c.Close()
9af4cb95	121
af146490 ILT	122	testWriteToConn(t, c.LocalAddr().String())
af146490 ILT	123	testWriteToPacketConn(t, c.LocalAddr().String())
9af4cb95 ILT	124	}
	125
	126	func testWriteToConn(t *testing.T, raddr string) {
	127	c, err := Dial("udp", raddr)
	128	if err != nil {
af146490	129	t.Fatal(err)
9af4cb95 ILT	130	}
	131	defer c.Close()
	132
	133	ra, err := ResolveUDPAddr("udp", raddr)
	134	if err != nil {
af146490	135	t.Fatal(err)
9af4cb95 ILT	136	}
9af4cb95 ILT	137
af146490 ILT	138	b := []byte("CONNECTED-MODE SOCKET")
af146490 ILT	139	_, err = c.(*UDPConn).WriteToUDP(b, ra)
9af4cb95	140	if err == nil {
af146490	141	t.Fatal("should fail")
9af4cb95 ILT	142	}
9af4cb95 ILT	143	if err != nil && err.(*OpError).Err != ErrWriteToConnected {
af146490	144	t.Fatalf("should fail as ErrWriteToConnected: %v", err)
9af4cb95	145	}
af146490	146	_, err = c.(*UDPConn).WriteTo(b, ra)
9af4cb95	147	if err == nil {
af146490	148	t.Fatal("should fail")
9af4cb95 ILT	149	}
9af4cb95 ILT	150	if err != nil && err.(*OpError).Err != ErrWriteToConnected {
af146490	151	t.Fatalf("should fail as ErrWriteToConnected: %v", err)
9af4cb95	152	}
af146490	153	_, err = c.Write(b)
9af4cb95	154	if err != nil {
af146490 ILT	155	t.Fatal(err)
	156	}
	157	_, _, err = c.(*UDPConn).WriteMsgUDP(b, nil, ra)
	158	if err == nil {
	159	t.Fatal("should fail")
	160	}
	161	if err != nil && err.(*OpError).Err != ErrWriteToConnected {
	162	t.Fatalf("should fail as ErrWriteToConnected: %v", err)
	163	}
	164	_, _, err = c.(*UDPConn).WriteMsgUDP(b, nil, nil)
5a8ea165 ILT	165	if err != nil {
5a8ea165 ILT	166	t.Fatal(err)
9af4cb95 ILT	167	}
	168	}
	169
	170	func testWriteToPacketConn(t *testing.T, raddr string) {
	171	c, err := ListenPacket("udp", "127.0.0.1:0")
	172	if err != nil {
af146490	173	t.Fatal(err)
9af4cb95 ILT	174	}
	175	defer c.Close()
	176
	177	ra, err := ResolveUDPAddr("udp", raddr)
	178	if err != nil {
af146490	179	t.Fatal(err)
9af4cb95 ILT	180	}
9af4cb95 ILT	181
af146490 ILT	182	b := []byte("UNCONNECTED-MODE SOCKET")
af146490 ILT	183	_, err = c.(*UDPConn).WriteToUDP(b, ra)
9af4cb95	184	if err != nil {
af146490	185	t.Fatal(err)
9af4cb95	186	}
af146490	187	_, err = c.WriteTo(b, ra)
9af4cb95	188	if err != nil {
af146490	189	t.Fatal(err)
9af4cb95	190	}
af146490 ILT	191	_, err = c.(*UDPConn).Write(b)
	192	if err == nil {
	193	t.Fatal("should fail")
	194	}
	195	_, _, err = c.(*UDPConn).WriteMsgUDP(b, nil, nil)
9af4cb95	196	if err == nil {
af146490 ILT	197	t.Fatal("should fail")
	198	}
	199	if err != nil && err.(*OpError).Err != errMissingAddress {
	200	t.Fatalf("should fail as errMissingAddress: %v", err)
	201	}
	202	_, _, err = c.(*UDPConn).WriteMsgUDP(b, nil, ra)
5a8ea165 ILT	203	if err != nil {
5a8ea165 ILT	204	t.Fatal(err)
9af4cb95 ILT	205	}
9af4cb95 ILT	206	}
fabcaa8d ILT	207
	208	var udpConnLocalNameTests = []struct {
	209	net string
	210	laddr *UDPAddr
	211	}{
	212	{"udp4", &UDPAddr{IP: IPv4(127, 0, 0, 1)}},
	213	{"udp4", &UDPAddr{}},
	214	{"udp4", nil},
	215	}
	216
	217	func TestUDPConnLocalName(t *testing.T) {
22b955cc	218	testenv.MustHaveExternalNetwork(t)
fabcaa8d ILT	219
	220	for _, tt := range udpConnLocalNameTests {
	221	c, err := ListenUDP(tt.net, tt.laddr)
	222	if err != nil {
af146490	223	t.Fatal(err)
fabcaa8d ILT	224	}
	225	defer c.Close()
	226	la := c.LocalAddr()
	227	if a, ok := la.(*UDPAddr); !ok \|\| a.Port == 0 {
be47d6ec ILT	228	t.Fatalf("got %v; expected a proper address with non-zero port number", la)
	229	}
	230	}
	231	}
	232
	233	func TestUDPConnLocalAndRemoteNames(t *testing.T) {
	234	for _, laddr := range []string{"", "127.0.0.1:0"} {
	235	c1, err := ListenPacket("udp", "127.0.0.1:0")
	236	if err != nil {
af146490	237	t.Fatal(err)
be47d6ec ILT	238	}
	239	defer c1.Close()
	240
	241	var la *UDPAddr
	242	if laddr != "" {
	243	var err error
	244	if la, err = ResolveUDPAddr("udp", laddr); err != nil {
af146490	245	t.Fatal(err)
be47d6ec ILT	246	}
	247	}
	248	c2, err := DialUDP("udp", la, c1.LocalAddr().(*UDPAddr))
	249	if err != nil {
af146490	250	t.Fatal(err)
be47d6ec ILT	251	}
	252	defer c2.Close()
	253
	254	var connAddrs = [4]struct {
	255	got Addr
	256	ok bool
	257	}{
	258	{c1.LocalAddr(), true},
	259	{c1.(*UDPConn).RemoteAddr(), false},
	260	{c2.LocalAddr(), true},
	261	{c2.RemoteAddr(), true},
	262	}
	263	for _, ca := range connAddrs {
	264	if a, ok := ca.got.(*UDPAddr); ok != ca.ok \|\| ok && a.Port == 0 {
	265	t.Fatalf("got %v; expected a proper address with non-zero port number", ca.got)
	266	}
	267	}
	268	}
	269	}
	270
	271	func TestIPv6LinkLocalUnicastUDP(t *testing.T) {
22b955cc ILT	272	testenv.MustHaveExternalNetwork(t)
22b955cc ILT	273
bc998d03	274	if !supportsIPv6() {
af146490	275	t.Skip("IPv6 is not supported")
be47d6ec ILT	276	}
be47d6ec ILT	277
af146490 ILT	278	for i, tt := range ipv6LinkLocalUnicastUDPTests {
af146490 ILT	279	c1, err := ListenPacket(tt.network, tt.address)
be47d6ec ILT	280	if err != nil {
	281	// It might return "LookupHost returned no
	282	// suitable address" error on some platforms.
af146490	283	t.Log(err)
be47d6ec ILT	284	continue
be47d6ec ILT	285	}
af146490 ILT	286	ls, err := (&packetListener{PacketConn: c1}).newLocalServer()
	287	if err != nil {
	288	t.Fatal(err)
	289	}
	290	defer ls.teardown()
	291	ch := make(chan error, 1)
	292	handler := func(ls *localPacketServer, c PacketConn) { packetTransponder(c, ch) }
	293	if err := ls.buildup(handler); err != nil {
	294	t.Fatal(err)
	295	}
be47d6ec ILT	296	if la, ok := c1.LocalAddr().(*UDPAddr); !ok \|\| !tt.nameLookup && la.Zone == "" {
	297	t.Fatalf("got %v; expected a proper address with zone identifier", la)
	298	}
	299
af146490	300	c2, err := Dial(tt.network, ls.PacketConn.LocalAddr().String())
be47d6ec	301	if err != nil {
af146490	302	t.Fatal(err)
be47d6ec ILT	303	}
	304	defer c2.Close()
	305	if la, ok := c2.LocalAddr().(*UDPAddr); !ok \|\| !tt.nameLookup && la.Zone == "" {
	306	t.Fatalf("got %v; expected a proper address with zone identifier", la)
	307	}
	308	if ra, ok := c2.RemoteAddr().(*UDPAddr); !ok \|\| !tt.nameLookup && ra.Zone == "" {
	309	t.Fatalf("got %v; expected a proper address with zone identifier", ra)
	310	}
	311
	312	if _, err := c2.Write([]byte("UDP OVER IPV6 LINKLOCAL TEST")); err != nil {
af146490	313	t.Fatal(err)
be47d6ec ILT	314	}
be47d6ec ILT	315	b := make([]byte, 32)
af146490 ILT	316	if _, err := c2.Read(b); err != nil {
	317	t.Fatal(err)
	318	}
	319
	320	for err := range ch {
	321	t.Errorf("#%d: %v", i, err)
	322	}
	323	}
	324	}
	325
	326	func TestUDPZeroBytePayload(t *testing.T) {
	327	switch runtime.GOOS {
5a8ea165	328	case "plan9":
af146490	329	t.Skipf("not supported on %s", runtime.GOOS)
4f4a855d ILT	330	case "darwin":
4f4a855d ILT	331	testenv.SkipFlaky(t, 29225)
af146490 ILT	332	}
	333
	334	c, err := newLocalPacketListener("udp")
	335	if err != nil {
	336	t.Fatal(err)
	337	}
	338	defer c.Close()
	339
	340	for _, genericRead := range []bool{false, true} {
	341	n, err := c.WriteTo(nil, c.LocalAddr())
	342	if err != nil {
	343	t.Fatal(err)
	344	}
	345	if n != 0 {
	346	t.Errorf("got %d; want 0", n)
	347	}
4f4a855d	348	c.SetReadDeadline(time.Now().Add(30 * time.Second))
af146490	349	var b [1]byte
4f4a855d	350	var name string
af146490 ILT	351	if genericRead {
af146490 ILT	352	_, err = c.(Conn).Read(b[:])
4f4a855d	353	name = "Read"
be47d6ec	354	} else {
af146490	355	_, _, err = c.ReadFrom(b[:])
4f4a855d	356	name = "ReadFrom"
af146490	357	}
4f4a855d ILT	358	if err != nil {
4f4a855d ILT	359	t.Errorf("%s of zero byte packet failed: %v", name, err)
af146490 ILT	360	}
	361	}
	362	}
	363
	364	func TestUDPZeroByteBuffer(t *testing.T) {
	365	switch runtime.GOOS {
5a8ea165	366	case "plan9":
af146490 ILT	367	t.Skipf("not supported on %s", runtime.GOOS)
	368	}
	369
	370	c, err := newLocalPacketListener("udp")
	371	if err != nil {
	372	t.Fatal(err)
	373	}
	374	defer c.Close()
	375
	376	b := []byte("UDP ZERO BYTE BUFFER TEST")
	377	for _, genericRead := range []bool{false, true} {
	378	n, err := c.WriteTo(b, c.LocalAddr())
	379	if err != nil {
	380	t.Fatal(err)
	381	}
	382	if n != len(b) {
	383	t.Errorf("got %d; want %d", n, len(b))
	384	}
	385	c.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
	386	if genericRead {
	387	_, err = c.(Conn).Read(nil)
	388	} else {
	389	_, _, err = c.ReadFrom(nil)
	390	}
	391	switch err {
	392	case nil: // ReadFrom succeeds
	393	default: // Read may timeout, it depends on the platform
dd931d9b ILT	394	if nerr, ok := err.(Error); (!ok \|\| !nerr.Timeout()) && runtime.GOOS != "windows" { // Windows returns WSAEMSGSIZE
	395	t.Fatal(err)
	396	}
	397	}
	398	}
	399	}
	400
	401	func TestUDPReadSizeError(t *testing.T) {
	402	switch runtime.GOOS {
5a8ea165	403	case "plan9":
dd931d9b ILT	404	t.Skipf("not supported on %s", runtime.GOOS)
	405	}
	406
	407	c1, err := newLocalPacketListener("udp")
	408	if err != nil {
	409	t.Fatal(err)
	410	}
	411	defer c1.Close()
	412
	413	c2, err := Dial("udp", c1.LocalAddr().String())
	414	if err != nil {
	415	t.Fatal(err)
	416	}
	417	defer c2.Close()
	418
	419	b1 := []byte("READ SIZE ERROR TEST")
	420	for _, genericRead := range []bool{false, true} {
	421	n, err := c2.Write(b1)
	422	if err != nil {
	423	t.Fatal(err)
	424	}
	425	if n != len(b1) {
	426	t.Errorf("got %d; want %d", n, len(b1))
	427	}
	428	c1.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
	429	b2 := make([]byte, len(b1)-1)
	430	if genericRead {
	431	n, err = c1.(Conn).Read(b2)
	432	} else {
	433	n, _, err = c1.ReadFrom(b2)
	434	}
	435	switch err {
	436	case nil: // ReadFrom succeeds
	437	default: // Read may timeout, it depends on the platform
	438	if nerr, ok := err.(Error); (!ok \|\| !nerr.Timeout()) && runtime.GOOS != "windows" { // Windows returns WSAEMSGSIZE
af146490	439	t.Fatal(err)
be47d6ec	440	}
fabcaa8d	441	}
dd931d9b ILT	442	if n != len(b1)-1 {
	443	t.Fatalf("got %d; want %d", n, len(b1)-1)
	444	}
fabcaa8d ILT	445	}
fabcaa8d ILT	446	}