netramesh

1
// Copyright 2015 The Go Authors. All rights reserved.
2
// Use of this source code is governed by a BSD-style
3
// license that can be found in the LICENSE file.
4

5
// Tests that use both the client & server, in both HTTP/1 and HTTP/2 mode.
6

7
package http_test
8

9
import (
10
	"bytes"
11
	"compress/gzip"
12
	"crypto/tls"
13
	"fmt"
14
	"io"
15
	"io/ioutil"
16
	"log"
17
	"net"
18
	. "net/http"
19
	"net/http/httptest"
20
	"net/http/httputil"
21
	"net/url"
22
	"os"
23
	"reflect"
24
	"runtime"
25
	"sort"
26
	"strings"
27
	"sync"
28
	"sync/atomic"
29
	"testing"
30
	"time"
31
)
32

33
type clientServerTest struct {
34
	t  *testing.T
35
	h2 bool
36
	h  Handler
37
	ts *httptest.Server
38
	tr *Transport
39
	c  *Client
40
}
41

42
func (t *clientServerTest) close() {
43
	t.tr.CloseIdleConnections()
44
	t.ts.Close()
45
}
46

47
func (t *clientServerTest) getURL(u string) string {
48
	res, err := t.c.Get(u)
49
	if err != nil {
50
		t.t.Fatal(err)
51
	}
52
	defer res.Body.Close()
53
	slurp, err := ioutil.ReadAll(res.Body)
54
	if err != nil {
55
		t.t.Fatal(err)
56
	}
57
	return string(slurp)
58
}
59

60
func (t *clientServerTest) scheme() string {
61
	if t.h2 {
62
		return "https"
63
	}
64
	return "http"
65
}
66

67
const (
68
	h1Mode = false
69
	h2Mode = true
70
)
71

72
var optQuietLog = func(ts *httptest.Server) {
73
	ts.Config.ErrorLog = quietLog
74
}
75

76
func newClientServerTest(t *testing.T, h2 bool, h Handler, opts ...interface{}) *clientServerTest {
77
	cst := &clientServerTest{
78
		t:  t,
79
		h2: h2,
80
		h:  h,
81
		tr: &Transport{},
82
	}
83
	cst.c = &Client{Transport: cst.tr}
84
	cst.ts = httptest.NewUnstartedServer(h)
85

86
	for _, opt := range opts {
87
		switch opt := opt.(type) {
88
		case func(*Transport):
89
			opt(cst.tr)
90
		case func(*httptest.Server):
91
			opt(cst.ts)
92
		default:
93
			t.Fatalf("unhandled option type %T", opt)
94
		}
95
	}
96

97
	if !h2 {
98
		cst.ts.Start()
99
		return cst
100
	}
101
	ExportHttp2ConfigureServer(cst.ts.Config, nil)
102
	cst.ts.TLS = cst.ts.Config.TLSConfig
103
	cst.ts.StartTLS()
104

105
	cst.tr.TLSClientConfig = &tls.Config{
106
		InsecureSkipVerify: true,
107
	}
108
	if err := ExportHttp2ConfigureTransport(cst.tr); err != nil {
109
		t.Fatal(err)
110
	}
111
	return cst
112
}
113

114
// Testing the newClientServerTest helper itself.
115
func TestNewClientServerTest(t *testing.T) {
116
	var got struct {
117
		sync.Mutex
118
		log []string
119
	}
120
	h := HandlerFunc(func(w ResponseWriter, r *Request) {
121
		got.Lock()
122
		defer got.Unlock()
123
		got.log = append(got.log, r.Proto)
124
	})
125
	for _, v := range [2]bool{false, true} {
126
		cst := newClientServerTest(t, v, h)
127
		if _, err := cst.c.Head(cst.ts.URL); err != nil {
128
			t.Fatal(err)
129
		}
130
		cst.close()
131
	}
132
	got.Lock() // no need to unlock
133
	if want := []string{"HTTP/1.1", "HTTP/2.0"}; !reflect.DeepEqual(got.log, want) {
134
		t.Errorf("got %q; want %q", got.log, want)
135
	}
136
}
137

138
func TestChunkedResponseHeaders_h1(t *testing.T) { testChunkedResponseHeaders(t, h1Mode) }
139
func TestChunkedResponseHeaders_h2(t *testing.T) { testChunkedResponseHeaders(t, h2Mode) }
140

141
func testChunkedResponseHeaders(t *testing.T, h2 bool) {
142
	defer afterTest(t)
143
	log.SetOutput(ioutil.Discard) // is noisy otherwise
144
	defer log.SetOutput(os.Stderr)
145
	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
146
		w.Header().Set("Content-Length", "intentional gibberish") // we check that this is deleted
147
		w.(Flusher).Flush()
148
		fmt.Fprintf(w, "I am a chunked response.")
149
	}))
150
	defer cst.close()
151

152
	res, err := cst.c.Get(cst.ts.URL)
153
	if err != nil {
154
		t.Fatalf("Get error: %v", err)
155
	}
156
	defer res.Body.Close()
157
	if g, e := res.ContentLength, int64(-1); g != e {
158
		t.Errorf("expected ContentLength of %d; got %d", e, g)
159
	}
160
	wantTE := []string{"chunked"}
161
	if h2 {
162
		wantTE = nil
163
	}
164
	if !reflect.DeepEqual(res.TransferEncoding, wantTE) {
165
		t.Errorf("TransferEncoding = %v; want %v", res.TransferEncoding, wantTE)
166
	}
167
	if got, haveCL := res.Header["Content-Length"]; haveCL {
168
		t.Errorf("Unexpected Content-Length: %q", got)
169
	}
170
}
171

172
type reqFunc func(c *Client, url string) (*Response, error)
173

174
// h12Compare is a test that compares HTTP/1 and HTTP/2 behavior
175
// against each other.
176
type h12Compare struct {
177
	Handler            func(ResponseWriter, *Request)    // required
178
	ReqFunc            reqFunc                           // optional
179
	CheckResponse      func(proto string, res *Response) // optional
180
	EarlyCheckResponse func(proto string, res *Response) // optional; pre-normalize
181
	Opts               []interface{}
182
}
183

184
func (tt h12Compare) reqFunc() reqFunc {
185
	if tt.ReqFunc == nil {
186
		return (*Client).Get
187
	}
188
	return tt.ReqFunc
189
}
190

191
func (tt h12Compare) run(t *testing.T) {
192
	setParallel(t)
193
	cst1 := newClientServerTest(t, false, HandlerFunc(tt.Handler), tt.Opts...)
194
	defer cst1.close()
195
	cst2 := newClientServerTest(t, true, HandlerFunc(tt.Handler), tt.Opts...)
196
	defer cst2.close()
197

198
	res1, err := tt.reqFunc()(cst1.c, cst1.ts.URL)
199
	if err != nil {
200
		t.Errorf("HTTP/1 request: %v", err)
201
		return
202
	}
203
	res2, err := tt.reqFunc()(cst2.c, cst2.ts.URL)
204
	if err != nil {
205
		t.Errorf("HTTP/2 request: %v", err)
206
		return
207
	}
208

209
	if fn := tt.EarlyCheckResponse; fn != nil {
210
		fn("HTTP/1.1", res1)
211
		fn("HTTP/2.0", res2)
212
	}
213

214
	tt.normalizeRes(t, res1, "HTTP/1.1")
215
	tt.normalizeRes(t, res2, "HTTP/2.0")
216
	res1body, res2body := res1.Body, res2.Body
217

218
	eres1 := mostlyCopy(res1)
219
	eres2 := mostlyCopy(res2)
220
	if !reflect.DeepEqual(eres1, eres2) {
221
		t.Errorf("Response headers to handler differed:\nhttp/1 (%v):\n\t%#v\nhttp/2 (%v):\n\t%#v",
222
			cst1.ts.URL, eres1, cst2.ts.URL, eres2)
223
	}
224
	if !reflect.DeepEqual(res1body, res2body) {
225
		t.Errorf("Response bodies to handler differed.\nhttp1: %v\nhttp2: %v\n", res1body, res2body)
226
	}
227
	if fn := tt.CheckResponse; fn != nil {
228
		res1.Body, res2.Body = res1body, res2body
229
		fn("HTTP/1.1", res1)
230
		fn("HTTP/2.0", res2)
231
	}
232
}
233

