Go 1.4.2, grep "Body.Close"

grep.Body.Close.txt

cmd/go/http.go-28-func httpGET(url string) ([]byte, error) {
cmd/go/http.go-29-	resp, err := httpClient.Get(url)
cmd/go/http.go-30-	if err != nil {
cmd/go/http.go-31-		return nil, err
cmd/go/http.go-32-	}
cmd/go/http.go:33:	defer resp.Body.Close()
cmd/go/http.go-34-	if resp.StatusCode != 200 {
cmd/go/http.go-35-		return nil, fmt.Errorf("%s: %s", url, resp.Status)
cmd/go/http.go-36-	}
cmd/go/http.go-37-	b, err := ioutil.ReadAll(resp.Body)
cmd/go/http.go-38-	if err != nil {
--
--
cmd/go/http.go-57-		res, err = httpClient.Get(urlStr)
cmd/go/http.go-58-		return
cmd/go/http.go-59-	}
cmd/go/http.go-60-	closeBody := func(res *http.Response) {
cmd/go/http.go-61-		if res != nil {
cmd/go/http.go:62:			res.Body.Close()
cmd/go/http.go-63-		}
cmd/go/http.go-64-	}
cmd/go/http.go-65-	urlStr, res, err := fetch("https")
cmd/go/http.go-66-	if err != nil || res.StatusCode != 200 {
cmd/go/http.go-67-		if buildV {
--
--
cmd/pprof/internal/fetch/fetch.go-64-		return nil, fmt.Errorf("http post %s: %v", source, err)
cmd/pprof/internal/fetch/fetch.go-65-	}
cmd/pprof/internal/fetch/fetch.go-66-	if resp.StatusCode != http.StatusOK {
cmd/pprof/internal/fetch/fetch.go-67-		return nil, fmt.Errorf("server response: %s", resp.Status)
cmd/pprof/internal/fetch/fetch.go-68-	}
cmd/pprof/internal/fetch/fetch.go:69:	defer resp.Body.Close()
cmd/pprof/internal/fetch/fetch.go-70-	return ioutil.ReadAll(resp.Body)
cmd/pprof/internal/fetch/fetch.go-71-}
cmd/pprof/internal/fetch/fetch.go-72-
cmd/pprof/internal/fetch/fetch.go-73-// httpGet is a wrapper around http.Get; it is defined as a variable
cmd/pprof/internal/fetch/fetch.go-74-// so it can be redefined during for testing.
--
--
net/http/client.go-373-			// No need to check for errors: if it fails, Transport won't reuse it anyway.
net/http/client.go-374-			const maxBodySlurpSize = 2 << 10
net/http/client.go-375-			if resp.ContentLength == -1 || resp.ContentLength <= maxBodySlurpSize {
net/http/client.go-376-				io.CopyN(ioutil.Discard, resp.Body, maxBodySlurpSize)
net/http/client.go-377-			}
net/http/client.go:378:			resp.Body.Close()
net/http/client.go-379-			if urlStr = resp.Header.Get("Location"); urlStr == "" {
net/http/client.go-380-				err = errors.New(fmt.Sprintf("%d response missing Location header", resp.StatusCode))
net/http/client.go-381-				break
net/http/client.go-382-			}
net/http/client.go-383-			base = req.URL
--
--
net/http/client.go-403-		// See http://golang.org/issue/3795
net/http/client.go-404-		return resp, urlErr
net/http/client.go-405-	}
net/http/client.go-406-
net/http/client.go-407-	if resp != nil {
net/http/client.go:408:		resp.Body.Close()
net/http/client.go-409-	}
net/http/client.go-410-	return nil, urlErr
net/http/client.go-411-}
net/http/client.go-412-
net/http/client.go-413-func defaultCheckRedirect(req *Request, via []*Request) error {
--
--
net/http/client_test.go-72-
net/http/client_test.go-73-	r, err := Get(ts.URL)
net/http/client_test.go-74-	var b []byte
net/http/client_test.go-75-	if err == nil {
net/http/client_test.go-76-		b, err = pedanticReadAll(r.Body)
net/http/client_test.go:77:		r.Body.Close()
net/http/client_test.go-78-	}
net/http/client_test.go-79-	if err != nil {
net/http/client_test.go-80-		t.Error(err)
net/http/client_test.go-81-	} else if s := string(b); !strings.HasPrefix(s, "User-agent:") {
net/http/client_test.go-82-		t.Errorf("Incorrect page body (did not begin with User-agent): %q", s)
--
--
net/http/client_test.go-238-	}}
net/http/client_test.go-239-	res, err := c.Get(ts.URL)
net/http/client_test.go-240-	if err != nil {
net/http/client_test.go-241-		t.Fatalf("Get error: %v", err)
net/http/client_test.go-242-	}
net/http/client_test.go:243:	res.Body.Close()
net/http/client_test.go-244-	finalUrl := res.Request.URL.String()
net/http/client_test.go-245-	if e, g := "<nil>", fmt.Sprintf("%v", err); e != g {
net/http/client_test.go-246-		t.Errorf("with custom client, expected error %q, got %q", e, g)
net/http/client_test.go-247-	}
net/http/client_test.go-248-	if !strings.HasSuffix(finalUrl, "/?n=15") {
--
--
net/http/client_test.go-258-		t.Errorf("with redirects forbidden, expected a *url.Error with our 'no redirects allowed' error inside; got %#v (%q)", err, err)
net/http/client_test.go-259-	}
net/http/client_test.go-260-	if res == nil {
net/http/client_test.go-261-		t.Fatalf("Expected a non-nil Response on CheckRedirect failure (http://golang.org/issue/3795)")
net/http/client_test.go-262-	}
net/http/client_test.go:263:	res.Body.Close()
net/http/client_test.go-264-	if res.Header.Get("Location") == "" {
net/http/client_test.go-265-		t.Errorf("no Location header in Response")
net/http/client_test.go-266-	}
net/http/client_test.go-267-}
net/http/client_test.go-268-
--
--
net/http/client_test.go-396-	c.Jar.SetCookies(u, []*Cookie{expectedCookies[0]})
net/http/client_test.go-397-	resp, err := c.Get(ts.URL)
net/http/client_test.go-398-	if err != nil {
net/http/client_test.go-399-		t.Fatalf("Get: %v", err)
net/http/client_test.go-400-	}
net/http/client_test.go:401:	resp.Body.Close()
net/http/client_test.go-402-	matchReturnedCookies(t, expectedCookies, resp.Cookies())
net/http/client_test.go-403-}
net/http/client_test.go-404-
net/http/client_test.go-405-func matchReturnedCookies(t *testing.T, expected, given []*Cookie) {
net/http/client_test.go-406-	if len(given) != len(expected) {
--
--
net/http/client_test.go-593-		res, err := c.Get(ts.URL)
net/http/client_test.go-594-		if (err == nil) != insecure {
net/http/client_test.go-595-			t.Errorf("insecure=%v: got unexpected err=%v", insecure, err)
net/http/client_test.go-596-		}
net/http/client_test.go-597-		if res != nil {
net/http/client_test.go:598:			res.Body.Close()
net/http/client_test.go-599-		}
net/http/client_test.go-600-	}
net/http/client_test.go-601-
net/http/client_test.go-602-	select {
net/http/client_test.go-603-	case v := <-errc:
--
--
net/http/client_test.go-706-	c := &Client{Transport: tr}
net/http/client_test.go-707-	res, err := c.Get("https://some-other-host.tld/")
net/http/client_test.go-708-	if err != nil {
net/http/client_test.go-709-		t.Fatal(err)
net/http/client_test.go-710-	}
net/http/client_test.go:711:	res.Body.Close()
net/http/client_test.go-712-}
net/http/client_test.go-713-
net/http/client_test.go-714-func TestResponseSetsTLSConnectionState(t *testing.T) {
net/http/client_test.go-715-	defer afterTest(t)
net/http/client_test.go-716-	ts := httptest.NewTLSServer(HandlerFunc(func(w ResponseWriter, r *Request) {
--
--
net/http/client_test.go-727-	c := &Client{Transport: tr}
net/http/client_test.go-728-	res, err := c.Get("https://example.com/")
net/http/client_test.go-729-	if err != nil {
net/http/client_test.go-730-		t.Fatal(err)
net/http/client_test.go-731-	}
net/http/client_test.go:732:	defer res.Body.Close()
net/http/client_test.go-733-	if res.TLS == nil {
net/http/client_test.go-734-		t.Fatal("Response didn't set TLS Connection State.")
net/http/client_test.go-735-	}
net/http/client_test.go-736-	if got, want := res.TLS.CipherSuite, tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA; got != want {
net/http/client_test.go-737-		t.Errorf("TLS Cipher Suite = %d; want %d", got, want)
--
--
net/http/client_test.go-803-	req.URL.User = url.User(gopher)
net/http/client_test.go-804-	resp, err := c.Do(req)
net/http/client_test.go-805-	if err != nil {
net/http/client_test.go-806-		t.Fatal(err)
net/http/client_test.go-807-	}
net/http/client_test.go:808:	defer resp.Body.Close()
net/http/client_test.go-809-}
net/http/client_test.go-810-
net/http/client_test.go-811-func TestBasicAuth(t *testing.T) {
net/http/client_test.go-812-	defer afterTest(t)
net/http/client_test.go-813-	tr := &recordingTransport{}
--
--
net/http/client_test.go-890-
net/http/client_test.go-891-	errc := make(chan error, 1)
net/http/client_test.go-892-	go func() {
net/http/client_test.go-893-		_, err := ioutil.ReadAll(res.Body)
net/http/client_test.go-894-		errc <- err
net/http/client_test.go:895:		res.Body.Close()
net/http/client_test.go-896-	}()
net/http/client_test.go-897-
net/http/client_test.go-898-	const failTime = timeout * 2
net/http/client_test.go-899-	select {
net/http/client_test.go-900-	case err := <-errc:
--
--
net/http/client_test.go-924-	}
net/http/client_test.go-925-	_, err = ioutil.ReadAll(res.Body)
net/http/client_test.go-926-	if err != nil {
net/http/client_test.go-927-		t.Fatal(err)
net/http/client_test.go-928-	}
net/http/client_test.go:929:	res.Body.Close()
net/http/client_test.go-930-
net/http/client_test.go-931-	var first string
net/http/client_test.go-932-	select {
net/http/client_test.go-933-	case first = <-saw:
net/http/client_test.go-934-	default:
--
--
net/http/doc.go-18-
net/http/doc.go-19-	resp, err := http.Get("http://example.com/")
net/http/doc.go-20-	if err != nil {
net/http/doc.go-21-		// handle error
net/http/doc.go-22-	}
net/http/doc.go:23:	defer resp.Body.Close()
net/http/doc.go-24-	body, err := ioutil.ReadAll(resp.Body)
net/http/doc.go-25-	// ...
net/http/doc.go-26-
net/http/doc.go-27-For control over HTTP client headers, redirect policy, and other
net/http/doc.go-28-settings, create a Client:
--
--
net/http/example_test.go-41-	res, err := http.Get("http://www.google.com/robots.txt")
net/http/example_test.go-42-	if err != nil {
net/http/example_test.go-43-		log.Fatal(err)
net/http/example_test.go-44-	}
net/http/example_test.go-45-	robots, err := ioutil.ReadAll(res.Body)
net/http/example_test.go:46:	res.Body.Close()
net/http/example_test.go-47-	if err != nil {
net/http/example_test.go-48-		log.Fatal(err)
net/http/example_test.go-49-	}
net/http/example_test.go-50-	fmt.Printf("%s", robots)
net/http/example_test.go-51-}
--
--
net/http/filetransport_test.go-59-	res, err := c.Get(badURL)
net/http/filetransport_test.go-60-	check("Get "+badURL, err)
net/http/filetransport_test.go-61-	if res.StatusCode != 404 {
net/http/filetransport_test.go-62-		t.Errorf("for %s, StatusCode = %d, want 404", badURL, res.StatusCode)
net/http/filetransport_test.go-63-	}
net/http/filetransport_test.go:64:	res.Body.Close()
net/http/filetransport_test.go-65-}
--
--
net/http/fs_test.go-185-	for _, data := range fsRedirectTestData {
net/http/fs_test.go-186-		res, err := Get(ts.URL + data.original)
net/http/fs_test.go-187-		if err != nil {
net/http/fs_test.go-188-			t.Fatal(err)
net/http/fs_test.go-189-		}
net/http/fs_test.go:190:		res.Body.Close()
net/http/fs_test.go-191-		if g, e := res.Request.URL.Path, data.redirect; g != e {
net/http/fs_test.go-192-			t.Errorf("redirect from %s: got %s, want %s", data.original, g, e)
net/http/fs_test.go-193-		}
net/http/fs_test.go-194-	}
net/http/fs_test.go-195-}
--
--
net/http/fs_test.go-269-			t.Errorf("test %q: listing dir, full output is %q, want prefix %q and suffix %q", test.name, s, dirListPrefix, dirListSuffix)
net/http/fs_test.go-270-		}
net/http/fs_test.go-271-		if trimmed := strings.TrimSuffix(strings.TrimPrefix(s, dirListPrefix), dirListSuffix); trimmed != test.escaped {
net/http/fs_test.go-272-			t.Errorf("test %q: listing dir, filename escaped to %q, want %q", test.name, trimmed, test.escaped)
net/http/fs_test.go-273-		}
net/http/fs_test.go:274:		res.Body.Close()
net/http/fs_test.go-275-	}
net/http/fs_test.go-276-}
net/http/fs_test.go-277-
net/http/fs_test.go-278-func mustRemoveAll(dir string) {
net/http/fs_test.go-279-	err := os.RemoveAll(dir)
--
--
net/http/fs_test.go-301-		}
net/http/fs_test.go-302-		b, err := ioutil.ReadAll(res.Body)
net/http/fs_test.go-303-		if err != nil {
net/http/fs_test.go-304-			t.Fatalf("ReadAll %s: %v", suffix, err)
net/http/fs_test.go-305-		}
net/http/fs_test.go:306:		res.Body.Close()
net/http/fs_test.go-307-		return string(b)
net/http/fs_test.go-308-	}
net/http/fs_test.go-309-	if s := get("/bar/"); !strings.Contains(s, ">foo.txt<") {
net/http/fs_test.go-310-		t.Logf("expected a directory listing with foo.txt, got %q", s)
net/http/fs_test.go-311-	}
--
--
net/http/fs_test.go-384-			t.Fatal(err)
net/http/fs_test.go-385-		}
net/http/fs_test.go-386-		if h := resp.Header["Content-Type"]; !reflect.DeepEqual(h, want) {
net/http/fs_test.go-387-			t.Errorf("Content-Type mismatch: got %v, want %v", h, want)
net/http/fs_test.go-388-		}
net/http/fs_test.go:389:		resp.Body.Close()
net/http/fs_test.go-390-	}
net/http/fs_test.go-391-	get("0", []string{"text/plain; charset=utf-8"})
net/http/fs_test.go-392-	get("1", []string{ctype})
net/http/fs_test.go-393-	get("2", nil)
net/http/fs_test.go-394-}
--
--
net/http/fs_test.go-401-	defer ts.Close()
net/http/fs_test.go-402-	resp, err := Get(ts.URL)
net/http/fs_test.go-403-	if err != nil {
net/http/fs_test.go-404-		t.Fatal(err)
net/http/fs_test.go-405-	}
net/http/fs_test.go:406:	resp.Body.Close()
net/http/fs_test.go-407-	want := "text/css; charset=utf-8"
net/http/fs_test.go-408-	if h := resp.Header.Get("Content-Type"); h != want {
net/http/fs_test.go-409-		t.Errorf("Content-Type mismatch: got %q, want %q", h, want)
net/http/fs_test.go-410-	}
net/http/fs_test.go-411-}
--
--
net/http/fs_test.go-418-	defer ts.Close()
net/http/fs_test.go-419-	r, err := Get(ts.URL)
net/http/fs_test.go-420-	if err != nil {
net/http/fs_test.go-421-		t.Fatal(err)
net/http/fs_test.go-422-	}
net/http/fs_test.go:423:	r.Body.Close()
net/http/fs_test.go-424-	if r.StatusCode != 200 {
net/http/fs_test.go-425-		t.Fatalf("expected 200 OK, got %s", r.Status)
net/http/fs_test.go-426-	}
net/http/fs_test.go-427-}
net/http/fs_test.go-428-
--
--
net/http/fs_test.go-435-	defer ts.Close()
net/http/fs_test.go-436-	resp, err := Get(ts.URL)
net/http/fs_test.go-437-	if err != nil {
net/http/fs_test.go-438-		t.Fatal(err)
net/http/fs_test.go-439-	}
net/http/fs_test.go:440:	resp.Body.Close()
net/http/fs_test.go-441-	if g, e := resp.ContentLength, int64(-1); g != e {
net/http/fs_test.go-442-		t.Errorf("Content-Length mismatch: got %d, want %d", g, e)
net/http/fs_test.go-443-	}
net/http/fs_test.go-444-}
net/http/fs_test.go-445-
--
--
net/http/fs_test.go-459-			t.Fatal("reading Body:", err)
net/http/fs_test.go-460-		}
net/http/fs_test.go-461-		if s := string(b); s != want {
net/http/fs_test.go-462-			t.Errorf("for path %q got %q, want %q", path, s, want)
net/http/fs_test.go-463-		}
net/http/fs_test.go:464:		res.Body.Close()
net/http/fs_test.go-465-	}
net/http/fs_test.go-466-}
net/http/fs_test.go-467-
net/http/fs_test.go-468-func TestFileServerZeroByte(t *testing.T) {
net/http/fs_test.go-469-	defer afterTest(t)
--
--
net/http/fs_test.go-576-		t.Fatal(err)
net/http/fs_test.go-577-	}
net/http/fs_test.go-578-	if string(b) != indexContents {
net/http/fs_test.go-579-		t.Fatalf("Got body %q; want %q", b, indexContents)
net/http/fs_test.go-580-	}
net/http/fs_test.go:581:	res.Body.Close()
net/http/fs_test.go-582-
net/http/fs_test.go-583-	lastMod := res.Header.Get("Last-Modified")
net/http/fs_test.go-584-	if lastMod != fileModStr {
net/http/fs_test.go-585-		t.Fatalf("initial Last-Modified = %q; want %q", lastMod, fileModStr)
net/http/fs_test.go-586-	}
--
--
net/http/fs_test.go-593-		t.Fatal(err)
net/http/fs_test.go-594-	}
net/http/fs_test.go-595-	if res.StatusCode != 304 {
net/http/fs_test.go-596-		t.Fatalf("Code after If-Modified-Since request = %v; want 304", res.StatusCode)
net/http/fs_test.go-597-	}
net/http/fs_test.go:598:	res.Body.Close()
net/http/fs_test.go-599-
net/http/fs_test.go-600-	// Advance the index.html file's modtime, but not the directory's.
net/http/fs_test.go-601-	indexFile.modtime = indexFile.modtime.Add(1 * time.Hour)
net/http/fs_test.go-602-
net/http/fs_test.go-603-	res, err = DefaultClient.Do(req)
--
--
net/http/fs_test.go-605-		t.Fatal(err)
net/http/fs_test.go-606-	}
net/http/fs_test.go-607-	if res.StatusCode != 200 {
net/http/fs_test.go-608-		t.Fatalf("Code after second If-Modified-Since request = %v; want 200; res is %#v", res.StatusCode, res)
net/http/fs_test.go-609-	}
net/http/fs_test.go:610:	res.Body.Close()
net/http/fs_test.go-611-}
net/http/fs_test.go-612-
net/http/fs_test.go-613-func mustStat(t *testing.T, fileName string) os.FileInfo {
net/http/fs_test.go-614-	fi, err := os.Stat(fileName)
net/http/fs_test.go-615-	if err != nil {
--
--
net/http/fs_test.go-774-		res, err := DefaultClient.Do(req)
net/http/fs_test.go-775-		if err != nil {
net/http/fs_test.go-776-			t.Fatal(err)
net/http/fs_test.go-777-		}
net/http/fs_test.go-778-		io.Copy(ioutil.Discard, res.Body)
net/http/fs_test.go:779:		res.Body.Close()
net/http/fs_test.go-780-		if res.StatusCode != tt.wantStatus {
net/http/fs_test.go-781-			t.Errorf("test %q: status = %d; want %d", testName, res.StatusCode, tt.wantStatus)
net/http/fs_test.go-782-		}
net/http/fs_test.go-783-		if g, e := res.Header.Get("Content-Type"), tt.wantContentType; g != e {
net/http/fs_test.go-784-			t.Errorf("test %q: content-type = %q, want %q", testName, g, e)
--
--
net/http/fs_test.go-825-	}
net/http/fs_test.go-826-	_, err = io.Copy(ioutil.Discard, res.Body)
net/http/fs_test.go-827-	if err != nil {
net/http/fs_test.go-828-		t.Fatalf("client body read error: %v", err)
net/http/fs_test.go-829-	}
net/http/fs_test.go:830:	res.Body.Close()
net/http/fs_test.go-831-
net/http/fs_test.go-832-	// Force child to exit cleanly.
net/http/fs_test.go-833-	Get(fmt.Sprintf("http://%s/quit", ln.Addr()))
net/http/fs_test.go-834-	child.Wait()
net/http/fs_test.go-835-
--
--
net/http/httptest/example_test.go-38-	res, err := http.Get(ts.URL)
net/http/httptest/example_test.go-39-	if err != nil {
net/http/httptest/example_test.go-40-		log.Fatal(err)
net/http/httptest/example_test.go-41-	}
net/http/httptest/example_test.go-42-	greeting, err := ioutil.ReadAll(res.Body)
net/http/httptest/example_test.go:43:	res.Body.Close()
net/http/httptest/example_test.go-44-	if err != nil {
net/http/httptest/example_test.go-45-		log.Fatal(err)
net/http/httptest/example_test.go-46-	}
net/http/httptest/example_test.go-47-
net/http/httptest/example_test.go-48-	fmt.Printf("%s", greeting)
--
--
net/http/httputil/dump.go-103-		req, err := http.ReadRequest(bufio.NewReader(pr))
net/http/httputil/dump.go-104-		if err == nil {
net/http/httputil/dump.go-105-			// Ensure all the body is read; otherwise
net/http/httputil/dump.go-106-			// we'll get a partial dump.
net/http/httputil/dump.go-107-			io.Copy(ioutil.Discard, req.Body)
net/http/httputil/dump.go:108:			req.Body.Close()
net/http/httputil/dump.go-109-		}
net/http/httputil/dump.go-110-		dr.c <- strings.NewReader("HTTP/1.1 204 No Content\r\n\r\n")
net/http/httputil/dump.go-111-	}()
net/http/httputil/dump.go-112-
net/http/httputil/dump.go-113-	t := &http.Transport{
--
--
net/http/httputil/reverseproxy.go-146-	if err != nil {
net/http/httputil/reverseproxy.go-147-		p.logf("http: proxy error: %v", err)
net/http/httputil/reverseproxy.go-148-		rw.WriteHeader(http.StatusInternalServerError)
net/http/httputil/reverseproxy.go-149-		return
net/http/httputil/reverseproxy.go-150-	}
net/http/httputil/reverseproxy.go:151:	defer res.Body.Close()
net/http/httputil/reverseproxy.go-152-
net/http/httputil/reverseproxy.go-153-	for _, h := range hopHeaders {
net/http/httputil/reverseproxy.go-154-		res.Header.Del(h)
net/http/httputil/reverseproxy.go-155-	}
net/http/httputil/reverseproxy.go-156-
--
--
net/http/httputil/reverseproxy_test.go-164-			t.Fatalf("%d. Get: %v", i, err)
net/http/httputil/reverseproxy_test.go-165-		}
net/http/httputil/reverseproxy_test.go-166-		if g, e := res.Header.Get("X-Got-Query"), tt.want; g != e {
net/http/httputil/reverseproxy_test.go-167-			t.Errorf("%d. got query %q; expected %q", i, g, e)
net/http/httputil/reverseproxy_test.go-168-		}
net/http/httputil/reverseproxy_test.go:169:		res.Body.Close()
net/http/httputil/reverseproxy_test.go-170-		frontend.Close()
net/http/httputil/reverseproxy_test.go-171-	}
net/http/httputil/reverseproxy_test.go-172-}
net/http/httputil/reverseproxy_test.go-173-
net/http/httputil/reverseproxy_test.go-174-func TestReverseProxyFlushInterval(t *testing.T) {
--
--
net/http/httputil/reverseproxy_test.go-197-	req.Close = true
net/http/httputil/reverseproxy_test.go-198-	res, err := http.DefaultClient.Do(req)
net/http/httputil/reverseproxy_test.go-199-	if err != nil {
net/http/httputil/reverseproxy_test.go-200-		t.Fatalf("Get: %v", err)
net/http/httputil/reverseproxy_test.go-201-	}
net/http/httputil/reverseproxy_test.go:202:	defer res.Body.Close()
net/http/httputil/reverseproxy_test.go-203-	if bodyBytes, _ := ioutil.ReadAll(res.Body); string(bodyBytes) != expected {
net/http/httputil/reverseproxy_test.go-204-		t.Errorf("got body %q; expected %q", bodyBytes, expected)
net/http/httputil/reverseproxy_test.go-205-	}
net/http/httputil/reverseproxy_test.go-206-
net/http/httputil/reverseproxy_test.go-207-	select {
--
--
net/http/request.go-914-	return hasToken(r.Header.get("Connection"), "close")
net/http/request.go-915-}
net/http/request.go-916-
net/http/request.go-917-func (r *Request) closeBody() {
net/http/request.go-918-	if r.Body != nil {
net/http/request.go:919:		r.Body.Close()
net/http/request.go-920-	}
net/http/request.go-921-}
--
--
net/http/request_test.go-194-	var end = regexp.MustCompile("/foo/$")
net/http/request_test.go-195-	r, err := Get(ts.URL)
net/http/request_test.go-196-	if err != nil {
net/http/request_test.go-197-		t.Fatal(err)
net/http/request_test.go-198-	}
net/http/request_test.go:199:	r.Body.Close()
net/http/request_test.go-200-	url := r.Request.URL.String()
net/http/request_test.go-201-	if r.StatusCode != 200 || !end.MatchString(url) {
net/http/request_test.go-202-		t.Fatalf("Get got status %d at %q, want 200 matching /foo/$", r.StatusCode, url)
net/http/request_test.go-203-	}
net/http/request_test.go-204-}
--
--
net/http/response.go-108-}
net/http/response.go-109-
net/http/response.go-110-// ReadResponse reads and returns an HTTP response from r.
net/http/response.go-111-// The req parameter optionally specifies the Request that corresponds
net/http/response.go-112-// to this Response. If nil, a GET request is assumed.
net/http/response.go:113:// Clients must call resp.Body.Close when finished reading resp.Body.
net/http/response.go-114-// After that call, clients can inspect resp.Trailer to find key/value
net/http/response.go-115-// pairs included in the response trailer.
net/http/response.go-116-func ReadResponse(r *bufio.Reader, req *Request) (*Response, error) {
net/http/response.go-117-	tp := textproto.NewReader(r)
net/http/response.go-118-	resp := &Response{
--
--
net/http/response_test.go-532-			fatalf("ReadFull only read %d bytes", n)
net/http/response_test.go-533-		}
net/http/response_test.go-534-		if test.compressed == false && !bytes.Equal(bytes.Repeat([]byte{'x'}, 2500), rbuf) {
net/http/response_test.go-535-			fatalf("ReadFull didn't read 2500 'x'; got %q", string(rbuf))
net/http/response_test.go-536-		}
net/http/response_test.go:537:		resp.Body.Close()
net/http/response_test.go-538-
net/http/response_test.go-539-		rest, err := ioutil.ReadAll(bufr)
net/http/response_test.go-540-		checkErr(err, "ReadAll on remainder")
net/http/response_test.go-541-		if e, g := "Next Request Here", string(rest); e != g {
net/http/response_test.go-542-			g = regexp.MustCompile(`(xx+)`).ReplaceAllStringFunc(g, func(match string) string {
--
--
net/http/serve_test.go-622-		}
net/http/serve_test.go-623-		if tl, expected := len(res.TransferEncoding), 0; tl != expected {
net/http/serve_test.go-624-			t.Errorf("for %s expected len(res.TransferEncoding) of %d; got %d (%v)",
net/http/serve_test.go-625-				url, expected, tl, res.TransferEncoding)
net/http/serve_test.go-626-		}
net/http/serve_test.go:627:		res.Body.Close()
net/http/serve_test.go-628-	}
net/http/serve_test.go-629-
net/http/serve_test.go-630-	// Verify that ErrContentLength is returned
net/http/serve_test.go-631-	url := ts.URL + "/?overwrite=1"
net/http/serve_test.go-632-	res, err := Get(url)
--
--
net/http/serve_test.go-631-	url := ts.URL + "/?overwrite=1"
net/http/serve_test.go-632-	res, err := Get(url)
net/http/serve_test.go-633-	if err != nil {
net/http/serve_test.go-634-		t.Fatalf("error with Get of %s: %v", url, err)
net/http/serve_test.go-635-	}
net/http/serve_test.go:636:	res.Body.Close()
net/http/serve_test.go-637-
net/http/serve_test.go-638-	// Verify that the connection is closed when the declared Content-Length
net/http/serve_test.go-639-	// is larger than what the handler wrote.
net/http/serve_test.go-640-	conn, err := net.Dial("tcp", ts.Listener.Addr().String())
net/http/serve_test.go-641-	if err != nil {
--
--
net/http/serve_test.go-764-
net/http/serve_test.go-765-	res, err := Get(ts.URL)
net/http/serve_test.go-766-	if err != nil {
net/http/serve_test.go-767-		t.Fatalf("Get error: %v", err)
net/http/serve_test.go-768-	}
net/http/serve_test.go:769:	defer res.Body.Close()
net/http/serve_test.go-770-	if g, e := res.ContentLength, int64(-1); g != e {
net/http/serve_test.go-771-		t.Errorf("expected ContentLength of %d; got %d", e, g)
net/http/serve_test.go-772-	}
net/http/serve_test.go-773-	if g, e := res.TransferEncoding, []string{"chunked"}; !reflect.DeepEqual(g, e) {
net/http/serve_test.go-774-		t.Errorf("expected TransferEncoding of %v; got %v", e, g)
--
--
net/http/serve_test.go-792-
net/http/serve_test.go-793-	res, err := Get(ts.URL)
net/http/serve_test.go-794-	if err != nil {
net/http/serve_test.go-795-		t.Fatalf("Get error: %v", err)
net/http/serve_test.go-796-	}
net/http/serve_test.go:797:	defer res.Body.Close()
net/http/serve_test.go-798-
net/http/serve_test.go-799-	if g, e := res.TransferEncoding, []string(nil); !reflect.DeepEqual(g, e) {
net/http/serve_test.go-800-		t.Errorf("expected TransferEncoding of %v; got %v", e, g)
net/http/serve_test.go-801-	}
net/http/serve_test.go-802-	if _, haveCL := res.Header["Content-Length"]; haveCL {
--
--
net/http/serve_test.go-949-		}
net/http/serve_test.go-950-		if res == nil {
net/http/serve_test.go-951-			t.Errorf("got nil Response")
net/http/serve_test.go-952-			return
net/http/serve_test.go-953-		}
net/http/serve_test.go:954:		defer res.Body.Close()
net/http/serve_test.go-955-		if res.Header.Get("X-TLS-Set") != "true" {
net/http/serve_test.go-956-			t.Errorf("expected X-TLS-Set response header")
net/http/serve_test.go-957-			return
net/http/serve_test.go-958-		}
net/http/serve_test.go-959-		if res.Header.Get("X-TLS-HandshakeComplete") != "true" {
--
--
net/http/serve_test.go-1250-			defer wg.Done()
net/http/serve_test.go-1251-			defer func() { <-gate }()
net/http/serve_test.go-1252-			res, err := Get(fmt.Sprintf("%s/%d", ts.URL, rand.Intn(50)))
net/http/serve_test.go-1253-			if err == nil {
net/http/serve_test.go-1254-				io.Copy(ioutil.Discard, res.Body)
net/http/serve_test.go:1255:				res.Body.Close()
net/http/serve_test.go-1256-			}
net/http/serve_test.go-1257-		}()
net/http/serve_test.go-1258-	}
net/http/serve_test.go-1259-	wg.Wait()
net/http/serve_test.go-1260-}
--
--
net/http/serve_test.go-1285-			res, err := Get(ts.URL)
net/http/serve_test.go-1286-			if err != nil {
net/http/serve_test.go-1287-				t.Error(err)
net/http/serve_test.go-1288-				return
net/http/serve_test.go-1289-			}
net/http/serve_test.go:1290:			defer res.Body.Close()
net/http/serve_test.go-1291-			io.Copy(ioutil.Discard, res.Body)
net/http/serve_test.go-1292-		}()
net/http/serve_test.go-1293-	}
net/http/serve_test.go-1294-	wg.Wait()
net/http/serve_test.go-1295-}
--
--
net/http/serve_test.go-1480-		t.Fatal(err)
net/http/serve_test.go-1481-	}
net/http/serve_test.go-1482-	if g, e := res.Header.Get("X-Path"), "/bar"; g != e {
net/http/serve_test.go-1483-		t.Errorf("test 1: got %s, want %s", g, e)
net/http/serve_test.go-1484-	}
net/http/serve_test.go:1485:	res.Body.Close()
net/http/serve_test.go-1486-
net/http/serve_test.go-1487-	res, err = Get(ts.URL + "/bar")
net/http/serve_test.go-1488-	if err != nil {
net/http/serve_test.go-1489-		t.Fatal(err)
net/http/serve_test.go-1490-	}
--
--
net/http/serve_test.go-1489-		t.Fatal(err)
net/http/serve_test.go-1490-	}
net/http/serve_test.go-1491-	if g, e := res.StatusCode, 404; g != e {
net/http/serve_test.go-1492-		t.Errorf("test 2: got status %v, want %v", g, e)
net/http/serve_test.go-1493-	}
net/http/serve_test.go:1494:	res.Body.Close()
net/http/serve_test.go-1495-}
net/http/serve_test.go-1496-
net/http/serve_test.go-1497-func TestRequestLimit(t *testing.T) {
net/http/serve_test.go-1498-	defer afterTest(t)
net/http/serve_test.go-1499-	ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
--
--
net/http/serve_test.go-1510-		// Some HTTP clients may fail on this undefined behavior (server replying and
net/http/serve_test.go-1511-		// closing the connection while the request is still being written), but
net/http/serve_test.go-1512-		// we do support it (at least currently), so we expect a response below.
net/http/serve_test.go-1513-		t.Fatalf("Do: %v", err)
net/http/serve_test.go-1514-	}
net/http/serve_test.go:1515:	defer res.Body.Close()
net/http/serve_test.go-1516-	if res.StatusCode != 413 {
net/http/serve_test.go-1517-		t.Fatalf("expected 413 response status; got: %d %s", res.StatusCode, res.Status)
net/http/serve_test.go-1518-	}
net/http/serve_test.go-1519-}
net/http/serve_test.go-1520-
--
--
net/http/serve_test.go-1688-	res, err := DefaultClient.Do(req)
net/http/serve_test.go-1689-	if err != nil {
net/http/serve_test.go-1690-		t.Error(err)
net/http/serve_test.go-1691-		return
net/http/serve_test.go-1692-	}
net/http/serve_test.go:1693:	res.Body.Close()
net/http/serve_test.go-1694-}
net/http/serve_test.go-1695-
net/http/serve_test.go-1696-// TestContentLengthZero tests that for both an HTTP/1.0 and HTTP/1.1
net/http/serve_test.go-1697-// request (both keep-alive), when a Handler never writes any
net/http/serve_test.go-1698-// response, the net/http package adds a "Content-Length: 0" response
--
--
net/http/serve_test.go-1828-
net/http/serve_test.go-1829-	res, err = Get(ts.URL + "/second")
net/http/serve_test.go-1830-	if err != nil {
net/http/serve_test.go-1831-		t.Fatal(err)
net/http/serve_test.go-1832-	}
net/http/serve_test.go:1833:	res.Body.Close()
net/http/serve_test.go-1834-	if got := <-uric; got != "/second" {
net/http/serve_test.go-1835-		t.Errorf("Handler saw request for %q; want /second", got)
net/http/serve_test.go-1836-	}
net/http/serve_test.go-1837-}
net/http/serve_test.go-1838-
--
--
net/http/serve_test.go-2171-		resp, err := ReadResponse(bufio.NewReader(conn), &Request{Method: "GET"})
net/http/serve_test.go-2172-		if err != nil {
net/http/serve_test.go-2173-			t.Fatal("ReadResponse err:", err)
net/http/serve_test.go-2174-		}
net/http/serve_test.go-2175-		conn.Close()
net/http/serve_test.go:2176:		resp.Body.Close()
net/http/serve_test.go-2177-
net/http/serve_test.go-2178-		got := resp.Header["Connection"]
net/http/serve_test.go-2179-		if !reflect.DeepEqual(got, tt.expect) {
net/http/serve_test.go-2180-			t.Errorf("wrong Connection headers for request %q. Got %q expect %q", tt.req, got, tt.expect)
net/http/serve_test.go-2181-		}
--
--
net/http/serve_test.go-2219-	}
net/http/serve_test.go-2220-	all, err := ioutil.ReadAll(res.Body)
net/http/serve_test.go-2221-	if err != nil {
net/http/serve_test.go-2222-		t.Fatal(err)
net/http/serve_test.go-2223-	}
net/http/serve_test.go:2224:	res.Body.Close()
net/http/serve_test.go-2225-	if string(all) != "hi" {
net/http/serve_test.go-2226-		t.Errorf("Body = %q; want hi", all)
net/http/serve_test.go-2227-	}
net/http/serve_test.go-2228-}
net/http/serve_test.go-2229-
--
--
net/http/serve_test.go-2326-	if err != nil {
net/http/serve_test.go-2327-		t.Fatalf("Original request: %v", err)
net/http/serve_test.go-2328-	}
net/http/serve_test.go-2329-
net/http/serve_test.go-2330-	// Cleanup, so we don't leak goroutines.
net/http/serve_test.go:2331:	res.Body.Close()
net/http/serve_test.go-2332-	close(unblockBackend)
--
net/http/serve_test.go-2332-	close(unblockBackend)
net/http/serve_test.go:2333:	(<-backendRespc).Body.Close()
net/http/serve_test.go-2334-}
net/http/serve_test.go-2335-
net/http/serve_test.go-2336-// Test that a hanging Request.Body.Read from another goroutine can't
--
net/http/serve_test.go-2334-}
net/http/serve_test.go-2335-
net/http/serve_test.go-2336-// Test that a hanging Request.Body.Read from another goroutine can't
net/http/serve_test.go:2337:// cause the Handler goroutine's Request.Body.Close to block.
net/http/serve_test.go-2338-func TestRequestBodyCloseDoesntBlock(t *testing.T) {
net/http/serve_test.go-2339-	t.Skipf("Skipping known issue; see golang.org/issue/7121")
net/http/serve_test.go-2340-	if testing.Short() {
net/http/serve_test.go-2341-		t.Skip("skipping in -short mode")
net/http/serve_test.go-2342-	}
--
--
net/http/serve_test.go-2558-	if err != nil {
net/http/serve_test.go-2559-		t.Errorf("Error fetching %s: %v", url, err)
net/http/serve_test.go-2560-		return
net/http/serve_test.go-2561-	}
net/http/serve_test.go-2562-	_, err = ioutil.ReadAll(res.Body)
net/http/serve_test.go:2563:	defer res.Body.Close()
net/http/serve_test.go-2564-	if err != nil {
net/http/serve_test.go-2565-		t.Errorf("Error reading %s: %v", url, err)
net/http/serve_test.go-2566-	}
net/http/serve_test.go-2567-}
net/http/serve_test.go-2568-
--
--
net/http/serve_test.go-2574-	defer ts.Close()
net/http/serve_test.go-2575-	res, err := Get(ts.URL)
net/http/serve_test.go-2576-	if err != nil {
net/http/serve_test.go-2577-		t.Fatal(err)
net/http/serve_test.go-2578-	}
net/http/serve_test.go:2579:	defer res.Body.Close()
net/http/serve_test.go-2580-	if !res.Close {
--
net/http/serve_test.go-2580-	if !res.Close {
net/http/serve_test.go:2581:		t.Errorf("Body.Close == false; want true")
net/http/serve_test.go-2582-	}
net/http/serve_test.go-2583-}
net/http/serve_test.go-2584-
net/http/serve_test.go-2585-// golang.org/issue/7856
net/http/serve_test.go-2586-func TestServerEmptyBodyRace(t *testing.T) {
--
--
net/http/serve_test.go-2599-			res, err := Get(ts.URL)
net/http/serve_test.go-2600-			if err != nil {
net/http/serve_test.go-2601-				t.Error(err)
net/http/serve_test.go-2602-				return
net/http/serve_test.go-2603-			}
net/http/serve_test.go:2604:			defer res.Body.Close()
net/http/serve_test.go-2605-			_, err = io.Copy(ioutil.Discard, res.Body)
net/http/serve_test.go-2606-			if err != nil {
net/http/serve_test.go-2607-				t.Error(err)
net/http/serve_test.go-2608-				return
net/http/serve_test.go-2609-			}
--
--
net/http/serve_test.go-2683-	defer ts.Close()
net/http/serve_test.go-2684-	res, err := Get(ts.URL)
net/http/serve_test.go-2685-	if err != nil {
net/http/serve_test.go-2686-		t.Fatal(err)
net/http/serve_test.go-2687-	}
net/http/serve_test.go:2688:	defer res.Body.Close()
net/http/serve_test.go-2689-	all, err := ioutil.ReadAll(res.Body)
net/http/serve_test.go-2690-	if err != nil {
net/http/serve_test.go-2691-		t.Fatal(err)
net/http/serve_test.go-2692-	}
net/http/serve_test.go-2693-	if want := "Hello, world!"; string(all) != want {
--
--
net/http/serve_test.go-2721-	go func() {
net/http/serve_test.go-2722-		defer close(errc)
net/http/serve_test.go-2723-		for i := 0; i < numReq; i++ {
net/http/serve_test.go-2724-			res, err := Get(ts.URL)
net/http/serve_test.go-2725-			if res != nil {
net/http/serve_test.go:2726:				res.Body.Close()
net/http/serve_test.go-2727-			}
net/http/serve_test.go-2728-			errc <- err
net/http/serve_test.go-2729-		}
net/http/serve_test.go-2730-	}()
net/http/serve_test.go-2731-
--
--
net/http/serve_test.go-2769-		res, err := Get(ts.URL)
net/http/serve_test.go-2770-		if err != nil {
net/http/serve_test.go-2771-			b.Fatal("Get:", err)
net/http/serve_test.go-2772-		}
net/http/serve_test.go-2773-		all, err := ioutil.ReadAll(res.Body)
net/http/serve_test.go:2774:		res.Body.Close()
net/http/serve_test.go-2775-		if err != nil {
net/http/serve_test.go-2776-			b.Fatal("ReadAll:", err)
net/http/serve_test.go-2777-		}
net/http/serve_test.go-2778-		body := string(all)
net/http/serve_test.go-2779-		if body != "Hello world.\n" {
--
--
net/http/serve_test.go-2826-			if err != nil {
net/http/serve_test.go-2827-				b.Logf("Get: %v", err)
net/http/serve_test.go-2828-				continue
net/http/serve_test.go-2829-			}
net/http/serve_test.go-2830-			all, err := ioutil.ReadAll(res.Body)
net/http/serve_test.go:2831:			res.Body.Close()
net/http/serve_test.go-2832-			if err != nil {
net/http/serve_test.go-2833-				b.Logf("ReadAll: %v", err)
net/http/serve_test.go-2834-				continue
net/http/serve_test.go-2835-			}
net/http/serve_test.go-2836-			body := string(all)
--
--
net/http/serve_test.go-2861-			res, err := Get(url)
net/http/serve_test.go-2862-			if err != nil {
net/http/serve_test.go-2863-				log.Panicf("Get: %v", err)
net/http/serve_test.go-2864-			}
net/http/serve_test.go-2865-			all, err := ioutil.ReadAll(res.Body)
net/http/serve_test.go:2866:			res.Body.Close()
net/http/serve_test.go-2867-			if err != nil {
net/http/serve_test.go-2868-				log.Panicf("ReadAll: %v", err)
net/http/serve_test.go-2869-			}
net/http/serve_test.go-2870-			body := string(all)
net/http/serve_test.go-2871-			if body != "Hello world.\n" {
--
--
net/http/server.go-800-			if n >= maxPostHandlerReadBytes {
net/http/server.go-801-				w.requestTooLarge()
net/http/server.go-802-				delHeader("Connection")
net/http/server.go-803-				setHeader.connection = "close"
net/http/server.go-804-			} else {
net/http/server.go:805:				w.req.Body.Close()
net/http/server.go-806-			}
net/http/server.go-807-		}
net/http/server.go-808-	}
net/http/server.go-809-
net/http/server.go-810-	code := w.status
--
--
net/http/server.go-1020-	w.cw.close()
net/http/server.go-1021-	w.conn.buf.Flush()
net/http/server.go-1022-
net/http/server.go-1023-	// Close the body (regardless of w.closeAfterReply) so we can
net/http/server.go-1024-	// re-use its bufio.Reader later safely.
net/http/server.go:1025:	w.req.Body.Close()
net/http/server.go-1026-
net/http/server.go-1027-	if w.req.MultipartForm != nil {
net/http/server.go-1028-		w.req.MultipartForm.RemoveAll()
net/http/server.go-1029-	}
net/http/server.go-1030-
--
--
net/http/sniff_test.go-79-		if err != nil {
net/http/sniff_test.go-80-			t.Errorf("%v: reading body: %v", tt.desc, err)
net/http/sniff_test.go-81-		} else if !bytes.Equal(data, tt.data) {
net/http/sniff_test.go-82-			t.Errorf("%v: data is %q, want %q", tt.desc, data, tt.data)
net/http/sniff_test.go-83-		}
net/http/sniff_test.go:84:		resp.Body.Close()
net/http/sniff_test.go-85-	}
net/http/sniff_test.go-86-}
net/http/sniff_test.go-87-
net/http/sniff_test.go-88-// Issue 5953: shouldn't sniff if the handler set a Content-Type header,
net/http/sniff_test.go-89-// even if it's the empty string.
--
--
net/http/sniff_test.go-103-	got := resp.Header["Content-Type"]
net/http/sniff_test.go-104-	want := []string{""}
net/http/sniff_test.go-105-	if !reflect.DeepEqual(got, want) {
net/http/sniff_test.go-106-		t.Errorf("Content-Type = %q; want %q", got, want)
net/http/sniff_test.go-107-	}
net/http/sniff_test.go:108:	resp.Body.Close()
net/http/sniff_test.go-109-}
net/http/sniff_test.go-110-
net/http/sniff_test.go-111-func TestContentTypeWithCopy(t *testing.T) {
net/http/sniff_test.go-112-	defer afterTest(t)
net/http/sniff_test.go-113-
--
--
net/http/sniff_test.go-137-	if err != nil {
net/http/sniff_test.go-138-		t.Errorf("reading body: %v", err)
net/http/sniff_test.go-139-	} else if !bytes.Equal(data, []byte(input)) {
net/http/sniff_test.go-140-		t.Errorf("data is %q, want %q", data, input)
net/http/sniff_test.go-141-	}
net/http/sniff_test.go:142:	resp.Body.Close()
net/http/sniff_test.go-143-}
net/http/sniff_test.go-144-
net/http/sniff_test.go-145-func TestSniffWriteSize(t *testing.T) {
net/http/sniff_test.go-146-	defer afterTest(t)
net/http/sniff_test.go-147-	ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
--
--
net/http/sniff_test.go-162-			t.Fatalf("size %d: %v", size, err)
net/http/sniff_test.go-163-		}
net/http/sniff_test.go-164-		if _, err := io.Copy(ioutil.Discard, res.Body); err != nil {
net/http/sniff_test.go-165-			t.Fatalf("size %d: io.Copy of body = %v", size, err)
net/http/sniff_test.go-166-		}
net/http/sniff_test.go:167:		if err := res.Body.Close(); err != nil {
net/http/sniff_test.go-168-			t.Fatalf("size %d: body Close = %v", size, err)
net/http/sniff_test.go-169-		}
net/http/sniff_test.go-170-	}
net/http/sniff_test.go-171-}
--
--
net/http/transport_test.go-174-
net/http/transport_test.go-175-			res, err := c.Do(req)
net/http/transport_test.go-176-			if err != nil {
net/http/transport_test.go-177-				t.Fatalf("error in connectionClose=%v, req #%d, Do: %v", connectionClose, n, err)
net/http/transport_test.go-178-			}
net/http/transport_test.go:179:			defer res.Body.Close()
net/http/transport_test.go-180-			body, err := ioutil.ReadAll(res.Body)
net/http/transport_test.go-181-			if err != nil {
net/http/transport_test.go-182-				t.Fatalf("error in connectionClose=%v, req #%d, ReadAll: %v", connectionClose, n, err)
net/http/transport_test.go-183-			}
net/http/transport_test.go-184-			return string(body)
--
--
net/http/transport_test.go-316-			// We want to close this body eventually (before the
net/http/transport_test.go-317-			// defer afterTest at top runs), but not before the
net/http/transport_test.go-318-			// len(addrSeen) check at the bottom of this test,
net/http/transport_test.go-319-			// since Closing this early in the loop would risk
net/http/transport_test.go-320-			// making connections be re-used for the wrong reason.
net/http/transport_test.go:321:			defer res.Body.Close()
net/http/transport_test.go-322-
net/http/transport_test.go-323-			if res.ContentLength != int64(wantLen) {
net/http/transport_test.go-324-				t.Errorf("%s res.ContentLength = %d; want %d", path, res.ContentLength, wantLen)
net/http/transport_test.go-325-			}
net/http/transport_test.go-326-			n, err := res.Body.Read(buf)
--
--
net/http/transport_test.go-430-			body, err := ioutil.ReadAll(res.Body)
net/http/transport_test.go-431-			if err != nil {
net/http/transport_test.go-432-				condFatalf("error in req #%d, ReadAll: %v", n, err)
net/http/transport_test.go-433-				continue
net/http/transport_test.go-434-			}
net/http/transport_test.go:435:			res.Body.Close()
net/http/transport_test.go-436-			return string(body)
net/http/transport_test.go-437-		}
net/http/transport_test.go-438-		panic("unreachable")
net/http/transport_test.go-439-	}
net/http/transport_test.go-440-
--
--
net/http/transport_test.go-496-					// hanging up on us after telling us to
net/http/transport_test.go-497-					// send more requests, so we don't
net/http/transport_test.go-498-					// actually care what the error is.
net/http/transport_test.go-499-					// But we want to close the body in cases
net/http/transport_test.go-500-					// where we won the race.
net/http/transport_test.go:501:					res.Body.Close()
net/http/transport_test.go-502-				}
net/http/transport_test.go-503-				activityc <- true
net/http/transport_test.go-504-			}
net/http/transport_test.go-505-		}()
net/http/transport_test.go-506-	}
--
--
net/http/transport_test.go-629-			if err != nil {
net/http/transport_test.go-630-				t.Errorf("%d. gzip NewReader: %v", i, err)
net/http/transport_test.go-631-				continue
net/http/transport_test.go-632-			}
net/http/transport_test.go-633-			body, err = ioutil.ReadAll(r)
net/http/transport_test.go:634:			res.Body.Close()
net/http/transport_test.go-635-		} else {
net/http/transport_test.go-636-			body, err = ioutil.ReadAll(res.Body)
net/http/transport_test.go-637-		}
net/http/transport_test.go-638-		if err != nil {
net/http/transport_test.go-639-			t.Errorf("%d. Error: %q", i, err)
--
--
net/http/transport_test.go-700-			t.Fatalf("partial read of large response: size=%d, %v", n, err)
net/http/transport_test.go-701-		}
net/http/transport_test.go-702-		if e, g := testString, string(buf); e != g {
net/http/transport_test.go-703-			t.Errorf("partial read got %q, expected %q", g, e)
net/http/transport_test.go-704-		}
net/http/transport_test.go:705:		res.Body.Close()
net/http/transport_test.go-706-		// Read on the body, even though it's closed
net/http/transport_test.go-707-		n, err = res.Body.Read(buf)
net/http/transport_test.go-708-		if n != 0 || err == nil {
net/http/transport_test.go-709-			t.Errorf("expected error post-closed large Read; got = %d, %v", n, err)
net/http/transport_test.go-710-		}
--
--
net/http/transport_test.go-728-		// Read on the body after it's been fully read:
net/http/transport_test.go-729-		n, err = res.Body.Read(buf)
net/http/transport_test.go-730-		if n != 0 || err == nil {
net/http/transport_test.go-731-			t.Errorf("expected Read error after exhausted reads; got %d, %v", n, err)
net/http/transport_test.go-732-		}
net/http/transport_test.go:733:		res.Body.Close()
net/http/transport_test.go-734-		n, err = res.Body.Read(buf)
net/http/transport_test.go-735-		if n != 0 || err == nil {
net/http/transport_test.go-736-			t.Errorf("expected Read error after Close; got %d, %v", n, err)
net/http/transport_test.go-737-		}
net/http/transport_test.go-738-	}
--
--
net/http/transport_test.go-818-	c := &Client{Transport: tr}
net/http/transport_test.go-819-	res, err := c.Get(ts.URL)
net/http/transport_test.go-820-	if err != nil {
net/http/transport_test.go-821-		t.Fatal(err)
net/http/transport_test.go-822-	}
net/http/transport_test.go:823:	defer res.Body.Close()
net/http/transport_test.go-824-	_, err = ioutil.ReadAll(res.Body)
net/http/transport_test.go-825-	if err == nil {
net/http/transport_test.go-826-		t.Fatal("Expect an error from reading a body.")
net/http/transport_test.go-827-	}
net/http/transport_test.go-828-	if err != io.ErrUnexpectedEOF {
--
--
net/http/transport_test.go-859-			didReqCh <- true
net/http/transport_test.go-860-			if err != nil {
net/http/transport_test.go-861-				t.Errorf("client fetch error: %v", err)
net/http/transport_test.go-862-				return
net/http/transport_test.go-863-			}
net/http/transport_test.go:864:			res.Body.Close()
net/http/transport_test.go-865-		}()
net/http/transport_test.go-866-	}
net/http/transport_test.go-867-
net/http/transport_test.go-868-	// Wait for all goroutines to be stuck in the Handler.
net/http/transport_test.go-869-	for i := 0; i < numReq; i++ {
--
--
net/http/transport_test.go-958-	go func() {
net/http/transport_test.go-959-		res, err := c.Get(ts.URL)
net/http/transport_test.go-960-		if err != nil {
net/http/transport_test.go-961-			t.Error(err)
net/http/transport_test.go-962-		} else {
net/http/transport_test.go:963:			res.Body.Close() // returns idle conn
net/http/transport_test.go-964-		}
net/http/transport_test.go-965-		didreq <- true
net/http/transport_test.go-966-	}()
net/http/transport_test.go-967-	unblockCh <- true
net/http/transport_test.go-968-	<-didreq
--
--
net/http/transport_test.go-986-	c := &Client{Transport: tr}
net/http/transport_test.go-987-	res, err := c.Get(ts.URL)
net/http/transport_test.go-988-	if err != nil {
net/http/transport_test.go-989-		t.Fatal(err)
net/http/transport_test.go-990-	}
net/http/transport_test.go:991:	defer res.Body.Close()
net/http/transport_test.go-992-	bs, err := ioutil.ReadAll(res.Body)
net/http/transport_test.go-993-	if err != nil {
net/http/transport_test.go-994-		t.Fatal(err)
net/http/transport_test.go-995-	}
net/http/transport_test.go-996-	if len(bs) != numFoos*len("foo ") {
--
--
net/http/transport_test.go-1039-			res, err := c.Get(ts.URL)
net/http/transport_test.go-1040-			if err != nil {
net/http/transport_test.go-1041-				t.Errorf("closingBody=%v, req %d/%d: %v", closeBody, i, n, err)
net/http/transport_test.go-1042-			} else {
net/http/transport_test.go-1043-				if closeBody {
net/http/transport_test.go:1044:					res.Body.Close()
net/http/transport_test.go-1045-				}
net/http/transport_test.go-1046-			}
net/http/transport_test.go-1047-		}
net/http/transport_test.go-1048-	}
net/http/transport_test.go-1049-}
--
--
net/http/transport_test.go-1095-					continue
net/http/transport_test.go-1096-				}
net/http/transport_test.go-1097-				if string(all) != req {
net/http/transport_test.go-1098-					t.Errorf("body of req %s = %q; want %q", req, all, req)
net/http/transport_test.go-1099-				}
net/http/transport_test.go:1100:				res.Body.Close()
net/http/transport_test.go-1101-				wg.Done()
net/http/transport_test.go-1102-			}
net/http/transport_test.go-1103-		}()
net/http/transport_test.go-1104-	}
net/http/transport_test.go-1105-	for i := 0; i < numReqs; i++ {
--
--
net/http/transport_test.go-1181-	mux := NewServeMux()
net/http/transport_test.go-1182-	mux.HandleFunc("/get", func(w ResponseWriter, r *Request) {
net/http/transport_test.go-1183-		io.Copy(w, neverEnding('a'))
net/http/transport_test.go-1184-	})
net/http/transport_test.go-1185-	mux.HandleFunc("/put", func(w ResponseWriter, r *Request) {
net/http/transport_test.go:1186:		defer r.Body.Close()
net/http/transport_test.go-1187-		io.Copy(ioutil.Discard, r.Body)
net/http/transport_test.go-1188-	})
net/http/transport_test.go-1189-	ts := httptest.NewServer(mux)
net/http/transport_test.go-1190-	timeout := 100 * time.Millisecond
net/http/transport_test.go-1191-
--
--
net/http/transport_test.go-1229-			break
net/http/transport_test.go-1230-		}
net/http/transport_test.go-1231-		req, _ := NewRequest("PUT", ts.URL+"/put", sres.Body)
net/http/transport_test.go-1232-		_, err = client.Do(req)
net/http/transport_test.go-1233-		if err == nil {
net/http/transport_test.go:1234:			sres.Body.Close()
net/http/transport_test.go-1235-			t.Errorf("Unexpected successful PUT")
net/http/transport_test.go-1236-			break
net/http/transport_test.go-1237-		}
--
net/http/transport_test.go-1235-			t.Errorf("Unexpected successful PUT")
net/http/transport_test.go-1236-			break
net/http/transport_test.go-1237-		}
net/http/transport_test.go:1238:		sres.Body.Close()
net/http/transport_test.go-1239-	}
net/http/transport_test.go-1240-	if debug {
net/http/transport_test.go-1241-		println("tests complete; waiting for handlers to finish")
net/http/transport_test.go-1242-	}
net/http/transport_test.go-1243-	ts.Close()
--
--
net/http/transport_test.go-1464-	if !bytes.Equal(buf, want) {
net/http/transport_test.go-1465-		t.Fatalf("read %q; want %q", buf, want)
net/http/transport_test.go-1466-	}
net/http/transport_test.go-1467-	didClose := make(chan error, 1)
net/http/transport_test.go-1468-	go func() {
net/http/transport_test.go:1469:		didClose <- res.Body.Close()
net/http/transport_test.go-1470-	}()
net/http/transport_test.go-1471-	select {
net/http/transport_test.go-1472-	case err := <-didClose:
net/http/transport_test.go-1473-		if err != nil {
net/http/transport_test.go-1474-			t.Errorf("Close = %v", err)
--
--
net/http/transport_test.go-1575-	time.AfterFunc(200*time.Millisecond, func() {
net/http/transport_test.go-1576-		// let the foo response finish so we can use its
net/http/transport_test.go-1577-		// connection for /bar
net/http/transport_test.go-1578-		fooGate <- true
net/http/transport_test.go-1579-		io.Copy(ioutil.Discard, fooRes.Body)
net/http/transport_test.go:1580:		fooRes.Body.Close()
net/http/transport_test.go-1581-	})
net/http/transport_test.go-1582-
net/http/transport_test.go-1583-	barRes, err := c.Get(ts.URL + "/bar")
net/http/transport_test.go-1584-	if err != nil {
net/http/transport_test.go-1585-		t.Fatal(err)
--
--
net/http/transport_test.go-1586-	}
net/http/transport_test.go-1587-	barAddr := barRes.Header.Get("bar-ipport")
net/http/transport_test.go-1588-	if barAddr != fooAddr {
net/http/transport_test.go-1589-		t.Fatalf("/foo came from conn %q; /bar came from %q instead", fooAddr, barAddr)
net/http/transport_test.go-1590-	}
net/http/transport_test.go:1591:	barRes.Body.Close()
net/http/transport_test.go-1592-	dialGate <- false
net/http/transport_test.go-1593-}
net/http/transport_test.go-1594-
net/http/transport_test.go-1595-// Issue 2184
net/http/transport_test.go-1596-func TestTransportReading100Continue(t *testing.T) {
--
--
net/http/transport_test.go-1837-
net/http/transport_test.go-1838-	res, err := cl.Post(ts.URL, "text/plain", countCloseReader{&closes, strings.NewReader("hello")})
net/http/transport_test.go-1839-	if err != nil {
net/http/transport_test.go-1840-		t.Fatal(err)
net/http/transport_test.go-1841-	}
net/http/transport_test.go:1842:	res.Body.Close()
net/http/transport_test.go-1843-	if closes != 1 {
net/http/transport_test.go-1844-		t.Errorf("closes = %d; want 1", closes)
net/http/transport_test.go-1845-	}
net/http/transport_test.go-1846-}
net/http/transport_test.go-1847-
--
--
net/http/transport_test.go-2097-			return nil
net/http/transport_test.go-2098-		}),
net/http/transport_test.go-2099-	})
net/http/transport_test.go-2100-	res, err := DefaultClient.Do(req)
net/http/transport_test.go-2101-	if res != nil {
net/http/transport_test.go:2102:		defer res.Body.Close()
net/http/transport_test.go-2103-	}
net/http/transport_test.go-2104-	if err == nil || !strings.Contains(err.Error(), fakeErr.Error()) {
net/http/transport_test.go-2105-		t.Fatalf("Do error = %v; want something containing %q", err, fakeErr.Error())
net/http/transport_test.go-2106-	}
net/http/transport_test.go-2107-	select {
--
--
net/http/transport_test.go-2113-		t.Error("timeout waiting for server handler to complete")
net/http/transport_test.go-2114-	}
net/http/transport_test.go-2115-	select {
net/http/transport_test.go-2116-	case <-didClose:
net/http/transport_test.go-2117-	default:
net/http/transport_test.go:2118:		t.Errorf("didn't see Body.Close")
net/http/transport_test.go-2119-	}
net/http/transport_test.go-2120-}
net/http/transport_test.go-2121-
net/http/transport_test.go-2122-func TestTransportDialTLS(t *testing.T) {
net/http/transport_test.go-2123-	var mu sync.Mutex // guards following
--
--
net/http/transport_test.go-2147-	client := &Client{Transport: tr}
net/http/transport_test.go-2148-	res, err := client.Get(ts.URL)
net/http/transport_test.go-2149-	if err != nil {
net/http/transport_test.go-2150-		t.Fatal(err)
net/http/transport_test.go-2151-	}
net/http/transport_test.go:2152:	res.Body.Close()
net/http/transport_test.go-2153-	mu.Lock()
net/http/transport_test.go-2154-	if !gotReq {
net/http/transport_test.go-2155-		t.Error("didn't get request")
net/http/transport_test.go-2156-	}
net/http/transport_test.go-2157-	if !didDial {
--
--
net/http/transport_test.go-2244-			t.Error("no Range in request")
net/http/transport_test.go-2245-		}
net/http/transport_test.go-2246-	case <-time.After(10 * time.Second):
net/http/transport_test.go-2247-		t.Fatal("timeout")
net/http/transport_test.go-2248-	}
net/http/transport_test.go:2249:	res.Body.Close()
net/http/transport_test.go-2250-}
net/http/transport_test.go-2251-
net/http/transport_test.go-2252-func wantBody(res *http.Response, err error, want string) error {
net/http/transport_test.go-2253-	if err != nil {
net/http/transport_test.go-2254-		return err
--
--
net/http/transport_test.go-2258-		return fmt.Errorf("error reading body: %v", err)
net/http/transport_test.go-2259-	}
net/http/transport_test.go-2260-	if string(slurp) != want {
net/http/transport_test.go-2261-		return fmt.Errorf("body = %q; want %q", slurp, want)
net/http/transport_test.go-2262-	}
net/http/transport_test.go:2263:	if err := res.Body.Close(); err != nil {
net/http/transport_test.go-2264-		return fmt.Errorf("body Close = %v", err)
net/http/transport_test.go-2265-	}
net/http/transport_test.go-2266-	return nil
net/http/transport_test.go-2267-}
net/http/transport_test.go-2268-
--
--
time/genzabbrs.go-73-func readWindowsZones() (zones, error) {
time/genzabbrs.go-74-	r, err := http.Get(wzURL)
time/genzabbrs.go-75-	if err != nil {
time/genzabbrs.go-76-		return nil, err
time/genzabbrs.go-77-	}
time/genzabbrs.go:78:	defer r.Body.Close()
time/genzabbrs.go-79-
time/genzabbrs.go-80-	data, err := ioutil.ReadAll(r.Body)
time/genzabbrs.go-81-	if err != nil {
time/genzabbrs.go-82-		return nil, err
time/genzabbrs.go-83-	}
--
--
unicode/maketables.go-148-
unicode/maketables.go-149-func (r *reader) close() {
unicode/maketables.go-150-	if r.fd != nil {
unicode/maketables.go-151-		r.fd.Close()
unicode/maketables.go-152-	} else {
unicode/maketables.go:153:		r.resp.Body.Close()
unicode/maketables.go-154-	}
unicode/maketables.go-155-}
unicode/maketables.go-156-
unicode/maketables.go-157-var category = map[string]bool{
unicode/maketables.go-158-	// Nd Lu etc.

run grep on Mac

% cd $GOROOT/src
% grep -A 5 -B 5 -H -n "Body.Close" **/*.go