code review 144650044: net/http/httputil: ensure DumpRequestOut dumps all of Body

src/net/http/httputil/dump_test.go

 // Copyright 2011 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 httputil
 
 import (
         "bytes"
         "fmt"
         "io"
@@ skipping 93 matching lines @@
                 Body: []byte("abcdef"),
 
                 WantDumpOut: "POST / HTTP/1.1\r\n" +
                         "Host: post.tld\r\n" +
                         "User-Agent: Go 1.1 package http\r\n" +
                         "Content-Length: 6\r\n" +
                         "Accept-Encoding: gzip\r\n\r\n",
 
                 NoBody: true,
         },
+
+        // Request with Body > 8196 (default buffer size)
+        {
+                Req: http.Request{
+                        Method: "POST",
+                        URL: &url.URL{
+                                Scheme: "http",
+                                Host:   "post.tld",
+                                Path:   "/",
+                        },
+                        ContentLength: 8193,
+                        ProtoMajor:    1,
+                        ProtoMinor:    1,
+                },
+
+                Body: bytes.Repeat([]byte("a"), 8193),
+
+                WantDumpOut: "POST / HTTP/1.1\r\n" +
+                        "Host: post.tld\r\n" +
+                        "User-Agent: Go 1.1 package http\r\n" +
+                        "Content-Length: 8193\r\n" +
+                        "Accept-Encoding: gzip\r\n\r\n" +
+                        strings.Repeat("a", 8193),
+        },
 }
 
 func TestDumpRequest(t *testing.T) {
         numg0 := runtime.NumGoroutine()
         for i, tt := range dumpTests {
                 setBody := func() {
                         if tt.Body == nil {
                                 return
                         }
                         switch b := tt.Body.(type) {
                         case []byte:
                                 tt.Req.Body = ioutil.NopCloser(bytes.NewReader(b))
                         case func() io.ReadCloser:
                                 tt.Req.Body = b()
+                        default:
+                                t.Fatalf("Test %d: unsupported Body of %T", i, tt.Body)
                         }
                 }
                 setBody()
                 if tt.Req.Header == nil {
                         tt.Req.Header = make(http.Header)
                 }
 
                 if tt.WantDump != "" {
                         setBody()
                         dump, err := DumpRequest(&tt.Req, !tt.NoBody)
@@ skipping 14 matching lines @@
                                 t.Errorf("DumpRequestOut #%d: %s", i, err)
                                 continue
                         }
                         if string(dump) != tt.WantDumpOut {
                                 t.Errorf("DumpRequestOut %d, expecting:\n%s\nGot:\n%s\n", i, tt.WantDumpOut, string(dump))
                                 continue
                         }
                 }
         }
         if dg := runtime.NumGoroutine() - numg0; dg > 4 {
-                t.Errorf("Unexpectedly large number of new goroutines: %d new", dg)
+                buf := make([]byte, 4096)
+                buf = buf[:runtime.Stack(buf, true)]
+                t.Errorf("Unexpectedly large number of new goroutines: %d new: %s", dg, buf)
         }
 }
 
 func chunk(s string) string {
         return fmt.Sprintf("%x\r\n%s\r\n", len(s), s)
 }
 
 func mustParseURL(s string) *url.URL {
         u, err := url.Parse(s)
         if err != nil {
@@ skipping 81 matching lines @@
                 }
                 got := string(gotb)
                 got = strings.TrimSpace(got)
                 got = strings.Replace(got, "\r", "", -1)
 
                 if got != tt.want {
                         t.Errorf("%d.\nDumpResponse got:\n%s\n\nWant:\n%s\n", i, got, tt.want)
                 }
         }
 }