x/net/ipv6: fix full stack test cases

Readjusts Traffic Class and ICMP test cases on older darwin kernels,
per-interface link-local address multicasting and loopback interface
required test cases on BSD variants.
Also simplifies error logs.

LGTM=iant
R=iant
CC=golang-codereviews
https://golang.org/cl/177790043

ipv6/icmp_test.go

@@ -28,7 +28,7 @@ func TestICMPString(t *testing.T) {
 	for _, tt := range icmpStringTests {
 		s := tt.in.String()
 		if s != tt.out {
-			t.Errorf("got %s; expected %s", s, tt.out)
+			t.Errorf("got %s; want %s", s, tt.out)
 		}
 	}
 }
@@ -80,7 +80,7 @@ func TestSetICMPFilter(t *testing.T) {
 
 	c, err := net.ListenPacket("ip6:ipv6-icmp", "::1")
 	if err != nil {
-		t.Fatalf("net.ListenPacket failed: %v", err)
+		t.Fatal(err)
 	}
 	defer c.Close()
 
@@ -91,13 +91,13 @@ func TestSetICMPFilter(t *testing.T) {
 	f.Set(ipv6.ICMPTypeEchoRequest, false)
 	f.Set(ipv6.ICMPTypeEchoReply, false)
 	if err := p.SetICMPFilter(&f); err != nil {
-		t.Fatalf("ipv6.PacketConn.SetICMPFilter failed: %v", err)
+		t.Fatal(err)
 	}
 	kf, err := p.ICMPFilter()
 	if err != nil {
-		t.Fatalf("ipv6.PacketConn.ICMPFilter failed: %v", err)
+		t.Fatal(err)
 	}
 	if !reflect.DeepEqual(kf, &f) {
-		t.Fatalf("got unexpected filter %#v; expected %#v", kf, f)
+		t.Fatalf("got %#v; want %#v", kf, f)
 	}
 }

ipv6/mocktransponder_test.go

@@ -14,7 +14,7 @@ func connector(t *testing.T, network, addr string, done chan<- bool) {
 
 	c, err := net.Dial(network, addr)
 	if err != nil {
-		t.Errorf("net.Dial failed: %v", err)
+		t.Error(err)
 		return
 	}
 	c.Close()
@@ -25,7 +25,7 @@ func acceptor(t *testing.T, ln net.Listener, done chan<- bool) {
 
 	c, err := ln.Accept()
 	if err != nil {
-		t.Errorf("net.Listener.Accept failed: %v", err)
+		t.Error(err)
 		return
 	}
 	c.Close()

ipv6/multicast_test.go

@@ -63,7 +63,7 @@ func TestPacketConnReadWriteMulticastUDP(t *testing.T) {
 			if err := p.JoinSourceSpecificGroup(ifi, &grp, tt.src); err != nil {
 				switch runtime.GOOS {
 				case "freebsd", "linux":
-				default: // platforms that don't support IGMPv2/3 fail here
+				default: // platforms that don't support MLDv2 fail here
 					t.Logf("not supported on %q", runtime.GOOS)
 					continue
 				}
@@ -113,7 +113,7 @@ func TestPacketConnReadWriteMulticastUDP(t *testing.T) {
 			if n, cm, _, err := p.ReadFrom(rb); err != nil {
 				t.Fatal(err)
 			} else if !bytes.Equal(rb[:n], wb) {
-				t.Fatalf("got %v; expected %v", rb[:n], wb)
+				t.Fatalf("got %v; want %v", rb[:n], wb)
 			} else {
 				t.Logf("rcvd cmsg: %v", cm)
 			}
@@ -131,6 +131,9 @@ var packetConnReadWriteMulticastICMPTests = []struct {
 
 func TestPacketConnReadWriteMulticastICMP(t *testing.T) {
 	switch runtime.GOOS {
+	case "freebsd": // due to a bug on loopback marking
+		// See http://www.freebsd.org/cgi/query-pr.cgi?pr=180065.
+		t.Skipf("not supported on %q", runtime.GOOS)
 	case "nacl", "plan9", "solaris", "windows":
 		t.Skipf("not supported on %q", runtime.GOOS)
 	}
@@ -164,7 +167,7 @@ func TestPacketConnReadWriteMulticastICMP(t *testing.T) {
 			if err := p.JoinSourceSpecificGroup(ifi, tt.grp, tt.src); err != nil {
 				switch runtime.GOOS {
 				case "freebsd", "linux":
-				default: // platforms that don't support IGMPv2/3 fail here
+				default: // platforms that don't support MLDv2 fail here
 					t.Logf("not supported on %q", runtime.GOOS)
 					continue
 				}
@@ -237,17 +240,22 @@ func TestPacketConnReadWriteMulticastICMP(t *testing.T) {
 			if n, err := p.WriteTo(wb, &cm, tt.grp); err != nil {
 				t.Fatal(err)
 			} else if n != len(wb) {
-				t.Fatalf("got %v; expected %v", n, len(wb))
+				t.Fatalf("got %v; want %v", n, len(wb))
 			}
 			rb := make([]byte, 128)
 			if n, cm, _, err := p.ReadFrom(rb); err != nil {
+				switch runtime.GOOS {
+				case "darwin": // older darwin kernels have some limitation on receiving icmp packet through raw socket
+					t.Logf("not supported on %q", runtime.GOOS)
+					continue
+				}
 				t.Fatal(err)
 			} else {
 				t.Logf("rcvd cmsg: %v", cm)
 				if m, err := icmp.ParseMessage(iana.ProtocolIPv6ICMP, rb[:n]); err != nil {
 					t.Fatal(err)
 				} else if m.Type != ipv6.ICMPTypeEchoReply || m.Code != 0 {
-					t.Fatalf("got type=%v, code=%v; expected type=%v, code=%v", m.Type, m.Code, ipv6.ICMPTypeEchoReply, 0)
+					t.Fatalf("got type=%v, code=%v; want type=%v, code=%v", m.Type, m.Code, ipv6.ICMPTypeEchoReply, 0)
 				}
 			}
 		}

ipv6/multicastlistener_test.go

@@ -33,7 +33,7 @@ func TestUDPSinglePacketConnWithMultipleGroupListeners(t *testing.T) {
 	for _, gaddr := range udpMultipleGroupListenerTests {
 		c, err := net.ListenPacket("udp6", "[::]:0") // wildcard address with non-reusable port
 		if err != nil {
-			t.Fatalf("net.ListenPacket failed: %v", err)
+			t.Fatal(err)
 		}
 		defer c.Close()
 
@@ -42,20 +42,20 @@ func TestUDPSinglePacketConnWithMultipleGroupListeners(t *testing.T) {
 
 		ift, err := net.Interfaces()
 		if err != nil {
-			t.Fatalf("net.Interfaces failed: %v", err)
+			t.Fatal(err)
 		}
 		for i, ifi := range ift {
 			if _, ok := nettest.IsMulticastCapable("ip6", &ifi); !ok {
 				continue
 			}
 			if err := p.JoinGroup(&ifi, gaddr); err != nil {
-				t.Fatalf("ipv6.PacketConn.JoinGroup %v on %v failed: %v", gaddr, ifi, err)
+				t.Fatal(err)
 			}
 			mift = append(mift, &ift[i])
 		}
 		for _, ifi := range mift {
 			if err := p.LeaveGroup(ifi, gaddr); err != nil {
-				t.Fatalf("ipv6.PacketConn.LeaveGroup %v on %v failed: %v", gaddr, ifi, err)
+				t.Fatal(err)
 			}
 		}
 	}
@@ -73,13 +73,13 @@ func TestUDPMultiplePacketConnWithMultipleGroupListeners(t *testing.T) {
 	for _, gaddr := range udpMultipleGroupListenerTests {
 		c1, err := net.ListenPacket("udp6", "[ff02::]:1024") // wildcard address with reusable port
 		if err != nil {
-			t.Fatalf("net.ListenPacket failed: %v", err)
+			t.Fatal(err)
 		}
 		defer c1.Close()
 
 		c2, err := net.ListenPacket("udp6", "[ff02::]:1024") // wildcard address with reusable port
 		if err != nil {
-			t.Fatalf("net.ListenPacket failed: %v", err)
+			t.Fatal(err)
 		}
 		defer c2.Close()
 
@@ -90,7 +90,7 @@ func TestUDPMultiplePacketConnWithMultipleGroupListeners(t *testing.T) {
 
 		ift, err := net.Interfaces()
 		if err != nil {
-			t.Fatalf("net.Interfaces failed: %v", err)
+			t.Fatal(err)
 		}
 		for i, ifi := range ift {
 			if _, ok := nettest.IsMulticastCapable("ip6", &ifi); !ok {
@@ -98,7 +98,7 @@ func TestUDPMultiplePacketConnWithMultipleGroupListeners(t *testing.T) {
 			}
 			for _, p := range ps {
 				if err := p.JoinGroup(&ifi, gaddr); err != nil {
-					t.Fatalf("ipv6.PacketConn.JoinGroup %v on %v failed: %v", gaddr, ifi, err)
+					t.Fatal(err)
 				}
 			}
 			mift = append(mift, &ift[i])
@@ -106,7 +106,7 @@ func TestUDPMultiplePacketConnWithMultipleGroupListeners(t *testing.T) {
 		for _, ifi := range mift {
 			for _, p := range ps {
 				if err := p.LeaveGroup(ifi, gaddr); err != nil {
-					t.Fatalf("ipv6.PacketConn.LeaveGroup %v on %v failed: %v", gaddr, ifi, err)
+					t.Fatal(err)
 				}
 			}
 		}
@@ -131,7 +131,7 @@ func TestUDPPerInterfaceSinglePacketConnWithSingleGroupListener(t *testing.T) {
 
 	ift, err := net.Interfaces()
 	if err != nil {
-		t.Fatalf("net.Interfaces failed: %v", err)
+		t.Fatal(err)
 	}
 	for i, ifi := range ift {
 		ip, ok := nettest.IsMulticastCapable("ip6", &ifi)
@@ -140,18 +140,18 @@ func TestUDPPerInterfaceSinglePacketConnWithSingleGroupListener(t *testing.T) {
 		}
 		c, err := net.ListenPacket("udp6", fmt.Sprintf("[%s%%%s]:1024", ip.String(), ifi.Name)) // unicast address with non-reusable port
 		if err != nil {
-			t.Fatalf("net.ListenPacket with %v failed: %v", ip, err)
+			t.Fatal(err)
 		}
 		defer c.Close()
 		p := ipv6.NewPacketConn(c)
 		if err := p.JoinGroup(&ifi, &gaddr); err != nil {
-			t.Fatalf("ipv6.PacketConn.JoinGroup on %v failed: %v", ifi, err)
+			t.Fatal(err)
 		}
 		mlt = append(mlt, &ml{p, &ift[i]})
 	}
 	for _, m := range mlt {
 		if err := m.c.LeaveGroup(m.ifi, &gaddr); err != nil {
-			t.Fatalf("ipv6.PacketConn.LeaveGroup on %v failed: %v", m.ifi, err)
+			t.Fatal(err)
 		}
 	}
 }
@@ -170,7 +170,7 @@ func TestIPSinglePacketConnWithSingleGroupListener(t *testing.T) {
 
 	c, err := net.ListenPacket("ip6:ipv6-icmp", "::") // wildcard address
 	if err != nil {
-		t.Fatalf("net.ListenPacket failed: %v", err)
+		t.Fatal(err)
 	}
 	defer c.Close()
 
@@ -180,27 +180,29 @@ func TestIPSinglePacketConnWithSingleGroupListener(t *testing.T) {
 
 	ift, err := net.Interfaces()
 	if err != nil {
-		t.Fatalf("net.Interfaces failed: %v", err)
+		t.Fatal(err)
 	}
 	for i, ifi := range ift {
 		if _, ok := nettest.IsMulticastCapable("ip6", &ifi); !ok {
 			continue
 		}
 		if err := p.JoinGroup(&ifi, &gaddr); err != nil {
-			t.Fatalf("ipv6.PacketConn.JoinGroup on %v failed: %v", ifi, err)
+			t.Fatal(err)
 		}
 		mift = append(mift, &ift[i])
 	}
 	for _, ifi := range mift {
 		if err := p.LeaveGroup(ifi, &gaddr); err != nil {
-			t.Fatalf("ipv6.PacketConn.LeaveGroup on %v failed: %v", ifi, err)
+			t.Fatal(err)
 		}
 	}
 }
 
 func TestIPPerInterfaceSinglePacketConnWithSingleGroupListener(t *testing.T) {
 	switch runtime.GOOS {
-	case "darwin", "dragonfly", "nacl", "plan9", "solaris", "windows":
+	case "darwin", "dragonfly", "openbsd": // platforms that return fe80::1%lo0: bind: can't assign requested address
+		t.Skipf("not supported on %q", runtime.GOOS)
+	case "nacl", "plan9", "solaris", "windows":
 		t.Skipf("not supported on %q", runtime.GOOS)
 	}
 	if !supportsIPv6 {
@@ -219,7 +221,7 @@ func TestIPPerInterfaceSinglePacketConnWithSingleGroupListener(t *testing.T) {
 
 	ift, err := net.Interfaces()
 	if err != nil {
-		t.Fatalf("net.Interfaces failed: %v", err)
+		t.Fatal(err)
 	}
 	for i, ifi := range ift {
 		ip, ok := nettest.IsMulticastCapable("ip6", &ifi)
@@ -228,18 +230,18 @@ func TestIPPerInterfaceSinglePacketConnWithSingleGroupListener(t *testing.T) {
 		}
 		c, err := net.ListenPacket("ip6:ipv6-icmp", fmt.Sprintf("%s%%%s", ip.String(), ifi.Name)) // unicast address
 		if err != nil {
-			t.Fatalf("net.ListenPacket failed: %v", err)
+			t.Fatal(err)
 		}
 		defer c.Close()
 		p := ipv6.NewPacketConn(c)
 		if err := p.JoinGroup(&ifi, &gaddr); err != nil {
-			t.Fatalf("ipv6.PacketConn.JoinGroup on %v failed: %v", ifi, err)
+			t.Fatal(err)
 		}
 		mlt = append(mlt, &ml{p, &ift[i]})
 	}
 	for _, m := range mlt {
 		if err := m.c.LeaveGroup(m.ifi, &gaddr); err != nil {
-			t.Fatalf("ipv6.PacketConn.LeaveGroup on %v failed: %v", m.ifi, err)
+			t.Fatal(err)
 		}
 	}
 }

ipv6/multicastsockopt_test.go

@@ -82,7 +82,7 @@ func testMulticastSocketOptions(t *testing.T, c testIPv6MulticastConn, ifi *net.
 		t.Error(err)
 		return
 	} else if v != hoplim {
-		t.Errorf("got unexpected multicast hop limit %v; expected %v", v, hoplim)
+		t.Errorf("got %v; want %v", v, hoplim)
 		return
 	}
 
@@ -95,7 +95,7 @@ func testMulticastSocketOptions(t *testing.T, c testIPv6MulticastConn, ifi *net.
 			t.Error(err)
 			return
 		} else if v != toggle {
-			t.Errorf("got unexpected multicast loopback %v; expected %v", v, toggle)
+			t.Errorf("got %v; want %v", v, toggle)
 			return
 		}
 	}
@@ -119,7 +119,7 @@ func testSourceSpecificMulticastSocketOptions(t *testing.T, c testIPv6MulticastC
 	if err := c.ExcludeSourceSpecificGroup(ifi, grp, src); err != nil {
 		switch runtime.GOOS {
 		case "freebsd", "linux":
-		default: // platforms that don't support IGMPv2/3 fail here
+		default: // platforms that don't support MLDv2 fail here
 			t.Logf("not supported on %q", runtime.GOOS)
 			return
 		}

ipv6/readwrite_test.go

@@ -30,9 +30,13 @@ func benchmarkUDPListener() (net.PacketConn, net.Addr, error) {
 }
 
 func BenchmarkReadWriteNetUDP(b *testing.B) {
+	if !supportsIPv6 {
+		b.Skip("ipv6 is not supported")
+	}
+
 	c, dst, err := benchmarkUDPListener()
 	if err != nil {
-		b.Fatalf("benchmarkUDPListener failed: %v", err)
+		b.Fatal(err)
 	}
 	defer c.Close()
 
@@ -45,24 +49,28 @@ func BenchmarkReadWriteNetUDP(b *testing.B) {
 
 func benchmarkReadWriteNetUDP(b *testing.B, c net.PacketConn, wb, rb []byte, dst net.Addr) {
 	if _, err := c.WriteTo(wb, dst); err != nil {
-		b.Fatalf("net.PacketConn.WriteTo failed: %v", err)
+		b.Fatal(err)
 	}
 	if _, _, err := c.ReadFrom(rb); err != nil {
-		b.Fatalf("net.PacketConn.ReadFrom failed: %v", err)
+		b.Fatal(err)
 	}
 }
 
 func BenchmarkReadWriteIPv6UDP(b *testing.B) {
+	if !supportsIPv6 {
+		b.Skip("ipv6 is not supported")
+	}
+
 	c, dst, err := benchmarkUDPListener()
 	if err != nil {
-		b.Fatalf("benchmarkUDPListener failed: %v", err)
+		b.Fatal(err)
 	}
 	defer c.Close()
 
 	p := ipv6.NewPacketConn(c)
 	cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagSrc | ipv6.FlagDst | ipv6.FlagInterface | ipv6.FlagPathMTU
 	if err := p.SetControlMessage(cf, true); err != nil {
-		b.Fatalf("ipv6.PacketConn.SetControlMessage failed: %v", err)
+		b.Fatal(err)
 	}
 	ifi := nettest.RoutedInterface("ip6", net.FlagUp|net.FlagLoopback)
 
@@ -82,12 +90,12 @@ func benchmarkReadWriteIPv6UDP(b *testing.B, p *ipv6.PacketConn, wb, rb []byte,
 		cm.IfIndex = ifi.Index
 	}
 	if n, err := p.WriteTo(wb, &cm, dst); err != nil {
-		b.Fatalf("ipv6.PacketConn.WriteTo failed: %v", err)
+		b.Fatal(err)
 	} else if n != len(wb) {
-		b.Fatalf("ipv6.PacketConn.WriteTo failed: short write: %v", n)
+		b.Fatal("got %v; want %v", n, len(wb))
 	}
 	if _, _, _, err := p.ReadFrom(rb); err != nil {
-		b.Fatalf("ipv6.PacketConn.ReadFrom failed: %v", err)
+		b.Fatal(err)
 	}
 }
 
@@ -102,7 +110,7 @@ func TestPacketConnConcurrentReadWriteUnicastUDP(t *testing.T) {
 
 	c, err := net.ListenPacket("udp6", "[::1]:0")
 	if err != nil {
-		t.Fatalf("net.ListenPacket failed: %v", err)
+		t.Fatal(err)
 	}
 	defer c.Close()
 	p := ipv6.NewPacketConn(c)
@@ -110,7 +118,7 @@ func TestPacketConnConcurrentReadWriteUnicastUDP(t *testing.T) {
 
 	dst, err := net.ResolveUDPAddr("udp6", c.LocalAddr().String())
 	if err != nil {
-		t.Fatalf("net.ResolveUDPAddr failed: %v", err)
+		t.Fatal(err)
 	}
 
 	ifi := nettest.RoutedInterface("ip6", net.FlagUp|net.FlagLoopback)
@@ -121,7 +129,7 @@ func TestPacketConnConcurrentReadWriteUnicastUDP(t *testing.T) {
 		if nettest.ProtocolNotSupported(err) {
 			t.Skipf("not supported on %q", runtime.GOOS)
 		}
-		t.Fatalf("ipv6.PacketConn.SetControlMessage failed: %v", err)
+		t.Fatal(err)
 	}
 
 	var wg sync.WaitGroup
@@ -129,10 +137,10 @@ func TestPacketConnConcurrentReadWriteUnicastUDP(t *testing.T) {
 		defer wg.Done()
 		rb := make([]byte, 128)
 		if n, cm, _, err := p.ReadFrom(rb); err != nil {
-			t.Errorf("ipv6.PacketConn.ReadFrom failed: %v", err)
+			t.Error(err)
 			return
 		} else if !bytes.Equal(rb[:n], wb) {
-			t.Errorf("got %v; expected %v", rb[:n], wb)
+			t.Errorf("got %v; want %v", rb[:n], wb)
 			return
 		} else {
 			t.Logf("rcvd cmsg: %v", cm)
@@ -148,14 +156,14 @@ func TestPacketConnConcurrentReadWriteUnicastUDP(t *testing.T) {
 			cm.IfIndex = ifi.Index
 		}
 		if err := p.SetControlMessage(cf, toggle); err != nil {
-			t.Errorf("ipv6.PacketConn.SetControlMessage failed: %v", err)
+			t.Error(err)
 			return
 		}
 		if n, err := p.WriteTo(wb, &cm, dst); err != nil {
-			t.Errorf("ipv6.PacketConn.WriteTo failed: %v", err)
+			t.Error(err)
 			return
 		} else if n != len(wb) {
-			t.Errorf("ipv6.PacketConn.WriteTo failed: short write: %v", n)
+			t.Errorf("got %v; want %v", n, len(wb))
 			return
 		}
 	}

ipv6/sockopt_test.go

@@ -10,26 +10,11 @@ import (
 	"runtime"
 	"testing"
 
+	"golang.org/x/net/internal/nettest"
 	"golang.org/x/net/ipv6"
 )
 
-var supportsIPv6 bool
-
-func init() {
-	if ln, err := net.Listen("tcp6", "[::1]:0"); err == nil {
-		ln.Close()
-		supportsIPv6 = true
-	}
-}
-
-var condFatalf = func() func(*testing.T, string, ...interface{}) {
-	// A few APIs are not implemented yet on some platforms.
-	switch runtime.GOOS {
-	case "darwin", "nacl", "plan9", "solaris", "windows":
-		return (*testing.T).Logf
-	}
-	return (*testing.T).Fatalf
-}()
+var supportsIPv6 bool = nettest.SupportsIPv6()
 
 func TestConnInitiatorPathMTU(t *testing.T) {
 	switch runtime.GOOS {
@@ -42,7 +27,7 @@ func TestConnInitiatorPathMTU(t *testing.T) {
 
 	ln, err := net.Listen("tcp6", "[::1]:0")
 	if err != nil {
-		t.Fatalf("net.Listen failed: %v", err)
+		t.Fatal(err)
 	}
 	defer ln.Close()
 
@@ -51,12 +36,12 @@ func TestConnInitiatorPathMTU(t *testing.T) {
 
 	c, err := net.Dial("tcp6", ln.Addr().String())
 	if err != nil {
-		t.Fatalf("net.Dial failed: %v", err)
+		t.Fatal(err)
 	}
 	defer c.Close()
 
 	if pmtu, err := ipv6.NewConn(c).PathMTU(); err != nil {
-		condFatalf(t, "ipv6.Conn.PathMTU failed: %v", err)
+		t.Fatal(err)
 	} else {
 		t.Logf("path mtu for %v: %v", c.RemoteAddr(), pmtu)
 	}
@@ -75,7 +60,7 @@ func TestConnResponderPathMTU(t *testing.T) {
 
 	ln, err := net.Listen("tcp6", "[::1]:0")
 	if err != nil {
-		t.Fatalf("net.Listen failed: %v", err)
+		t.Fatal(err)
 	}
 	defer ln.Close()
 
@@ -84,12 +69,12 @@ func TestConnResponderPathMTU(t *testing.T) {
 
 	c, err := ln.Accept()
 	if err != nil {
-		t.Fatalf("net.Accept failed: %v", err)
+		t.Fatal(err)
 	}
 	defer c.Close()
 
 	if pmtu, err := ipv6.NewConn(c).PathMTU(); err != nil {
-		condFatalf(t, "ipv6.Conn.PathMTU failed: %v", err)
+		t.Fatal(err)
 	} else {
 		t.Logf("path mtu for %v: %v", c.RemoteAddr(), pmtu)
 	}
@@ -111,7 +96,7 @@ func TestPacketConnChecksum(t *testing.T) {
 
 	c, err := net.ListenPacket("ip6:89", "::") // OSPF for IPv6
 	if err != nil {
-		t.Fatalf("net.ListenPacket failed: %v", err)
+		t.Fatal(err)
 	}
 	defer c.Close()
 
@@ -129,7 +114,7 @@ func TestPacketConnChecksum(t *testing.T) {
 			}
 		}
 		if on, offset, err := p.Checksum(); err != nil {
-			t.Fatalf("ipv6.PacketConn.Checksum failed: %v", err)
+			t.Fatal(err)
 		} else {
 			t.Logf("kernel checksum processing enabled=%v, offset=%v", on, offset)
 		}

ipv6/unicast_test.go

@@ -29,7 +29,7 @@ func TestPacketConnReadWriteUnicastUDP(t *testing.T) {
 
 	c, err := net.ListenPacket("udp6", "[::1]:0")
 	if err != nil {
-		t.Fatalf("net.ListenPacket failed: %v", err)
+		t.Fatal(err)
 	}
 	defer c.Close()
 	p := ipv6.NewPacketConn(c)
@@ -37,7 +37,7 @@ func TestPacketConnReadWriteUnicastUDP(t *testing.T) {
 
 	dst, err := net.ResolveUDPAddr("udp6", c.LocalAddr().String())
 	if err != nil {
-		t.Fatalf("net.ResolveUDPAddr failed: %v", err)
+		t.Fatal(err)
 	}
 
 	cm := ipv6.ControlMessage{
@@ -56,25 +56,25 @@ func TestPacketConnReadWriteUnicastUDP(t *testing.T) {
 			if nettest.ProtocolNotSupported(err) {
 				t.Skipf("not supported on %q", runtime.GOOS)
 			}
-			t.Fatalf("ipv6.PacketConn.SetControlMessage failed: %v", err)
+			t.Fatal(err)
 		}
 		cm.HopLimit = i + 1
 		if err := p.SetWriteDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
-			t.Fatalf("ipv6.PacketConn.SetWriteDeadline failed: %v", err)
+			t.Fatal(err)
 		}
 		if n, err := p.WriteTo(wb, &cm, dst); err != nil {
-			t.Fatalf("ipv6.PacketConn.WriteTo failed: %v", err)
+			t.Fatal(err)
 		} else if n != len(wb) {
-			t.Fatalf("ipv6.PacketConn.WriteTo failed: short write: %v", n)
+			t.Fatalf("got %v; want %v", n, len(wb))
 		}
 		rb := make([]byte, 128)
 		if err := p.SetReadDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
-			t.Fatalf("ipv6.PacketConn.SetReadDeadline failed: %v", err)
+			t.Fatal(err)
 		}
 		if n, cm, _, err := p.ReadFrom(rb); err != nil {
-			t.Fatalf("ipv6.PacketConn.ReadFrom failed: %v", err)
+			t.Fatal(err)
 		} else if !bytes.Equal(rb[:n], wb) {
-			t.Fatalf("got %v; expected %v", rb[:n], wb)
+			t.Fatalf("got %v; want %v", rb[:n], wb)
 		} else {
 			t.Logf("rcvd cmsg: %v", cm)
 		}
@@ -95,7 +95,7 @@ func TestPacketConnReadWriteUnicastICMP(t *testing.T) {
 
 	c, err := net.ListenPacket("ip6:ipv6-icmp", "::1")
 	if err != nil {
-		t.Fatalf("net.ListenPacket failed: %v", err)
+		t.Fatal(err)
 	}
 	defer c.Close()
 	p := ipv6.NewPacketConn(c)
@@ -103,7 +103,7 @@ func TestPacketConnReadWriteUnicastICMP(t *testing.T) {
 
 	dst, err := net.ResolveIPAddr("ip6", "::1")
 	if err != nil {
-		t.Fatalf("net.ResolveIPAddr failed: %v", err)
+		t.Fatal(err)
 	}
 
 	pshicmp := icmp.IPv6PseudoHeader(c.LocalAddr().(*net.IPAddr).IP, dst.IP)
@@ -121,7 +121,7 @@ func TestPacketConnReadWriteUnicastICMP(t *testing.T) {
 	f.SetAll(true)
 	f.Set(ipv6.ICMPTypeEchoReply, false)
 	if err := p.SetICMPFilter(&f); err != nil {
-		t.Fatalf("ipv6.PacketConn.SetICMPFilter failed: %v", err)
+		t.Fatal(err)
 	}
 
 	var psh []byte
@@ -129,7 +129,7 @@ func TestPacketConnReadWriteUnicastICMP(t *testing.T) {
 		if toggle {
 			psh = nil
 			if err := p.SetChecksum(true, 2); err != nil {
-				t.Fatalf("ipv6.PacketConn.SetChecksum failed: %v", err)
+				t.Fatal(err)
 			}
 		} else {
 			psh = pshicmp
@@ -145,35 +145,40 @@ func TestPacketConnReadWriteUnicastICMP(t *testing.T) {
 			},
 		}).Marshal(psh)
 		if err != nil {
-			t.Fatalf("icmp.Message.Marshal failed: %v", err)
+			t.Fatal(err)
 		}
 		if err := p.SetControlMessage(cf, toggle); err != nil {
 			if nettest.ProtocolNotSupported(err) {
 				t.Skipf("not supported on %q", runtime.GOOS)
 			}
-			t.Fatalf("ipv6.PacketConn.SetControlMessage failed: %v", err)
+			t.Fatal(err)
 		}
 		cm.HopLimit = i + 1
 		if err := p.SetWriteDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
-			t.Fatalf("ipv6.PacketConn.SetWriteDeadline failed: %v", err)
+			t.Fatal(err)
 		}
 		if n, err := p.WriteTo(wb, &cm, dst); err != nil {
-			t.Fatalf("ipv6.PacketConn.WriteTo failed: %v", err)
+			t.Fatal(err)
 		} else if n != len(wb) {
-			t.Fatalf("ipv6.PacketConn.WriteTo failed: short write: %v", n)
+			t.Fatalf("got %v; want %v", n, len(wb))
 		}
 		rb := make([]byte, 128)
 		if err := p.SetReadDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
-			t.Fatalf("ipv6.PacketConn.SetReadDeadline failed: %v", err)
+			t.Fatal(err)
 		}
 		if n, cm, _, err := p.ReadFrom(rb); err != nil {
-			t.Fatalf("ipv6.PacketConn.ReadFrom failed: %v", err)
+			switch runtime.GOOS {
+			case "darwin": // older darwin kernels have some limitation on receiving icmp packet through raw socket
+				t.Logf("not supported on %q", runtime.GOOS)
+				continue
+			}
+			t.Fatal(err)
 		} else {
 			t.Logf("rcvd cmsg: %v", cm)
 			if m, err := icmp.ParseMessage(iana.ProtocolIPv6ICMP, rb[:n]); err != nil {
-				t.Fatalf("icmp.ParseMessage failed: %v", err)
+				t.Fatal(err)
 			} else if m.Type != ipv6.ICMPTypeEchoReply || m.Code != 0 {
-				t.Fatalf("got type=%v, code=%v; expected type=%v, code=%v", m.Type, m.Code, ipv6.ICMPTypeEchoReply, 0)
+				t.Fatalf("got type=%v, code=%v; want type=%v, code=%v", m.Type, m.Code, ipv6.ICMPTypeEchoReply, 0)
 			}
 		}
 	}

ipv6/unicastsockopt_test.go

@@ -25,7 +25,7 @@ func TestConnUnicastSocketOptions(t *testing.T) {
 
 	ln, err := net.Listen("tcp6", "[::1]:0")
 	if err != nil {
-		t.Fatalf("net.Listen failed: %v", err)
+		t.Fatal(err)
 	}
 	defer ln.Close()
 
@@ -34,7 +34,7 @@ func TestConnUnicastSocketOptions(t *testing.T) {
 
 	c, err := net.Dial("tcp6", ln.Addr().String())
 	if err != nil {
-		t.Fatalf("net.Dial failed: %v", err)
+		t.Fatal(err)
 	}
 	defer c.Close()
 
@@ -65,7 +65,7 @@ func TestPacketConnUnicastSocketOptions(t *testing.T) {
 		}
 		c, err := net.ListenPacket(tt.net+tt.proto, tt.addr)
 		if err != nil {
-			t.Fatalf("net.ListenPacket(%q, %q) failed: %v", tt.net+tt.proto, tt.addr, err)
+			t.Fatal(err)
 		}
 		defer c.Close()
 
@@ -83,21 +83,27 @@ type testIPv6UnicastConn interface {
 func testUnicastSocketOptions(t *testing.T, c testIPv6UnicastConn) {
 	tclass := iana.DiffServCS0 | iana.NotECNTransport
 	if err := c.SetTrafficClass(tclass); err != nil {
-		t.Fatalf("ipv6.Conn.SetTrafficClass failed: %v", err)
+		switch runtime.GOOS {
+		case "darwin": // older darwin kernels don't support IPV6_TCLASS option
+			t.Logf("not supported on %q", runtime.GOOS)
+			goto next
+		}
+		t.Fatal(err)
 	}
 	if v, err := c.TrafficClass(); err != nil {
-		t.Fatalf("ipv6.Conn.TrafficClass failed: %v", err)
+		t.Fatal(err)
 	} else if v != tclass {
-		t.Fatalf("got unexpected traffic class %v; expected %v", v, tclass)
+		t.Fatalf("got %v; want %v", v, tclass)
 	}
 
+next:
 	hoplim := 255
 	if err := c.SetHopLimit(hoplim); err != nil {
-		t.Fatalf("ipv6.Conn.SetHopLimit failed: %v", err)
+		t.Fatal(err)
 	}
 	if v, err := c.HopLimit(); err != nil {
-		t.Fatalf("ipv6.Conn.HopLimit failed: %v", err)
+		t.Fatal(err)
 	} else if v != hoplim {
-		t.Fatalf("got unexpected hop limit %v; expected %v", v, hoplim)
+		t.Fatalf("got %v; want %v", v, hoplim)
 	}
 }