libgo/go/net/file_test.go

   1 // Copyright 2011 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package net
   6
   7 import (
   8         "os"
   9         "reflect"
  10         "runtime"
  11         "testing"
  12 )
  13
  14 type listenerFile interface {
  15         Listener
  16         File() (f *os.File, err error)
  17 }
  18
  19 type packetConnFile interface {
  20         PacketConn
  21         File() (f *os.File, err error)
  22 }
  23
  24 type connFile interface {
  25         Conn
  26         File() (f *os.File, err error)
  27 }
  28
  29 func testFileListener(t *testing.T, net, laddr string) {
  30         switch net {
  31         case "tcp", "tcp4", "tcp6":
  32                 laddr += ":0" // any available port
  33         }
  34         l, err := Listen(net, laddr)
  35         if err != nil {
  36                 t.Fatalf("Listen failed: %v", err)
  37         }
  38         defer l.Close()
  39         lf := l.(listenerFile)
  40         f, err := lf.File()
  41         if err != nil {
  42                 t.Fatalf("File failed: %v", err)
  43         }
  44         c, err := FileListener(f)
  45         if err != nil {
  46                 t.Fatalf("FileListener failed: %v", err)
  47         }
  48         if !reflect.DeepEqual(l.Addr(), c.Addr()) {
  49                 t.Fatalf("Addrs not equal: %#v != %#v", l.Addr(), c.Addr())
  50         }
  51         if err := c.Close(); err != nil {
  52                 t.Fatalf("Close failed: %v", err)
  53         }
  54         if err := f.Close(); err != nil {
  55                 t.Fatalf("Close failed: %v", err)
  56         }
  57 }
  58
  59 var fileListenerTests = []struct {
  60         net   string
  61         laddr string
  62         ipv6  bool // test with underlying AF_INET6 socket
  63         linux bool // test with abstract unix domain socket, a Linux-ism
  64 }{
  65         {net: "tcp", laddr: ""},
  66         {net: "tcp", laddr: "0.0.0.0"},
  67         {net: "tcp", laddr: "[::ffff:0.0.0.0]"},
  68         {net: "tcp", laddr: "[::]", ipv6: true},
  69
  70         {net: "tcp", laddr: "127.0.0.1"},
  71         {net: "tcp", laddr: "[::ffff:127.0.0.1]"},
  72         {net: "tcp", laddr: "[::1]", ipv6: true},
  73
  74         {net: "tcp4", laddr: ""},
  75         {net: "tcp4", laddr: "0.0.0.0"},
  76         {net: "tcp4", laddr: "[::ffff:0.0.0.0]"},
  77
  78         {net: "tcp4", laddr: "127.0.0.1"},
  79         {net: "tcp4", laddr: "[::ffff:127.0.0.1]"},
  80
  81         {net: "tcp6", laddr: "", ipv6: true},
  82         {net: "tcp6", laddr: "[::]", ipv6: true},
  83
  84         {net: "tcp6", laddr: "[::1]", ipv6: true},
  85
  86         {net: "unix", laddr: "@gotest/net", linux: true},
  87         {net: "unixpacket", laddr: "@gotest/net", linux: true},
  88 }
  89
  90 func TestFileListener(t *testing.T) {
  91         switch runtime.GOOS {
  92         case "windows":
  93                 t.Skipf("skipping test on %q", runtime.GOOS)
  94         }
  95
  96         for _, tt := range fileListenerTests {
  97                 if skipServerTest(tt.net, "unix", tt.laddr, tt.ipv6, false, tt.linux) {
  98                         continue
  99                 }
 100                 if skipServerTest(tt.net, "unixpacket", tt.laddr, tt.ipv6, false, tt.linux) {
 101                         continue
 102                 }
 103                 testFileListener(t, tt.net, tt.laddr)
 104         }
 105 }
 106
 107 func testFilePacketConn(t *testing.T, pcf packetConnFile, listen bool) {
 108         f, err := pcf.File()
 109         if err != nil {
 110                 t.Fatalf("File failed: %v", err)
 111         }
 112         c, err := FilePacketConn(f)
 113         if err != nil {
 114                 t.Fatalf("FilePacketConn failed: %v", err)
 115         }
 116         if !reflect.DeepEqual(pcf.LocalAddr(), c.LocalAddr()) {
 117                 t.Fatalf("LocalAddrs not equal: %#v != %#v", pcf.LocalAddr(), c.LocalAddr())
 118         }
 119         if listen {
 120                 if _, err := c.WriteTo([]byte{}, c.LocalAddr()); err != nil {
 121                         t.Fatalf("WriteTo failed: %v", err)
 122                 }
 123         }
 124         if err := c.Close(); err != nil {
 125                 t.Fatalf("Close failed: %v", err)
 126         }
 127         if err := f.Close(); err != nil {
 128                 t.Fatalf("Close failed: %v", err)
 129         }
 130 }
 131
 132 func testFilePacketConnListen(t *testing.T, net, laddr string) {
 133         switch net {
 134         case "udp", "udp4", "udp6":
 135                 laddr += ":0" // any available port
 136         }
 137         l, err := ListenPacket(net, laddr)
 138         if err != nil {
 139                 t.Fatalf("ListenPacket failed: %v", err)
 140         }
 141         testFilePacketConn(t, l.(packetConnFile), true)
 142         if err := l.Close(); err != nil {
 143                 t.Fatalf("Close failed: %v", err)
 144         }
 145 }
 146
 147 func testFilePacketConnDial(t *testing.T, net, raddr string) {
 148         switch net {
 149         case "udp", "udp4", "udp6":
 150                 raddr += ":12345"
 151         }
 152         c, err := Dial(net, raddr)
 153         if err != nil {
 154                 t.Fatalf("Dial failed: %v", err)
 155         }
 156         testFilePacketConn(t, c.(packetConnFile), false)
 157         if err := c.Close(); err != nil {
 158                 t.Fatalf("Close failed: %v", err)
 159         }
 160 }
 161
 162 var filePacketConnTests = []struct {
 163         net   string
 164         addr  string
 165         ipv6  bool // test with underlying AF_INET6 socket
 166         linux bool // test with abstract unix domain socket, a Linux-ism
 167 }{
 168         {net: "udp", addr: "127.0.0.1"},
 169         {net: "udp", addr: "[::ffff:127.0.0.1]"},
 170         {net: "udp", addr: "[::1]", ipv6: true},
 171
 172         {net: "udp4", addr: "127.0.0.1"},
 173         {net: "udp4", addr: "[::ffff:127.0.0.1]"},
 174
 175         {net: "udp6", addr: "[::1]", ipv6: true},
 176
 177         {net: "ip4:icmp", addr: "127.0.0.1"},
 178
 179         {net: "unixgram", addr: "@gotest3/net", linux: true},
 180 }
 181
 182 func TestFilePacketConn(t *testing.T) {
 183         switch runtime.GOOS {
 184         case "nacl", "plan9", "windows":
 185                 t.Skipf("skipping test on %q", runtime.GOOS)
 186         }
 187
 188         for _, tt := range filePacketConnTests {
 189                 if skipServerTest(tt.net, "unixgram", tt.addr, tt.ipv6, false, tt.linux) {
 190                         continue
 191                 }
 192                 if os.Getuid() != 0 && tt.net == "ip4:icmp" {
 193                         t.Log("skipping test; must be root")
 194                         continue
 195                 }
 196                 testFilePacketConnListen(t, tt.net, tt.addr)
 197                 switch tt.addr {
 198                 case "", "0.0.0.0", "[::ffff:0.0.0.0]", "[::]":
 199                 default:
 200                         if tt.net != "unixgram" {
 201                                 testFilePacketConnDial(t, tt.net, tt.addr)
 202                         }
 203                 }
 204         }
 205 }