code review 5228041: http: cancel a timer in a test

src/pkg/http/serve_test.go

 // Copyright 2010 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.
 
 // End-to-end serving tests
 
 package http_test
 
 import (
         "bufio"
@@ skipping 338 matching lines @@
         // Verify that the connection is closed when the declared Content-Length
         // is larger than what the handler wrote.
         conn, err := net.Dial("tcp", ts.Listener.Addr().String())
         if err != nil {
                 t.Fatalf("error dialing: %v", err)
         }
         _, err = conn.Write([]byte("GET /?underwrite=1 HTTP/1.1\r\nHost: foo\r\n\r\n"))
         if err != nil {
                 t.Fatalf("error writing: %v", err)
         }
-        // The next ReadAll will hang for a failing test, so use a Timer instead
-        // to fail more traditionally
-        timer := time.AfterFunc(2e9, func() {
-                t.Fatalf("Timeout expired in ReadAll.")
+
+        // The ReadAll will hang for a failing test, so use a Timer to
+        // fail explicitly.
+        goTimeout(t, 2e9, func() {
+                got, _ := ioutil.ReadAll(conn)
+                expectedSuffix := "\r\n\r\ntoo short"
+                if !strings.HasSuffix(string(got), expectedSuffix) {
+                        t.Errorf("Expected output to end with %q; got response body %q",
+                                expectedSuffix, string(got))
+                }
         })
-        defer timer.Stop()
-        got, _ := ioutil.ReadAll(conn)
-        expectedSuffix := "\r\n\r\ntoo short"
-        if !strings.HasSuffix(string(got), expectedSuffix) {
-                t.Fatalf("Expected output to end with %q; got response body %q",
-                        expectedSuffix, string(got))
-        }
 }
 
 func testTcpConnectionCloses(t *testing.T, req string, h Handler) {
         s := httptest.NewServer(h)
         defer s.Close()
 
         conn, err := net.Dial("tcp", s.Listener.Addr().String())
         if err != nil {
                 t.Fatal("dial error:", err)
         }
@@ skipping 161 matching lines @@
         }
         ts := httptest.NewUnstartedServer(HandlerFunc(func(w ResponseWriter, r *Request) {}))
         ts.Config.ReadTimeout = 250e6
         ts.StartTLS()
         defer ts.Close()
         conn, err := net.Dial("tcp", ts.Listener.Addr().String())
         if err != nil {
                 t.Fatalf("Dial: %v", err)
         }
         defer conn.Close()
-        timer := time.AfterFunc(10e9, func() { t.Fatalf("Timeout") })
-        defer timer.Stop()
-
-        var buf [1]byte
-        n, err := conn.Read(buf[:])
-        if err == nil || n != 0 {
-                t.Errorf("Read = %d, %v; want an error and no bytes", n, err)
-        }
+        goTimeout(t, 10e9, func() {
+                var buf [1]byte
+                n, err := conn.Read(buf[:])
+                if err == nil || n != 0 {
+                        t.Errorf("Read = %d, %v; want an error and no bytes", n, err)
+                }
+        })
 }
 
 func TestTLSServer(t *testing.T) {
         ts := httptest.NewTLSServer(HandlerFunc(func(w ResponseWriter, r *Request) {
                 if r.TLS != nil {
                         w.Header().Set("X-TLS-Set", "true")
                         if r.TLS.HandshakeComplete {
                                 w.Header().Set("X-TLS-HandshakeComplete", "true")
                         }
                 }
         }))
         defer ts.Close()
 
         // Connect an idle TCP connection to this server before we run
         // our real tests.  This idle connection used to block forever
         // in the TLS handshake, preventing future connections from
         // being accepted. It may prevent future accidental blocking
         // in newConn.
         idleConn, err := net.Dial("tcp", ts.Listener.Addr().String())
         if err != nil {
                 t.Fatalf("Dial: %v", err)
         }
         defer idleConn.Close()
-        timer := time.AfterFunc(10e9, func() { t.Fatalf("Timeout") })
-        defer timer.Stop()
-
-        if !strings.HasPrefix(ts.URL, "https://") {
-                t.Fatalf("expected test TLS server to start with https://, got %q", ts.URL)
-        }
-        res, err := Get(ts.URL)
-        if err != nil {
-                t.Fatal(err)
-        }
-        if res == nil {
-                t.Fatalf("got nil Response")
-        }
-        defer res.Body.Close()
-        if res.Header.Get("X-TLS-Set") != "true" {
-                t.Errorf("expected X-TLS-Set response header")
-        }
-        if res.Header.Get("X-TLS-HandshakeComplete") != "true" {
-                t.Errorf("expected X-TLS-HandshakeComplete header")
-        }
+        goTimeout(t, 10e9, func() {
+                if !strings.HasPrefix(ts.URL, "https://") {
+                        t.Errorf("expected test TLS server to start with https://, got %q", ts.URL)
+                        return
+                }
+                res, err := Get(ts.URL)
+                if err != nil {
+                        t.Error(err)
+                        return
+                }
+                if res == nil {
+                        t.Errorf("got nil Response")
+                        return
+                }
+                defer res.Body.Close()
+                if res.Header.Get("X-TLS-Set") != "true" {
+                        t.Errorf("expected X-TLS-Set response header")
+                        return
+                }
+                if res.Header.Get("X-TLS-HandshakeComplete") != "true" {
+                        t.Errorf("expected X-TLS-HandshakeComplete header")
+                }
+        })
 }
 
 type serverExpectTest struct {
         contentLength    int    // of request body
         expectation      string // e.g. "100-continue"
         readBody         bool   // whether handler should read the body (if false, sends StatusUnauthorized)
         expectedResponse string // expected substring in first line of http response
 }
 
 var serverExpectTests = []serverExpectTest{
@@ skipping 400 matching lines @@
                         t.Errorf("read %q from server; want nothing", got)
                 }
         }()
         select {
         case <-donec:
         case <-time.After(10e9):
                 t.Fatalf("timeout")
         }
 }
 
+// goTimeout runs f, failing t if f takes more than ns to complete.
+func goTimeout(t *testing.T, ns int64, f func()) {
+        ch := make(chan bool, 2)
+        timer := time.AfterFunc(ns, func() {
+                t.Errorf("Timeout expired after %d ns", ns)
+                ch <- true
+        })
+        defer timer.Stop()
+        go func() {
+                defer func() { ch <- true }()
+                f()
+        }()
+        <-ch
+}
+
 type errorListener struct {
         errs []os.Error
 }
 
 func (l *errorListener) Accept() (c net.Conn, err os.Error) {
         if len(l.errs) == 0 {
                 return nil, os.EOF
         }
         err = l.errs[0]
         l.errs = l.errs[1:]
@@ skipping 41 matching lines @@
                         panic("ReadAll: " + err.String())
                 }
                 body := string(all)
                 if body != "Hello world.\n" {
                         panic("Got body: " + body)
                 }
         }
 
         b.StopTimer()
 }