234
func mostlyCopy(r *Response) *Response {
235
	c := *r
236
	c.Body = nil
237
	c.TransferEncoding = nil
238
	c.TLS = nil
239
	c.Request = nil
240
	return &c
241
}
242

243
type slurpResult struct {
244
	io.ReadCloser
245
	body []byte
246
	err  error
247
}
248

249
func (sr slurpResult) String() string { return fmt.Sprintf("body %q; err %v", sr.body, sr.err) }
250

251
func (tt h12Compare) normalizeRes(t *testing.T, res *Response, wantProto string) {
252
	if res.Proto == wantProto {
253
		res.Proto, res.ProtoMajor, res.ProtoMinor = "", 0, 0
254
	} else {
255
		t.Errorf("got %q response; want %q", res.Proto, wantProto)
256
	}
257
	slurp, err := ioutil.ReadAll(res.Body)
258

259
	res.Body.Close()
260
	res.Body = slurpResult{
261
		ReadCloser: ioutil.NopCloser(bytes.NewReader(slurp)),
262
		body:       slurp,
263
		err:        err,
264
	}
265
	for i, v := range res.Header["Date"] {
266
		res.Header["Date"][i] = strings.Repeat("x", len(v))
267
	}
268
	if res.Request == nil {
269
		t.Errorf("for %s, no request", wantProto)
270
	}
271
	if (res.TLS != nil) != (wantProto == "HTTP/2.0") {
272
		t.Errorf("TLS set = %v; want %v", res.TLS != nil, res.TLS == nil)
273
	}
274
}
275

276
// Issue 13532
277
func TestH12_HeadContentLengthNoBody(t *testing.T) {
278
	h12Compare{
279
		ReqFunc: (*Client).Head,
280
		Handler: func(w ResponseWriter, r *Request) {
281
		},
282
	}.run(t)
283
}
284

285
func TestH12_HeadContentLengthSmallBody(t *testing.T) {
286
	h12Compare{
287
		ReqFunc: (*Client).Head,
288
		Handler: func(w ResponseWriter, r *Request) {
289
			io.WriteString(w, "small")
290
		},
291
	}.run(t)
292
}
293

294
func TestH12_HeadContentLengthLargeBody(t *testing.T) {
295
	h12Compare{
296
		ReqFunc: (*Client).Head,
297
		Handler: func(w ResponseWriter, r *Request) {
298
			chunk := strings.Repeat("x", 512<<10)
299
			for i := 0; i < 10; i++ {
300
				io.WriteString(w, chunk)
301
			}
302
		},
303
	}.run(t)
304
}
305

306
func TestH12_200NoBody(t *testing.T) {
307
	h12Compare{Handler: func(w ResponseWriter, r *Request) {}}.run(t)
308
}
309

310
func TestH2_204NoBody(t *testing.T) { testH12_noBody(t, 204) }
311
func TestH2_304NoBody(t *testing.T) { testH12_noBody(t, 304) }
312
func TestH2_404NoBody(t *testing.T) { testH12_noBody(t, 404) }
313

314
func testH12_noBody(t *testing.T, status int) {
315
	h12Compare{Handler: func(w ResponseWriter, r *Request) {
316
		w.WriteHeader(status)
317
	}}.run(t)
318
}
319

320
func TestH12_SmallBody(t *testing.T) {
321
	h12Compare{Handler: func(w ResponseWriter, r *Request) {
322
		io.WriteString(w, "small body")
323
	}}.run(t)
324
}
325

326
func TestH12_ExplicitContentLength(t *testing.T) {
327
	h12Compare{Handler: func(w ResponseWriter, r *Request) {
328
		w.Header().Set("Content-Length", "3")
329
		io.WriteString(w, "foo")
330
	}}.run(t)
331
}
332

333
func TestH12_FlushBeforeBody(t *testing.T) {
334
	h12Compare{Handler: func(w ResponseWriter, r *Request) {
335
		w.(Flusher).Flush()
336
		io.WriteString(w, "foo")
337
	}}.run(t)
338
}
339

340
func TestH12_FlushMidBody(t *testing.T) {
341
	h12Compare{Handler: func(w ResponseWriter, r *Request) {
342
		io.WriteString(w, "foo")
343
		w.(Flusher).Flush()
344
		io.WriteString(w, "bar")
345
	}}.run(t)
346
}
347

348
func TestH12_Head_ExplicitLen(t *testing.T) {
349
	h12Compare{
350
		ReqFunc: (*Client).Head,
351
		Handler: func(w ResponseWriter, r *Request) {
352
			if r.Method != "HEAD" {
353
				t.Errorf("unexpected method %q", r.Method)
354
			}
355
			w.Header().Set("Content-Length", "1235")
356
		},
357
	}.run(t)
358
}
359

360
func TestH12_Head_ImplicitLen(t *testing.T) {
361
	h12Compare{
362
		ReqFunc: (*Client).Head,
363
		Handler: func(w ResponseWriter, r *Request) {
364
			if r.Method != "HEAD" {
365
				t.Errorf("unexpected method %q", r.Method)
366
			}
367
			io.WriteString(w, "foo")
368
		},
369
	}.run(t)
370
}
371

372
func TestH12_HandlerWritesTooLittle(t *testing.T) {
373
	h12Compare{
374
		Handler: func(w ResponseWriter, r *Request) {
375
			w.Header().Set("Content-Length", "3")
376
			io.WriteString(w, "12") // one byte short
377
		},
378
		CheckResponse: func(proto string, res *Response) {
379
			sr, ok := res.Body.(slurpResult)
380
			if !ok {
381
				t.Errorf("%s body is %T; want slurpResult", proto, res.Body)
382
				return
383
			}
384
			if sr.err != io.ErrUnexpectedEOF {
385
				t.Errorf("%s read error = %v; want io.ErrUnexpectedEOF", proto, sr.err)
386
			}
387
			if string(sr.body) != "12" {
388
				t.Errorf("%s body = %q; want %q", proto, sr.body, "12")
389
			}
390
		},
391
	}.run(t)
392
}
393

