libgo/go/net/protoconn_test.go

   1 // Copyright 2012 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 // This file implements API tests across platforms and will never have a build
   6 // tag.
   7
   8 // +build !js
   9
  10 package net
  11
  12 import (
  13         "os"
  14         "runtime"
  15         "testing"
  16         "time"
  17 )
  18
  19 // The full stack test cases for IPConn have been moved to the
  20 // following:
  21 //      golang.org/x/net/ipv4
  22 //      golang.org/x/net/ipv6
  23 //      golang.org/x/net/icmp
  24
  25 func TestTCPListenerSpecificMethods(t *testing.T) {
  26         switch runtime.GOOS {
  27         case "plan9":
  28                 t.Skipf("not supported on %s", runtime.GOOS)
  29         }
  30
  31         la, err := ResolveTCPAddr("tcp4", "127.0.0.1:0")
  32         if err != nil {
  33                 t.Fatal(err)
  34         }
  35         ln, err := ListenTCP("tcp4", la)
  36         if err != nil {
  37                 t.Fatal(err)
  38         }
  39         defer ln.Close()
  40         ln.Addr()
  41         ln.SetDeadline(time.Now().Add(30 * time.Nanosecond))
  42
  43         if c, err := ln.Accept(); err != nil {
  44                 if !err.(Error).Timeout() {
  45                         t.Fatal(err)
  46                 }
  47         } else {
  48                 c.Close()
  49         }
  50         if c, err := ln.AcceptTCP(); err != nil {
  51                 if !err.(Error).Timeout() {
  52                         t.Fatal(err)
  53                 }
  54         } else {
  55                 c.Close()
  56         }
  57
  58         if f, err := ln.File(); err != nil {
  59                 condFatalf(t, "file+net", "%v", err)
  60         } else {
  61                 f.Close()
  62         }
  63 }
  64
  65 func TestTCPConnSpecificMethods(t *testing.T) {
  66         la, err := ResolveTCPAddr("tcp4", "127.0.0.1:0")
  67         if err != nil {
  68                 t.Fatal(err)
  69         }
  70         ln, err := ListenTCP("tcp4", la)
  71         if err != nil {
  72                 t.Fatal(err)
  73         }
  74         ch := make(chan error, 1)
  75         handler := func(ls *localServer, ln Listener) { transponder(ls.Listener, ch) }
  76         ls, err := (&streamListener{Listener: ln}).newLocalServer()
  77         if err != nil {
  78                 t.Fatal(err)
  79         }
  80         defer ls.teardown()
  81         if err := ls.buildup(handler); err != nil {
  82                 t.Fatal(err)
  83         }
  84
  85         ra, err := ResolveTCPAddr("tcp4", ls.Listener.Addr().String())
  86         if err != nil {
  87                 t.Fatal(err)
  88         }
  89         c, err := DialTCP("tcp4", nil, ra)
  90         if err != nil {
  91                 t.Fatal(err)
  92         }
  93         defer c.Close()
  94         c.SetKeepAlive(false)
  95         c.SetKeepAlivePeriod(3 * time.Second)
  96         c.SetLinger(0)
  97         c.SetNoDelay(false)
  98         c.LocalAddr()
  99         c.RemoteAddr()
 100         c.SetDeadline(time.Now().Add(someTimeout))
 101         c.SetReadDeadline(time.Now().Add(someTimeout))
 102         c.SetWriteDeadline(time.Now().Add(someTimeout))
 103
 104         if _, err := c.Write([]byte("TCPCONN TEST")); err != nil {
 105                 t.Fatal(err)
 106         }
 107         rb := make([]byte, 128)
 108         if _, err := c.Read(rb); err != nil {
 109                 t.Fatal(err)
 110         }
 111
 112         for err := range ch {
 113                 t.Error(err)
 114         }
 115 }
 116
 117 func TestUDPConnSpecificMethods(t *testing.T) {
 118         la, err := ResolveUDPAddr("udp4", "127.0.0.1:0")
 119         if err != nil {
 120                 t.Fatal(err)
 121         }
 122         c, err := ListenUDP("udp4", la)
 123         if err != nil {
 124                 t.Fatal(err)
 125         }
 126         defer c.Close()
 127         c.LocalAddr()
 128         c.RemoteAddr()
 129         c.SetDeadline(time.Now().Add(someTimeout))
 130         c.SetReadDeadline(time.Now().Add(someTimeout))
 131         c.SetWriteDeadline(time.Now().Add(someTimeout))
 132         c.SetReadBuffer(2048)
 133         c.SetWriteBuffer(2048)
 134
 135         wb := []byte("UDPCONN TEST")
 136         rb := make([]byte, 128)
 137         if _, err := c.WriteToUDP(wb, c.LocalAddr().(*UDPAddr)); err != nil {
 138                 t.Fatal(err)
 139         }
 140         if _, _, err := c.ReadFromUDP(rb); err != nil {
 141                 t.Fatal(err)
 142         }
 143         if _, _, err := c.WriteMsgUDP(wb, nil, c.LocalAddr().(*UDPAddr)); err != nil {
 144                 condFatalf(t, c.LocalAddr().Network(), "%v", err)
 145         }
 146         if _, _, _, _, err := c.ReadMsgUDP(rb, nil); err != nil {
 147                 condFatalf(t, c.LocalAddr().Network(), "%v", err)
 148         }
 149
 150         if f, err := c.File(); err != nil {
 151                 condFatalf(t, "file+net", "%v", err)
 152         } else {
 153                 f.Close()
 154         }
 155
 156         defer func() {
 157                 if p := recover(); p != nil {
 158                         t.Fatalf("panicked: %v", p)
 159                 }
 160         }()
 161
 162         c.WriteToUDP(wb, nil)
 163         c.WriteMsgUDP(wb, nil, nil)
 164 }
 165
 166 func TestIPConnSpecificMethods(t *testing.T) {
 167         if os.Getuid() != 0 {
 168                 t.Skip("must be root")
 169         }
 170
 171         la, err := ResolveIPAddr("ip4", "127.0.0.1")
 172         if err != nil {
 173                 t.Fatal(err)
 174         }
 175         c, err := ListenIP("ip4:icmp", la)
 176         if err != nil {
 177                 t.Fatal(err)
 178         }
 179         defer c.Close()
 180         c.LocalAddr()
 181         c.RemoteAddr()
 182         c.SetDeadline(time.Now().Add(someTimeout))
 183         c.SetReadDeadline(time.Now().Add(someTimeout))
 184         c.SetWriteDeadline(time.Now().Add(someTimeout))
 185         c.SetReadBuffer(2048)
 186         c.SetWriteBuffer(2048)
 187
 188         if f, err := c.File(); err != nil {
 189                 condFatalf(t, "file+net", "%v", err)
 190         } else {
 191                 f.Close()
 192         }
 193
 194         defer func() {
 195                 if p := recover(); p != nil {
 196                         t.Fatalf("panicked: %v", p)
 197                 }
 198         }()
 199
 200         wb := []byte("IPCONN TEST")
 201         c.WriteToIP(wb, nil)
 202         c.WriteMsgIP(wb, nil, nil)
 203 }
 204
 205 func TestUnixListenerSpecificMethods(t *testing.T) {
 206         if !testableNetwork("unix") {
 207                 t.Skip("unix test")
 208         }
 209
 210         addr := testUnixAddr()
 211         la, err := ResolveUnixAddr("unix", addr)
 212         if err != nil {
 213                 t.Fatal(err)
 214         }
 215         ln, err := ListenUnix("unix", la)
 216         if err != nil {
 217                 t.Fatal(err)
 218         }
 219         defer ln.Close()
 220         defer os.Remove(addr)
 221         ln.Addr()
 222         ln.SetDeadline(time.Now().Add(30 * time.Nanosecond))
 223
 224         if c, err := ln.Accept(); err != nil {
 225                 if !err.(Error).Timeout() {
 226                         t.Fatal(err)
 227                 }
 228         } else {
 229                 c.Close()
 230         }
 231         if c, err := ln.AcceptUnix(); err != nil {
 232                 if !err.(Error).Timeout() {
 233                         t.Fatal(err)
 234                 }
 235         } else {
 236                 c.Close()
 237         }
 238
 239         if f, err := ln.File(); err != nil {
 240                 t.Fatal(err)
 241         } else {
 242                 f.Close()
 243         }
 244 }
 245
 246 func TestUnixConnSpecificMethods(t *testing.T) {
 247         if !testableNetwork("unixgram") {
 248                 t.Skip("unixgram test")
 249         }
 250
 251         addr1, addr2, addr3 := testUnixAddr(), testUnixAddr(), testUnixAddr()
 252
 253         a1, err := ResolveUnixAddr("unixgram", addr1)
 254         if err != nil {
 255                 t.Fatal(err)
 256         }
 257         c1, err := DialUnix("unixgram", a1, nil)
 258         if err != nil {
 259                 t.Fatal(err)
 260         }
 261         defer c1.Close()
 262         defer os.Remove(addr1)
 263         c1.LocalAddr()
 264         c1.RemoteAddr()
 265         c1.SetDeadline(time.Now().Add(someTimeout))
 266         c1.SetReadDeadline(time.Now().Add(someTimeout))
 267         c1.SetWriteDeadline(time.Now().Add(someTimeout))
 268         c1.SetReadBuffer(2048)
 269         c1.SetWriteBuffer(2048)
 270
 271         a2, err := ResolveUnixAddr("unixgram", addr2)
 272         if err != nil {
 273                 t.Fatal(err)
 274         }
 275         c2, err := DialUnix("unixgram", a2, nil)
 276         if err != nil {
 277                 t.Fatal(err)
 278         }
 279         defer c2.Close()
 280         defer os.Remove(addr2)
 281         c2.LocalAddr()
 282         c2.RemoteAddr()
 283         c2.SetDeadline(time.Now().Add(someTimeout))
 284         c2.SetReadDeadline(time.Now().Add(someTimeout))
 285         c2.SetWriteDeadline(time.Now().Add(someTimeout))
 286         c2.SetReadBuffer(2048)
 287         c2.SetWriteBuffer(2048)
 288
 289         a3, err := ResolveUnixAddr("unixgram", addr3)
 290         if err != nil {
 291                 t.Fatal(err)
 292         }
 293         c3, err := ListenUnixgram("unixgram", a3)
 294         if err != nil {
 295                 t.Fatal(err)
 296         }
 297         defer c3.Close()
 298         defer os.Remove(addr3)
 299         c3.LocalAddr()
 300         c3.RemoteAddr()
 301         c3.SetDeadline(time.Now().Add(someTimeout))
 302         c3.SetReadDeadline(time.Now().Add(someTimeout))
 303         c3.SetWriteDeadline(time.Now().Add(someTimeout))
 304         c3.SetReadBuffer(2048)
 305         c3.SetWriteBuffer(2048)
 306
 307         wb := []byte("UNIXCONN TEST")
 308         rb1 := make([]byte, 128)
 309         rb2 := make([]byte, 128)
 310         rb3 := make([]byte, 128)
 311         if _, _, err := c1.WriteMsgUnix(wb, nil, a2); err != nil {
 312                 t.Fatal(err)
 313         }
 314         if _, _, _, _, err := c2.ReadMsgUnix(rb2, nil); err != nil {
 315                 t.Fatal(err)
 316         }
 317         if _, err := c2.WriteToUnix(wb, a1); err != nil {
 318                 t.Fatal(err)
 319         }
 320         if _, _, err := c1.ReadFromUnix(rb1); err != nil {
 321                 t.Fatal(err)
 322         }
 323         if _, err := c3.WriteToUnix(wb, a1); err != nil {
 324                 t.Fatal(err)
 325         }
 326         if _, _, err := c1.ReadFromUnix(rb1); err != nil {
 327                 t.Fatal(err)
 328         }
 329         if _, err := c2.WriteToUnix(wb, a3); err != nil {
 330                 t.Fatal(err)
 331         }
 332         if _, _, err := c3.ReadFromUnix(rb3); err != nil {
 333                 t.Fatal(err)
 334         }
 335
 336         if f, err := c1.File(); err != nil {
 337                 t.Fatal(err)
 338         } else {
 339                 f.Close()
 340         }
 341
 342         defer func() {
 343                 if p := recover(); p != nil {
 344                         t.Fatalf("panicked: %v", p)
 345                 }
 346         }()
 347
 348         c1.WriteToUnix(wb, nil)
 349         c1.WriteMsgUnix(wb, nil, nil)
 350         c3.WriteToUnix(wb, nil)
 351         c3.WriteMsgUnix(wb, nil, nil)
 352 }