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         "syscall"
  12         "testing"
  13 )
  14
  15 type listenerFile interface {
  16         Listener
  17         File() (f *os.File, err os.Error)
  18 }
  19
  20 type packetConnFile interface {
  21         PacketConn
  22         File() (f *os.File, err os.Error)
  23 }
  24
  25 type connFile interface {
  26         Conn
  27         File() (f *os.File, err os.Error)
  28 }
  29
  30 func testFileListener(t *testing.T, net, laddr string) {
  31         if net == "tcp" {
  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 func TestFileListener(t *testing.T) {
  60         if runtime.GOOS == "windows" || runtime.GOOS == "plan9" {
  61                 return
  62         }
  63         testFileListener(t, "tcp", "127.0.0.1")
  64         testFileListener(t, "tcp", "127.0.0.1")
  65         if supportsIPv6 && supportsIPv4map {
  66                 testFileListener(t, "tcp", "[::ffff:127.0.0.1]")
  67                 testFileListener(t, "tcp", "127.0.0.1")
  68                 testFileListener(t, "tcp", "[::ffff:127.0.0.1]")
  69         }
  70         if syscall.OS == "linux" {
  71                 testFileListener(t, "unix", "@gotest/net")
  72                 testFileListener(t, "unixpacket", "@gotest/net")
  73         }
  74 }
  75
  76 func testFilePacketConn(t *testing.T, pcf packetConnFile, listen bool) {
  77         f, err := pcf.File()
  78         if err != nil {
  79                 t.Fatalf("File failed: %v", err)
  80         }
  81         c, err := FilePacketConn(f)
  82         if err != nil {
  83                 t.Fatalf("FilePacketConn failed: %v", err)
  84         }
  85         if !reflect.DeepEqual(pcf.LocalAddr(), c.LocalAddr()) {
  86                 t.Fatalf("LocalAddrs not equal: %#v != %#v", pcf.LocalAddr(), c.LocalAddr())
  87         }
  88         if listen {
  89                 if _, err := c.WriteTo([]byte{}, c.LocalAddr()); err != nil {
  90                         t.Fatalf("WriteTo failed: %v", err)
  91                 }
  92         }
  93         if err := c.Close(); err != nil {
  94                 t.Fatalf("Close failed: %v", err)
  95         }
  96         if err := f.Close(); err != nil {
  97                 t.Fatalf("Close failed: %v", err)
  98         }
  99 }
 100
 101 func testFilePacketConnListen(t *testing.T, net, laddr string) {
 102         l, err := ListenPacket(net, laddr)
 103         if err != nil {
 104                 t.Fatalf("Listen failed: %v", err)
 105         }
 106         testFilePacketConn(t, l.(packetConnFile), true)
 107         if err := l.Close(); err != nil {
 108                 t.Fatalf("Close failed: %v", err)
 109         }
 110 }
 111
 112 func testFilePacketConnDial(t *testing.T, net, raddr string) {
 113         c, err := Dial(net, raddr)
 114         if err != nil {
 115                 t.Fatalf("Dial failed: %v", err)
 116         }
 117         testFilePacketConn(t, c.(packetConnFile), false)
 118         if err := c.Close(); err != nil {
 119                 t.Fatalf("Close failed: %v", err)
 120         }
 121 }
 122
 123 func TestFilePacketConn(t *testing.T) {
 124         if runtime.GOOS == "windows" || runtime.GOOS == "plan9" {
 125                 return
 126         }
 127         testFilePacketConnListen(t, "udp", "127.0.0.1:0")
 128         testFilePacketConnDial(t, "udp", "127.0.0.1:12345")
 129         if supportsIPv6 {
 130                 testFilePacketConnListen(t, "udp", "[::1]:0")
 131         }
 132         if supportsIPv6 && supportsIPv4map {
 133                 testFilePacketConnDial(t, "udp", "[::ffff:127.0.0.1]:12345")
 134         }
 135         if syscall.OS == "linux" {
 136                 testFilePacketConnListen(t, "unixgram", "@gotest1/net")
 137         }
 138 }