394
// Tests that the HTTP/1 and HTTP/2 servers prevent handlers from
395
// writing more than they declared. This test does not test whether
396
// the transport deals with too much data, though, since the server
397
// doesn't make it possible to send bogus data. For those tests, see
398
// transport_test.go (for HTTP/1) or x/net/http2/transport_test.go
399
// (for HTTP/2).
400
func TestH12_HandlerWritesTooMuch(t *testing.T) {
401
	h12Compare{
402
		Handler: func(w ResponseWriter, r *Request) {
403
			w.Header().Set("Content-Length", "3")
404
			w.(Flusher).Flush()
405
			io.WriteString(w, "123")
406
			w.(Flusher).Flush()
407
			n, err := io.WriteString(w, "x") // too many
408
			if n > 0 || err == nil {
409
				t.Errorf("for proto %q, final write = %v, %v; want 0, some error", r.Proto, n, err)
410
			}
411
		},
412
	}.run(t)
413
}
414

415
// Verify that both our HTTP/1 and HTTP/2 request and auto-decompress gzip.
416
// Some hosts send gzip even if you don't ask for it; see golang.org/issue/13298
417
func TestH12_AutoGzip(t *testing.T) {
418
	h12Compare{
419
		Handler: func(w ResponseWriter, r *Request) {
420
			if ae := r.Header.Get("Accept-Encoding"); ae != "gzip" {
421
				t.Errorf("%s Accept-Encoding = %q; want gzip", r.Proto, ae)
422
			}
423
			w.Header().Set("Content-Encoding", "gzip")
424
			gz := gzip.NewWriter(w)
425
			io.WriteString(gz, "I am some gzipped content. Go go go go go go go go go go go go should compress well.")
426
			gz.Close()
427
		},
428
	}.run(t)
429
}
430

431
func TestH12_AutoGzip_Disabled(t *testing.T) {
432
	h12Compare{
433
		Opts: []interface{}{
434
			func(tr *Transport) { tr.DisableCompression = true },
435
		},
436
		Handler: func(w ResponseWriter, r *Request) {
437
			fmt.Fprintf(w, "%q", r.Header["Accept-Encoding"])
438
			if ae := r.Header.Get("Accept-Encoding"); ae != "" {
439
				t.Errorf("%s Accept-Encoding = %q; want empty", r.Proto, ae)
440
			}
441
		},
442
	}.run(t)
443
}
444

445
// Test304Responses verifies that 304s don't declare that they're
446
// chunking in their response headers and aren't allowed to produce
447
// output.
448
func Test304Responses_h1(t *testing.T) { test304Responses(t, h1Mode) }
449
func Test304Responses_h2(t *testing.T) { test304Responses(t, h2Mode) }
450

451
func test304Responses(t *testing.T, h2 bool) {
452
	defer afterTest(t)
453
	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
454
		w.WriteHeader(StatusNotModified)
455
		_, err := w.Write([]byte("illegal body"))
456
		if err != ErrBodyNotAllowed {
457
			t.Errorf("on Write, expected ErrBodyNotAllowed, got %v", err)
458
		}
459
	}))
460
	defer cst.close()
461
	res, err := cst.c.Get(cst.ts.URL)
462
	if err != nil {
463
		t.Fatal(err)
464
	}
465
	if len(res.TransferEncoding) > 0 {
466
		t.Errorf("expected no TransferEncoding; got %v", res.TransferEncoding)
467
	}
468
	body, err := ioutil.ReadAll(res.Body)
469
	if err != nil {
470
		t.Error(err)
471
	}
472
	if len(body) > 0 {
473
		t.Errorf("got unexpected body %q", string(body))
474
	}
475
}
476

477
func TestH12_ServerEmptyContentLength(t *testing.T) {
478
	h12Compare{
479
		Handler: func(w ResponseWriter, r *Request) {
480
			w.Header()["Content-Type"] = []string{""}
481
			io.WriteString(w, "<html><body>hi</body></html>")
482
		},
483
	}.run(t)
484
}
485

486
func TestH12_RequestContentLength_Known_NonZero(t *testing.T) {
487
	h12requestContentLength(t, func() io.Reader { return strings.NewReader("FOUR") }, 4)
488
}
489

490
func TestH12_RequestContentLength_Known_Zero(t *testing.T) {
491
	h12requestContentLength(t, func() io.Reader { return nil }, 0)
492
}
493

494
func TestH12_RequestContentLength_Unknown(t *testing.T) {
495
	h12requestContentLength(t, func() io.Reader { return struct{ io.Reader }{strings.NewReader("Stuff")} }, -1)
496
}
497

498
func h12requestContentLength(t *testing.T, bodyfn func() io.Reader, wantLen int64) {
499
	h12Compare{
500
		Handler: func(w ResponseWriter, r *Request) {
501
			w.Header().Set("Got-Length", fmt.Sprint(r.ContentLength))
502
			fmt.Fprintf(w, "Req.ContentLength=%v", r.ContentLength)
503
		},
504
		ReqFunc: func(c *Client, url string) (*Response, error) {
505
			return c.Post(url, "text/plain", bodyfn())
506
		},
507
		CheckResponse: func(proto string, res *Response) {
508
			if got, want := res.Header.Get("Got-Length"), fmt.Sprint(wantLen); got != want {
509
				t.Errorf("Proto %q got length %q; want %q", proto, got, want)
510
			}
511
		},
512
	}.run(t)
513
}
514

515
// Tests that closing the Request.Cancel channel also while still
516
// reading the response body. Issue 13159.
517
func TestCancelRequestMidBody_h1(t *testing.T) { testCancelRequestMidBody(t, h1Mode) }
518
func TestCancelRequestMidBody_h2(t *testing.T) { testCancelRequestMidBody(t, h2Mode) }
519
func testCancelRequestMidBody(t *testing.T, h2 bool) {
520
	defer afterTest(t)
521
	unblock := make(chan bool)
522
	didFlush := make(chan bool, 1)
523
	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
524
		io.WriteString(w, "Hello")
525
		w.(Flusher).Flush()
526
		didFlush <- true
527
		<-unblock
528
		io.WriteString(w, ", world.")
529
	}))
530
	defer cst.close()
531
	defer close(unblock)
532

533
	req, _ := NewRequest("GET", cst.ts.URL, nil)
534
	cancel := make(chan struct{})
535
	req.Cancel = cancel
536

537
	res, err := cst.c.Do(req)
538
	if err != nil {
539
		t.Fatal(err)
540
	}
541
	defer res.Body.Close()
542
	<-didFlush
543

544
	// Read a bit before we cancel. (Issue 13626)
545
	// We should have "Hello" at least sitting there.
546
	firstRead := make([]byte, 10)
547
	n, err := res.Body.Read(firstRead)
548
	if err != nil {
549
		t.Fatal(err)
550
	}
551
	firstRead = firstRead[:n]
552

553
	close(cancel)
554

555
	rest, err := ioutil.ReadAll(res.Body)
556
	all := string(firstRead) + string(rest)
557
	if all != "Hello" {
558
		t.Errorf("Read %q (%q + %q); want Hello", all, firstRead, rest)
559
	}
560
	if !reflect.DeepEqual(err, ExportErrRequestCanceled) {
561
		t.Errorf("ReadAll error = %v; want %v", err, ExportErrRequestCanceled)
562
	}
563
}
564

565
// Tests that clients can send trailers to a server and that the server can read them.
566
func TestTrailersClientToServer_h1(t *testing.T) { testTrailersClientToServer(t, h1Mode) }
567
func TestTrailersClientToServer_h2(t *testing.T) { testTrailersClientToServer(t, h2Mode) }
568

