mirror of
https://github.com/autc04/Retro68.git
synced 2024-09-08 20:55:01 +00:00
294 lines
5.6 KiB
Go
294 lines
5.6 KiB
Go
// 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)
|
|
}
|
|
}
|
|
}
|