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 "plan9", "windows":
  93                 t.Logf("skipping test on %q", runtime.GOOS)
  94                 return
  95         }
  96
  97         for _, tt := range fileListenerTests {
  98                 if skipServerTest(tt.net, "unix", tt.laddr, tt.ipv6, false, tt.linux) {
  99                         continue
 100                 }
 101                 if skipServerTest(tt.net, "unixpacket", tt.laddr, tt.ipv6, false, tt.linux) {
 102                         continue
 103                 }
 104                 testFileListener(t, tt.net, tt.laddr)
 105         }
 106 }
 107
 108 func testFilePacketConn(t *testing.T, pcf packetConnFile, listen bool) {
 109         f, err := pcf.File()
 110         if err != nil {
 111                 t.Fatalf("File failed: %v", err)
 112         }
 113         c, err := FilePacketConn(f)
 114         if err != nil {
 115                 t.Fatalf("FilePacketConn failed: %v", err)
 116         }
 117         if !reflect.DeepEqual(pcf.LocalAddr(), c.LocalAddr()) {
 118                 t.Fatalf("LocalAddrs not equal: %#v != %#v", pcf.LocalAddr(), c.LocalAddr())
 119         }
 120         if listen {
 121                 if _, err := c.WriteTo([]byte{}, c.LocalAddr()); err != nil {
 122                         t.Fatalf("WriteTo failed: %v", err)
 123                 }
 124         }
 125         if err := c.Close(); err != nil {
 126                 t.Fatalf("Close failed: %v", err)
 127         }
 128         if err := f.Close(); err != nil {
 129                 t.Fatalf("Close failed: %v", err)
 130         }
 131 }
 132
 133 func testFilePacketConnListen(t *testing.T, net, laddr string) {
 134         switch net {
 135         case "udp", "udp4", "udp6":
 136                 laddr += ":0" // any available port
 137         }
 138         l, err := ListenPacket(net, laddr)
 139         if err != nil {
 140                 t.Fatalf("ListenPacket failed: %v", err)
 141         }
 142         testFilePacketConn(t, l.(packetConnFile), true)
 143         if err := l.Close(); err != nil {
 144                 t.Fatalf("Close failed: %v", err)
 145         }
 146 }
 147
 148 func testFilePacketConnDial(t *testing.T, net, raddr string) {
 149         switch net {
 150         case "udp", "udp4", "udp6":
 151                 raddr += ":12345"
 152         }
 153         c, err := Dial(net, raddr)
 154         if err != nil {
 155                 t.Fatalf("Dial failed: %v", err)
 156         }
 157         testFilePacketConn(t, c.(packetConnFile), false)
 158         if err := c.Close(); err != nil {
 159                 t.Fatalf("Close failed: %v", err)
 160         }
 161 }
 162
 163 var filePacketConnTests = []struct {
 164         net   string
 165         addr  string
 166         ipv6  bool // test with underlying AF_INET6 socket
 167         linux bool // test with abstract unix domain socket, a Linux-ism
 168 }{
 169         {net: "udp", addr: "127.0.0.1"},
 170         {net: "udp", addr: "[::ffff:127.0.0.1]"},
 171         {net: "udp", addr: "[::1]", ipv6: true},
 172
 173         {net: "udp4", addr: "127.0.0.1"},
 174         {net: "udp4", addr: "[::ffff:127.0.0.1]"},
 175
 176         {net: "udp6", addr: "[::1]", ipv6: true},
 177
 178         {net: "unixgram", addr: "@gotest3/net", linux: true},
 179 }
 180
 181 func TestFilePacketConn(t *testing.T) {
 182         switch runtime.GOOS {
 183         case "plan9", "windows":
 184                 t.Logf("skipping test on %q", runtime.GOOS)
 185                 return
 186         }
 187
 188         for _, tt := range filePacketConnTests {
 189                 if skipServerTest(tt.net, "unixgram", tt.addr, tt.ipv6, false, tt.linux) {
 190                         continue
 191                 }
 192                 testFilePacketConnListen(t, tt.net, tt.addr)
 193                 switch tt.addr {
 194                 case "", "0.0.0.0", "[::ffff:0.0.0.0]", "[::]":
 195                 default:
 196                         if tt.net != "unixgram" {
 197                                 testFilePacketConnDial(t, tt.net, tt.addr)
 198                         }
 199                 }
 200         }
 201 }