569
func testTrailersClientToServer(t *testing.T, h2 bool) {
570
	defer afterTest(t)
571
	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
572
		var decl []string
573
		for k := range r.Trailer {
574
			decl = append(decl, k)
575
		}
576
		sort.Strings(decl)
577

578
		slurp, err := ioutil.ReadAll(r.Body)
579
		if err != nil {
580
			t.Errorf("Server reading request body: %v", err)
581
		}
582
		if string(slurp) != "foo" {
583
			t.Errorf("Server read request body %q; want foo", slurp)
584
		}
585
		if r.Trailer == nil {
586
			io.WriteString(w, "nil Trailer")
587
		} else {
588
			fmt.Fprintf(w, "decl: %v, vals: %s, %s",
589
				decl,
590
				r.Trailer.Get("Client-Trailer-A"),
591
				r.Trailer.Get("Client-Trailer-B"))
592
		}
593
	}))
594
	defer cst.close()
595

596
	var req *Request
597
	req, _ = NewRequest("POST", cst.ts.URL, io.MultiReader(
598
		eofReaderFunc(func() {
599
			req.Trailer["Client-Trailer-A"] = []string{"valuea"}
600
		}),
601
		strings.NewReader("foo"),
602
		eofReaderFunc(func() {
603
			req.Trailer["Client-Trailer-B"] = []string{"valueb"}
604
		}),
605
	))
606
	req.Trailer = Header{
607
		"Client-Trailer-A": nil, //  to be set later
608
		"Client-Trailer-B": nil, //  to be set later
609
	}
610
	req.ContentLength = -1
611
	res, err := cst.c.Do(req)
612
	if err != nil {
613
		t.Fatal(err)
614
	}
615
	if err := wantBody(res, err, "decl: [Client-Trailer-A Client-Trailer-B], vals: valuea, valueb"); err != nil {
616
		t.Error(err)
617
	}
618
}
619

620
// Tests that servers send trailers to a client and that the client can read them.
621
func TestTrailersServerToClient_h1(t *testing.T)       { testTrailersServerToClient(t, h1Mode, false) }
622
func TestTrailersServerToClient_h2(t *testing.T)       { testTrailersServerToClient(t, h2Mode, false) }
623
func TestTrailersServerToClient_Flush_h1(t *testing.T) { testTrailersServerToClient(t, h1Mode, true) }
624
func TestTrailersServerToClient_Flush_h2(t *testing.T) { testTrailersServerToClient(t, h2Mode, true) }
625

626
func testTrailersServerToClient(t *testing.T, h2, flush bool) {
627
	defer afterTest(t)
628
	const body = "Some body"
629
	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
630
		w.Header().Set("Trailer", "Server-Trailer-A, Server-Trailer-B")
631
		w.Header().Add("Trailer", "Server-Trailer-C")
632

633
		io.WriteString(w, body)
634
		if flush {
635
			w.(Flusher).Flush()
636
		}
637

638
		// How handlers set Trailers: declare it ahead of time
639
		// with the Trailer header, and then mutate the
640
		// Header() of those values later, after the response
641
		// has been written (we wrote to w above).
642
		w.Header().Set("Server-Trailer-A", "valuea")
643
		w.Header().Set("Server-Trailer-C", "valuec") // skipping B
644
		w.Header().Set("Server-Trailer-NotDeclared", "should be omitted")
645
	}))
646
	defer cst.close()
647

648
	res, err := cst.c.Get(cst.ts.URL)
649
	if err != nil {
650
		t.Fatal(err)
651
	}
652

653
	wantHeader := Header{
654
		"Content-Type": {"text/plain; charset=utf-8"},
655
	}
656
	wantLen := -1
657
	if h2 && !flush {
658
		// In HTTP/1.1, any use of trailers forces HTTP/1.1
659
		// chunking and a flush at the first write. That's
660
		// unnecessary with HTTP/2's framing, so the server
661
		// is able to calculate the length while still sending
662
		// trailers afterwards.
663
		wantLen = len(body)
664
		wantHeader["Content-Length"] = []string{fmt.Sprint(wantLen)}
665
	}
666
	if res.ContentLength != int64(wantLen) {
667
		t.Errorf("ContentLength = %v; want %v", res.ContentLength, wantLen)
668
	}
669

670
	delete(res.Header, "Date") // irrelevant for test
671
	if !reflect.DeepEqual(res.Header, wantHeader) {
672
		t.Errorf("Header = %v; want %v", res.Header, wantHeader)
673
	}
674

675
	if got, want := res.Trailer, (Header{
676
		"Server-Trailer-A": nil,
677
		"Server-Trailer-B": nil,
678
		"Server-Trailer-C": nil,
679
	}); !reflect.DeepEqual(got, want) {
680
		t.Errorf("Trailer before body read = %v; want %v", got, want)
681
	}
682

683
	if err := wantBody(res, nil, body); err != nil {
684
		t.Fatal(err)
685
	}
686

687
	if got, want := res.Trailer, (Header{
688
		"Server-Trailer-A": {"valuea"},
689
		"Server-Trailer-B": nil,
690
		"Server-Trailer-C": {"valuec"},
691
	}); !reflect.DeepEqual(got, want) {
692
		t.Errorf("Trailer after body read = %v; want %v", got, want)
693
	}
694
}
695

696
// Don't allow a Body.Read after Body.Close. Issue 13648.
697
func TestResponseBodyReadAfterClose_h1(t *testing.T) { testResponseBodyReadAfterClose(t, h1Mode) }
698
func TestResponseBodyReadAfterClose_h2(t *testing.T) { testResponseBodyReadAfterClose(t, h2Mode) }
699

700
func testResponseBodyReadAfterClose(t *testing.T, h2 bool) {
701
	defer afterTest(t)
702
	const body = "Some body"
703
	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
704
		io.WriteString(w, body)
705
	}))
706
	defer cst.close()
707
	res, err := cst.c.Get(cst.ts.URL)
708
	if err != nil {
709
		t.Fatal(err)
710
	}
711
	res.Body.Close()
712
	data, err := ioutil.ReadAll(res.Body)
713
	if len(data) != 0 || err == nil {
714
		t.Fatalf("ReadAll returned %q, %v; want error", data, err)
715
	}
716
}
717

718
func TestConcurrentReadWriteReqBody_h1(t *testing.T) { testConcurrentReadWriteReqBody(t, h1Mode) }
719
func TestConcurrentReadWriteReqBody_h2(t *testing.T) { testConcurrentReadWriteReqBody(t, h2Mode) }
720
func testConcurrentReadWriteReqBody(t *testing.T, h2 bool) {
721
	defer afterTest(t)
722
	const reqBody = "some request body"
723
	const resBody = "some response body"
724
	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
725
		var wg sync.WaitGroup
726
		wg.Add(2)
727
		didRead := make(chan bool, 1)
728
		// Read in one goroutine.
729
		go func() {
730
			defer wg.Done()
731
			data, err := ioutil.ReadAll(r.Body)
732
			if string(data) != reqBody {
733
				t.Errorf("Handler read %q; want %q", data, reqBody)
734
			}
735
			if err != nil {
736
				t.Errorf("Handler Read: %v", err)
737
			}
738
			didRead <- true
739
		}()
740
		// Write in another goroutine.
741
		go func() {
742
			defer wg.Done()
743
			if !h2 {
744
				// our HTTP/1 implementation intentionally
745
				// doesn't permit writes during read (mostly
746
				// due to it being undefined); if that is ever
747
				// relaxed, change this.
748
				<-didRead
749
			}
750
			io.WriteString(w, resBody)
751
		}()
752
		wg.Wait()
753
	}))
754
	defer cst.close()
755
	req, _ := NewRequest("POST", cst.ts.URL, strings.NewReader(reqBody))
756
	req.Header.Add("Expect", "100-continue") // just to complicate things
757
	res, err := cst.c.Do(req)
758
	if err != nil {
759
		t.Fatal(err)
760
	}
761
	data, err := ioutil.ReadAll(res.Body)
762
	defer res.Body.Close()
763
	if err != nil {
764
		t.Fatal(err)
765
	}
766
	if string(data) != resBody {
767
		t.Errorf("read %q; want %q", data, resBody)
768
	}
769
}
770

771
func TestConnectRequest_h1(t *testing.T) { testConnectRequest(t, h1Mode) }
772
func TestConnectRequest_h2(t *testing.T) { testConnectRequest(t, h2Mode) }
773
func testConnectRequest(t *testing.T, h2 bool) {
774
	defer afterTest(t)
775
	gotc := make(chan *Request, 1)
776
	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
777
		gotc <- r
778
	}))
779
	defer cst.close()
780

781
	u, err := url.Parse(cst.ts.URL)
782
	if err != nil {
783
		t.Fatal(err)
784
	}
785

786
	tests := []struct {
787
		req  *Request
788
		want string
789
	}{
790
		{
791
			req: &Request{
792
				Method: "CONNECT",
793
				Header: Header{},
794
				URL:    u,
795
			},
796
			want: u.Host,
797
		},
798
		{
799
			req: &Request{
800
				Method: "CONNECT",
801
				Header: Header{},
802
				URL:    u,
803
				Host:   "example.com:123",
804
			},
805
			want: "example.com:123",
806
		},
807
	}
808

809
	for i, tt := range tests {
810
		res, err := cst.c.Do(tt.req)
811
		if err != nil {
812
			t.Errorf("%d. RoundTrip = %v", i, err)
813
			continue
814
		}
815
		res.Body.Close()
816
		req := <-gotc
817
		if req.Method != "CONNECT" {
818
			t.Errorf("method = %q; want CONNECT", req.Method)
819
		}
820
		if req.Host != tt.want {
821
			t.Errorf("Host = %q; want %q", req.Host, tt.want)
822
		}
823
		if req.URL.Host != tt.want {
824
			t.Errorf("URL.Host = %q; want %q", req.URL.Host, tt.want)
825
		}
826
	}
827
}
828

829
func TestTransportUserAgent_h1(t *testing.T) { testTransportUserAgent(t, h1Mode) }
830
func TestTransportUserAgent_h2(t *testing.T) { testTransportUserAgent(t, h2Mode) }
831
func testTransportUserAgent(t *testing.T, h2 bool) {
832
	defer afterTest(t)
833
	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
834
		fmt.Fprintf(w, "%q", r.Header["User-Agent"])
835
	}))
836
	defer cst.close()
837

838
	either := func(a, b string) string {
839
		if h2 {
840
			return b
841
		}
842
		return a
843
	}
844

845
	tests := []struct {
846
		setup func(*Request)
847
		want  string
848
	}{
849
		{
850
			func(r *Request) {},
851
			either(`["Go-http-client/1.1"]`, `["Go-http-client/2.0"]`),
852
		},
853
		{
854
			func(r *Request) { r.Header.Set("User-Agent", "foo/1.2.3") },
855
			`["foo/1.2.3"]`,
856
		},
857
		{
858
			func(r *Request) { r.Header["User-Agent"] = []string{"single", "or", "multiple"} },
859
			`["single"]`,
860
		},
861
		{
862
			func(r *Request) { r.Header.Set("User-Agent", "") },
863
			`[]`,
864
		},
865
		{
866
			func(r *Request) { r.Header["User-Agent"] = nil },
867
			`[]`,
868
		},
869
	}
870
	for i, tt := range tests {
871
		req, _ := NewRequest("GET", cst.ts.URL, nil)
872
		tt.setup(req)
873
		res, err := cst.c.Do(req)
874
		if err != nil {
875
			t.Errorf("%d. RoundTrip = %v", i, err)
876
			continue
877
		}
878
		slurp, err := ioutil.ReadAll(res.Body)
879
		res.Body.Close()
880
		if err != nil {
881
			t.Errorf("%d. read body = %v", i, err)
882
			continue
883
		}
884
		if string(slurp) != tt.want {
885
			t.Errorf("%d. body mismatch.\n got: %s\nwant: %s\n", i, slurp, tt.want)
886
		}
887
	}
888
}
889

890
func TestStarRequestFoo_h1(t *testing.T)     { testStarRequest(t, "FOO", h1Mode) }
891
func TestStarRequestFoo_h2(t *testing.T)     { testStarRequest(t, "FOO", h2Mode) }
892
func TestStarRequestOptions_h1(t *testing.T) { testStarRequest(t, "OPTIONS", h1Mode) }
893
func TestStarRequestOptions_h2(t *testing.T) { testStarRequest(t, "OPTIONS", h2Mode) }
894
func testStarRequest(t *testing.T, method string, h2 bool) {
895
	defer afterTest(t)
896
	gotc := make(chan *Request, 1)
897
	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
898
		w.Header().Set("foo", "bar")
899
		gotc <- r
900
		w.(Flusher).Flush()
901
	}))
902
	defer cst.close()
903

904
	u, err := url.Parse(cst.ts.URL)
905
	if err != nil {
906
		t.Fatal(err)
907
	}
908
	u.Path = "*"
909

910
	req := &Request{
911
		Method: method,
912
		Header: Header{},
913
		URL:    u,
914
	}
915

916
	res, err := cst.c.Do(req)
917
	if err != nil {
918
		t.Fatalf("RoundTrip = %v", err)
919
	}
920
	res.Body.Close()
921

922
	wantFoo := "bar"
923
	wantLen := int64(-1)
924
	if method == "OPTIONS" {
925
		wantFoo = ""
926
		wantLen = 0
927
	}
928
	if res.StatusCode != 200 {
929
		t.Errorf("status code = %v; want %d", res.Status, 200)
930
	}
931
	if res.ContentLength != wantLen {
932
		t.Errorf("content length = %v; want %d", res.ContentLength, wantLen)
933
	}
934
	if got := res.Header.Get("foo"); got != wantFoo {
935
		t.Errorf("response \"foo\" header = %q; want %q", got, wantFoo)
936
	}
937
	select {
938
	case req = <-gotc:
939
	default:
940
		req = nil
941
	}
942
	if req == nil {
943
		if method != "OPTIONS" {
944
			t.Fatalf("handler never got request")
945
		}
946
		return
947
	}
948
	if req.Method != method {
949
		t.Errorf("method = %q; want %q", req.Method, method)
950
	}
951
	if req.URL.Path != "*" {
952
		t.Errorf("URL.Path = %q; want *", req.URL.Path)
953
	}
954
	if req.RequestURI != "*" {
955
		t.Errorf("RequestURI = %q; want *", req.RequestURI)
956
	}
957
}
958

959
// Issue 13957
960
func TestTransportDiscardsUnneededConns(t *testing.T) {
961
	setParallel(t)
962
	defer afterTest(t)
963
	cst := newClientServerTest(t, h2Mode, HandlerFunc(func(w ResponseWriter, r *Request) {
964
		fmt.Fprintf(w, "Hello, %v", r.RemoteAddr)
965
	}))
966
	defer cst.close()
967

968
	var numOpen, numClose int32 // atomic
969

970
	tlsConfig := &tls.Config{InsecureSkipVerify: true}
971
	tr := &Transport{
972
		TLSClientConfig: tlsConfig,
973
		DialTLS: func(_, addr string) (net.Conn, error) {
974
			time.Sleep(10 * time.Millisecond)
975
			rc, err := net.Dial("tcp", addr)
976
			if err != nil {
977
				return nil, err
978
			}
979
			atomic.AddInt32(&numOpen, 1)
980
			c := noteCloseConn{rc, func() { atomic.AddInt32(&numClose, 1) }}
981
			return tls.Client(c, tlsConfig), nil
982
		},
983
	}
984
	if err := ExportHttp2ConfigureTransport(tr); err != nil {
985
		t.Fatal(err)
986
	}
987
	defer tr.CloseIdleConnections()
988

989
	c := &Client{Transport: tr}
990

991
	const N = 10
992
	gotBody := make(chan string, N)
993
	var wg sync.WaitGroup
994
	for i := 0; i < N; i++ {
995
		wg.Add(1)
996
		go func() {
997
			defer wg.Done()
998
			resp, err := c.Get(cst.ts.URL)
999
			if err != nil {
1000
				t.Errorf("Get: %v", err)
1001
				return
1002
			}
1003
			defer resp.Body.Close()
1004
			slurp, err := ioutil.ReadAll(resp.Body)
1005
			if err != nil {
1006
				t.Error(err)
1007
			}
1008
			gotBody <- string(slurp)
1009
		}()
1010
	}
1011
	wg.Wait()
1012
	close(gotBody)
1013

1014
	var last string
1015
	for got := range gotBody {
1016
		if last == "" {
1017
			last = got
1018
			continue
1019
		}
1020
		if got != last {
1021
			t.Errorf("Response body changed: %q -> %q", last, got)
1022
		}
1023
	}
1024

1025
	var open, close int32
1026
	for i := 0; i < 150; i++ {
1027
		open, close = atomic.LoadInt32(&numOpen), atomic.LoadInt32(&numClose)
1028
		if open < 1 {
1029
			t.Fatalf("open = %d; want at least", open)
1030
		}
1031
		if close == open-1 {
1032
			// Success
1033
			return
1034
		}
1035
		time.Sleep(10 * time.Millisecond)
1036
	}
1037
	t.Errorf("%d connections opened, %d closed; want %d to close", open, close, open-1)
1038
}
1039

1040
// tests that Transport doesn't retain a pointer to the provided request.
1041
func TestTransportGCRequest_Body_h1(t *testing.T)   { testTransportGCRequest(t, h1Mode, true) }
1042
func TestTransportGCRequest_Body_h2(t *testing.T)   { testTransportGCRequest(t, h2Mode, true) }
1043
func TestTransportGCRequest_NoBody_h1(t *testing.T) { testTransportGCRequest(t, h1Mode, false) }
1044
func TestTransportGCRequest_NoBody_h2(t *testing.T) { testTransportGCRequest(t, h2Mode, false) }
1045
func testTransportGCRequest(t *testing.T, h2, body bool) {
1046
	setParallel(t)
1047
	defer afterTest(t)
1048
	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
1049
		ioutil.ReadAll(r.Body)
1050
		if body {
1051
			io.WriteString(w, "Hello.")
1052
		}
1053
	}))
1054
	defer cst.close()
1055

1056
	didGC := make(chan struct{})
1057
	(func() {
1058
		body := strings.NewReader("some body")
1059
		req, _ := NewRequest("POST", cst.ts.URL, body)
1060
		runtime.SetFinalizer(req, func(*Request) { close(didGC) })
1061
		res, err := cst.c.Do(req)
1062
		if err != nil {
1063
			t.Fatal(err)
1064
		}
1065
		if _, err := ioutil.ReadAll(res.Body); err != nil {
1066
			t.Fatal(err)
1067
		}
1068
		if err := res.Body.Close(); err != nil {
1069
			t.Fatal(err)
1070
		}
1071
	})()
1072
	timeout := time.NewTimer(5 * time.Second)
1073
	defer timeout.Stop()
1074
	for {
1075
		select {
1076
		case <-didGC:
1077
			return
1078
		case <-time.After(100 * time.Millisecond):
1079
			runtime.GC()
1080
		case <-timeout.C:
1081
			t.Fatal("never saw GC of request")
1082
		}
1083
	}
1084
}
1085

1086
func TestTransportRejectsInvalidHeaders_h1(t *testing.T) {
1087
	testTransportRejectsInvalidHeaders(t, h1Mode)
1088
}
1089
func TestTransportRejectsInvalidHeaders_h2(t *testing.T) {
1090
	testTransportRejectsInvalidHeaders(t, h2Mode)
1091
}
1092
func testTransportRejectsInvalidHeaders(t *testing.T, h2 bool) {
1093
	setParallel(t)
1094
	defer afterTest(t)
1095
	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
1096
		fmt.Fprintf(w, "Handler saw headers: %q", r.Header)
1097
	}), optQuietLog)
1098
	defer cst.close()
1099
	cst.tr.DisableKeepAlives = true
1100

1101
	tests := []struct {
1102
		key, val string
1103
		ok       bool
1104
	}{
1105
		{"Foo", "capital-key", true}, // verify h2 allows capital keys
1106
		{"Foo", "foo\x00bar", false}, // \x00 byte in value not allowed
1107
		{"Foo", "two\nlines", false}, // \n byte in value not allowed
1108
		{"bogus\nkey", "v", false},   // \n byte also not allowed in key
1109
		{"A space", "v", false},      // spaces in keys not allowed
1110
		{"имя", "v", false},          // key must be ascii
1111
		{"name", "валю", true},       // value may be non-ascii
1112
		{"", "v", false},             // key must be non-empty
1113
		{"k", "", true},              // value may be empty
1114
	}
1115
	for _, tt := range tests {
1116
		dialedc := make(chan bool, 1)
1117
		cst.tr.Dial = func(netw, addr string) (net.Conn, error) {
1118
			dialedc <- true
1119
			return net.Dial(netw, addr)
1120
		}
1121
		req, _ := NewRequest("GET", cst.ts.URL, nil)
1122
		req.Header[tt.key] = []string{tt.val}
1123
		res, err := cst.c.Do(req)
1124
		var body []byte
1125
		if err == nil {
1126
			body, _ = ioutil.ReadAll(res.Body)
1127
			res.Body.Close()
1128
		}
1129
		var dialed bool
1130
		select {
1131
		case <-dialedc:
1132
			dialed = true
1133
		default:
1134
		}
1135

1136
		if !tt.ok && dialed {
1137
			t.Errorf("For key %q, value %q, transport dialed. Expected local failure. Response was: (%v, %v)\nServer replied with: %s", tt.key, tt.val, res, err, body)
1138
		} else if (err == nil) != tt.ok {
1139
			t.Errorf("For key %q, value %q; got err = %v; want ok=%v", tt.key, tt.val, err, tt.ok)
1140
		}
1141
	}
1142
}
1143

