diff --git a/unix/affinity_linux.go b/unix/affinity_linux.go
index 72afe333..14e4d5ca 100644
--- a/unix/affinity_linux.go
+++ b/unix/affinity_linux.go
@@ -91,9 +91,13 @@ func onesCount64(x uint64) int {
 	const m0 = 0x5555555555555555 // 01010101 ...
 	const m1 = 0x3333333333333333 // 00110011 ...
 	const m2 = 0x0f0f0f0f0f0f0f0f // 00001111 ...
-	const m3 = 0x00ff00ff00ff00ff // etc.
-	const m4 = 0x0000ffff0000ffff
 
+	// Unused in this function, but definitions preserved for
+	// documentation purposes:
+	//
+	//   const m3 = 0x00ff00ff00ff00ff // etc.
+	//   const m4 = 0x0000ffff0000ffff
+	//
 	// Implementation: Parallel summing of adjacent bits.
 	// See "Hacker's Delight", Chap. 5: Counting Bits.
 	// The following pattern shows the general approach:
diff --git a/unix/sendfile_test.go b/unix/sendfile_test.go
index d41fb93c..814b4d91 100644
--- a/unix/sendfile_test.go
+++ b/unix/sendfile_test.go
@@ -41,10 +41,15 @@ func TestSendfile(t *testing.T) {
 	go func() {
 		conn, err := ln.Accept()
 		if err != nil {
-			t.Fatal(err)
+			t.Errorf("failed to accept: %v", err)
+			return
 		}
 		defer conn.Close()
 		b, err := ioutil.ReadAll(conn)
+		if err != nil {
+			t.Errorf("failed to read: %v", err)
+			return
+		}
 		if string(b) != contents {
 			t.Errorf("contents not transmitted: got %s (len=%d), want %s", string(b), len(b), contents)
 		}
diff --git a/unix/syscall_linux_test.go b/unix/syscall_linux_test.go
index 00aa6556..6ceeb426 100644
--- a/unix/syscall_linux_test.go
+++ b/unix/syscall_linux_test.go
@@ -516,7 +516,7 @@ func TestClockNanosleep(t *testing.T) {
 		t.Skip("clock_nanosleep syscall is not available, skipping test")
 	} else if err != nil {
 		t.Errorf("ClockNanosleep(CLOCK_MONOTONIC, 0, %#v, nil) = %v", &rel, err)
-	} else if slept := time.Now().Sub(start); slept < delay {
+	} else if slept := time.Since(start); slept < delay {
 		t.Errorf("ClockNanosleep(CLOCK_MONOTONIC, 0, %#v, nil) slept only %v", &rel, slept)
 	}
 
@@ -527,7 +527,7 @@ func TestClockNanosleep(t *testing.T) {
 	err = unix.ClockNanosleep(unix.CLOCK_REALTIME, unix.TIMER_ABSTIME, &abs, nil)
 	if err != nil {
 		t.Errorf("ClockNanosleep(CLOCK_REALTIME, TIMER_ABSTIME, %#v (=%v), nil) = %v", &abs, until, err)
-	} else if slept := time.Now().Sub(start); slept < delay {
+	} else if slept := time.Since(start); slept < delay {
 		t.Errorf("ClockNanosleep(CLOCK_REALTIME, TIMER_ABSTIME, %#v (=%v), nil) slept only %v", &abs, until, slept)
 	}
 
diff --git a/unix/syscall_test.go b/unix/syscall_test.go
index e0ecfa70..1538c720 100644
--- a/unix/syscall_test.go
+++ b/unix/syscall_test.go
@@ -62,13 +62,10 @@ func TestUname(t *testing.T) {
 // Test that this compiles. (Issue #31735)
 func TestStatFieldNames(t *testing.T) {
 	var st unix.Stat_t
-	var ts *unix.Timespec
-	ts = &st.Atim
-	ts = &st.Mtim
-	ts = &st.Ctim
-	_ = ts
-	secs := int64(st.Mtim.Sec)
-	nsecs := int64(st.Mtim.Nsec)
-	_ = secs
-	_ = nsecs
+	var _ *unix.Timespec
+	_ = &st.Atim
+	_ = &st.Mtim
+	_ = &st.Ctim
+	_ = int64(st.Mtim.Sec)
+	_ = int64(st.Mtim.Nsec)
 }