x/net/ipv4: fix full stack test cases

Readjusts ICMP test cases on older darwin kernels
Also simplifies error logs.

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

ipv4/header_test.go

@@ -70,7 +70,7 @@ var (
 func TestMarshalHeader(t *testing.T) {
 	b, err := testHeader.Marshal()
 	if err != nil {
-		t.Fatalf("ipv4.Header.Marshal failed: %v", err)
+		t.Fatal(err)
 	}
 	var wh []byte
 	if supportsNewIPInput {
@@ -79,7 +79,7 @@ func TestMarshalHeader(t *testing.T) {
 		wh = wireHeaderToTradBSDKernel[:]
 	}
 	if !bytes.Equal(b, wh) {
-		t.Fatalf("ipv4.Header.Marshal failed: %#v not equal %#v", b, wh)
+		t.Fatalf("got %#v; want %#v", b, wh)
 	}
 }
 
@@ -96,9 +96,9 @@ func TestParseHeader(t *testing.T) {
 	}
 	h, err := ParseHeader(wh)
 	if err != nil {
-		t.Fatalf("ipv4.ParseHeader failed: %v", err)
+		t.Fatal(err)
 	}
 	if !reflect.DeepEqual(h, testHeader) {
-		t.Fatalf("ipv4.ParseHeader failed: %#v not equal %#v", h, testHeader)
+		t.Fatalf("got %#v; want %#v", h, testHeader)
 	}
 }

ipv4/mocktransponder_test.go

@@ -14,7 +14,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()

ipv4/multicast_test.go

@@ -95,13 +95,13 @@ func TestPacketConnReadWriteMulticastUDP(t *testing.T) {
 			if n, err := p.WriteTo(wb, nil, &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 {
 				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)
 			}
@@ -195,7 +195,7 @@ func TestPacketConnReadWriteMulticastICMP(t *testing.T) {
 			if n, err := p.WriteTo(wb, nil, 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 {
@@ -210,7 +210,7 @@ func TestPacketConnReadWriteMulticastICMP(t *testing.T) {
 				case m.Type == ipv4.ICMPTypeEchoReply && m.Code == 0: // net.inet.icmp.bmcastecho=1
 				case m.Type == ipv4.ICMPTypeEcho && m.Code == 0: // net.inet.icmp.bmcastecho=0
 				default:
-					t.Fatalf("got type=%v, code=%v; expected type=%v, code=%v", m.Type, m.Code, ipv4.ICMPTypeEchoReply, 0)
+					t.Fatalf("got type=%v, code=%v; want type=%v, code=%v", m.Type, m.Code, ipv4.ICMPTypeEchoReply, 0)
 				}
 			}
 		}
@@ -326,7 +326,7 @@ func TestRawConnReadWriteMulticastICMP(t *testing.T) {
 				case (rh.Dst.IsLoopback() || rh.Dst.IsLinkLocalUnicast() || rh.Dst.IsGlobalUnicast()) && m.Type == ipv4.ICMPTypeEchoReply && m.Code == 0: // net.inet.icmp.bmcastecho=1
 				case rh.Dst.IsMulticast() && m.Type == ipv4.ICMPTypeEcho && m.Code == 0: // net.inet.icmp.bmcastecho=0
 				default:
-					t.Fatalf("got type=%v, code=%v; expected type=%v, code=%v", m.Type, m.Code, ipv4.ICMPTypeEchoReply, 0)
+					t.Fatalf("got type=%v, code=%v; want type=%v, code=%v", m.Type, m.Code, ipv4.ICMPTypeEchoReply, 0)
 				}
 			}
 		}

ipv4/multicastlistener_test.go

@@ -32,7 +32,7 @@ func TestUDPSinglePacketConnWithMultipleGroupListeners(t *testing.T) {
 	for _, gaddr := range udpMultipleGroupListenerTests {
 		c, err := net.ListenPacket("udp4", "0.0.0.0:0") // wildcard address with no reusable port
 		if err != nil {
-			t.Fatalf("net.ListenPacket failed: %v", err)
+			t.Fatal(err)
 		}
 		defer c.Close()
 
@@ -41,20 +41,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("ip4", &ifi); !ok {
 				continue
 			}
 			if err := p.JoinGroup(&ifi, gaddr); err != nil {
-				t.Fatalf("ipv4.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("ipv4.PacketConn.LeaveGroup %v on %v failed: %v", gaddr, ifi, err)
+				t.Fatal(err)
 			}
 		}
 	}
@@ -72,13 +72,13 @@ func TestUDPMultiplePacketConnWithMultipleGroupListeners(t *testing.T) {
 	for _, gaddr := range udpMultipleGroupListenerTests {
 		c1, err := net.ListenPacket("udp4", "224.0.0.0: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("udp4", "224.0.0.0:1024") // wildcard address with reusable port
 		if err != nil {
-			t.Fatalf("net.ListenPacket failed: %v", err)
+			t.Fatal(err)
 		}
 		defer c2.Close()
 
@@ -89,7 +89,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("ip4", &ifi); !ok {
@@ -97,7 +97,7 @@ func TestUDPMultiplePacketConnWithMultipleGroupListeners(t *testing.T) {
 			}
 			for _, p := range ps {
 				if err := p.JoinGroup(&ifi, gaddr); err != nil {
-					t.Fatalf("ipv4.PacketConn.JoinGroup %v on %v failed: %v", gaddr, ifi, err)
+					t.Fatal(err)
 				}
 			}
 			mift = append(mift, &ift[i])
@@ -105,7 +105,7 @@ func TestUDPMultiplePacketConnWithMultipleGroupListeners(t *testing.T) {
 		for _, ifi := range mift {
 			for _, p := range ps {
 				if err := p.LeaveGroup(ifi, gaddr); err != nil {
-					t.Fatalf("ipv4.PacketConn.LeaveGroup %v on %v failed: %v", gaddr, ifi, err)
+					t.Fatal(err)
 				}
 			}
 		}
@@ -130,7 +130,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("ip4", &ifi)
@@ -139,18 +139,18 @@ func TestUDPPerInterfaceSinglePacketConnWithSingleGroupListener(t *testing.T) {
 		}
 		c, err := net.ListenPacket("udp4", ip.String()+":"+"1024") // 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 := ipv4.NewPacketConn(c)
 		if err := p.JoinGroup(&ifi, &gaddr); err != nil {
-			t.Fatalf("ipv4.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("ipv4.PacketConn.LeaveGroup on %v failed: %v", m.ifi, err)
+			t.Fatal(err)
 		}
 	}
 }
@@ -169,33 +169,33 @@ func TestIPSingleRawConnWithSingleGroupListener(t *testing.T) {
 
 	c, err := net.ListenPacket("ip4:icmp", "0.0.0.0") // wildcard address
 	if err != nil {
-		t.Fatalf("net.ListenPacket failed: %v", err)
+		t.Fatal(err)
 	}
 	defer c.Close()
 
 	r, err := ipv4.NewRawConn(c)
 	if err != nil {
-		t.Fatalf("ipv4.RawConn failed: %v", err)
+		t.Fatal(err)
 	}
 	gaddr := net.IPAddr{IP: net.IPv4(224, 0, 0, 254)} // see RFC 4727
 	var mift []*net.Interface
 
 	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("ip4", &ifi); !ok {
 			continue
 		}
 		if err := r.JoinGroup(&ifi, &gaddr); err != nil {
-			t.Fatalf("ipv4.RawConn.JoinGroup on %v failed: %v", ifi, err)
+			t.Fatal(err)
 		}
 		mift = append(mift, &ift[i])
 	}
 	for _, ifi := range mift {
 		if err := r.LeaveGroup(ifi, &gaddr); err != nil {
-			t.Fatalf("ipv4.RawConn.LeaveGroup on %v failed: %v", ifi, err)
+			t.Fatal(err)
 		}
 	}
 }
@@ -221,7 +221,7 @@ func TestIPPerInterfaceSingleRawConnWithSingleGroupListener(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("ip4", &ifi)
@@ -230,21 +230,21 @@ func TestIPPerInterfaceSingleRawConnWithSingleGroupListener(t *testing.T) {
 		}
 		c, err := net.ListenPacket("ip4:253", ip.String()) // unicast address
 		if err != nil {
-			t.Fatalf("net.ListenPacket with %v failed: %v", ip, err)
+			t.Fatal(err)
 		}
 		defer c.Close()
 		r, err := ipv4.NewRawConn(c)
 		if err != nil {
-			t.Fatalf("ipv4.NewRawConn failed: %v", err)
+			t.Fatal(err)
 		}
 		if err := r.JoinGroup(&ifi, &gaddr); err != nil {
-			t.Fatalf("ipv4.RawConn.JoinGroup on %v failed: %v", ifi, err)
+			t.Fatal(err)
 		}
 		mlt = append(mlt, &ml{r, &ift[i]})
 	}
 	for _, m := range mlt {
 		if err := m.c.LeaveGroup(m.ifi, &gaddr); err != nil {
-			t.Fatalf("ipv4.RawConn.LeaveGroup on %v failed: %v", m.ifi, err)
+			t.Fatal(err)
 		}
 	}
 }

ipv4/multicastsockopt_test.go

@@ -120,7 +120,7 @@ func testMulticastSocketOptions(t *testing.T, c testIPv4MulticastConn, ifi *net.
 		t.Error(err)
 		return
 	} else if v != ttl {
-		t.Errorf("got unexpected multicast ttl %v; expected %v", v, ttl)
+		t.Errorf("got %v; want %v", v, ttl)
 		return
 	}
 
@@ -133,7 +133,7 @@ func testMulticastSocketOptions(t *testing.T, c testIPv4MulticastConn, 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
 		}
 	}

ipv4/readwrite_test.go

@@ -31,7 +31,7 @@ func benchmarkUDPListener() (net.PacketConn, net.Addr, error) {
 func BenchmarkReadWriteNetUDP(b *testing.B) {
 	c, dst, err := benchmarkUDPListener()
 	if err != nil {
-		b.Fatalf("benchmarkUDPListener failed: %v", err)
+		b.Fatal(err)
 	}
 	defer c.Close()
 
@@ -44,17 +44,17 @@ 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 BenchmarkReadWriteIPv4UDP(b *testing.B) {
 	c, dst, err := benchmarkUDPListener()
 	if err != nil {
-		b.Fatalf("benchmarkUDPListener failed: %v", err)
+		b.Fatal(err)
 	}
 	defer c.Close()
 
@@ -62,7 +62,7 @@ func BenchmarkReadWriteIPv4UDP(b *testing.B) {
 	defer p.Close()
 	cf := ipv4.FlagTTL | ipv4.FlagInterface
 	if err := p.SetControlMessage(cf, true); err != nil {
-		b.Fatalf("ipv4.PacketConn.SetControlMessage failed: %v", err)
+		b.Fatal(err)
 	}
 	ifi := nettest.RoutedInterface("ip4", net.FlagUp|net.FlagLoopback)
 
@@ -79,12 +79,12 @@ func benchmarkReadWriteIPv4UDP(b *testing.B, p *ipv4.PacketConn, wb, rb []byte,
 		cm.IfIndex = ifi.Index
 	}
 	if n, err := p.WriteTo(wb, &cm, dst); err != nil {
-		b.Fatalf("ipv4.PacketConn.WriteTo failed: %v", err)
+		b.Fatal(err)
 	} else if n != len(wb) {
-		b.Fatalf("ipv4.PacketConn.WriteTo failed: short write: %v", n)
+		b.Fatalf("got %v; want %v", n, len(wb))
 	}
 	if _, _, _, err := p.ReadFrom(rb); err != nil {
-		b.Fatalf("ipv4.PacketConn.ReadFrom failed: %v", err)
+		b.Fatal(err)
 	}
 }
 
@@ -115,7 +115,7 @@ func TestPacketConnConcurrentReadWriteUnicastUDP(t *testing.T) {
 		if nettest.ProtocolNotSupported(err) {
 			t.Skipf("not supported on %q", runtime.GOOS)
 		}
-		t.Fatalf("ipv4.PacketConn.SetControlMessage failed: %v", err)
+		t.Fatal(err)
 	}
 
 	var wg sync.WaitGroup

ipv4/unicast_test.go

@@ -5,6 +5,7 @@
 package ipv4_test
 
 import (
+	"bytes"
 	"net"
 	"os"
 	"runtime"
@@ -29,38 +30,44 @@ func TestPacketConnReadWriteUnicastUDP(t *testing.T) {
 
 	c, err := net.ListenPacket("udp4", "127.0.0.1:0")
 	if err != nil {
-		t.Fatalf("net.ListenPacket failed: %v", err)
+		t.Fatal(err)
 	}
 	defer c.Close()
 
 	dst, err := net.ResolveUDPAddr("udp4", c.LocalAddr().String())
 	if err != nil {
-		t.Fatalf("net.ResolveUDPAddr failed: %v", err)
+		t.Fatal(err)
 	}
 	p := ipv4.NewPacketConn(c)
 	defer p.Close()
 	cf := ipv4.FlagTTL | ipv4.FlagDst | ipv4.FlagInterface
+	wb := []byte("HELLO-R-U-THERE")
 
 	for i, toggle := range []bool{true, false, true} {
 		if err := p.SetControlMessage(cf, toggle); err != nil {
 			if nettest.ProtocolNotSupported(err) {
-				t.Skipf("not supported on %q", runtime.GOOS)
+				t.Logf("not supported on %q", runtime.GOOS)
+				continue
 			}
-			t.Fatalf("ipv4.PacketConn.SetControlMessage failed: %v", err)
+			t.Fatal(err)
 		}
 		p.SetTTL(i + 1)
 		if err := p.SetWriteDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
-			t.Fatalf("ipv4.PacketConn.SetWriteDeadline failed: %v", err)
+			t.Fatal(err)
 		}
-		if _, err := p.WriteTo([]byte("HELLO-R-U-THERE"), nil, dst); err != nil {
-			t.Fatalf("ipv4.PacketConn.WriteTo failed: %v", err)
+		if n, err := p.WriteTo(wb, nil, dst); err != nil {
+			t.Fatal(err)
+		} else if n != len(wb) {
+			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("ipv4.PacketConn.SetReadDeadline failed: %v", err)
+			t.Fatal(err)
 		}
-		if _, cm, _, err := p.ReadFrom(rb); err != nil {
-			t.Fatalf("ipv4.PacketConn.ReadFrom failed: %v", err)
+		if n, cm, _, err := p.ReadFrom(rb); err != nil {
+			t.Fatal(err)
+		} else if !bytes.Equal(rb[:n], wb) {
+			t.Fatalf("got %v; want %v", rb[:n], wb)
 		} else {
 			t.Logf("rcvd cmsg: %v", cm)
 		}
@@ -82,13 +89,13 @@ func TestPacketConnReadWriteUnicastICMP(t *testing.T) {
 
 	c, err := net.ListenPacket("ip4:icmp", "0.0.0.0")
 	if err != nil {
-		t.Fatalf("net.ListenPacket failed: %v", err)
+		t.Fatal(err)
 	}
 	defer c.Close()
 
 	dst, err := net.ResolveIPAddr("ip4", "127.0.0.1")
 	if err != nil {
-		t.Fatalf("ResolveIPAddr failed: %v", err)
+		t.Fatal(err)
 	}
 	p := ipv4.NewPacketConn(c)
 	defer p.Close()
@@ -103,40 +110,48 @@ func TestPacketConnReadWriteUnicastICMP(t *testing.T) {
 			},
 		}).Marshal(nil)
 		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.Logf("not supported on %q", runtime.GOOS)
+				continue
 			}
-			t.Fatalf("ipv4.PacketConn.SetControlMessage failed: %v", err)
+			t.Fatal(err)
 		}
 		p.SetTTL(i + 1)
 		if err := p.SetWriteDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
-			t.Fatalf("ipv4.PacketConn.SetWriteDeadline failed: %v", err)
+			t.Fatal(err)
 		}
-		if _, err := p.WriteTo(wb, nil, dst); err != nil {
-			t.Fatalf("ipv4.PacketConn.WriteTo failed: %v", err)
+		if n, err := p.WriteTo(wb, nil, dst); err != nil {
+			t.Fatal(err)
+		} else if n != len(wb) {
+			t.Fatalf("got %v; want %v", n, len(wb))
 		}
-		b := make([]byte, 128)
+		rb := make([]byte, 128)
 	loop:
 		if err := p.SetReadDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
-			t.Fatalf("ipv4.PacketConn.SetReadDeadline failed: %v", err)
+			t.Fatal(err)
 		}
-		if n, cm, _, err := p.ReadFrom(b); err != nil {
-			t.Fatalf("ipv4.PacketConn.ReadFrom failed: %v", err)
+		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)
-			m, err := icmp.ParseMessage(iana.ProtocolICMP, b[:n])
+			m, err := icmp.ParseMessage(iana.ProtocolICMP, rb[:n])
 			if err != nil {
-				t.Fatalf("icmp.ParseMessage failed: %v", err)
+				t.Fatal(err)
 			}
 			if runtime.GOOS == "linux" && m.Type == ipv4.ICMPTypeEcho {
 				// On Linux we must handle own sent packets.
 				goto loop
 			}
 			if m.Type != ipv4.ICMPTypeEchoReply || m.Code != 0 {
-				t.Fatalf("got type=%v, code=%v; expected type=%v, code=%v", m.Type, m.Code, ipv4.ICMPTypeEchoReply, 0)
+				t.Fatalf("got type=%v, code=%v; want type=%v, code=%v", m.Type, m.Code, ipv4.ICMPTypeEchoReply, 0)
 			}
 		}
 	}
@@ -157,17 +172,17 @@ func TestRawConnReadWriteUnicastICMP(t *testing.T) {
 
 	c, err := net.ListenPacket("ip4:icmp", "0.0.0.0")
 	if err != nil {
-		t.Fatalf("net.ListenPacket failed: %v", err)
+		t.Fatal(err)
 	}
 	defer c.Close()
 
 	dst, err := net.ResolveIPAddr("ip4", "127.0.0.1")
 	if err != nil {
-		t.Fatalf("ResolveIPAddr failed: %v", err)
+		t.Fatal(err)
 	}
 	r, err := ipv4.NewRawConn(c)
 	if err != nil {
-		t.Fatalf("ipv4.NewRawConn failed: %v", err)
+		t.Fatal(err)
 	}
 	defer r.Close()
 	cf := ipv4.FlagTTL | ipv4.FlagDst | ipv4.FlagInterface
@@ -181,7 +196,7 @@ func TestRawConnReadWriteUnicastICMP(t *testing.T) {
 			},
 		}).Marshal(nil)
 		if err != nil {
-			t.Fatalf("icmp.Message.Marshal failed: %v", err)
+			t.Fatal(err)
 		}
 		wh := &ipv4.Header{
 			Version:  ipv4.Version,
@@ -194,35 +209,41 @@ func TestRawConnReadWriteUnicastICMP(t *testing.T) {
 		}
 		if err := r.SetControlMessage(cf, toggle); err != nil {
 			if nettest.ProtocolNotSupported(err) {
-				t.Skipf("not supported on %q", runtime.GOOS)
+				t.Logf("not supported on %q", runtime.GOOS)
+				continue
 			}
-			t.Fatalf("ipv4.RawConn.SetControlMessage failed: %v", err)
+			t.Fatal(err)
 		}
 		if err := r.SetWriteDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
-			t.Fatalf("ipv4.RawConn.SetWriteDeadline failed: %v", err)
+			t.Fatal(err)
 		}
 		if err := r.WriteTo(wh, wb, nil); err != nil {
-			t.Fatalf("ipv4.RawConn.WriteTo failed: %v", err)
+			t.Fatal(err)
 		}
 		rb := make([]byte, ipv4.HeaderLen+128)
 	loop:
 		if err := r.SetReadDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
-			t.Fatalf("ipv4.RawConn.SetReadDeadline failed: %v", err)
+			t.Fatal(err)
 		}
 		if _, b, cm, err := r.ReadFrom(rb); err != nil {
-			t.Fatalf("ipv4.RawConn.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)
 			m, err := icmp.ParseMessage(iana.ProtocolICMP, b)
 			if err != nil {
-				t.Fatalf("icmp.ParseMessage failed: %v", err)
+				t.Fatal(err)
 			}
 			if runtime.GOOS == "linux" && m.Type == ipv4.ICMPTypeEcho {
 				// On Linux we must handle own sent packets.
 				goto loop
 			}
 			if m.Type != ipv4.ICMPTypeEchoReply || m.Code != 0 {
-				t.Fatalf("got type=%v, code=%v; expected type=%v, code=%v", m.Type, m.Code, ipv4.ICMPTypeEchoReply, 0)
+				t.Fatalf("got type=%v, code=%v; want type=%v, code=%v", m.Type, m.Code, ipv4.ICMPTypeEchoReply, 0)
 			}
 		}
 	}

ipv4/unicastsockopt_test.go

@@ -27,7 +27,7 @@ func TestConnUnicastSocketOptions(t *testing.T) {
 
 	ln, err := net.Listen("tcp4", "127.0.0.1:0")
 	if err != nil {
-		t.Fatalf("net.Listen failed: %v", err)
+		t.Fatal(err)
 	}
 	defer ln.Close()
 
@@ -36,7 +36,7 @@ func TestConnUnicastSocketOptions(t *testing.T) {
 
 	c, err := net.Dial("tcp4", ln.Addr().String())
 	if err != nil {
-		t.Fatalf("net.Dial failed: %v", err)
+		t.Fatal(err)
 	}
 	defer c.Close()
 
@@ -64,11 +64,12 @@ func TestPacketConnUnicastSocketOptions(t *testing.T) {
 
 	for _, tt := range packetConnUnicastSocketOptionTests {
 		if tt.net == "ip4" && os.Getuid() != 0 {
-			t.Skip("must be root")
+			t.Log("must be root")
+			continue
 		}
 		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()
 
@@ -91,13 +92,13 @@ func TestRawConnUnicastSocketOptions(t *testing.T) {
 
 	c, err := net.ListenPacket("ip4:icmp", "127.0.0.1")
 	if err != nil {
-		t.Fatalf("net.ListenPacket failed: %v", err)
+		t.Fatal(err)
 	}
 	defer c.Close()
 
 	r, err := ipv4.NewRawConn(c)
 	if err != nil {
-		t.Fatalf("ipv4.NewRawConn failed: %v", err)
+		t.Fatal(err)
 	}
 
 	testUnicastSocketOptions(t, r)
@@ -115,24 +116,24 @@ func testUnicastSocketOptions(t *testing.T, c testIPv4UnicastConn) {
 	switch runtime.GOOS {
 	case "windows":
 		// IP_TOS option is supported on Windows 8 and beyond.
-		t.Skipf("skipping IP_TOS test on %q", runtime.GOOS)
+		t.Skipf("not supported on %q", runtime.GOOS)
 	}
 
 	if err := c.SetTOS(tos); err != nil {
-		t.Fatalf("ipv4.Conn.SetTOS failed: %v", err)
+		t.Fatal(err)
 	}
 	if v, err := c.TOS(); err != nil {
-		t.Fatalf("ipv4.Conn.TOS failed: %v", err)
+		t.Fatal(err)
 	} else if v != tos {
-		t.Fatalf("got unexpected TOS value %v; expected %v", v, tos)
+		t.Fatalf("got %v; want %v", v, tos)
 	}
 	const ttl = 255
 	if err := c.SetTTL(ttl); err != nil {
-		t.Fatalf("ipv4.Conn.SetTTL failed: %v", err)
+		t.Fatal(err)
 	}
 	if v, err := c.TTL(); err != nil {
-		t.Fatalf("ipv4.Conn.TTL failed: %v", err)
+		t.Fatal(err)
 	} else if v != ttl {
-		t.Fatalf("got unexpected TTL value %v; expected %v", v, ttl)
+		t.Fatalf("got %v; want %v", v, ttl)
 	}
 }