Skip to content

G
golang
Commit 6a1c2a59 authored by Mikio Hara's avatar Mikio Hara
Browse files
Options

net: add missing File{Conn,Listener,PacketConn} read/write tests 

At present, the series of File{Conn,Listener,PacketConn} APIs are the
only way to configure platform-specific socket options such as
SO_REUSE{ADDR,PORT}, TCP_FASTOPEN. This change adds missing test cases
that test read and write operations on connections created by File APIs
and removes redundant parameter tests which are already tested in
server_test.go.

Also adds comment on full stack test cases for IPConn.

Fixes #10730.

Change-Id: I67abb083781b602e876f72a6775a593c0f363c38
Reviewed-on: https://go-review.googlesource.com/17476Reviewed-by: 's avatarIan Lance Taylor <iant@golang.org>
parent a0288928
Hide whitespace changes
Inline Side-by-side
Showing with 233 additions and 133 deletions
src/net/file_test.go
View file @ 6a1c2a59
...@@ -8,158 +8,222 @@ import ( ...@@ -8,158 +8,222 @@ import (
"os" "os"
"reflect" "reflect"
"runtime" "runtime"
"sync"
"testing" "testing"
) )
type listenerFile interface { // The full stack test cases for IPConn have been moved to the
Listener // following:
File() (f *os.File, err error) // golang.org/x/net/ipv4
} // golang.org/x/net/ipv6
// golang.org/x/net/icmp
type packetConnFile interface {
PacketConn
File() (f *os.File, err error)
}
type connFile interface { var fileConnTests = []struct {
Conn network string
File() (f *os.File, err error) }{
{"tcp"},
{"udp"},
{"unix"},
{"unixpacket"},
} }
func testFileListener(t *testing.T, net, laddr string) { func TestFileConn(t *testing.T) {
l, err := Listen(net, laddr) switch runtime.GOOS {
if err != nil { case "nacl", "plan9", "windows":
t.Fatal(err) t.Skipf("not supported on %s", runtime.GOOS)
}
defer l.Close()
lf := l.(listenerFile)
f, err := lf.File()
if err != nil {
t.Fatal(err)
}
c, err := FileListener(f)
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(l.Addr(), c.Addr()) {
t.Fatalf("got %#v; want%#v", l.Addr(), c.Addr())
}
if err := c.Close(); err != nil {
t.Fatal(err)
}
if err := f.Close(); err != nil {
t.Fatal(err)
} }
}
var fileListenerTests = []struct { for _, tt := range fileConnTests {
net string if !testableNetwork(tt.network) {
laddr string t.Logf("skipping %s test", tt.network)
}{ continue
{net: "tcp", laddr: ":0"}, }
{net: "tcp", laddr: "0.0.0.0:0"},
{net: "tcp", laddr: "[::ffff:0.0.0.0]:0"},
{net: "tcp", laddr: "[::]:0"},
{net: "tcp", laddr: "127.0.0.1:0"}, var network, address string
{net: "tcp", laddr: "[::ffff:127.0.0.1]:0"}, switch tt.network {
{net: "tcp", laddr: "[::1]:0"}, case "udp":
c, err := newLocalPacketListener(tt.network)
if err != nil {
t.Fatal(err)
}
defer c.Close()
network = c.LocalAddr().Network()
address = c.LocalAddr().String()
default:
handler := func(ls *localServer, ln Listener) {
c, err := ln.Accept()
if err != nil {
return
}
defer c.Close()
var b [1]byte
c.Read(b[:])
}
ls, err := newLocalServer(tt.network)
if err != nil {
t.Fatal(err)
}
defer ls.teardown()
if err := ls.buildup(handler); err != nil {
t.Fatal(err)
}
network = ls.Listener.Addr().Network()
address = ls.Listener.Addr().String()
}
{net: "tcp4", laddr: ":0"}, c1, err := Dial(network, address)
{net: "tcp4", laddr: "0.0.0.0:0"}, if err != nil {
{net: "tcp4", laddr: "[::ffff:0.0.0.0]:0"}, if perr := parseDialError(err); perr != nil {
t.Error(perr)
}
t.Fatal(err)
}
addr := c1.LocalAddr()
{net: "tcp4", laddr: "127.0.0.1:0"}, var f *os.File
{net: "tcp4", laddr: "[::ffff:127.0.0.1]:0"}, switch c1 := c1.(type) {
case *TCPConn:
f, err = c1.File()
case *UDPConn:
f, err = c1.File()
case *UnixConn:
f, err = c1.File()
}
if err := c1.Close(); err != nil {
if perr := parseCloseError(err); perr != nil {
t.Error(perr)
}
t.Error(err)
}
if err != nil {
if perr := parseCommonError(err); perr != nil {
t.Error(perr)
}
t.Fatal(err)
}
{net: "tcp6", laddr: ":0"}, c2, err := FileConn(f)
{net: "tcp6", laddr: "[::]:0"}, if err := f.Close(); err != nil {
t.Error(err)
}
if err != nil {
if perr := parseCommonError(err); perr != nil {
t.Error(perr)
}
t.Fatal(err)
}
defer c2.Close()
{net: "tcp6", laddr: "[::1]:0"}, if _, err := c2.Write([]byte("FILECONN TEST")); err != nil {
if perr := parseWriteError(err); perr != nil {
t.Error(perr)
}
t.Fatal(err)
}
if !reflect.DeepEqual(c2.LocalAddr(), addr) {
t.Fatalf("got %#v; want %#v", c2.LocalAddr(), addr)
}
}
}
{net: "unix", laddr: "@gotest/net"}, var fileListenerTests = []struct {
{net: "unixpacket", laddr: "@gotest/net"}, network string
}{
{"tcp"},
{"unix"},
{"unixpacket"},
} }
func TestFileListener(t *testing.T) { func TestFileListener(t *testing.T) {
switch runtime.GOOS { switch runtime.GOOS {
case "nacl", "windows": case "nacl", "plan9", "windows":
t.Skipf("not supported on %s", runtime.GOOS) t.Skipf("not supported on %s", runtime.GOOS)
} }
for _, tt := range fileListenerTests { for _, tt := range fileListenerTests {
if !testableListenArgs(tt.net, tt.laddr, "") { if !testableNetwork(tt.network) {
t.Logf("skipping %s test", tt.net+" "+tt.laddr) t.Logf("skipping %s test", tt.network)
continue continue
} }
testFileListener(t, tt.net, tt.laddr)
}
}
func testFilePacketConn(t *testing.T, pcf packetConnFile, listen bool) { ln1, err := newLocalListener(tt.network)
f, err := pcf.File() if err != nil {
if err != nil {
t.Fatal(err)
}
c, err := FilePacketConn(f)
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(pcf.LocalAddr(), c.LocalAddr()) {
t.Fatalf("got %#v; want %#v", pcf.LocalAddr(), c.LocalAddr())
}
if listen {
if _, err := c.WriteTo([]byte{}, c.LocalAddr()); err != nil {
t.Fatal(err) t.Fatal(err)
} }
} switch tt.network {
if err := c.Close(); err != nil { case "unix", "unixpacket":
t.Fatal(err) defer os.Remove(ln1.Addr().String())
} }
if err := f.Close(); err != nil { addr := ln1.Addr()
t.Fatal(err)
}
}
func testFilePacketConnListen(t *testing.T, net, laddr string) { var f *os.File
l, err := ListenPacket(net, laddr) switch ln1 := ln1.(type) {
if err != nil { case *TCPListener:
t.Fatal(err) f, err = ln1.File()
} case *UnixListener:
testFilePacketConn(t, l.(packetConnFile), true) f, err = ln1.File()
if err := l.Close(); err != nil { }
t.Fatal(err) switch tt.network {
} case "unix", "unixpacket":
} defer ln1.Close() // UnixListener.Close calls syscall.Unlink internally
default:
if err := ln1.Close(); err != nil {
t.Error(err)
}
}
if err != nil {
if perr := parseCommonError(err); perr != nil {
t.Error(perr)
}
t.Fatal(err)
}
func testFilePacketConnDial(t *testing.T, net, raddr string) { ln2, err := FileListener(f)
c, err := Dial(net, raddr) if err := f.Close(); err != nil {
if err != nil { t.Error(err)
t.Fatal(err) }
} if err != nil {
testFilePacketConn(t, c.(packetConnFile), false) if perr := parseCommonError(err); perr != nil {
if err := c.Close(); err != nil { t.Error(perr)
t.Fatal(err) }
t.Fatal(err)
}
defer ln2.Close()
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
c, err := Dial(ln2.Addr().Network(), ln2.Addr().String())
if err != nil {
if perr := parseDialError(err); perr != nil {
t.Error(perr)
}
t.Error(err)
return
}
c.Close()
}()
c, err := ln2.Accept()
if err != nil {
if perr := parseAcceptError(err); perr != nil {
t.Error(perr)
}
t.Fatal(err)
}
c.Close()
wg.Wait()
if !reflect.DeepEqual(ln2.Addr(), addr) {
t.Fatalf("got %#v; want %#v", ln2.Addr(), addr)
}
} }
} }
var filePacketConnTests = []struct { var filePacketConnTests = []struct {
net string network string
addr string
}{ }{
{net: "udp", addr: "127.0.0.1:0"}, {"udp"},
{net: "udp", addr: "[::ffff:127.0.0.1]:0"}, {"unixgram"},
{net: "udp", addr: "[::1]:0"},
{net: "udp4", addr: "127.0.0.1:0"},
{net: "udp4", addr: "[::ffff:127.0.0.1]:0"},
{net: "udp6", addr: "[::1]:0"},
// TODO(mikioh,bradfitz): reenable once 10730 is fixed
// {net: "ip4:icmp", addr: "127.0.0.1"},
{net: "unixgram", addr: "@gotest3/net"},
} }
func TestFilePacketConn(t *testing.T) { func TestFilePacketConn(t *testing.T) {
...@@ -169,25 +233,61 @@ func TestFilePacketConn(t *testing.T) { ...@@ -169,25 +233,61 @@ func TestFilePacketConn(t *testing.T) {
} }
for _, tt := range filePacketConnTests { for _, tt := range filePacketConnTests {
if !testableListenArgs(tt.net, tt.addr, "") { if !testableNetwork(tt.network) {
t.Logf("skipping %s test", tt.net+" "+tt.addr) t.Logf("skipping %s test", tt.network)
continue continue
} }
if os.Getuid() != 0 && tt.net == "ip4:icmp" {
t.Log("skipping test; must be root") c1, err := newLocalPacketListener(tt.network)
continue if err != nil {
t.Fatal(err)
} }
testFilePacketConnListen(t, tt.net, tt.addr) switch tt.network {
switch tt.net { case "unixgram":
case "udp", "udp4", "udp6": defer os.Remove(c1.LocalAddr().String())
host, _, err := SplitHostPort(tt.addr) }
if err != nil { addr := c1.LocalAddr()
t.Error(err)
continue var f *os.File
switch c1 := c1.(type) {
case *UDPConn:
f, err = c1.File()
case *UnixConn:
f, err = c1.File()
}
if err := c1.Close(); err != nil {
if perr := parseCloseError(err); perr != nil {
t.Error(perr)
} }
testFilePacketConnDial(t, tt.net, JoinHostPort(host, "12345")) t.Error(err)
case "ip4:icmp": }
testFilePacketConnDial(t, tt.net, tt.addr) if err != nil {
if perr := parseCommonError(err); perr != nil {
t.Error(perr)
}
t.Fatal(err)
}
c2, err := FilePacketConn(f)
if err := f.Close(); err != nil {
t.Error(err)
}
if err != nil {
if perr := parseCommonError(err); perr != nil {
t.Error(perr)
}
t.Fatal(err)
}
defer c2.Close()
if _, err := c2.WriteTo([]byte("FILEPACKETCONN TEST"), addr); err != nil {
if perr := parseWriteError(err); perr != nil {
t.Error(perr)
}
t.Fatal(err)
}
if !reflect.DeepEqual(c2.LocalAddr(), addr) {
t.Fatalf("got %#v; want %#v", c2.LocalAddr(), addr)
} }
} }
} }
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment