...
Run Format

Source file src/net/file_test.go

Documentation: net

     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  	"sync"
    12  	"testing"
    13  )
    14  
    15  // The full stack test cases for IPConn have been moved to the
    16  // following:
    17  //      golang.org/x/net/ipv4
    18  //      golang.org/x/net/ipv6
    19  //      golang.org/x/net/icmp
    20  
    21  var fileConnTests = []struct {
    22  	network string
    23  }{
    24  	{"tcp"},
    25  	{"udp"},
    26  	{"unix"},
    27  	{"unixpacket"},
    28  }
    29  
    30  func TestFileConn(t *testing.T) {
    31  	switch runtime.GOOS {
    32  	case "nacl", "plan9", "windows":
    33  		t.Skipf("not supported on %s", runtime.GOOS)
    34  	}
    35  
    36  	for _, tt := range fileConnTests {
    37  		if !testableNetwork(tt.network) {
    38  			t.Logf("skipping %s test", tt.network)
    39  			continue
    40  		}
    41  
    42  		var network, address string
    43  		switch tt.network {
    44  		case "udp":
    45  			c, err := newLocalPacketListener(tt.network)
    46  			if err != nil {
    47  				t.Fatal(err)
    48  			}
    49  			defer c.Close()
    50  			network = c.LocalAddr().Network()
    51  			address = c.LocalAddr().String()
    52  		default:
    53  			handler := func(ls *localServer, ln Listener) {
    54  				c, err := ln.Accept()
    55  				if err != nil {
    56  					return
    57  				}
    58  				defer c.Close()
    59  				var b [1]byte
    60  				c.Read(b[:])
    61  			}
    62  			ls, err := newLocalServer(tt.network)
    63  			if err != nil {
    64  				t.Fatal(err)
    65  			}
    66  			defer ls.teardown()
    67  			if err := ls.buildup(handler); err != nil {
    68  				t.Fatal(err)
    69  			}
    70  			network = ls.Listener.Addr().Network()
    71  			address = ls.Listener.Addr().String()
    72  		}
    73  
    74  		c1, err := Dial(network, address)
    75  		if err != nil {
    76  			if perr := parseDialError(err); perr != nil {
    77  				t.Error(perr)
    78  			}
    79  			t.Fatal(err)
    80  		}
    81  		addr := c1.LocalAddr()
    82  
    83  		var f *os.File
    84  		switch c1 := c1.(type) {
    85  		case *TCPConn:
    86  			f, err = c1.File()
    87  		case *UDPConn:
    88  			f, err = c1.File()
    89  		case *UnixConn:
    90  			f, err = c1.File()
    91  		}
    92  		if err := c1.Close(); err != nil {
    93  			if perr := parseCloseError(err, false); perr != nil {
    94  				t.Error(perr)
    95  			}
    96  			t.Error(err)
    97  		}
    98  		if err != nil {
    99  			if perr := parseCommonError(err); perr != nil {
   100  				t.Error(perr)
   101  			}
   102  			t.Fatal(err)
   103  		}
   104  
   105  		c2, err := FileConn(f)
   106  		if err := f.Close(); err != nil {
   107  			t.Error(err)
   108  		}
   109  		if err != nil {
   110  			if perr := parseCommonError(err); perr != nil {
   111  				t.Error(perr)
   112  			}
   113  			t.Fatal(err)
   114  		}
   115  		defer c2.Close()
   116  
   117  		if _, err := c2.Write([]byte("FILECONN TEST")); err != nil {
   118  			if perr := parseWriteError(err); perr != nil {
   119  				t.Error(perr)
   120  			}
   121  			t.Fatal(err)
   122  		}
   123  		if !reflect.DeepEqual(c2.LocalAddr(), addr) {
   124  			t.Fatalf("got %#v; want %#v", c2.LocalAddr(), addr)
   125  		}
   126  	}
   127  }
   128  
   129  var fileListenerTests = []struct {
   130  	network string
   131  }{
   132  	{"tcp"},
   133  	{"unix"},
   134  	{"unixpacket"},
   135  }
   136  
   137  func TestFileListener(t *testing.T) {
   138  	switch runtime.GOOS {
   139  	case "nacl", "plan9", "windows":
   140  		t.Skipf("not supported on %s", runtime.GOOS)
   141  	}
   142  
   143  	for _, tt := range fileListenerTests {
   144  		if !testableNetwork(tt.network) {
   145  			t.Logf("skipping %s test", tt.network)
   146  			continue
   147  		}
   148  
   149  		ln1, err := newLocalListener(tt.network)
   150  		if err != nil {
   151  			t.Fatal(err)
   152  		}
   153  		switch tt.network {
   154  		case "unix", "unixpacket":
   155  			defer os.Remove(ln1.Addr().String())
   156  		}
   157  		addr := ln1.Addr()
   158  
   159  		var f *os.File
   160  		switch ln1 := ln1.(type) {
   161  		case *TCPListener:
   162  			f, err = ln1.File()
   163  		case *UnixListener:
   164  			f, err = ln1.File()
   165  		}
   166  		switch tt.network {
   167  		case "unix", "unixpacket":
   168  			defer ln1.Close() // UnixListener.Close calls syscall.Unlink internally
   169  		default:
   170  			if err := ln1.Close(); err != nil {
   171  				t.Error(err)
   172  			}
   173  		}
   174  		if err != nil {
   175  			if perr := parseCommonError(err); perr != nil {
   176  				t.Error(perr)
   177  			}
   178  			t.Fatal(err)
   179  		}
   180  
   181  		ln2, err := FileListener(f)
   182  		if err := f.Close(); err != nil {
   183  			t.Error(err)
   184  		}
   185  		if err != nil {
   186  			if perr := parseCommonError(err); perr != nil {
   187  				t.Error(perr)
   188  			}
   189  			t.Fatal(err)
   190  		}
   191  		defer ln2.Close()
   192  
   193  		var wg sync.WaitGroup
   194  		wg.Add(1)
   195  		go func() {
   196  			defer wg.Done()
   197  			c, err := Dial(ln2.Addr().Network(), ln2.Addr().String())
   198  			if err != nil {
   199  				if perr := parseDialError(err); perr != nil {
   200  					t.Error(perr)
   201  				}
   202  				t.Error(err)
   203  				return
   204  			}
   205  			c.Close()
   206  		}()
   207  		c, err := ln2.Accept()
   208  		if err != nil {
   209  			if perr := parseAcceptError(err); perr != nil {
   210  				t.Error(perr)
   211  			}
   212  			t.Fatal(err)
   213  		}
   214  		c.Close()
   215  		wg.Wait()
   216  		if !reflect.DeepEqual(ln2.Addr(), addr) {
   217  			t.Fatalf("got %#v; want %#v", ln2.Addr(), addr)
   218  		}
   219  	}
   220  }
   221  
   222  var filePacketConnTests = []struct {
   223  	network string
   224  }{
   225  	{"udp"},
   226  	{"unixgram"},
   227  }
   228  
   229  func TestFilePacketConn(t *testing.T) {
   230  	switch runtime.GOOS {
   231  	case "nacl", "plan9", "windows":
   232  		t.Skipf("not supported on %s", runtime.GOOS)
   233  	}
   234  
   235  	for _, tt := range filePacketConnTests {
   236  		if !testableNetwork(tt.network) {
   237  			t.Logf("skipping %s test", tt.network)
   238  			continue
   239  		}
   240  
   241  		c1, err := newLocalPacketListener(tt.network)
   242  		if err != nil {
   243  			t.Fatal(err)
   244  		}
   245  		switch tt.network {
   246  		case "unixgram":
   247  			defer os.Remove(c1.LocalAddr().String())
   248  		}
   249  		addr := c1.LocalAddr()
   250  
   251  		var f *os.File
   252  		switch c1 := c1.(type) {
   253  		case *UDPConn:
   254  			f, err = c1.File()
   255  		case *UnixConn:
   256  			f, err = c1.File()
   257  		}
   258  		if err := c1.Close(); err != nil {
   259  			if perr := parseCloseError(err, false); perr != nil {
   260  				t.Error(perr)
   261  			}
   262  			t.Error(err)
   263  		}
   264  		if err != nil {
   265  			if perr := parseCommonError(err); perr != nil {
   266  				t.Error(perr)
   267  			}
   268  			t.Fatal(err)
   269  		}
   270  
   271  		c2, err := FilePacketConn(f)
   272  		if err := f.Close(); err != nil {
   273  			t.Error(err)
   274  		}
   275  		if err != nil {
   276  			if perr := parseCommonError(err); perr != nil {
   277  				t.Error(perr)
   278  			}
   279  			t.Fatal(err)
   280  		}
   281  		defer c2.Close()
   282  
   283  		if _, err := c2.WriteTo([]byte("FILEPACKETCONN TEST"), addr); err != nil {
   284  			if perr := parseWriteError(err); perr != nil {
   285  				t.Error(perr)
   286  			}
   287  			t.Fatal(err)
   288  		}
   289  		if !reflect.DeepEqual(c2.LocalAddr(), addr) {
   290  			t.Fatalf("got %#v; want %#v", c2.LocalAddr(), addr)
   291  		}
   292  	}
   293  }
   294  

View as plain text