This change simplifies unnecessarily redundant error messages in tests.
There's no need to worry any more because package APIs now return
consistent, self-descriptive error values.
Alos renames ambiguous test functions and makes use of test tables.
Change-Id: I7b61027607c4ae2a3cf605d08d58cf449fa27eb2
Reviewed-on: https://go-review.googlesource.com/9662
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Mikio Hara <mikioh.mikioh@gmail.com>
t.Errorf("cgoLookupIP must not be a placeholder")
}
if err != nil {
- t.Errorf("cgoLookupIP failed: %v", err)
+ t.Error(err)
}
if _, err := goLookupIP(host); err != nil {
- t.Errorf("goLookupIP failed: %v", err)
+ t.Error(err)
}
}
for _, ht := range tt.hostTests {
gotOrder := tt.c.hostLookupOrder(ht.host)
if gotOrder != ht.want {
- t.Errorf("%s: useCgoLookupHost(%q) = %v; want %v", tt.name, ht.host, gotOrder, ht.want)
+ t.Errorf("%s: hostLookupOrder(%q) = %v; want %v", tt.name, ht.host, gotOrder, ht.want)
}
}
}
ls, err := newLocalServer(network)
if err != nil {
- t.Fatalf("Listen failed: %v", err)
+ t.Fatal(err)
}
defer ls.teardown()
ch := make(chan error, 1)
c, err := Dial(ls.Listener.Addr().Network(), ls.Listener.Addr().String())
if err != nil {
- t.Fatalf("Dial failed: %v", err)
+ t.Fatal(err)
}
defer c.Close()
if c.LocalAddr().Network() != network || c.LocalAddr().Network() != network {
- t.Fatalf("got %v->%v; want %v->%v", c.LocalAddr().Network(), c.RemoteAddr().Network(), network, network)
+ t.Fatalf("got %s->%s; want %s->%s", c.LocalAddr().Network(), c.RemoteAddr().Network(), network, network)
}
c.SetDeadline(time.Now().Add(someTimeout))
c.SetReadDeadline(time.Now().Add(someTimeout))
c.SetWriteDeadline(time.Now().Add(someTimeout))
- if _, err := c.Write([]byte("CONN TEST")); err != nil {
- t.Fatalf("Conn.Write failed: %v", err)
+ if _, err := c.Write([]byte("CONN AND LISTENER TEST")); err != nil {
+ t.Fatal(err)
}
rb := make([]byte, 128)
if _, err := c.Read(rb); err != nil {
- t.Fatalf("Conn.Read failed: %v", err)
+ t.Fatal(err)
}
for err := range ch {
package net
import (
- "fmt"
"net/internal/socktest"
"runtime"
"sync"
func TestSelfConnect(t *testing.T) {
if runtime.GOOS == "windows" {
// TODO(brainman): do not know why it hangs.
- t.Skip("skipping known-broken test on windows")
+ t.Skip("known-broken test on windows")
}
// Test that Dial does not honor self-connects.
handler := func(ls *localServer, ln Listener) {
c, err := ln.Accept()
if err != nil {
- ch <- fmt.Errorf("Accept failed: %v", err)
+ ch <- err
return
}
defer c.Close()
laddr, err := ResolveTCPAddr(ls.Listener.Addr().Network(), ls.Listener.Addr().String())
if err != nil {
- t.Fatalf("ResolveTCPAddr failed: %v", err)
+ t.Fatal(err)
}
laddr.Port = 0
d := &Dialer{LocalAddr: laddr}
c, err := d.Dial(ls.Listener.Addr().Network(), ls.Addr().String())
if err != nil {
- t.Fatalf("Dial failed: %v", err)
+ t.Fatal(err)
}
defer c.Close()
c.Read(make([]byte, 1))
if err := ls.buildup(handler); err != nil {
t.Fatal(err)
}
- defer func() {
- testHookSetKeepAlive = func() {}
- }()
+ defer func() { testHookSetKeepAlive = func() {} }()
for _, keepAlive := range []bool{false, true} {
got := false
checkDistribution(t, data, margin)
}
-func TestUniformity(t *testing.T) {
+func TestDNSSRVUniformity(t *testing.T) {
testUniformity(t, 2, 0.05)
testUniformity(t, 3, 0.10)
testUniformity(t, 10, 0.20)
func TestDNSTransportFallback(t *testing.T) {
if testing.Short() || !*testExternal {
- t.Skip("skipping test to avoid external network")
+ t.Skip("avoid external network")
}
for _, tt := range dnsTransportFallbackTests {
func TestSpecialDomainName(t *testing.T) {
if testing.Short() || !*testExternal {
- t.Skip("skipping test to avoid external network")
+ t.Skip("avoid external network")
}
server := "8.8.8.8:53"
func newResolvConfTest(t *testing.T) *resolvConfTest {
dir, err := ioutil.TempDir("", "resolvConfTest")
if err != nil {
- t.Fatalf("could not create temp dir: %v", err)
+ t.Fatal(err)
}
// Disable the default loadConfig
cfg.mu.RLock()
defer cfg.mu.RUnlock()
if got := cfg.dnsConfig.servers; !reflect.DeepEqual(got, want) {
- r.Fatalf("Unexpected dns server loaded, got %v want %v", got, want)
+ r.Fatalf("unexpected dns server loaded, got %v want %v", got, want)
}
}
func TestReloadResolvConfFail(t *testing.T) {
if testing.Short() || !*testExternal {
- t.Skip("skipping test to avoid external network")
+ t.Skip("avoid external network")
}
r := newResolvConfTest(t)
r.SetConf("nameserver 8.8.8.8")
if _, err := goLookupIP("golang.org"); err != nil {
- t.Fatalf("goLookupIP(missing; good) failed: %v", err)
+ t.Fatal(err)
}
// Using an empty resolv.conf should use localhost as servers
t.Fatalf("goLookupIP(missing; good; bad) failed: servers=%v, want: %v", cfg.dnsConfig.servers, defaultNS)
}
}
-
}
func TestReloadResolvConfChange(t *testing.T) {
if testing.Short() || !*testExternal {
- t.Skip("skipping test to avoid external network")
+ t.Skip("avoid external network")
}
r := newResolvConfTest(t)
r.SetConf("nameserver 8.8.8.8")
if _, err := goLookupIP("golang.org"); err != nil {
- t.Fatalf("goLookupIP(good) failed: %v", err)
+ t.Fatal(err)
}
r.WantServers([]string{"8.8.8.8"})
t.Fatal(conf.err)
}
if !reflect.DeepEqual(conf, tt.want) {
- t.Errorf("%s:\n got: %+v\nwant: %+v", tt.name, conf, tt.want)
+ t.Errorf("%s:\ngot: %+v\nwant: %+v", tt.name, conf, tt.want)
}
}
}
func TestDNSReadMissingFile(t *testing.T) {
conf := dnsReadConfig("a-nonexistent-file")
if !os.IsNotExist(conf.err) {
- t.Errorf("Missing resolv.conf:\n got: %v\nwant: %v", conf.err, os.ErrNotExist)
+ t.Errorf("missing resolv.conf:\ngot: %v\nwant: %v", conf.err, os.ErrNotExist)
}
conf.err = nil
want := &dnsConfig{
attempts: 2,
}
if !reflect.DeepEqual(conf, want) {
- t.Errorf("Missing resolv.conf:\n got: %+v\nwant: %+v", conf, want)
+ t.Errorf("missing resolv.conf:\ngot: %+v\nwant: %+v", conf, want)
}
}
msg := new(dnsMsg)
ok := msg.Unpack(data)
if !ok {
- t.Fatalf("unpacking packet failed")
+ t.Fatal("unpacking packet failed")
}
msg.String() // exercise this code path
if g, e := len(msg.answer), 5; g != e {
"testing"
)
-type testCase struct {
+type dnsNameTest struct {
name string
result bool
}
-var tests = []testCase{
+var dnsNameTests = []dnsNameTest{
// RFC2181, section 11.
{"_xmpp-server._tcp.google.com", true},
{"foo.com", true},
{"b.com.", true},
}
-func getTestCases(ch chan<- testCase) {
+func emitDNSNameTest(ch chan<- dnsNameTest) {
defer close(ch)
var char59 = ""
var char63 = ""
char63 = char59 + "aaaa"
char64 = char63 + "a"
- for _, tc := range tests {
+ for _, tc := range dnsNameTests {
ch <- tc
}
- ch <- testCase{char63 + ".com", true}
- ch <- testCase{char64 + ".com", false}
+ ch <- dnsNameTest{char63 + ".com", true}
+ ch <- dnsNameTest{char64 + ".com", false}
// 255 char name is fine:
- ch <- testCase{char59 + "." + char63 + "." + char63 + "." +
+ ch <- dnsNameTest{char59 + "." + char63 + "." + char63 + "." +
char63 + ".com",
true}
// 256 char name is bad:
- ch <- testCase{char59 + "a." + char63 + "." + char63 + "." +
+ ch <- dnsNameTest{char59 + "a." + char63 + "." + char63 + "." +
char63 + ".com",
false}
}
-func TestDNSNames(t *testing.T) {
- ch := make(chan testCase)
- go getTestCases(ch)
+func TestDNSName(t *testing.T) {
+ ch := make(chan dnsNameTest)
+ go emitDNSNameTest(ch)
for tc := range ch {
if isDomainName(tc.name) != tc.result {
- t.Errorf("isDomainName(%v) failed: Should be %v",
- tc.name, tc.result)
+ t.Errorf("isDomainName(%q) = %v; want %v", tc.name, !tc.result, tc.result)
}
}
}
-func BenchmarkDNSNames(b *testing.B) {
+func BenchmarkDNSName(b *testing.B) {
testHookUninstaller.Do(func() { uninstallTestHooks() })
- benchmarks := append(tests, []testCase{
+ benchmarks := append(dnsNameTests, []dnsNameTest{
{strings.Repeat("a", 63), true},
{strings.Repeat("a", 64), false},
}...)
func testFileListener(t *testing.T, net, laddr string) {
l, err := Listen(net, laddr)
if err != nil {
- t.Fatalf("Listen failed: %v", err)
+ t.Fatal(err)
}
defer l.Close()
lf := l.(listenerFile)
f, err := lf.File()
if err != nil {
- t.Fatalf("File failed: %v", err)
+ t.Fatal(err)
}
c, err := FileListener(f)
if err != nil {
- t.Fatalf("FileListener failed: %v", err)
+ t.Fatal(err)
}
if !reflect.DeepEqual(l.Addr(), c.Addr()) {
- t.Fatalf("Addrs not equal: %#v != %#v", l.Addr(), c.Addr())
+ t.Fatalf("got %#v; want%#v", l.Addr(), c.Addr())
}
if err := c.Close(); err != nil {
- t.Fatalf("Close failed: %v", err)
+ t.Fatal(err)
}
if err := f.Close(); err != nil {
- t.Fatalf("Close failed: %v", err)
+ t.Fatal(err)
}
}
func TestFileListener(t *testing.T) {
switch runtime.GOOS {
case "nacl", "windows":
- t.Skipf("skipping test on %q", runtime.GOOS)
+ t.Skipf("not supported on %s", runtime.GOOS)
}
for _, tt := range fileListenerTests {
if !testableListenArgs(tt.net, tt.laddr, "") {
- t.Logf("skipping %s test", tt.net+":"+tt.laddr+"->")
+ t.Logf("skipping %s test", tt.net+" "+tt.laddr)
continue
}
testFileListener(t, tt.net, tt.laddr)
func testFilePacketConn(t *testing.T, pcf packetConnFile, listen bool) {
f, err := pcf.File()
if err != nil {
- t.Fatalf("File failed: %v", err)
+ t.Fatal(err)
}
c, err := FilePacketConn(f)
if err != nil {
- t.Fatalf("FilePacketConn failed: %v", err)
+ t.Fatal(err)
}
if !reflect.DeepEqual(pcf.LocalAddr(), c.LocalAddr()) {
- t.Fatalf("LocalAddrs not equal: %#v != %#v", pcf.LocalAddr(), c.LocalAddr())
+ t.Fatalf("got %#v; want %#v", pcf.LocalAddr(), c.LocalAddr())
}
if listen {
if _, err := c.WriteTo([]byte{}, c.LocalAddr()); err != nil {
- t.Fatalf("WriteTo failed: %v", err)
+ t.Fatal(err)
}
}
if err := c.Close(); err != nil {
- t.Fatalf("Close failed: %v", err)
+ t.Fatal(err)
}
if err := f.Close(); err != nil {
- t.Fatalf("Close failed: %v", err)
+ t.Fatal(err)
}
}
func testFilePacketConnListen(t *testing.T, net, laddr string) {
l, err := ListenPacket(net, laddr)
if err != nil {
- t.Fatalf("ListenPacket failed: %v", err)
+ t.Fatal(err)
}
testFilePacketConn(t, l.(packetConnFile), true)
if err := l.Close(); err != nil {
- t.Fatalf("Close failed: %v", err)
+ t.Fatal(err)
}
}
func testFilePacketConnDial(t *testing.T, net, raddr string) {
c, err := Dial(net, raddr)
if err != nil {
- t.Fatalf("Dial failed: %v", err)
+ t.Fatal(err)
}
testFilePacketConn(t, c.(packetConnFile), false)
if err := c.Close(); err != nil {
- t.Fatalf("Close failed: %v", err)
+ t.Fatal(err)
}
}
func TestFilePacketConn(t *testing.T) {
switch runtime.GOOS {
case "nacl", "plan9", "windows":
- t.Skipf("skipping test on %q", runtime.GOOS)
+ t.Skipf("not supported on %s", runtime.GOOS)
}
for _, tt := range filePacketConnTests {
if !testableListenArgs(tt.net, tt.addr, "") {
- t.Logf("skipping %s test", tt.net+":"+tt.addr+"->")
+ t.Logf("skipping %s test", tt.net+" "+tt.addr)
continue
}
if os.Getuid() != 0 && tt.net == "ip4:icmp" {
tt := hosttests[i]
ips := lookupStaticHost(tt.host)
if len(ips) != len(tt.ips) {
- t.Errorf("# of hosts = %v; want %v",
- len(ips), len(tt.ips))
+ t.Errorf("# of hosts = %v; want %v", len(ips), len(tt.ips))
continue
}
for k, v := range ips {
if tt.ips[k].String() != v {
- t.Errorf("lookupStaticHost(%q) = %v; want %v",
- tt.host, v, tt.ips[k])
+ t.Errorf("lookupStaticHost(%q) = %v; want %v", tt.host, v, tt.ips[k])
}
}
}
func TestParseProcNet(t *testing.T) {
defer func() {
if p := recover(); p != nil {
- t.Fatalf("parseProcNetIGMP or parseProtNetIGMP6 panicked: %v", p)
+ t.Fatalf("panicked: %v", p)
}
}()
ifmat4 = append(ifmat4, ifmat...)
}
if len(ifmat4) != numOfTestIPv4MCAddrs {
- t.Fatalf("parseProcNetIGMP returns %v addresses, expected %v", len(ifmat4), numOfTestIPv4MCAddrs)
+ t.Fatalf("got %d; want %d", len(ifmat4), numOfTestIPv4MCAddrs)
}
var ifmat6 []Addr
ifmat6 = append(ifmat6, ifmat...)
}
if len(ifmat6) != numOfTestIPv6MCAddrs {
- t.Fatalf("parseProcNetIGMP6 returns %v addresses, expected %v", len(ifmat6), numOfTestIPv6MCAddrs)
+ t.Fatalf("got %d; want %d", len(ifmat6), numOfTestIPv6MCAddrs)
}
}
func TestPointToPointInterface(t *testing.T) {
if testing.Short() {
- t.Skip("skipping test in short mode")
+ t.Skip("avoid external network")
}
- switch {
- case runtime.GOOS == "darwin":
- t.Skipf("skipping read test on %q", runtime.GOOS)
+ if runtime.GOOS == "darwin" {
+ t.Skipf("not supported on %s", runtime.GOOS)
}
if os.Getuid() != 0 {
- t.Skip("skipping test; must be root")
+ t.Skip("must be root")
}
local, remote := "169.254.0.1", "169.254.0.254"
t.Skipf("test requries external command: %v", err)
}
if err := ti.setup(); err != nil {
- t.Fatalf("testInterface.setup failed: %v", err)
+ t.Fatal(err)
} else {
time.Sleep(3 * time.Millisecond)
}
ift, err := Interfaces()
if err != nil {
ti.teardown()
- t.Fatalf("Interfaces failed: %v", err)
+ t.Fatal(err)
}
for _, ifi := range ift {
if ti.name == ifi.Name {
ifat, err := ifi.Addrs()
if err != nil {
ti.teardown()
- t.Fatalf("Interface.Addrs failed: %v", err)
+ t.Fatal(err)
}
for _, ifa := range ifat {
if ip.Equal(ifa.(*IPNet).IP) {
}
}
if err := ti.teardown(); err != nil {
- t.Fatalf("testInterface.teardown failed: %v", err)
+ t.Fatal(err)
} else {
time.Sleep(3 * time.Millisecond)
}
func TestInterfaceArrivalAndDeparture(t *testing.T) {
if testing.Short() {
- t.Skip("skipping test in short mode")
+ t.Skip("avoid external network")
}
if os.Getuid() != 0 {
- t.Skip("skipping test; must be root")
+ t.Skip("must be root")
}
for i := 0; i < 3; i++ {
ift1, err := Interfaces()
if err != nil {
- t.Fatalf("Interfaces failed: %v", err)
+ t.Fatal(err)
}
ti := &testInterface{}
if err := ti.setBroadcast(5682 + i); err != nil {
t.Skipf("test requires external command: %v", err)
}
if err := ti.setup(); err != nil {
- t.Fatalf("testInterface.setup failed: %v", err)
+ t.Fatal(err)
} else {
time.Sleep(3 * time.Millisecond)
}
ift2, err := Interfaces()
if err != nil {
ti.teardown()
- t.Fatalf("Interfaces failed: %v", err)
+ t.Fatal(err)
}
if len(ift2) <= len(ift1) {
for _, ifi := range ift1 {
t.Fatalf("got %v; want gt %v", len(ift2), len(ift1))
}
if err := ti.teardown(); err != nil {
- t.Fatalf("testInterface.teardown failed: %v", err)
+ t.Fatal(err)
} else {
time.Sleep(3 * time.Millisecond)
}
ift3, err := Interfaces()
if err != nil {
- t.Fatalf("Interfaces failed: %v", err)
+ t.Fatal(err)
}
if len(ift3) >= len(ift2) {
for _, ifi := range ift2 {
}
c, err := ListenIP(tt.net, tt.laddr)
if err != nil {
- t.Fatalf("ListenIP failed: %v", err)
+ t.Fatal(err)
}
defer c.Close()
if la := c.LocalAddr(); la == nil {
- t.Fatal("IPConn.LocalAddr failed")
+ t.Fatal("should not fail")
}
}
}
raddr := &IPAddr{IP: IPv4(127, 0, 0, 1).To4()}
c, err := DialIP("ip:tcp", &IPAddr{IP: IPv4(127, 0, 0, 1)}, raddr)
if err != nil {
- t.Fatalf("DialIP failed: %v", err)
+ t.Fatal(err)
}
defer c.Close()
if !reflect.DeepEqual(raddr, c.RemoteAddr()) {
- t.Fatalf("got %#v, expected %#v", c.RemoteAddr(), raddr)
+ t.Fatalf("got %#v; want %#v", c.RemoteAddr(), raddr)
}
}
defer func() {
if p := recover(); p != nil {
- t.Fatal("panicked: %v", p)
+ t.Fatalf("panicked: %v", p)
}
}()
func TestLookupGoogleSRV(t *testing.T) {
if testing.Short() || !*testExternal {
- t.Skip("skipping test to avoid external network")
+ t.Skip("avoid external network")
}
for _, tt := range lookupGoogleSRVTests {
func TestLookupGmailMX(t *testing.T) {
if testing.Short() || !*testExternal {
- t.Skip("skipping test to avoid external network")
+ t.Skip("avoid external network")
}
mxs, err := LookupMX("gmail.com")
func TestLookupGmailNS(t *testing.T) {
if testing.Short() || !*testExternal {
- t.Skip("skipping test to avoid external network")
+ t.Skip("avoid external network")
}
nss, err := LookupNS("gmail.com")
func TestLookupGmailTXT(t *testing.T) {
if testing.Short() || !*testExternal {
- t.Skip("skipping test to avoid external network")
+ t.Skip("avoid external network")
}
txts, err := LookupTXT("gmail.com")
func TestLookupGooglePublicDNSAddr(t *testing.T) {
if testing.Short() || !*testExternal {
- t.Skip("skipping test to avoid external network")
+ t.Skip("avoid external network")
}
for _, tt := range lookupGooglePublicDNSAddrs {
func TestLookupIANACNAME(t *testing.T) {
if testing.Short() || !*testExternal {
- t.Skip("skipping test to avoid external network")
+ t.Skip("avoid external network")
}
cname, err := LookupCNAME("www.iana.org")
func TestLookupGoogleHost(t *testing.T) {
if testing.Short() || !*testExternal {
- t.Skip("skipping test to avoid external network")
+ t.Skip("avoid external network")
}
addrs, err := LookupHost("google.com")
func TestLookupGoogleIP(t *testing.T) {
if testing.Short() || !*testExternal {
- t.Skip("skipping test to avoid external network")
+ t.Skip("avoid external network")
}
ips, err := LookupIP("google.com")
func TestLookupMX(t *testing.T) {
if testing.Short() || !*testExternal {
- t.Skip("skipping test to avoid external network")
+ t.Skip("avoid external network")
}
+
for _, server := range nslookupTestServers {
mx, err := LookupMX(server)
if err != nil {
- t.Errorf("failed %s: %s", server, err)
+ t.Error(err)
continue
}
if len(mx) == 0 {
func TestLookupCNAME(t *testing.T) {
if testing.Short() || !*testExternal {
- t.Skip("skipping test to avoid external network")
+ t.Skip("avoid external network")
}
+
for _, server := range nslookupTestServers {
cname, err := LookupCNAME(server)
if err != nil {
func TestLookupNS(t *testing.T) {
if testing.Short() || !*testExternal {
- t.Skip("skipping test to avoid external network")
+ t.Skip("avoid external network")
}
+
for _, server := range nslookupTestServers {
ns, err := LookupNS(server)
if err != nil {
func TestLookupTXT(t *testing.T) {
if testing.Short() || !*testExternal {
- t.Skip("skipping test to avoid external network")
+ t.Skip("avoid external network")
}
+
for _, server := range nslookupTestServers {
txt, err := LookupTXT(server)
if err != nil {
"testing"
)
-var mactests = []struct {
+var parseMACTests = []struct {
in string
out HardwareAddr
err string
{"0123.4567.89AB.CDEF", HardwareAddr{1, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef}, ""},
}
-func match(err error, s string) bool {
- if s == "" {
- return err == nil
+func TestParseMAC(t *testing.T) {
+ match := func(err error, s string) bool {
+ if s == "" {
+ return err == nil
+ }
+ return err != nil && strings.Contains(err.Error(), s)
}
- return err != nil && strings.Contains(err.Error(), s)
-}
-func TestMACParseString(t *testing.T) {
- for i, tt := range mactests {
+ for i, tt := range parseMACTests {
out, err := ParseMAC(tt.in)
if !reflect.DeepEqual(out, tt.out) || !match(err, tt.err) {
- t.Errorf("ParseMAC(%q) = %v, %v, want %v, %v", tt.in, out, err, tt.out,
- tt.err)
+ t.Errorf("ParseMAC(%q) = %v, %v, want %v, %v", tt.in, out, err, tt.out, tt.err)
}
if tt.err == "" {
// Verify that serialization works too, and that it round-trips.
// In child process.
c, err := Dial("tcp", envaddr)
if err != nil {
- t.Fatalf("Dial failed: %v", err)
+ t.Fatal(err)
}
fmt.Printf("sleeping\n")
time.Sleep(time.Minute) // process will be killed here
ln, err := Listen("tcp", "127.0.0.1:0")
if err != nil {
- t.Fatalf("Listen failed: %v", err)
+ t.Fatal(err)
}
defer ln.Close()
t.Errorf("cgoLookupIP must be a placeholder")
}
if err != nil {
- t.Errorf("cgoLookupIP failed: %v", err)
+ t.Error(err)
}
if _, err := goLookupIP(host); err != nil {
- t.Errorf("goLookupIP failed: %v", err)
+ t.Error(err)
}
}
c1, err := ListenPacket(tt.net, tt.addr1)
if err != nil {
- t.Fatalf("ListenPacket failed: %v", err)
+ t.Fatal(err)
}
defer closer(c1, tt.net, tt.addr1, tt.addr2)
c1.LocalAddr()
c2, err := ListenPacket(tt.net, tt.addr2)
if err != nil {
- t.Fatalf("ListenPacket failed: %v", err)
+ t.Fatal(err)
}
defer closer(c2, tt.net, tt.addr1, tt.addr2)
c2.LocalAddr()
rb2 := make([]byte, 128)
if _, err := c1.WriteTo(wb, c2.LocalAddr()); err != nil {
- t.Fatalf("PacketConn.WriteTo failed: %v", err)
+ t.Fatal(err)
}
if _, _, err := c2.ReadFrom(rb2); err != nil {
- t.Fatalf("PacketConn.ReadFrom failed: %v", err)
+ t.Fatal(err)
}
if _, err := c2.WriteTo(wb, c1.LocalAddr()); err != nil {
- t.Fatalf("PacketConn.WriteTo failed: %v", err)
+ t.Fatal(err)
}
rb1 := make([]byte, 128)
if _, _, err := c1.ReadFrom(rb1); err != nil {
- t.Fatalf("PacketConn.ReadFrom failed: %v", err)
+ t.Fatal(err)
}
}
}
c1, err := ListenPacket(tt.net, tt.addr1)
if err != nil {
- t.Fatalf("ListenPacket failed: %v", err)
+ t.Fatal(err)
}
defer closer(c1, tt.net, tt.addr1, tt.addr2)
c1.LocalAddr()
c2, err := Dial(tt.net, c1.LocalAddr().String())
if err != nil {
- t.Fatalf("Dial failed: %v", err)
+ t.Fatal(err)
}
defer c2.Close()
c2.LocalAddr()
c2.SetWriteDeadline(time.Now().Add(500 * time.Millisecond))
if _, err := c2.Write(wb); err != nil {
- t.Fatalf("Conn.Write failed: %v", err)
+ t.Fatal(err)
}
rb1 := make([]byte, 128)
if _, _, err := c1.ReadFrom(rb1); err != nil {
- t.Fatalf("PacketConn.ReadFrom failed: %v", err)
+ t.Fatal(err)
}
var dst Addr
switch tt.net {
dst = c2.LocalAddr()
}
if _, err := c1.WriteTo(wb, dst); err != nil {
- t.Fatalf("PacketConn.WriteTo failed: %v", err)
+ t.Fatal(err)
}
rb2 := make([]byte, 128)
if _, err := c2.Read(rb2); err != nil {
- t.Fatalf("Conn.Read failed: %v", err)
+ t.Fatal(err)
}
}
}
// /etc/services file does not exist on android, plan9, windows.
switch runtime.GOOS {
case "android", "plan9", "windows":
- t.Skipf("skipping test on %q", runtime.GOOS)
+ t.Skipf("not supported on %s", runtime.GOOS)
}
filename := "/etc/services" // a nice big file
fd, err := os.Open(filename)
if err != nil {
- t.Fatalf("open %s: %v", filename, err)
+ t.Fatal(err)
}
defer fd.Close()
br := bufio.NewReader(fd)
file, err := open(filename)
if file == nil {
- t.Fatalf("net.open(%s) = nil", filename)
+ t.Fatal(err)
}
defer file.close()
}
line, ok := file.readLine()
if (berr != nil) != !ok || bline != line {
- t.Fatalf("%s:%d (#%d)\nbufio => %q, %v\nnet => %q, %v",
- filename, lineno, byteno, bline, berr, line, ok)
+ t.Fatalf("%s:%d (#%d)\nbufio => %q, %v\nnet => %q, %v", filename, lineno, byteno, bline, berr, line, ok)
}
if !ok {
break
"testing"
)
-func checkWrite(t *testing.T, w io.Writer, data []byte, c chan int) {
+func checkPipeWrite(t *testing.T, w io.Writer, data []byte, c chan int) {
n, err := w.Write(data)
if err != nil {
- t.Errorf("write: %v", err)
+ t.Error(err)
}
if n != len(data) {
t.Errorf("short write: %d != %d", n, len(data))
c <- 0
}
-func checkRead(t *testing.T, r io.Reader, data []byte, wantErr error) {
+func checkPipeRead(t *testing.T, r io.Reader, data []byte, wantErr error) {
buf := make([]byte, len(data)+10)
n, err := r.Read(buf)
if err != wantErr {
- t.Errorf("read: %v", err)
+ t.Error(err)
return
}
if n != len(data) || !bytes.Equal(buf[0:n], data) {
}
}
-// Test a simple read/write/close sequence.
+// TestPipe tests a simple read/write/close sequence.
// Assumes that the underlying io.Pipe implementation
// is solid and we're just testing the net wrapping.
-
func TestPipe(t *testing.T) {
c := make(chan int)
cli, srv := Pipe()
- go checkWrite(t, cli, []byte("hello, world"), c)
- checkRead(t, srv, []byte("hello, world"), nil)
+ go checkPipeWrite(t, cli, []byte("hello, world"), c)
+ checkPipeRead(t, srv, []byte("hello, world"), nil)
<-c
- go checkWrite(t, srv, []byte("line 2"), c)
- checkRead(t, cli, []byte("line 2"), nil)
+ go checkPipeWrite(t, srv, []byte("line 2"), c)
+ checkPipeRead(t, cli, []byte("line 2"), nil)
<-c
- go checkWrite(t, cli, []byte("a third line"), c)
- checkRead(t, srv, []byte("a third line"), nil)
+ go checkPipeWrite(t, cli, []byte("a third line"), c)
+ checkPipeRead(t, srv, []byte("a third line"), nil)
<-c
go srv.Close()
- checkRead(t, cli, nil, io.EOF)
+ checkPipeRead(t, cli, nil, io.EOF)
cli.Close()
}
"testing"
)
-type portTest struct {
- netw string
- name string
- port int
- ok bool
-}
-
-var porttests = []portTest{
+var portTests = []struct {
+ network string
+ name string
+ port int
+ ok bool
+}{
{"tcp", "echo", 7, true},
{"tcp", "discard", 9, true},
{"tcp", "systat", 11, true},
func TestLookupPort(t *testing.T) {
switch runtime.GOOS {
case "nacl":
- t.Skipf("skipping test on %q", runtime.GOOS)
+ t.Skipf("not supported on %s", runtime.GOOS)
}
- for i := 0; i < len(porttests); i++ {
- tt := porttests[i]
- if port, err := LookupPort(tt.netw, tt.name); port != tt.port || (err == nil) != tt.ok {
- t.Errorf("LookupPort(%q, %q) = %v, %v; want %v",
- tt.netw, tt.name, port, err, tt.port)
+ for _, tt := range portTests {
+ if port, err := LookupPort(tt.network, tt.name); port != tt.port || (err == nil) != tt.ok {
+ t.Errorf("LookupPort(%q, %q) = %v, %v; want %v", tt.network, tt.name, port, err, tt.port)
}
}
}
func TestTCPListenerSpecificMethods(t *testing.T) {
switch runtime.GOOS {
case "plan9":
- t.Skipf("skipping test on %q", runtime.GOOS)
+ t.Skipf("not supported on %s", runtime.GOOS)
}
la, err := ResolveTCPAddr("tcp4", "127.0.0.1:0")
if err != nil {
- t.Fatalf("ResolveTCPAddr failed: %v", err)
+ t.Fatal(err)
}
ln, err := ListenTCP("tcp4", la)
if err != nil {
- t.Fatalf("ListenTCP failed: %v", err)
+ t.Fatal(err)
}
defer ln.Close()
ln.Addr()
if c, err := ln.Accept(); err != nil {
if !err.(Error).Timeout() {
- t.Fatalf("TCPListener.Accept failed: %v", err)
+ t.Fatal(err)
}
} else {
c.Close()
}
if c, err := ln.AcceptTCP(); err != nil {
if !err.(Error).Timeout() {
- t.Fatalf("TCPListener.AcceptTCP failed: %v", err)
+ t.Fatal(err)
}
} else {
c.Close()
}
if f, err := ln.File(); err != nil {
- condFatalf(t, "TCPListener.File failed: %v", err)
+ condFatalf(t, "%v", err)
} else {
f.Close()
}
func TestTCPConnSpecificMethods(t *testing.T) {
la, err := ResolveTCPAddr("tcp4", "127.0.0.1:0")
if err != nil {
- t.Fatalf("ResolveTCPAddr failed: %v", err)
+ t.Fatal(err)
}
ln, err := ListenTCP("tcp4", la)
if err != nil {
- t.Fatalf("ListenTCP failed: %v", err)
+ t.Fatal(err)
}
ch := make(chan error, 1)
handler := func(ls *localServer, ln Listener) { transponder(ls.Listener, ch) }
ra, err := ResolveTCPAddr("tcp4", ls.Listener.Addr().String())
if err != nil {
- t.Fatalf("ResolveTCPAddr failed: %v", err)
+ t.Fatal(err)
}
c, err := DialTCP("tcp4", nil, ra)
if err != nil {
- t.Fatalf("DialTCP failed: %v", err)
+ t.Fatal(err)
}
defer c.Close()
c.SetKeepAlive(false)
c.SetWriteDeadline(time.Now().Add(someTimeout))
if _, err := c.Write([]byte("TCPCONN TEST")); err != nil {
- t.Fatalf("TCPConn.Write failed: %v", err)
+ t.Fatal(err)
}
rb := make([]byte, 128)
if _, err := c.Read(rb); err != nil {
- t.Fatalf("TCPConn.Read failed: %v", err)
+ t.Fatal(err)
}
for err := range ch {
func TestUDPConnSpecificMethods(t *testing.T) {
la, err := ResolveUDPAddr("udp4", "127.0.0.1:0")
if err != nil {
- t.Fatalf("ResolveUDPAddr failed: %v", err)
+ t.Fatal(err)
}
c, err := ListenUDP("udp4", la)
if err != nil {
- t.Fatalf("ListenUDP failed: %v", err)
+ t.Fatal(err)
}
defer c.Close()
c.LocalAddr()
wb := []byte("UDPCONN TEST")
rb := make([]byte, 128)
if _, err := c.WriteToUDP(wb, c.LocalAddr().(*UDPAddr)); err != nil {
- t.Fatalf("UDPConn.WriteToUDP failed: %v", err)
+ t.Fatal(err)
}
if _, _, err := c.ReadFromUDP(rb); err != nil {
- t.Fatalf("UDPConn.ReadFromUDP failed: %v", err)
+ t.Fatal(err)
}
if _, _, err := c.WriteMsgUDP(wb, nil, c.LocalAddr().(*UDPAddr)); err != nil {
- condFatalf(t, "UDPConn.WriteMsgUDP failed: %v", err)
+ condFatalf(t, "%v", err)
}
if _, _, _, _, err := c.ReadMsgUDP(rb, nil); err != nil {
- condFatalf(t, "UDPConn.ReadMsgUDP failed: %v", err)
+ condFatalf(t, "%v", err)
}
if f, err := c.File(); err != nil {
- condFatalf(t, "UDPConn.File failed: %v", err)
+ condFatalf(t, "%v", err)
} else {
f.Close()
}
defer func() {
if p := recover(); p != nil {
- t.Fatalf("UDPConn.WriteToUDP or WriteMsgUDP panicked: %v", p)
+ t.Fatalf("panicked: %v", p)
}
}()
la, err := ResolveIPAddr("ip4", "127.0.0.1")
if err != nil {
- t.Fatalf("ResolveIPAddr failed: %v", err)
+ t.Fatal(err)
}
c, err := ListenIP("ip4:icmp", la)
if err != nil {
- t.Fatalf("ListenIP failed: %v", err)
+ t.Fatal(err)
}
defer c.Close()
c.LocalAddr()
c.SetWriteBuffer(2048)
if f, err := c.File(); err != nil {
- condFatalf(t, "IPConn.File failed: %v", err)
+ condFatalf(t, "%v", err)
} else {
f.Close()
}
defer func() {
if p := recover(); p != nil {
- t.Fatalf("IPConn.WriteToIP or WriteMsgIP panicked: %v", p)
+ t.Fatalf("panicked: %v", p)
}
}()
addr := testUnixAddr()
la, err := ResolveUnixAddr("unix", addr)
if err != nil {
- t.Fatalf("ResolveUnixAddr failed: %v", err)
+ t.Fatal(err)
}
ln, err := ListenUnix("unix", la)
if err != nil {
- t.Fatalf("ListenUnix failed: %v", err)
+ t.Fatal(err)
}
defer ln.Close()
defer os.Remove(addr)
if c, err := ln.Accept(); err != nil {
if !err.(Error).Timeout() {
- t.Fatalf("UnixListener.Accept failed: %v", err)
+ t.Fatal(err)
}
} else {
c.Close()
}
if c, err := ln.AcceptUnix(); err != nil {
if !err.(Error).Timeout() {
- t.Fatalf("UnixListener.AcceptUnix failed: %v", err)
+ t.Fatal(err)
}
} else {
c.Close()
}
if f, err := ln.File(); err != nil {
- t.Fatalf("UnixListener.File failed: %v", err)
+ t.Fatal(err)
} else {
f.Close()
}
a1, err := ResolveUnixAddr("unixgram", addr1)
if err != nil {
- t.Fatalf("ResolveUnixAddr failed: %v", err)
+ t.Fatal(err)
}
c1, err := DialUnix("unixgram", a1, nil)
if err != nil {
- t.Fatalf("DialUnix failed: %v", err)
+ t.Fatal(err)
}
defer c1.Close()
defer os.Remove(addr1)
a2, err := ResolveUnixAddr("unixgram", addr2)
if err != nil {
- t.Fatalf("ResolveUnixAddr failed: %v", err)
+ t.Fatal(err)
}
c2, err := DialUnix("unixgram", a2, nil)
if err != nil {
- t.Fatalf("DialUnix failed: %v", err)
+ t.Fatal(err)
}
defer c2.Close()
defer os.Remove(addr2)
a3, err := ResolveUnixAddr("unixgram", addr3)
if err != nil {
- t.Fatalf("ResolveUnixAddr failed: %v", err)
+ t.Fatal(err)
}
c3, err := ListenUnixgram("unixgram", a3)
if err != nil {
- t.Fatalf("ListenUnixgram failed: %v", err)
+ t.Fatal(err)
}
defer c3.Close()
defer os.Remove(addr3)
rb2 := make([]byte, 128)
rb3 := make([]byte, 128)
if _, _, err := c1.WriteMsgUnix(wb, nil, a2); err != nil {
- t.Fatalf("UnixConn.WriteMsgUnix failed: %v", err)
+ t.Fatal(err)
}
if _, _, _, _, err := c2.ReadMsgUnix(rb2, nil); err != nil {
- t.Fatalf("UnixConn.ReadMsgUnix failed: %v", err)
+ t.Fatal(err)
}
if _, err := c2.WriteToUnix(wb, a1); err != nil {
- t.Fatalf("UnixConn.WriteToUnix failed: %v", err)
+ t.Fatal(err)
}
if _, _, err := c1.ReadFromUnix(rb1); err != nil {
- t.Fatalf("UnixConn.ReadFromUnix failed: %v", err)
+ t.Fatal(err)
}
if _, err := c3.WriteToUnix(wb, a1); err != nil {
- t.Fatalf("UnixConn.WriteToUnix failed: %v", err)
+ t.Fatal(err)
}
if _, _, err := c1.ReadFromUnix(rb1); err != nil {
- t.Fatalf("UnixConn.ReadFromUnix failed: %v", err)
+ t.Fatal(err)
}
if _, err := c2.WriteToUnix(wb, a3); err != nil {
- t.Fatalf("UnixConn.WriteToUnix failed: %v", err)
+ t.Fatal(err)
}
if _, _, err := c3.ReadFromUnix(rb3); err != nil {
- t.Fatalf("UnixConn.ReadFromUnix failed: %v", err)
+ t.Fatal(err)
}
if f, err := c1.File(); err != nil {
- t.Fatalf("UnixConn.File failed: %v", err)
+ t.Fatal(err)
} else {
f.Close()
}
defer func() {
if p := recover(); p != nil {
- t.Fatalf("UnixConn.WriteToUnix or WriteMsgUnix panicked: %v", p)
+ t.Fatalf("panicked: %v", p)
}
}()
for i, tt := range tcpServerTests {
if !testableListenArgs(tt.snet, tt.saddr, tt.taddr) {
- t.Logf("skipping %s test", tt.snet+":"+tt.saddr+"->"+tt.taddr)
+ t.Logf("skipping %s test", tt.snet+" "+tt.saddr+"->"+tt.taddr)
continue
}
for i, tt := range unixAndUnixpacketServerTests {
if !testableListenArgs(tt.network, tt.address, "") {
- t.Logf("skipping %s test", tt.network+":"+tt.address+"->")
+ t.Logf("skipping %s test", tt.network+" "+tt.address)
continue
}
func TestUDPServer(t *testing.T) {
for i, tt := range udpServerTests {
if !testableListenArgs(tt.snet, tt.saddr, tt.taddr) {
- t.Logf("skipping %s test", tt.snet+":"+tt.saddr+"->"+tt.taddr)
+ t.Logf("skipping %s test", tt.snet+" "+tt.saddr+"->"+tt.taddr)
continue
}
func TestUnixgramServer(t *testing.T) {
for i, tt := range unixgramServerTests {
if !testableListenArgs("unixgram", tt.saddr, "") {
- t.Logf("skipping %s test", "unixgram:"+tt.saddr+"->"+tt.caddr)
+ t.Logf("skipping %s test", "unixgram "+tt.saddr+"->"+tt.caddr)
continue
}
sendMsg := func(c Conn, buf []byte) bool {
n, err := c.Write(buf)
if n != len(buf) || err != nil {
- b.Logf("Write failed: %v", err)
+ b.Log(err)
return false
}
return true
n, err := c.Read(buf)
read += n
if err != nil {
- b.Logf("Read failed: %v", err)
+ b.Log(err)
return false
}
}
}
ln, err := Listen("tcp", laddr)
if err != nil {
- b.Fatalf("Listen failed: %v", err)
+ b.Fatal(err)
}
defer ln.Close()
serverSem := make(chan bool, numConcurrent)
}()
c, err := Dial("tcp", ln.Addr().String())
if err != nil {
- b.Logf("Dial failed: %v", err)
+ b.Log(err)
return
}
defer c.Close()
servers := make([]Conn, P)
ln, err := Listen("tcp", laddr)
if err != nil {
- b.Fatalf("Listen failed: %v", err)
+ b.Fatal(err)
}
defer ln.Close()
done := make(chan bool)
for p := 0; p < P; p++ {
s, err := ln.Accept()
if err != nil {
- b.Errorf("Accept failed: %v", err)
+ b.Error(err)
return
}
servers[p] = s
for p := 0; p < P; p++ {
c, err := Dial("tcp", ln.Addr().String())
if err != nil {
- b.Fatalf("Dial failed: %v", err)
+ b.Fatal(err)
}
clients[p] = c
}
buf[0] = v
_, err := c.Write(buf[:])
if err != nil {
- b.Errorf("Write failed: %v", err)
+ b.Error(err)
return
}
}
for i := 0; i < N; i++ {
_, err := s.Read(buf[:])
if err != nil {
- b.Errorf("Read failed: %v", err)
+ b.Error(err)
return
}
pipe <- buf[0]
buf[0] = v
_, err := s.Write(buf[:])
if err != nil {
- b.Errorf("Write failed: %v", err)
+ b.Error(err)
return
}
}
for i := 0; i < N; i++ {
_, err := c.Read(buf[:])
if err != nil {
- b.Errorf("Read failed: %v", err)
+ b.Error(err)
return
}
}
func TestTCPListenerName(t *testing.T) {
if testing.Short() || !*testExternal {
- t.Skip("skipping test to avoid external network")
+ t.Skip("avoid external network")
}
for _, tt := range tcpListenerNameTests {
ln, err := ListenTCP(tt.net, tt.laddr)
if err != nil {
- t.Fatalf("ListenTCP failed: %v", err)
+ t.Fatal(err)
}
defer ln.Close()
la := ln.Addr()
func TestIPv6LinkLocalUnicastTCP(t *testing.T) {
if testing.Short() || !*testExternal {
- t.Skip("skipping test to avoid external network")
+ t.Skip("avoid external network")
}
if !supportsIPv6 {
t.Skip("ipv6 is not supported")
if err != nil {
// It might return "LookupHost returned no
// suitable address" error on some platforms.
- t.Logf("Listen failed: %v", err)
+ t.Log(err)
continue
}
ls, err := (&streamListener{Listener: ln}).newLocalServer()
c, err := Dial(tt.net, ls.Listener.Addr().String())
if err != nil {
- t.Fatalf("Dial failed: %v", err)
+ t.Fatal(err)
}
defer c.Close()
if la, ok := c.LocalAddr().(*TCPAddr); !ok || !tt.nameLookup && la.Zone == "" {
}
if _, err := c.Write([]byte("TCP OVER IPV6 LINKLOCAL TEST")); err != nil {
- t.Fatalf("Conn.Write failed: %v", err)
+ t.Fatal(err)
}
b := make([]byte, 32)
if _, err := c.Read(b); err != nil {
- t.Fatalf("Conn.Read failed: %v", err)
+ t.Fatal(err)
}
for err := range ch {
defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(4))
ln, err := Listen("tcp", "127.0.0.1:0")
if err != nil {
- t.Fatalf("Listen failed: %v", err)
+ t.Fatal(err)
}
const N = 10
var wg sync.WaitGroup
sendMsg := func(c Conn, buf []byte) bool {
n, err := c.Write(buf)
if n != len(buf) || err != nil {
- t.Logf("Write failed: %v", err)
+ t.Log(err)
return false
}
return true
n, err := c.Read(buf)
read += n
if err != nil {
- t.Logf("Read failed: %v", err)
+ t.Log(err)
return false
}
}
ln, err := Listen("tcp", "127.0.0.1:0")
if err != nil {
- t.Fatalf("Listen failed: %v", err)
+ t.Fatal(err)
}
defer ln.Close()
// Acceptor.
}()
c, err := Dial("tcp", ln.Addr().String())
if err != nil {
- t.Logf("Dial failed: %v", err)
+ t.Log(err)
return
}
defer c.Close()
func TestWriteToUDP(t *testing.T) {
switch runtime.GOOS {
case "plan9":
- t.Skipf("skipping test on %q", runtime.GOOS)
+ t.Skipf("not supported on %s", runtime.GOOS)
}
c, err := ListenPacket("udp", "127.0.0.1:0")
t.Fatal(err)
}
- _, err = c.(*UDPConn).WriteToUDP([]byte("Connection-oriented mode socket"), ra)
+ b := []byte("CONNECTED-MODE SOCKET")
+ _, err = c.(*UDPConn).WriteToUDP(b, ra)
if err == nil {
- t.Fatal("WriteToUDP should fail")
+ t.Fatal("should fail")
}
if err != nil && err.(*OpError).Err != ErrWriteToConnected {
- t.Fatalf("WriteToUDP should fail as ErrWriteToConnected: %v", err)
+ t.Fatalf("should fail as ErrWriteToConnected: %v", err)
}
-
- _, err = c.(*UDPConn).WriteTo([]byte("Connection-oriented mode socket"), ra)
+ _, err = c.(*UDPConn).WriteTo(b, ra)
if err == nil {
- t.Fatal("WriteTo should fail")
+ t.Fatal("should fail")
}
if err != nil && err.(*OpError).Err != ErrWriteToConnected {
- t.Fatalf("WriteTo should fail as ErrWriteToConnected: %v", err)
+ t.Fatalf("should fail as ErrWriteToConnected: %v", err)
}
-
- _, err = c.Write([]byte("Connection-oriented mode socket"))
+ _, err = c.Write(b)
if err != nil {
t.Fatal(err)
}
-
- _, _, err = c.(*UDPConn).WriteMsgUDP([]byte("Connection-oriented mode socket"), nil, ra)
+ _, _, err = c.(*UDPConn).WriteMsgUDP(b, nil, ra)
if err == nil {
- t.Fatal("WriteMsgUDP should fail")
+ t.Fatal("should fail")
}
if err != nil && err.(*OpError).Err != ErrWriteToConnected {
- t.Fatalf("WriteMsgUDP should fail as ErrWriteToConnected: %v", err)
+ t.Fatalf("should fail as ErrWriteToConnected: %v", err)
}
- _, _, err = c.(*UDPConn).WriteMsgUDP([]byte("Connection-oriented mode socket"), nil, nil)
+ _, _, err = c.(*UDPConn).WriteMsgUDP(b, nil, nil)
switch runtime.GOOS {
case "nacl", "windows": // see golang.org/issue/9252
t.Skipf("not implemented yet on %s", runtime.GOOS)
t.Fatal(err)
}
- _, err = c.(*UDPConn).WriteToUDP([]byte("Connection-less mode socket"), ra)
+ b := []byte("UNCONNECTED-MODE SOCKET")
+ _, err = c.(*UDPConn).WriteToUDP(b, ra)
if err != nil {
t.Fatal(err)
}
-
- _, err = c.WriteTo([]byte("Connection-less mode socket"), ra)
+ _, err = c.WriteTo(b, ra)
if err != nil {
t.Fatal(err)
}
-
- _, err = c.(*UDPConn).Write([]byte("Connection-less mode socket"))
+ _, err = c.(*UDPConn).Write(b)
if err == nil {
- t.Fatal("Write should fail")
+ t.Fatal("should fail")
}
-
- _, _, err = c.(*UDPConn).WriteMsgUDP([]byte("Connection-less mode socket"), nil, nil)
+ _, _, err = c.(*UDPConn).WriteMsgUDP(b, nil, nil)
if err == nil {
- t.Fatal("WriteMsgUDP should fail")
+ t.Fatal("should fail")
}
if err != nil && err.(*OpError).Err != errMissingAddress {
- t.Fatalf("WriteMsgUDP should fail as errMissingAddress: %v", err)
+ t.Fatalf("should fail as errMissingAddress: %v", err)
}
- _, _, err = c.(*UDPConn).WriteMsgUDP([]byte("Connection-less mode socket"), nil, ra)
+ _, _, err = c.(*UDPConn).WriteMsgUDP(b, nil, ra)
switch runtime.GOOS {
case "nacl", "windows": // see golang.org/issue/9252
t.Skipf("not implemented yet on %s", runtime.GOOS)
func TestUDPConnLocalName(t *testing.T) {
if testing.Short() || !*testExternal {
- t.Skip("skipping test to avoid external network")
+ t.Skip("avoid external network")
}
for _, tt := range udpConnLocalNameTests {
c, err := ListenUDP(tt.net, tt.laddr)
if err != nil {
- t.Fatalf("ListenUDP failed: %v", err)
+ t.Fatal(err)
}
defer c.Close()
la := c.LocalAddr()
for _, laddr := range []string{"", "127.0.0.1:0"} {
c1, err := ListenPacket("udp", "127.0.0.1:0")
if err != nil {
- t.Fatalf("ListenUDP failed: %v", err)
+ t.Fatal(err)
}
defer c1.Close()
if laddr != "" {
var err error
if la, err = ResolveUDPAddr("udp", laddr); err != nil {
- t.Fatalf("ResolveUDPAddr failed: %v", err)
+ t.Fatal(err)
}
}
c2, err := DialUDP("udp", la, c1.LocalAddr().(*UDPAddr))
if err != nil {
- t.Fatalf("DialUDP failed: %v", err)
+ t.Fatal(err)
}
defer c2.Close()
func TestIPv6LinkLocalUnicastUDP(t *testing.T) {
if testing.Short() || !*testExternal {
- t.Skip("skipping test to avoid external network")
+ t.Skip("avoid external network")
}
if !supportsIPv6 {
t.Skip("ipv6 is not supported")
if err != nil {
// It might return "LookupHost returned no
// suitable address" error on some platforms.
- t.Logf("ListenPacket failed: %v", err)
+ t.Log(err)
continue
}
defer c1.Close()
c2, err := Dial(tt.net, c1.LocalAddr().String())
if err != nil {
- t.Fatalf("Dial failed: %v", err)
+ t.Fatal(err)
}
defer c2.Close()
if la, ok := c2.LocalAddr().(*UDPAddr); !ok || !tt.nameLookup && la.Zone == "" {
}
if _, err := c2.Write([]byte("UDP OVER IPV6 LINKLOCAL TEST")); err != nil {
- t.Fatalf("Conn.Write failed: %v", err)
+ t.Fatal(err)
}
b := make([]byte, 32)
if _, from, err := c1.ReadFrom(b); err != nil {
- t.Fatalf("PacketConn.ReadFrom failed: %v", err)
+ t.Fatal(err)
} else {
if ra, ok := from.(*UDPAddr); !ok || !tt.nameLookup && ra.Zone == "" {
t.Fatalf("got %v; expected a proper address with zone identifier", ra)
}
defer c.Close()
- b := []byte("UDP ZERO BYTE BUFFER")
+ b := []byte("UDP ZERO BYTE BUFFER TEST")
for _, genericRead := range []bool{false, true} {
n, err := c.WriteTo(b, c.LocalAddr())
if err != nil {
addr := testUnixAddr()
la, err := ResolveUnixAddr("unixgram", addr)
if err != nil {
- t.Fatalf("ResolveUnixAddr failed: %v", err)
+ t.Fatal(err)
}
c, err := ListenUnixgram("unixgram", la)
if err != nil {
- t.Fatalf("ListenUnixgram failed: %v", err)
+ t.Fatal(err)
}
defer func() {
c.Close()
defer func() { off <- true }()
s, err := syscall.Socket(syscall.AF_UNIX, syscall.SOCK_DGRAM, 0)
if err != nil {
- t.Errorf("syscall.Socket failed: %v", err)
+ t.Error(err)
return
}
defer syscall.Close(s)
rsa := &syscall.SockaddrUnix{Name: addr}
if err := syscall.Sendto(s, data[:], 0, rsa); err != nil {
- t.Errorf("syscall.Sendto failed: %v", err)
+ t.Error(err)
return
}
}()
c.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
n, from, err := c.ReadFrom(b)
if err != nil {
- t.Fatalf("UnixConn.ReadFrom failed: %v", err)
+ t.Fatal(err)
}
if from != nil {
- t.Fatalf("neighbor address is %v", from)
+ t.Fatalf("unexpected peer address: %v", from)
}
if !bytes.Equal(b[:n], data[:]) {
- t.Fatalf("got %v, want %v", b[:n], data[:])
+ t.Fatalf("got %v; want %v", b[:n], data[:])
}
}
defer os.Remove(c2.LocalAddr().String())
defer c2.Close()
- b := []byte("UNIXGRAM ZERO BYTE BUFFER")
+ b := []byte("UNIXGRAM ZERO BYTE BUFFER TEST")
for _, genericRead := range []bool{false, true} {
n, err := c2.Write(b)
if err != nil {
func TestUnixgramAutobind(t *testing.T) {
if runtime.GOOS != "linux" {
- t.Skip("skipping: autobind is linux only")
+ t.Skip("autobind is linux only")
}
laddr := &UnixAddr{Name: "", Net: "unixgram"}
c1, err := ListenUnixgram("unixgram", laddr)
if err != nil {
- t.Fatalf("ListenUnixgram failed: %v", err)
+ t.Fatal(err)
}
defer c1.Close()
c2, err := DialUnix("unixgram", nil, autoAddr)
if err != nil {
- t.Fatalf("DialUnix failed: %v", err)
+ t.Fatal(err)
}
defer c2.Close()
func TestUnixAutobindClose(t *testing.T) {
if runtime.GOOS != "linux" {
- t.Skip("skipping: autobind is linux only")
+ t.Skip("autobind is linux only")
}
laddr := &UnixAddr{Name: "", Net: "unix"}
ln, err := ListenUnix("unix", laddr)
if err != nil {
- t.Fatalf("ListenUnix failed: %v", err)
+ t.Fatal(err)
}
ln.Close()
}
addr := testUnixAddr()
laddr, err := ResolveUnixAddr("unixgram", addr)
if err != nil {
- t.Fatalf("ResolveUnixAddr failed: %v", err)
+ t.Fatal(err)
}
c, err := ListenPacket("unixgram", addr)
if err != nil {
- t.Fatalf("ListenPacket failed: %v", err)
+ t.Fatal(err)
}
defer os.Remove(addr)
defer c.Close()
func testUnixgramWriteConn(t *testing.T, raddr *UnixAddr) {
c, err := Dial("unixgram", raddr.String())
if err != nil {
- t.Fatalf("Dial failed: %v", err)
+ t.Fatal(err)
}
defer c.Close()
- if _, err := c.(*UnixConn).WriteToUnix([]byte("Connection-oriented mode socket"), raddr); err == nil {
- t.Fatal("WriteToUnix should fail")
+ b := []byte("CONNECTED-MODE SOCKET")
+ if _, err := c.(*UnixConn).WriteToUnix(b, raddr); err == nil {
+ t.Fatal("should fail")
} else if err.(*OpError).Err != ErrWriteToConnected {
- t.Fatalf("WriteToUnix should fail as ErrWriteToConnected: %v", err)
+ t.Fatalf("should fail as ErrWriteToConnected: %v", err)
}
- if _, err = c.(*UnixConn).WriteTo([]byte("Connection-oriented mode socket"), raddr); err == nil {
- t.Fatal("WriteTo should fail")
+ if _, err = c.(*UnixConn).WriteTo(b, raddr); err == nil {
+ t.Fatal("should fail")
} else if err.(*OpError).Err != ErrWriteToConnected {
- t.Fatalf("WriteTo should fail as ErrWriteToConnected: %v", err)
+ t.Fatalf("should fail as ErrWriteToConnected: %v", err)
}
- if _, _, err = c.(*UnixConn).WriteMsgUnix([]byte("Connection-oriented mode socket"), nil, raddr); err == nil {
- t.Fatal("WriteTo should fail")
+ if _, _, err = c.(*UnixConn).WriteMsgUnix(b, nil, raddr); err == nil {
+ t.Fatal("should fail")
} else if err.(*OpError).Err != ErrWriteToConnected {
- t.Fatalf("WriteMsgUnix should fail as ErrWriteToConnected: %v", err)
+ t.Fatalf("should fail as ErrWriteToConnected: %v", err)
}
- if _, err := c.Write([]byte("Connection-oriented mode socket")); err != nil {
- t.Fatalf("Write failed: %v", err)
+ if _, err := c.Write(b); err != nil {
+ t.Fatal(err)
}
}
addr := testUnixAddr()
c, err := ListenPacket("unixgram", addr)
if err != nil {
- t.Fatalf("ListenPacket failed: %v", err)
+ t.Fatal(err)
}
defer os.Remove(addr)
defer c.Close()
- if _, err := c.(*UnixConn).WriteToUnix([]byte("Connectionless mode socket"), raddr); err != nil {
- t.Fatalf("WriteToUnix failed: %v", err)
+ b := []byte("UNCONNECTED-MODE SOCKET")
+ if _, err := c.(*UnixConn).WriteToUnix(b, raddr); err != nil {
+ t.Fatal(err)
}
- if _, err := c.WriteTo([]byte("Connectionless mode socket"), raddr); err != nil {
- t.Fatalf("WriteTo failed: %v", err)
+ if _, err := c.WriteTo(b, raddr); err != nil {
+ t.Fatal(err)
}
- if _, _, err := c.(*UnixConn).WriteMsgUnix([]byte("Connectionless mode socket"), nil, raddr); err != nil {
- t.Fatalf("WriteMsgUnix failed: %v", err)
+ if _, _, err := c.(*UnixConn).WriteMsgUnix(b, nil, raddr); err != nil {
+ t.Fatal(err)
}
- if _, err := c.(*UnixConn).Write([]byte("Connectionless mode socket")); err == nil {
- t.Fatal("Write should fail")
+ if _, err := c.(*UnixConn).Write(b); err == nil {
+ t.Fatal("should fail")
}
}
taddr := testUnixAddr()
ta, err := ResolveUnixAddr("unix", taddr)
if err != nil {
- t.Fatalf("ResolveUnixAddr failed: %v", err)
+ t.Fatal(err)
}
ln, err := ListenUnix("unix", ta)
if err != nil {
- t.Fatalf("ListenUnix failed: %v", err)
+ t.Fatal(err)
}
ls, err := (&streamListener{Listener: ln}).newLocalServer()
if err != nil {
la, err := ResolveUnixAddr("unix", laddr)
if err != nil {
- t.Fatalf("ResolveUnixAddr failed: %v", err)
+ t.Fatal(err)
}
c, err := DialUnix("unix", la, ta)
if err != nil {
- t.Fatalf("DialUnix failed: %v", err)
+ t.Fatal(err)
}
defer func() {
c.Close()
}
}()
if _, err := c.Write([]byte("UNIXCONN LOCAL AND REMOTE NAME TEST")); err != nil {
- t.Fatalf("UnixConn.Write failed: %v", err)
+ t.Fatal(err)
}
switch runtime.GOOS {
taddr := testUnixAddr()
ta, err := ResolveUnixAddr("unixgram", taddr)
if err != nil {
- t.Fatalf("ResolveUnixAddr failed: %v", err)
+ t.Fatal(err)
}
c1, err := ListenUnixgram("unixgram", ta)
if err != nil {
- t.Fatalf("ListenUnixgram failed: %v", err)
+ t.Fatal(err)
}
defer func() {
c1.Close()
var la *UnixAddr
if laddr != "" {
if la, err = ResolveUnixAddr("unixgram", laddr); err != nil {
- t.Fatalf("ResolveUnixAddr failed: %v", err)
+ t.Fatal(err)
}
}
c2, err := DialUnix("unixgram", la, ta)
if err != nil {
- t.Fatalf("DialUnix failed: %v", err)
+ t.Fatal(err)
}
defer func() {
c2.Close()
}
for _, ca := range connAddrs {
if !reflect.DeepEqual(ca.got, ca.want) {
- t.Fatalf("got %#v, expected %#v", ca.got, ca.want)
+ t.Fatalf("got %#v; want %#v", ca.got, ca.want)
}
}
}