1144
func TestInterruptWithPanic_h1(t *testing.T)     { testInterruptWithPanic(t, h1Mode, "boom") }
1145
func TestInterruptWithPanic_h2(t *testing.T)     { testInterruptWithPanic(t, h2Mode, "boom") }
1146
func TestInterruptWithPanic_nil_h1(t *testing.T) { testInterruptWithPanic(t, h1Mode, nil) }
1147
func TestInterruptWithPanic_nil_h2(t *testing.T) { testInterruptWithPanic(t, h2Mode, nil) }
1148
func TestInterruptWithPanic_ErrAbortHandler_h1(t *testing.T) {
1149
	testInterruptWithPanic(t, h1Mode, ErrAbortHandler)
1150
}
1151
func TestInterruptWithPanic_ErrAbortHandler_h2(t *testing.T) {
1152
	testInterruptWithPanic(t, h2Mode, ErrAbortHandler)
1153
}
1154
func testInterruptWithPanic(t *testing.T, h2 bool, panicValue interface{}) {
1155
	setParallel(t)
1156
	const msg = "hello"
1157
	defer afterTest(t)
1158

1159
	testDone := make(chan struct{})
1160
	defer close(testDone)
1161

1162
	var errorLog lockedBytesBuffer
1163
	gotHeaders := make(chan bool, 1)
1164
	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
1165
		io.WriteString(w, msg)
1166
		w.(Flusher).Flush()
1167

1168
		select {
1169
		case <-gotHeaders:
1170
		case <-testDone:
1171
		}
1172
		panic(panicValue)
1173
	}), func(ts *httptest.Server) {
1174
		ts.Config.ErrorLog = log.New(&errorLog, "", 0)
1175
	})
1176
	defer cst.close()
1177
	res, err := cst.c.Get(cst.ts.URL)
1178
	if err != nil {
1179
		t.Fatal(err)
1180
	}
1181
	gotHeaders <- true
1182
	defer res.Body.Close()
1183
	slurp, err := ioutil.ReadAll(res.Body)
1184
	if string(slurp) != msg {
1185
		t.Errorf("client read %q; want %q", slurp, msg)
1186
	}
1187
	if err == nil {
1188
		t.Errorf("client read all successfully; want some error")
1189
	}
1190
	logOutput := func() string {
1191
		errorLog.Lock()
1192
		defer errorLog.Unlock()
1193
		return errorLog.String()
1194
	}
1195
	wantStackLogged := panicValue != nil && panicValue != ErrAbortHandler
1196

1197
	if err := waitErrCondition(5*time.Second, 10*time.Millisecond, func() error {
1198
		gotLog := logOutput()
1199
		if !wantStackLogged {
1200
			if gotLog == "" {
1201
				return nil
1202
			}
1203
			return fmt.Errorf("want no log output; got: %s", gotLog)
1204
		}
1205
		if gotLog == "" {
1206
			return fmt.Errorf("wanted a stack trace logged; got nothing")
1207
		}
1208
		if !strings.Contains(gotLog, "created by ") && strings.Count(gotLog, "\n") < 6 {
1209
			return fmt.Errorf("output doesn't look like a panic stack trace. Got: %s", gotLog)
1210
		}
1211
		return nil
1212
	}); err != nil {
1213
		t.Fatal(err)
1214
	}
1215
}
1216

1217
type lockedBytesBuffer struct {
1218
	sync.Mutex
1219
	bytes.Buffer
1220
}
1221

1222
func (b *lockedBytesBuffer) Write(p []byte) (int, error) {
1223
	b.Lock()
1224
	defer b.Unlock()
1225
	return b.Buffer.Write(p)
1226
}
1227

1228
// Issue 15366
1229
func TestH12_AutoGzipWithDumpResponse(t *testing.T) {
1230
	h12Compare{
1231
		Handler: func(w ResponseWriter, r *Request) {
1232
			h := w.Header()
1233
			h.Set("Content-Encoding", "gzip")
1234
			h.Set("Content-Length", "23")
1235
			io.WriteString(w, "\x1f\x8b\b\x00\x00\x00\x00\x00\x00\x00s\xf3\xf7\a\x00\xab'\xd4\x1a\x03\x00\x00\x00")
1236
		},
1237
		EarlyCheckResponse: func(proto string, res *Response) {
1238
			if !res.Uncompressed {
1239
				t.Errorf("%s: expected Uncompressed to be set", proto)
1240
			}
1241
			dump, err := httputil.DumpResponse(res, true)
1242
			if err != nil {
1243
				t.Errorf("%s: DumpResponse: %v", proto, err)
1244
				return
1245
			}
1246
			if strings.Contains(string(dump), "Connection: close") {
1247
				t.Errorf("%s: should not see \"Connection: close\" in dump; got:\n%s", proto, dump)
1248
			}
1249
			if !strings.Contains(string(dump), "FOO") {
1250
				t.Errorf("%s: should see \"FOO\" in response; got:\n%s", proto, dump)
1251
			}
1252
		},
1253
	}.run(t)
1254
}
1255

1256
// Issue 14607
1257
func TestCloseIdleConnections_h1(t *testing.T) { testCloseIdleConnections(t, h1Mode) }
1258
func TestCloseIdleConnections_h2(t *testing.T) { testCloseIdleConnections(t, h2Mode) }
1259
func testCloseIdleConnections(t *testing.T, h2 bool) {
1260
	setParallel(t)
1261
	defer afterTest(t)
1262
	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
1263
		w.Header().Set("X-Addr", r.RemoteAddr)
1264
	}))
1265
	defer cst.close()
1266
	get := func() string {
1267
		res, err := cst.c.Get(cst.ts.URL)
1268
		if err != nil {
1269
			t.Fatal(err)
1270
		}
1271
		res.Body.Close()
1272
		v := res.Header.Get("X-Addr")
1273
		if v == "" {
1274
			t.Fatal("didn't get X-Addr")
1275
		}
1276
		return v
1277
	}
1278
	a1 := get()
1279
	cst.tr.CloseIdleConnections()
1280
	a2 := get()
1281
	if a1 == a2 {
1282
		t.Errorf("didn't close connection")
1283
	}
1284
}
1285

1286
type noteCloseConn struct {
1287
	net.Conn
1288
	closeFunc func()
1289
}
1290

1291
func (x noteCloseConn) Close() error {
1292
	x.closeFunc()
1293
	return x.Conn.Close()
1294
}
1295

1296
type testErrorReader struct{ t *testing.T }
1297

1298
func (r testErrorReader) Read(p []byte) (n int, err error) {
1299
	r.t.Error("unexpected Read call")
1300
	return 0, io.EOF
1301
}
1302

1303
func TestNoSniffExpectRequestBody_h1(t *testing.T) { testNoSniffExpectRequestBody(t, h1Mode) }
1304
func TestNoSniffExpectRequestBody_h2(t *testing.T) { testNoSniffExpectRequestBody(t, h2Mode) }
1305

1306
func testNoSniffExpectRequestBody(t *testing.T, h2 bool) {
1307
	defer afterTest(t)
1308
	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
1309
		w.WriteHeader(StatusUnauthorized)
1310
	}))
1311
	defer cst.close()
1312

1313
	// Set ExpectContinueTimeout non-zero so RoundTrip won't try to write it.
1314
	cst.tr.ExpectContinueTimeout = 10 * time.Second
1315

1316
	req, err := NewRequest("POST", cst.ts.URL, testErrorReader{t})
1317
	if err != nil {
1318
		t.Fatal(err)
1319
	}
1320
	req.ContentLength = 0 // so transport is tempted to sniff it
