...
Run Format

Source file src/net/protoconn_test.go

Documentation: net

     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  }
   353  

View as plain text