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 //go: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) { ls.transponder(ls.Listener, ch) }
  76         ls := (&streamListener{Listener: ln}).newLocalServer()
  77         defer ls.teardown()
  78         if err := ls.buildup(handler); err != nil {
  79                 t.Fatal(err)
  80         }
  81
  82         ra, err := ResolveTCPAddr("tcp4", ls.Listener.Addr().String())
  83         if err != nil {
  84                 t.Fatal(err)
  85         }
  86         c, err := DialTCP("tcp4", nil, ra)
  87         if err != nil {
  88                 t.Fatal(err)
  89         }
  90         defer c.Close()
  91         c.SetKeepAlive(false)
  92         c.SetKeepAlivePeriod(3 * time.Second)
  93         c.SetLinger(0)
  94         c.SetNoDelay(false)
  95         c.LocalAddr()
  96         c.RemoteAddr()
  97         c.SetDeadline(time.Now().Add(someTimeout))
  98         c.SetReadDeadline(time.Now().Add(someTimeout))
  99         c.SetWriteDeadline(time.Now().Add(someTimeout))
 100
 101         if _, err := c.Write([]byte("TCPCONN TEST")); err != nil {
 102                 t.Fatal(err)
 103         }
 104         rb := make([]byte, 128)
 105         if _, err := c.Read(rb); err != nil {
 106                 t.Fatal(err)
 107         }
 108
 109         for err := range ch {
 110                 t.Error(err)
 111         }
 112 }
 113
 114 func TestUDPConnSpecificMethods(t *testing.T) {
 115         la, err := ResolveUDPAddr("udp4", "127.0.0.1:0")
 116         if err != nil {
 117                 t.Fatal(err)
 118         }
 119         c, err := ListenUDP("udp4", la)
 120         if err != nil {
 121                 t.Fatal(err)
 122         }
 123         defer c.Close()
 124         c.LocalAddr()
 125         c.RemoteAddr()
 126         c.SetDeadline(time.Now().Add(someTimeout))
 127         c.SetReadDeadline(time.Now().Add(someTimeout))
 128         c.SetWriteDeadline(time.Now().Add(someTimeout))
 129         c.SetReadBuffer(2048)
 130         c.SetWriteBuffer(2048)
 131
 132         wb := []byte("UDPCONN TEST")
 133         rb := make([]byte, 128)
 134         if _, err := c.WriteToUDP(wb, c.LocalAddr().(*UDPAddr)); err != nil {
 135                 t.Fatal(err)
 136         }
 137         if _, _, err := c.ReadFromUDP(rb); err != nil {
 138                 t.Fatal(err)
 139         }
 140         if _, _, err := c.WriteMsgUDP(wb, nil, c.LocalAddr().(*UDPAddr)); err != nil {
 141                 condFatalf(t, c.LocalAddr().Network(), "%v", err)
 142         }
 143         if _, _, _, _, err := c.ReadMsgUDP(rb, nil); err != nil {
 144                 condFatalf(t, c.LocalAddr().Network(), "%v", err)
 145         }
 146
 147         if f, err := c.File(); err != nil {
 148                 condFatalf(t, "file+net", "%v", err)
 149         } else {
 150                 f.Close()
 151         }
 152
 153         defer func() {
 154                 if p := recover(); p != nil {
 155                         t.Fatalf("panicked: %v", p)
 156                 }
 157         }()
 158
 159         c.WriteToUDP(wb, nil)
 160         c.WriteMsgUDP(wb, nil, nil)
 161 }
 162
 163 func TestIPConnSpecificMethods(t *testing.T) {
 164         if os.Getuid() != 0 {
 165                 t.Skip("must be root")
 166         }
 167
 168         la, err := ResolveIPAddr("ip4", "127.0.0.1")
 169         if err != nil {
 170                 t.Fatal(err)
 171         }
 172         c, err := ListenIP("ip4:icmp", la)
 173         if err != nil {
 174                 t.Fatal(err)
 175         }
 176         defer c.Close()
 177         c.LocalAddr()
 178         c.RemoteAddr()
 179         c.SetDeadline(time.Now().Add(someTimeout))
 180         c.SetReadDeadline(time.Now().Add(someTimeout))
 181         c.SetWriteDeadline(time.Now().Add(someTimeout))
 182         c.SetReadBuffer(2048)
 183         c.SetWriteBuffer(2048)
 184
 185         if f, err := c.File(); err != nil {
 186                 condFatalf(t, "file+net", "%v", err)
 187         } else {
 188                 f.Close()
 189         }
 190
 191         defer func() {
 192                 if p := recover(); p != nil {
 193                         t.Fatalf("panicked: %v", p)
 194                 }
 195         }()
 196
 197         wb := []byte("IPCONN TEST")
 198         c.WriteToIP(wb, nil)
 199         c.WriteMsgIP(wb, nil, nil)
 200 }
 201
 202 func TestUnixListenerSpecificMethods(t *testing.T) {
 203         if !testableNetwork("unix") {
 204                 t.Skip("unix test")
 205         }
 206
 207         addr := testUnixAddr(t)
 208         la, err := ResolveUnixAddr("unix", addr)
 209         if err != nil {
 210                 t.Fatal(err)
 211         }
 212         ln, err := ListenUnix("unix", la)
 213         if err != nil {
 214                 t.Fatal(err)
 215         }
 216         defer ln.Close()
 217         defer os.Remove(addr)
 218         ln.Addr()
 219         ln.SetDeadline(time.Now().Add(30 * time.Nanosecond))
 220
 221         if c, err := ln.Accept(); err != nil {
 222                 if !err.(Error).Timeout() {
 223                         t.Fatal(err)
 224                 }
 225         } else {
 226                 c.Close()
 227         }
 228         if c, err := ln.AcceptUnix(); err != nil {
 229                 if !err.(Error).Timeout() {
 230                         t.Fatal(err)
 231                 }
 232         } else {
 233                 c.Close()
 234         }
 235
 236         if f, err := ln.File(); err != nil {
 237                 t.Fatal(err)
 238         } else {
 239                 f.Close()
 240         }
 241 }
 242
 243 func TestUnixConnSpecificMethods(t *testing.T) {
 244         if !testableNetwork("unixgram") {
 245                 t.Skip("unixgram test")
 246         }
 247
 248         addr1, addr2, addr3 := testUnixAddr(t), testUnixAddr(t), testUnixAddr(t)
 249
 250         a1, err := ResolveUnixAddr("unixgram", addr1)
 251         if err != nil {
 252                 t.Fatal(err)
 253         }
 254         c1, err := DialUnix("unixgram", a1, nil)
 255         if err != nil {
 256                 t.Fatal(err)
 257         }
 258         defer c1.Close()
 259         defer os.Remove(addr1)
 260         c1.LocalAddr()
 261         c1.RemoteAddr()
 262         c1.SetDeadline(time.Now().Add(someTimeout))
 263         c1.SetReadDeadline(time.Now().Add(someTimeout))
 264         c1.SetWriteDeadline(time.Now().Add(someTimeout))
 265         c1.SetReadBuffer(2048)
 266         c1.SetWriteBuffer(2048)
 267
 268         a2, err := ResolveUnixAddr("unixgram", addr2)
 269         if err != nil {
 270                 t.Fatal(err)
 271         }
 272         c2, err := DialUnix("unixgram", a2, nil)
 273         if err != nil {
 274                 t.Fatal(err)
 275         }
 276         defer c2.Close()
 277         defer os.Remove(addr2)
 278         c2.LocalAddr()
 279         c2.RemoteAddr()
 280         c2.SetDeadline(time.Now().Add(someTimeout))
 281         c2.SetReadDeadline(time.Now().Add(someTimeout))
 282         c2.SetWriteDeadline(time.Now().Add(someTimeout))
 283         c2.SetReadBuffer(2048)
 284         c2.SetWriteBuffer(2048)
 285
 286         a3, err := ResolveUnixAddr("unixgram", addr3)
 287         if err != nil {
 288                 t.Fatal(err)
 289         }
 290         c3, err := ListenUnixgram("unixgram", a3)
 291         if err != nil {
 292                 t.Fatal(err)
 293         }
 294         defer c3.Close()
 295         defer os.Remove(addr3)
 296         c3.LocalAddr()
 297         c3.RemoteAddr()
 298         c3.SetDeadline(time.Now().Add(someTimeout))
 299         c3.SetReadDeadline(time.Now().Add(someTimeout))
 300         c3.SetWriteDeadline(time.Now().Add(someTimeout))
 301         c3.SetReadBuffer(2048)
 302         c3.SetWriteBuffer(2048)
 303
 304         wb := []byte("UNIXCONN TEST")
 305         rb1 := make([]byte, 128)
 306         rb2 := make([]byte, 128)
 307         rb3 := make([]byte, 128)
 308         if _, _, err := c1.WriteMsgUnix(wb, nil, a2); err != nil {
 309                 t.Fatal(err)
 310         }
 311         if _, _, _, _, err := c2.ReadMsgUnix(rb2, nil); err != nil {
 312                 t.Fatal(err)
 313         }
 314         if _, err := c2.WriteToUnix(wb, a1); err != nil {
 315                 t.Fatal(err)
 316         }
 317         if _, _, err := c1.ReadFromUnix(rb1); err != nil {
 318                 t.Fatal(err)
 319         }
 320         if _, err := c3.WriteToUnix(wb, a1); err != nil {
 321                 t.Fatal(err)
 322         }
 323         if _, _, err := c1.ReadFromUnix(rb1); err != nil {
 324                 t.Fatal(err)
 325         }
 326         if _, err := c2.WriteToUnix(wb, a3); err != nil {
 327                 t.Fatal(err)
 328         }
 329         if _, _, err := c3.ReadFromUnix(rb3); err != nil {
 330                 t.Fatal(err)
 331         }
 332
 333         if f, err := c1.File(); err != nil {
 334                 t.Fatal(err)
 335         } else {
 336                 f.Close()
 337         }
 338
 339         defer func() {
 340                 if p := recover(); p != nil {
 341                         t.Fatalf("panicked: %v", p)
 342                 }
 343         }()
 344
 345         c1.WriteToUnix(wb, nil)
 346         c1.WriteMsgUnix(wb, nil, nil)
 347         c3.WriteToUnix(wb, nil)
 348         c3.WriteMsgUnix(wb, nil, nil)
 349 }