all: use t.Skip{,f}

src/pkg/net/timeout_test.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package net
 
 import (
         "fmt"
         "io"
         "io/ioutil"
         "runtime"
         "testing"
         "time"
 )
 
 func isTimeout(err error) bool {
         e, ok := err.(Error)
         return ok && e.Timeout()
 }
 
 type copyRes struct {
         n   int64
         err error
         d   time.Duration
 }
 
 func TestAcceptTimeout(t *testing.T) {
         switch runtime.GOOS {
         case "plan9":
-                t.Logf("skipping test on %q", runtime.GOOS)
-                return
+                t.Skipf("skipping test on %q", runtime.GOOS)
         }
 
         ln := newLocalListener(t).(*TCPListener)
         defer ln.Close()
         ln.SetDeadline(time.Now().Add(-1 * time.Second))
         if _, err := ln.Accept(); !isTimeout(err) {
                 t.Fatalf("Accept: expected err %v, got %v", errTimeout, err)
         }
         if _, err := ln.Accept(); !isTimeout(err) {
                 t.Fatalf("Accept: expected err %v, got %v", errTimeout, err)
@@ skipping 26 matching lines @@
         default:
                 if err != errClosing {
                         t.Fatalf("Accept: expected err %v, got %v", errClosing, err)
                 }
         }
 }
 
 func TestReadTimeout(t *testing.T) {
         switch runtime.GOOS {
         case "plan9":
-                t.Logf("skipping test on %q", runtime.GOOS)
-                return
+                t.Skipf("skipping test on %q", runtime.GOOS)
         }
 
         ln := newLocalListener(t)
         defer ln.Close()
         c, err := DialTCP("tcp", nil, ln.Addr().(*TCPAddr))
         if err != nil {
                 t.Fatalf("Connect: %v", err)
         }
         defer c.Close()
         c.SetDeadline(time.Now().Add(time.Hour))
@@ skipping 34 matching lines @@
         default:
                 if err != errClosing {
                         t.Fatalf("Read: expected err %v, got %v", errClosing, err)
                 }
         }
 }
 
 func TestWriteTimeout(t *testing.T) {
         switch runtime.GOOS {
         case "plan9":
-                t.Logf("skipping test on %q", runtime.GOOS)
-                return
+                t.Skipf("skipping test on %q", runtime.GOOS)
         }
 
         ln := newLocalListener(t)
         defer ln.Close()
         c, err := DialTCP("tcp", nil, ln.Addr().(*TCPAddr))
         if err != nil {
                 t.Fatalf("Connect: %v", err)
         }
         defer c.Close()
         c.SetDeadline(time.Now().Add(time.Hour))
@@ skipping 85 matching lines @@
                         t.Error(err)
                 }
         case <-time.After(1 * time.Second):
                 t.Errorf("%s(%q, %q) took over 1 second, expected 0.1s", what, net, addr)
         }
 }
 
 func TestTimeoutUDP(t *testing.T) {
         switch runtime.GOOS {
         case "plan9":
-                t.Logf("skipping test on %q", runtime.GOOS)
-                return
+                t.Skipf("skipping test on %q", runtime.GOOS)
         }
 
         // set up a listener that won't talk back
         listening := make(chan string)
         done := make(chan int)
         go runDatagramPacketConnServer(t, "udp", "127.0.0.1:0", listening, done)
         addr := <-listening
 
         testTimeout(t, "udp", addr, false)
         testTimeout(t, "udp", addr, true)
         <-done
 }
 
 func TestTimeoutTCP(t *testing.T) {
         switch runtime.GOOS {
         case "plan9":
-                t.Logf("skipping test on %q", runtime.GOOS)
-                return
+                t.Skipf("skipping test on %q", runtime.GOOS)
         }
 
         // set up a listener that won't talk back
         listening := make(chan string)
         done := make(chan int)
         go runStreamConnServer(t, "tcp", "127.0.0.1:0", listening, done)
         addr := <-listening
 
         testTimeout(t, "tcp", addr, false)
         <-done
 }
 
 func TestDeadlineReset(t *testing.T) {
         switch runtime.GOOS {
         case "plan9":
-                t.Logf("skipping test on %q", runtime.GOOS)
-                return
+                t.Skipf("skipping test on %q", runtime.GOOS)
         }
         ln, err := Listen("tcp", "127.0.0.1:0")
         if err != nil {
                 t.Fatal(err)
         }
         defer ln.Close()
         tl := ln.(*TCPListener)
         tl.SetDeadline(time.Now().Add(1 * time.Minute))
         tl.SetDeadline(noDeadline) // reset it
         errc := make(chan error, 1)
         go func() {
                 _, err := ln.Accept()
                 errc <- err
         }()
         select {
         case <-time.After(50 * time.Millisecond):
                 // Pass.
         case err := <-errc:
                 // Accept should never return; we never
                 // connected to it.
                 t.Errorf("unexpected return from Accept; err=%v", err)
         }
 }
 
 func TestTimeoutAccept(t *testing.T) {
         switch runtime.GOOS {
         case "plan9":
-                t.Logf("skipping test on %q", runtime.GOOS)
-                return
+                t.Skipf("skipping test on %q", runtime.GOOS)
         }
         ln, err := Listen("tcp", "127.0.0.1:0")
         if err != nil {
                 t.Fatal(err)
         }
         defer ln.Close()
         tl := ln.(*TCPListener)
         tl.SetDeadline(time.Now().Add(100 * time.Millisecond))
         errc := make(chan error, 1)
         go func() {
                 _, err := ln.Accept()
                 errc <- err
         }()
         select {
         case <-time.After(1 * time.Second):
                 // Accept shouldn't block indefinitely
                 t.Errorf("Accept didn't return in an expected time")
         case <-errc:
                 // Pass.
         }
 }
 
 func TestReadWriteDeadline(t *testing.T) {
         switch runtime.GOOS {
         case "plan9":
-                t.Logf("skipping test on %q", runtime.GOOS)
-                return
+                t.Skipf("skipping test on %q", runtime.GOOS)
         }
 
         if !canCancelIO {
-                t.Logf("skipping test on this system")
-                return
+                t.Skip("skipping test on this system")
         }
         const (
                 readTimeout  = 50 * time.Millisecond
                 writeTimeout = 250 * time.Millisecond
         )
         checkTimeout := func(command string, start time.Time, should time.Duration) {
                 is := time.Now().Sub(start)
                 d := is - should
                 if d < -30*time.Millisecond || !testing.Short() && 150*time.Millisecond < d {
                         t.Errorf("%s timeout test failed: is=%v should=%v\n", command, is, should)
@@ skipping 239 matching lines @@
         if !isTimeout(res.err) {
                 t.Errorf("Write error = %v; want timeout", res.err)
         }
 }
 
 // TestProlongTimeout tests concurrent deadline modification.
 // Known to cause data races in the past.
 func TestProlongTimeout(t *testing.T) {
         switch runtime.GOOS {
         case "plan9":
-                t.Logf("skipping test on %q", runtime.GOOS)
-                return
+                t.Skipf("skipping test on %q", runtime.GOOS)
         }
 
         ln := newLocalListener(t)
         defer ln.Close()
         connected := make(chan bool)
         go func() {
                 s, err := ln.Accept()
                 connected <- true
                 if err != nil {
                         t.Fatalf("ln.Accept: %v", err)
@@ skipping 23 matching lines @@
         if err != nil {
                 t.Fatalf("DialTCP: %v", err)
         }
         defer c.Close()
         <-connected
         for i := 0; i < 1024; i++ {
                 var buf [1]byte
                 c.Write(buf[:])
         }
 }