...
Run Format

Source file src/net/file_test.go

Documentation: net

  // Copyright 2011 The Go Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
  
  package net
  
  import (
  	"os"
  	"reflect"
  	"runtime"
  	"sync"
  	"testing"
  )
  
  // The full stack test cases for IPConn have been moved to the
  // following:
  //      golang.org/x/net/ipv4
  //      golang.org/x/net/ipv6
  //      golang.org/x/net/icmp
  
  var fileConnTests = []struct {
  	network string
  }{
  	{"tcp"},
  	{"udp"},
  	{"unix"},
  	{"unixpacket"},
  }
  
  func TestFileConn(t *testing.T) {
  	switch runtime.GOOS {
  	case "nacl", "plan9", "windows":
  		t.Skipf("not supported on %s", runtime.GOOS)
  	}
  
  	for _, tt := range fileConnTests {
  		if !testableNetwork(tt.network) {
  			t.Logf("skipping %s test", tt.network)
  			continue
  		}
  
  		var network, address string
  		switch tt.network {
  		case "udp":
  			c, err := newLocalPacketListener(tt.network)
  			if err != nil {
  				t.Fatal(err)
  			}
  			defer c.Close()
  			network = c.LocalAddr().Network()
  			address = c.LocalAddr().String()
  		default:
  			handler := func(ls *localServer, ln Listener) {
  				c, err := ln.Accept()
  				if err != nil {
  					return
  				}
  				defer c.Close()
  				var b [1]byte
  				c.Read(b[:])
  			}
  			ls, err := newLocalServer(tt.network)
  			if err != nil {
  				t.Fatal(err)
  			}
  			defer ls.teardown()
  			if err := ls.buildup(handler); err != nil {
  				t.Fatal(err)
  			}
  			network = ls.Listener.Addr().Network()
  			address = ls.Listener.Addr().String()
  		}
  
  		c1, err := Dial(network, address)
  		if err != nil {
  			if perr := parseDialError(err); perr != nil {
  				t.Error(perr)
  			}
  			t.Fatal(err)
  		}
  		addr := c1.LocalAddr()
  
  		var f *os.File
  		switch c1 := c1.(type) {
  		case *TCPConn:
  			f, err = c1.File()
  		case *UDPConn:
  			f, err = c1.File()
  		case *UnixConn:
  			f, err = c1.File()
  		}
  		if err := c1.Close(); err != nil {
  			if perr := parseCloseError(err, false); perr != nil {
  				t.Error(perr)
  			}
  			t.Error(err)
  		}
  		if err != nil {
  			if perr := parseCommonError(err); perr != nil {
  				t.Error(perr)
  			}
  			t.Fatal(err)
  		}
  
  		c2, err := FileConn(f)
  		if err := f.Close(); err != nil {
  			t.Error(err)
  		}
  		if err != nil {
  			if perr := parseCommonError(err); perr != nil {
  				t.Error(perr)
  			}
  			t.Fatal(err)
  		}
  		defer c2.Close()
  
  		if _, err := c2.Write([]byte("FILECONN TEST")); err != nil {
  			if perr := parseWriteError(err); perr != nil {
  				t.Error(perr)
  			}
  			t.Fatal(err)
  		}
  		if !reflect.DeepEqual(c2.LocalAddr(), addr) {
  			t.Fatalf("got %#v; want %#v", c2.LocalAddr(), addr)
  		}
  	}
  }
  
  var fileListenerTests = []struct {
  	network string
  }{
  	{"tcp"},
  	{"unix"},
  	{"unixpacket"},
  }
  
  func TestFileListener(t *testing.T) {
  	switch runtime.GOOS {
  	case "nacl", "plan9", "windows":
  		t.Skipf("not supported on %s", runtime.GOOS)
  	}
  
  	for _, tt := range fileListenerTests {
  		if !testableNetwork(tt.network) {
  			t.Logf("skipping %s test", tt.network)
  			continue
  		}
  
  		ln1, err := newLocalListener(tt.network)
  		if err != nil {
  			t.Fatal(err)
  		}
  		switch tt.network {
  		case "unix", "unixpacket":
  			defer os.Remove(ln1.Addr().String())
  		}
  		addr := ln1.Addr()
  
  		var f *os.File
  		switch ln1 := ln1.(type) {
  		case *TCPListener:
  			f, err = ln1.File()
  		case *UnixListener:
  			f, err = ln1.File()
  		}
  		switch tt.network {
  		case "unix", "unixpacket":
  			defer ln1.Close() // UnixListener.Close calls syscall.Unlink internally
  		default:
  			if err := ln1.Close(); err != nil {
  				t.Error(err)
  			}
  		}
  		if err != nil {
  			if perr := parseCommonError(err); perr != nil {
  				t.Error(perr)
  			}
  			t.Fatal(err)
  		}
  
  		ln2, err := FileListener(f)
  		if err := f.Close(); err != nil {
  			t.Error(err)
  		}
  		if err != nil {
  			if perr := parseCommonError(err); perr != nil {
  				t.Error(perr)
  			}
  			t.Fatal(err)
  		}
  		defer ln2.Close()
  
  		var wg sync.WaitGroup
  		wg.Add(1)
  		go func() {
  			defer wg.Done()
  			c, err := Dial(ln2.Addr().Network(), ln2.Addr().String())
  			if err != nil {
  				if perr := parseDialError(err); perr != nil {
  					t.Error(perr)
  				}
  				t.Error(err)
  				return
  			}
  			c.Close()
  		}()
  		c, err := ln2.Accept()
  		if err != nil {
  			if perr := parseAcceptError(err); perr != nil {
  				t.Error(perr)
  			}
  			t.Fatal(err)
  		}
  		c.Close()
  		wg.Wait()
  		if !reflect.DeepEqual(ln2.Addr(), addr) {
  			t.Fatalf("got %#v; want %#v", ln2.Addr(), addr)
  		}
  	}
  }
  
  var filePacketConnTests = []struct {
  	network string
  }{
  	{"udp"},
  	{"unixgram"},
  }
  
  func TestFilePacketConn(t *testing.T) {
  	switch runtime.GOOS {
  	case "nacl", "plan9", "windows":
  		t.Skipf("not supported on %s", runtime.GOOS)
  	}
  
  	for _, tt := range filePacketConnTests {
  		if !testableNetwork(tt.network) {
  			t.Logf("skipping %s test", tt.network)
  			continue
  		}
  
  		c1, err := newLocalPacketListener(tt.network)
  		if err != nil {
  			t.Fatal(err)
  		}
  		switch tt.network {
  		case "unixgram":
  			defer os.Remove(c1.LocalAddr().String())
  		}
  		addr := c1.LocalAddr()
  
  		var f *os.File
  		switch c1 := c1.(type) {
  		case *UDPConn:
  			f, err = c1.File()
  		case *UnixConn:
  			f, err = c1.File()
  		}
  		if err := c1.Close(); err != nil {
  			if perr := parseCloseError(err, false); perr != nil {
  				t.Error(perr)
  			}
  			t.Error(err)
  		}
  		if err != nil {
  			if perr := parseCommonError(err); perr != nil {
  				t.Error(perr)
  			}
  			t.Fatal(err)
  		}
  
  		c2, err := FilePacketConn(f)
  		if err := f.Close(); err != nil {
  			t.Error(err)
  		}
  		if err != nil {
  			if perr := parseCommonError(err); perr != nil {
  				t.Error(perr)
  			}
  			t.Fatal(err)
  		}
  		defer c2.Close()
  
  		if _, err := c2.WriteTo([]byte("FILEPACKETCONN TEST"), addr); err != nil {
  			if perr := parseWriteError(err); perr != nil {
  				t.Error(perr)
  			}
  			t.Fatal(err)
  		}
  		if !reflect.DeepEqual(c2.LocalAddr(), addr) {
  			t.Fatalf("got %#v; want %#v", c2.LocalAddr(), addr)
  		}
  	}
  }
  

View as plain text