1321
	req.Header.Set("Expect", "100-continue")
1322
	res, err := cst.tr.RoundTrip(req)
1323
	if err != nil {
1324
		t.Fatal(err)
1325
	}
1326
	defer res.Body.Close()
1327
	if res.StatusCode != StatusUnauthorized {
1328
		t.Errorf("status code = %v; want %v", res.StatusCode, StatusUnauthorized)
1329
	}
1330
}
1331

1332
func TestServerUndeclaredTrailers_h1(t *testing.T) { testServerUndeclaredTrailers(t, h1Mode) }
1333
func TestServerUndeclaredTrailers_h2(t *testing.T) { testServerUndeclaredTrailers(t, h2Mode) }
1334
func testServerUndeclaredTrailers(t *testing.T, h2 bool) {
1335
	defer afterTest(t)
1336
	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
1337
		w.Header().Set("Foo", "Bar")
1338
		w.Header().Set("Trailer:Foo", "Baz")
1339
		w.(Flusher).Flush()
1340
		w.Header().Add("Trailer:Foo", "Baz2")
1341
		w.Header().Set("Trailer:Bar", "Quux")
1342
	}))
1343
	defer cst.close()
1344
	res, err := cst.c.Get(cst.ts.URL)
1345
	if err != nil {
1346
		t.Fatal(err)
1347
	}
1348
	if _, err := io.Copy(ioutil.Discard, res.Body); err != nil {
1349
		t.Fatal(err)
1350
	}
1351
	res.Body.Close()
1352
	delete(res.Header, "Date")
1353
	delete(res.Header, "Content-Type")
1354

1355
	if want := (Header{"Foo": {"Bar"}}); !reflect.DeepEqual(res.Header, want) {
1356
		t.Errorf("Header = %#v; want %#v", res.Header, want)
1357
	}
1358
	if want := (Header{"Foo": {"Baz", "Baz2"}, "Bar": {"Quux"}}); !reflect.DeepEqual(res.Trailer, want) {
1359
		t.Errorf("Trailer = %#v; want %#v", res.Trailer, want)
1360
	}
1361
}
1362

1363
func TestBadResponseAfterReadingBody(t *testing.T) {
1364
	defer afterTest(t)
1365
	cst := newClientServerTest(t, false, HandlerFunc(func(w ResponseWriter, r *Request) {
1366
		_, err := io.Copy(ioutil.Discard, r.Body)
1367
		if err != nil {
1368
			t.Fatal(err)
1369
		}
1370
		c, _, err := w.(Hijacker).Hijack()
1371
		if err != nil {
1372
			t.Fatal(err)
1373
		}
1374
		defer c.Close()
1375
		fmt.Fprintln(c, "some bogus crap")
1376
	}))
1377
	defer cst.close()
1378

1379
	closes := 0
1380
	res, err := cst.c.Post(cst.ts.URL, "text/plain", countCloseReader{&closes, strings.NewReader("hello")})
1381
	if err == nil {
1382
		res.Body.Close()
1383
		t.Fatal("expected an error to be returned from Post")
1384
	}
1385
	if closes != 1 {
1386
		t.Errorf("closes = %d; want 1", closes)
1387
	}
1388
}
1389

1390
func TestWriteHeader0_h1(t *testing.T) { testWriteHeader0(t, h1Mode) }
1391
func TestWriteHeader0_h2(t *testing.T) { testWriteHeader0(t, h2Mode) }
1392
func testWriteHeader0(t *testing.T, h2 bool) {
1393
	defer afterTest(t)
1394
	gotpanic := make(chan bool, 1)
1395
	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
1396
		defer close(gotpanic)
1397
		defer func() {
1398
			if e := recover(); e != nil {
1399
				got := fmt.Sprintf("%T, %v", e, e)
1400
				want := "string, invalid WriteHeader code 0"
1401
				if got != want {
1402
					t.Errorf("unexpected panic value:\n got: %v\nwant: %v\n", got, want)
1403
				}
1404
				gotpanic <- true
1405

1406
				// Set an explicit 503. This also tests that the WriteHeader call panics
1407
				// before it recorded that an explicit value was set and that bogus
1408
				// value wasn't stuck.
1409
				w.WriteHeader(503)
1410
			}
1411
		}()
1412
		w.WriteHeader(0)
1413
	}))
1414
	defer cst.close()
1415
	res, err := cst.c.Get(cst.ts.URL)
1416
	if err != nil {
1417
		t.Fatal(err)
1418
	}
1419
	if res.StatusCode != 503 {
1420
		t.Errorf("Response: %v %q; want 503", res.StatusCode, res.Status)
1421
	}
1422
	if !<-gotpanic {
1423
		t.Error("expected panic in handler")
1424
	}
1425
}
1426

1427
// Issue 23010: don't be super strict checking WriteHeader's code if
1428
// it's not even valid to call WriteHeader then anyway.
1429
func TestWriteHeaderNoCodeCheck_h1(t *testing.T)       { testWriteHeaderAfterWrite(t, h1Mode, false) }
1430
func TestWriteHeaderNoCodeCheck_h1hijack(t *testing.T) { testWriteHeaderAfterWrite(t, h1Mode, true) }
1431
func TestWriteHeaderNoCodeCheck_h2(t *testing.T)       { testWriteHeaderAfterWrite(t, h2Mode, false) }
1432
func testWriteHeaderAfterWrite(t *testing.T, h2, hijack bool) {
1433
	setParallel(t)
1434
	defer afterTest(t)
1435

1436
	var errorLog lockedBytesBuffer
1437
	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
1438
		if hijack {
1439
			conn, _, _ := w.(Hijacker).Hijack()
1440
			defer conn.Close()
1441
			conn.Write([]byte("HTTP/1.1 200 OK\r\nContent-Length: 6\r\n\r\nfoo"))
1442
			w.WriteHeader(0) // verify this doesn't panic if there's already output; Issue 23010
1443
			conn.Write([]byte("bar"))
1444
			return
1445
		}
1446
		io.WriteString(w, "foo")
1447
		w.(Flusher).Flush()
1448
		w.WriteHeader(0) // verify this doesn't panic if there's already output; Issue 23010
1449
		io.WriteString(w, "bar")
1450
	}), func(ts *httptest.Server) {
1451
		ts.Config.ErrorLog = log.New(&errorLog, "", 0)
1452
	})
1453
	defer cst.close()
1454
	res, err := cst.c.Get(cst.ts.URL)
1455
	if err != nil {
1456
		t.Fatal(err)
1457
	}
1458
	defer res.Body.Close()
1459
	body, err := ioutil.ReadAll(res.Body)
1460
	if err != nil {
1461
		t.Fatal(err)
1462
	}
1463
	if got, want := string(body), "foobar"; got != want {
1464
		t.Errorf("got = %q; want %q", got, want)
1465
	}
1466

1467
	// Also check the stderr output:
1468
	if h2 {
1469
		// TODO: also emit this log message for HTTP/2?
1470
		// We historically haven't, so don't check.
1471
		return
1472
	}
1473
	gotLog := strings.TrimSpace(errorLog.String())
1474
	wantLog := "http: multiple response.WriteHeader calls"
1475
	if hijack {
1476
		wantLog = "http: response.WriteHeader on hijacked connection"
1477
	}
1478
	if gotLog != wantLog {
1479
		t.Errorf("stderr output = %q; want %q", gotLog, wantLog)
1480
	}
1481
}
1482