| // 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. |
| |
| // Tests for transport.go |
| |
| package http_test |
| |
| import ( |
| "bufio" |
| "bytes" |
| "compress/gzip" |
| "crypto/rand" |
| "crypto/tls" |
| "errors" |
| "fmt" |
| "io" |
| "io/ioutil" |
| "log" |
| "net" |
| "net/http" |
| . "net/http" |
| "net/http/httptest" |
| "net/url" |
| "os" |
| "runtime" |
| "strconv" |
| "strings" |
| "sync" |
| "testing" |
| "time" |
| ) |
| |
| // TODO: test 5 pipelined requests with responses: 1) OK, 2) OK, Connection: Close |
| // and then verify that the final 2 responses get errors back. |
| |
| // hostPortHandler writes back the client's "host:port". |
| var hostPortHandler = HandlerFunc(func(w ResponseWriter, r *Request) { |
| if r.FormValue("close") == "true" { |
| w.Header().Set("Connection", "close") |
| } |
| w.Write([]byte(r.RemoteAddr)) |
| }) |
| |
| // testCloseConn is a net.Conn tracked by a testConnSet. |
| type testCloseConn struct { |
| net.Conn |
| set *testConnSet |
| } |
| |
| func (c *testCloseConn) Close() error { |
| c.set.remove(c) |
| return c.Conn.Close() |
| } |
| |
| // testConnSet tracks a set of TCP connections and whether they've |
| // been closed. |
| type testConnSet struct { |
| t *testing.T |
| mu sync.Mutex // guards closed and list |
| closed map[net.Conn]bool |
| list []net.Conn // in order created |
| } |
| |
| func (tcs *testConnSet) insert(c net.Conn) { |
| tcs.mu.Lock() |
| defer tcs.mu.Unlock() |
| tcs.closed[c] = false |
| tcs.list = append(tcs.list, c) |
| } |
| |
| func (tcs *testConnSet) remove(c net.Conn) { |
| tcs.mu.Lock() |
| defer tcs.mu.Unlock() |
| tcs.closed[c] = true |
| } |
| |
| // some tests use this to manage raw tcp connections for later inspection |
| func makeTestDial(t *testing.T) (*testConnSet, func(n, addr string) (net.Conn, error)) { |
| connSet := &testConnSet{ |
| t: t, |
| closed: make(map[net.Conn]bool), |
| } |
| dial := func(n, addr string) (net.Conn, error) { |
| c, err := net.Dial(n, addr) |
| if err != nil { |
| return nil, err |
| } |
| tc := &testCloseConn{c, connSet} |
| connSet.insert(tc) |
| return tc, nil |
| } |
| return connSet, dial |
| } |
| |
| func (tcs *testConnSet) check(t *testing.T) { |
| tcs.mu.Lock() |
| defer tcs.mu.Unlock() |
| for i := 4; i >= 0; i-- { |
| for i, c := range tcs.list { |
| if tcs.closed[c] { |
| continue |
| } |
| if i != 0 { |
| tcs.mu.Unlock() |
| time.Sleep(50 * time.Millisecond) |
| tcs.mu.Lock() |
| continue |
| } |
| t.Errorf("TCP connection #%d, %p (of %d total) was not closed", i+1, c, len(tcs.list)) |
| } |
| } |
| } |
| |
| // Two subsequent requests and verify their response is the same. |
| // The response from the server is our own IP:port |
| func TestTransportKeepAlives(t *testing.T) { |
| defer afterTest(t) |
| ts := httptest.NewServer(hostPortHandler) |
| defer ts.Close() |
| |
| for _, disableKeepAlive := range []bool{false, true} { |
| tr := &Transport{DisableKeepAlives: disableKeepAlive} |
| defer tr.CloseIdleConnections() |
| c := &Client{Transport: tr} |
| |
| fetch := func(n int) string { |
| res, err := c.Get(ts.URL) |
| if err != nil { |
| t.Fatalf("error in disableKeepAlive=%v, req #%d, GET: %v", disableKeepAlive, n, err) |
| } |
| body, err := ioutil.ReadAll(res.Body) |
| if err != nil { |
| t.Fatalf("error in disableKeepAlive=%v, req #%d, ReadAll: %v", disableKeepAlive, n, err) |
| } |
| return string(body) |
| } |
| |
| body1 := fetch(1) |
| body2 := fetch(2) |
| |
| bodiesDiffer := body1 != body2 |
| if bodiesDiffer != disableKeepAlive { |
| t.Errorf("error in disableKeepAlive=%v. unexpected bodiesDiffer=%v; body1=%q; body2=%q", |
| disableKeepAlive, bodiesDiffer, body1, body2) |
| } |
| } |
| } |
| |
| func TestTransportConnectionCloseOnResponse(t *testing.T) { |
| defer afterTest(t) |
| ts := httptest.NewServer(hostPortHandler) |
| defer ts.Close() |
| |
| connSet, testDial := makeTestDial(t) |
| |
| for _, connectionClose := range []bool{false, true} { |
| tr := &Transport{ |
| Dial: testDial, |
| } |
| c := &Client{Transport: tr} |
| |
| fetch := func(n int) string { |
| req := new(Request) |
| var err error |
| req.URL, err = url.Parse(ts.URL + fmt.Sprintf("/?close=%v", connectionClose)) |
| if err != nil { |
| t.Fatalf("URL parse error: %v", err) |
| } |
| req.Method = "GET" |
| req.Proto = "HTTP/1.1" |
| req.ProtoMajor = 1 |
| req.ProtoMinor = 1 |
| |
| res, err := c.Do(req) |
| if err != nil { |
| t.Fatalf("error in connectionClose=%v, req #%d, Do: %v", connectionClose, n, err) |
| } |
| defer res.Body.Close() |
| body, err := ioutil.ReadAll(res.Body) |
| if err != nil { |
| t.Fatalf("error in connectionClose=%v, req #%d, ReadAll: %v", connectionClose, n, err) |
| } |
| return string(body) |
| } |
| |
| body1 := fetch(1) |
| body2 := fetch(2) |
| bodiesDiffer := body1 != body2 |
| if bodiesDiffer != connectionClose { |
| t.Errorf("error in connectionClose=%v. unexpected bodiesDiffer=%v; body1=%q; body2=%q", |
| connectionClose, bodiesDiffer, body1, body2) |
| } |
| |
| tr.CloseIdleConnections() |
| } |
| |
| connSet.check(t) |
| } |
| |
| func TestTransportConnectionCloseOnRequest(t *testing.T) { |
| defer afterTest(t) |
| ts := httptest.NewServer(hostPortHandler) |
| defer ts.Close() |
| |
| connSet, testDial := makeTestDial(t) |
| |
| for _, connectionClose := range []bool{false, true} { |
| tr := &Transport{ |
| Dial: testDial, |
| } |
| c := &Client{Transport: tr} |
| |
| fetch := func(n int) string { |
| req := new(Request) |
| var err error |
| req.URL, err = url.Parse(ts.URL) |
| if err != nil { |
| t.Fatalf("URL parse error: %v", err) |
| } |
| req.Method = "GET" |
| req.Proto = "HTTP/1.1" |
| req.ProtoMajor = 1 |
| req.ProtoMinor = 1 |
| req.Close = connectionClose |
| |
| res, err := c.Do(req) |
| if err != nil { |
| t.Fatalf("error in connectionClose=%v, req #%d, Do: %v", connectionClose, n, err) |
| } |
| body, err := ioutil.ReadAll(res.Body) |
| if err != nil { |
| t.Fatalf("error in connectionClose=%v, req #%d, ReadAll: %v", connectionClose, n, err) |
| } |
| return string(body) |
| } |
| |
| body1 := fetch(1) |
| body2 := fetch(2) |
| bodiesDiffer := body1 != body2 |
| if bodiesDiffer != connectionClose { |
| t.Errorf("error in connectionClose=%v. unexpected bodiesDiffer=%v; body1=%q; body2=%q", |
| connectionClose, bodiesDiffer, body1, body2) |
| } |
| |
| tr.CloseIdleConnections() |
| } |
| |
| connSet.check(t) |
| } |
| |
| func TestTransportIdleCacheKeys(t *testing.T) { |
| defer afterTest(t) |
| ts := httptest.NewServer(hostPortHandler) |
| defer ts.Close() |
| |
| tr := &Transport{DisableKeepAlives: false} |
| c := &Client{Transport: tr} |
| |
| if e, g := 0, len(tr.IdleConnKeysForTesting()); e != g { |
| t.Errorf("After CloseIdleConnections expected %d idle conn cache keys; got %d", e, g) |
| } |
| |
| resp, err := c.Get(ts.URL) |
| if err != nil { |
| t.Error(err) |
| } |
| ioutil.ReadAll(resp.Body) |
| |
| keys := tr.IdleConnKeysForTesting() |
| if e, g := 1, len(keys); e != g { |
| t.Fatalf("After Get expected %d idle conn cache keys; got %d", e, g) |
| } |
| |
| if e := "|http|" + ts.Listener.Addr().String(); keys[0] != e { |
| t.Errorf("Expected idle cache key %q; got %q", e, keys[0]) |
| } |
| |
| tr.CloseIdleConnections() |
| if e, g := 0, len(tr.IdleConnKeysForTesting()); e != g { |
| t.Errorf("After CloseIdleConnections expected %d idle conn cache keys; got %d", e, g) |
| } |
| } |
| |
| // Tests that the HTTP transport re-uses connections when a client |
| // reads to the end of a response Body without closing it. |
| func TestTransportReadToEndReusesConn(t *testing.T) { |
| defer afterTest(t) |
| const msg = "foobar" |
| |
| var addrSeen map[string]int |
| ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| addrSeen[r.RemoteAddr]++ |
| if r.URL.Path == "/chunked/" { |
| w.WriteHeader(200) |
| w.(http.Flusher).Flush() |
| } else { |
| w.Header().Set("Content-Type", strconv.Itoa(len(msg))) |
| w.WriteHeader(200) |
| } |
| w.Write([]byte(msg)) |
| })) |
| defer ts.Close() |
| |
| buf := make([]byte, len(msg)) |
| |
| for pi, path := range []string{"/content-length/", "/chunked/"} { |
| wantLen := []int{len(msg), -1}[pi] |
| addrSeen = make(map[string]int) |
| for i := 0; i < 3; i++ { |
| res, err := http.Get(ts.URL + path) |
| if err != nil { |
| t.Errorf("Get %s: %v", path, err) |
| continue |
| } |
| // We want to close this body eventually (before the |
| // defer afterTest at top runs), but not before the |
| // len(addrSeen) check at the bottom of this test, |
| // since Closing this early in the loop would risk |
| // making connections be re-used for the wrong reason. |
| defer res.Body.Close() |
| |
| if res.ContentLength != int64(wantLen) { |
| t.Errorf("%s res.ContentLength = %d; want %d", path, res.ContentLength, wantLen) |
| } |
| n, err := res.Body.Read(buf) |
| if n != len(msg) || err != io.EOF { |
| t.Errorf("%s Read = %v, %v; want %d, EOF", path, n, err, len(msg)) |
| } |
| } |
| if len(addrSeen) != 1 { |
| t.Errorf("for %s, server saw %d distinct client addresses; want 1", path, len(addrSeen)) |
| } |
| } |
| } |
| |
| func TestTransportMaxPerHostIdleConns(t *testing.T) { |
| defer afterTest(t) |
| resch := make(chan string) |
| gotReq := make(chan bool) |
| ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| gotReq <- true |
| msg := <-resch |
| _, err := w.Write([]byte(msg)) |
| if err != nil { |
| t.Fatalf("Write: %v", err) |
| } |
| })) |
| defer ts.Close() |
| maxIdleConns := 2 |
| tr := &Transport{DisableKeepAlives: false, MaxIdleConnsPerHost: maxIdleConns} |
| c := &Client{Transport: tr} |
| |
| // Start 3 outstanding requests and wait for the server to get them. |
| // Their responses will hang until we write to resch, though. |
| donech := make(chan bool) |
| doReq := func() { |
| resp, err := c.Get(ts.URL) |
| if err != nil { |
| t.Error(err) |
| return |
| } |
| if _, err := ioutil.ReadAll(resp.Body); err != nil { |
| t.Errorf("ReadAll: %v", err) |
| return |
| } |
| donech <- true |
| } |
| go doReq() |
| <-gotReq |
| go doReq() |
| <-gotReq |
| go doReq() |
| <-gotReq |
| |
| if e, g := 0, len(tr.IdleConnKeysForTesting()); e != g { |
| t.Fatalf("Before writes, expected %d idle conn cache keys; got %d", e, g) |
| } |
| |
| resch <- "res1" |
| <-donech |
| keys := tr.IdleConnKeysForTesting() |
| if e, g := 1, len(keys); e != g { |
| t.Fatalf("after first response, expected %d idle conn cache keys; got %d", e, g) |
| } |
| cacheKey := "|http|" + ts.Listener.Addr().String() |
| if keys[0] != cacheKey { |
| t.Fatalf("Expected idle cache key %q; got %q", cacheKey, keys[0]) |
| } |
| if e, g := 1, tr.IdleConnCountForTesting(cacheKey); e != g { |
| t.Errorf("after first response, expected %d idle conns; got %d", e, g) |
| } |
| |
| resch <- "res2" |
| <-donech |
| if e, g := 2, tr.IdleConnCountForTesting(cacheKey); e != g { |
| t.Errorf("after second response, expected %d idle conns; got %d", e, g) |
| } |
| |
| resch <- "res3" |
| <-donech |
| if e, g := maxIdleConns, tr.IdleConnCountForTesting(cacheKey); e != g { |
| t.Errorf("after third response, still expected %d idle conns; got %d", e, g) |
| } |
| } |
| |
| func TestTransportServerClosingUnexpectedly(t *testing.T) { |
| defer afterTest(t) |
| ts := httptest.NewServer(hostPortHandler) |
| defer ts.Close() |
| |
| tr := &Transport{} |
| c := &Client{Transport: tr} |
| |
| fetch := func(n, retries int) string { |
| condFatalf := func(format string, arg ...interface{}) { |
| if retries <= 0 { |
| t.Fatalf(format, arg...) |
| } |
| t.Logf("retrying shortly after expected error: "+format, arg...) |
| time.Sleep(time.Second / time.Duration(retries)) |
| } |
| for retries >= 0 { |
| retries-- |
| res, err := c.Get(ts.URL) |
| if err != nil { |
| condFatalf("error in req #%d, GET: %v", n, err) |
| continue |
| } |
| body, err := ioutil.ReadAll(res.Body) |
| if err != nil { |
| condFatalf("error in req #%d, ReadAll: %v", n, err) |
| continue |
| } |
| res.Body.Close() |
| return string(body) |
| } |
| panic("unreachable") |
| } |
| |
| body1 := fetch(1, 0) |
| body2 := fetch(2, 0) |
| |
| ts.CloseClientConnections() // surprise! |
| |
| // This test has an expected race. Sleeping for 25 ms prevents |
| // it on most fast machines, causing the next fetch() call to |
| // succeed quickly. But if we do get errors, fetch() will retry 5 |
| // times with some delays between. |
| time.Sleep(25 * time.Millisecond) |
| |
| body3 := fetch(3, 5) |
| |
| if body1 != body2 { |
| t.Errorf("expected body1 and body2 to be equal") |
| } |
| if body2 == body3 { |
| t.Errorf("expected body2 and body3 to be different") |
| } |
| } |
| |
| // Test for http://golang.org/issue/2616 (appropriate issue number) |
| // This fails pretty reliably with GOMAXPROCS=100 or something high. |
| func TestStressSurpriseServerCloses(t *testing.T) { |
| defer afterTest(t) |
| if testing.Short() { |
| t.Skip("skipping test in short mode") |
| } |
| ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| w.Header().Set("Content-Length", "5") |
| w.Header().Set("Content-Type", "text/plain") |
| w.Write([]byte("Hello")) |
| w.(Flusher).Flush() |
| conn, buf, _ := w.(Hijacker).Hijack() |
| buf.Flush() |
| conn.Close() |
| })) |
| defer ts.Close() |
| |
| tr := &Transport{DisableKeepAlives: false} |
| c := &Client{Transport: tr} |
| |
| // Do a bunch of traffic from different goroutines. Send to activityc |
| // after each request completes, regardless of whether it failed. |
| const ( |
| numClients = 50 |
| reqsPerClient = 250 |
| ) |
| activityc := make(chan bool) |
| for i := 0; i < numClients; i++ { |
| go func() { |
| for i := 0; i < reqsPerClient; i++ { |
| res, err := c.Get(ts.URL) |
| if err == nil { |
| // We expect errors since the server is |
| // hanging up on us after telling us to |
| // send more requests, so we don't |
| // actually care what the error is. |
| // But we want to close the body in cases |
| // where we won the race. |
| res.Body.Close() |
| } |
| activityc <- true |
| } |
| }() |
| } |
| |
| // Make sure all the request come back, one way or another. |
| for i := 0; i < numClients*reqsPerClient; i++ { |
| select { |
| case <-activityc: |
| case <-time.After(5 * time.Second): |
| t.Fatalf("presumed deadlock; no HTTP client activity seen in awhile") |
| } |
| } |
| } |
| |
| // TestTransportHeadResponses verifies that we deal with Content-Lengths |
| // with no bodies properly |
| func TestTransportHeadResponses(t *testing.T) { |
| defer afterTest(t) |
| ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| if r.Method != "HEAD" { |
| panic("expected HEAD; got " + r.Method) |
| } |
| w.Header().Set("Content-Length", "123") |
| w.WriteHeader(200) |
| })) |
| defer ts.Close() |
| |
| tr := &Transport{DisableKeepAlives: false} |
| c := &Client{Transport: tr} |
| for i := 0; i < 2; i++ { |
| res, err := c.Head(ts.URL) |
| if err != nil { |
| t.Errorf("error on loop %d: %v", i, err) |
| continue |
| } |
| if e, g := "123", res.Header.Get("Content-Length"); e != g { |
| t.Errorf("loop %d: expected Content-Length header of %q, got %q", i, e, g) |
| } |
| if e, g := int64(123), res.ContentLength; e != g { |
| t.Errorf("loop %d: expected res.ContentLength of %v, got %v", i, e, g) |
| } |
| if all, err := ioutil.ReadAll(res.Body); err != nil { |
| t.Errorf("loop %d: Body ReadAll: %v", i, err) |
| } else if len(all) != 0 { |
| t.Errorf("Bogus body %q", all) |
| } |
| } |
| } |
| |
| // TestTransportHeadChunkedResponse verifies that we ignore chunked transfer-encoding |
| // on responses to HEAD requests. |
| func TestTransportHeadChunkedResponse(t *testing.T) { |
| defer afterTest(t) |
| ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| if r.Method != "HEAD" { |
| panic("expected HEAD; got " + r.Method) |
| } |
| w.Header().Set("Transfer-Encoding", "chunked") // client should ignore |
| w.Header().Set("x-client-ipport", r.RemoteAddr) |
| w.WriteHeader(200) |
| })) |
| defer ts.Close() |
| |
| tr := &Transport{DisableKeepAlives: false} |
| c := &Client{Transport: tr} |
| |
| res1, err := c.Head(ts.URL) |
| if err != nil { |
| t.Fatalf("request 1 error: %v", err) |
| } |
| res2, err := c.Head(ts.URL) |
| if err != nil { |
| t.Fatalf("request 2 error: %v", err) |
| } |
| if v1, v2 := res1.Header.Get("x-client-ipport"), res2.Header.Get("x-client-ipport"); v1 != v2 { |
| t.Errorf("ip/ports differed between head requests: %q vs %q", v1, v2) |
| } |
| } |
| |
| var roundTripTests = []struct { |
| accept string |
| expectAccept string |
| compressed bool |
| }{ |
| // Requests with no accept-encoding header use transparent compression |
| {"", "gzip", false}, |
| // Requests with other accept-encoding should pass through unmodified |
| {"foo", "foo", false}, |
| // Requests with accept-encoding == gzip should be passed through |
| {"gzip", "gzip", true}, |
| } |
| |
| // Test that the modification made to the Request by the RoundTripper is cleaned up |
| func TestRoundTripGzip(t *testing.T) { |
| defer afterTest(t) |
| const responseBody = "test response body" |
| ts := httptest.NewServer(HandlerFunc(func(rw ResponseWriter, req *Request) { |
| accept := req.Header.Get("Accept-Encoding") |
| if expect := req.FormValue("expect_accept"); accept != expect { |
| t.Errorf("in handler, test %v: Accept-Encoding = %q, want %q", |
| req.FormValue("testnum"), accept, expect) |
| } |
| if accept == "gzip" { |
| rw.Header().Set("Content-Encoding", "gzip") |
| gz := gzip.NewWriter(rw) |
| gz.Write([]byte(responseBody)) |
| gz.Close() |
| } else { |
| rw.Header().Set("Content-Encoding", accept) |
| rw.Write([]byte(responseBody)) |
| } |
| })) |
| defer ts.Close() |
| |
| for i, test := range roundTripTests { |
| // Test basic request (no accept-encoding) |
| req, _ := NewRequest("GET", fmt.Sprintf("%s/?testnum=%d&expect_accept=%s", ts.URL, i, test.expectAccept), nil) |
| if test.accept != "" { |
| req.Header.Set("Accept-Encoding", test.accept) |
| } |
| res, err := DefaultTransport.RoundTrip(req) |
| var body []byte |
| if test.compressed { |
| var r *gzip.Reader |
| r, err = gzip.NewReader(res.Body) |
| if err != nil { |
| t.Errorf("%d. gzip NewReader: %v", i, err) |
| continue |
| } |
| body, err = ioutil.ReadAll(r) |
| res.Body.Close() |
| } else { |
| body, err = ioutil.ReadAll(res.Body) |
| } |
| if err != nil { |
| t.Errorf("%d. Error: %q", i, err) |
| continue |
| } |
| if g, e := string(body), responseBody; g != e { |
| t.Errorf("%d. body = %q; want %q", i, g, e) |
| } |
| if g, e := req.Header.Get("Accept-Encoding"), test.accept; g != e { |
| t.Errorf("%d. Accept-Encoding = %q; want %q (it was mutated, in violation of RoundTrip contract)", i, g, e) |
| } |
| if g, e := res.Header.Get("Content-Encoding"), test.accept; g != e { |
| t.Errorf("%d. Content-Encoding = %q; want %q", i, g, e) |
| } |
| } |
| |
| } |
| |
| func TestTransportGzip(t *testing.T) { |
| defer afterTest(t) |
| const testString = "The test string aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
| const nRandBytes = 1024 * 1024 |
| ts := httptest.NewServer(HandlerFunc(func(rw ResponseWriter, req *Request) { |
| if req.Method == "HEAD" { |
| if g := req.Header.Get("Accept-Encoding"); g != "" { |
| t.Errorf("HEAD request sent with Accept-Encoding of %q; want none", g) |
| } |
| return |
| } |
| if g, e := req.Header.Get("Accept-Encoding"), "gzip"; g != e { |
| t.Errorf("Accept-Encoding = %q, want %q", g, e) |
| } |
| rw.Header().Set("Content-Encoding", "gzip") |
| |
| var w io.Writer = rw |
| var buf bytes.Buffer |
| if req.FormValue("chunked") == "0" { |
| w = &buf |
| defer io.Copy(rw, &buf) |
| defer func() { |
| rw.Header().Set("Content-Length", strconv.Itoa(buf.Len())) |
| }() |
| } |
| gz := gzip.NewWriter(w) |
| gz.Write([]byte(testString)) |
| if req.FormValue("body") == "large" { |
| io.CopyN(gz, rand.Reader, nRandBytes) |
| } |
| gz.Close() |
| })) |
| defer ts.Close() |
| |
| for _, chunked := range []string{"1", "0"} { |
| c := &Client{Transport: &Transport{}} |
| |
| // First fetch something large, but only read some of it. |
| res, err := c.Get(ts.URL + "/?body=large&chunked=" + chunked) |
| if err != nil { |
| t.Fatalf("large get: %v", err) |
| } |
| buf := make([]byte, len(testString)) |
| n, err := io.ReadFull(res.Body, buf) |
| if err != nil { |
| t.Fatalf("partial read of large response: size=%d, %v", n, err) |
| } |
| if e, g := testString, string(buf); e != g { |
| t.Errorf("partial read got %q, expected %q", g, e) |
| } |
| res.Body.Close() |
| // Read on the body, even though it's closed |
| n, err = res.Body.Read(buf) |
| if n != 0 || err == nil { |
| t.Errorf("expected error post-closed large Read; got = %d, %v", n, err) |
| } |
| |
| // Then something small. |
| res, err = c.Get(ts.URL + "/?chunked=" + chunked) |
| if err != nil { |
| t.Fatal(err) |
| } |
| body, err := ioutil.ReadAll(res.Body) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if g, e := string(body), testString; g != e { |
| t.Fatalf("body = %q; want %q", g, e) |
| } |
| if g, e := res.Header.Get("Content-Encoding"), ""; g != e { |
| t.Fatalf("Content-Encoding = %q; want %q", g, e) |
| } |
| |
| // Read on the body after it's been fully read: |
| n, err = res.Body.Read(buf) |
| if n != 0 || err == nil { |
| t.Errorf("expected Read error after exhausted reads; got %d, %v", n, err) |
| } |
| res.Body.Close() |
| n, err = res.Body.Read(buf) |
| if n != 0 || err == nil { |
| t.Errorf("expected Read error after Close; got %d, %v", n, err) |
| } |
| } |
| |
| // And a HEAD request too, because they're always weird. |
| c := &Client{Transport: &Transport{}} |
| res, err := c.Head(ts.URL) |
| if err != nil { |
| t.Fatalf("Head: %v", err) |
| } |
| if res.StatusCode != 200 { |
| t.Errorf("Head status=%d; want=200", res.StatusCode) |
| } |
| } |
| |
| func TestTransportProxy(t *testing.T) { |
| defer afterTest(t) |
| ch := make(chan string, 1) |
| ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| ch <- "real server" |
| })) |
| defer ts.Close() |
| proxy := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| ch <- "proxy for " + r.URL.String() |
| })) |
| defer proxy.Close() |
| |
| pu, err := url.Parse(proxy.URL) |
| if err != nil { |
| t.Fatal(err) |
| } |
| c := &Client{Transport: &Transport{Proxy: ProxyURL(pu)}} |
| c.Head(ts.URL) |
| got := <-ch |
| want := "proxy for " + ts.URL + "/" |
| if got != want { |
| t.Errorf("want %q, got %q", want, got) |
| } |
| } |
| |
| // TestTransportGzipRecursive sends a gzip quine and checks that the |
| // client gets the same value back. This is more cute than anything, |
| // but checks that we don't recurse forever, and checks that |
| // Content-Encoding is removed. |
| func TestTransportGzipRecursive(t *testing.T) { |
| defer afterTest(t) |
| ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| w.Header().Set("Content-Encoding", "gzip") |
| w.Write(rgz) |
| })) |
| defer ts.Close() |
| |
| c := &Client{Transport: &Transport{}} |
| res, err := c.Get(ts.URL) |
| if err != nil { |
| t.Fatal(err) |
| } |
| body, err := ioutil.ReadAll(res.Body) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if !bytes.Equal(body, rgz) { |
| t.Fatalf("Incorrect result from recursive gz:\nhave=%x\nwant=%x", |
| body, rgz) |
| } |
| if g, e := res.Header.Get("Content-Encoding"), ""; g != e { |
| t.Fatalf("Content-Encoding = %q; want %q", g, e) |
| } |
| } |
| |
| // golang.org/issue/7750: request fails when server replies with |
| // a short gzip body |
| func TestTransportGzipShort(t *testing.T) { |
| defer afterTest(t) |
| ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| w.Header().Set("Content-Encoding", "gzip") |
| w.Write([]byte{0x1f, 0x8b}) |
| })) |
| defer ts.Close() |
| |
| tr := &Transport{} |
| defer tr.CloseIdleConnections() |
| c := &Client{Transport: tr} |
| res, err := c.Get(ts.URL) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer res.Body.Close() |
| _, err = ioutil.ReadAll(res.Body) |
| if err == nil { |
| t.Fatal("Expect an error from reading a body.") |
| } |
| if err != io.ErrUnexpectedEOF { |
| t.Errorf("ReadAll error = %v; want io.ErrUnexpectedEOF", err) |
| } |
| } |
| |
| // tests that persistent goroutine connections shut down when no longer desired. |
| func TestTransportPersistConnLeak(t *testing.T) { |
| if runtime.GOOS == "plan9" { |
| t.Skip("skipping test; see http://golang.org/issue/7237") |
| } |
| defer afterTest(t) |
| gotReqCh := make(chan bool) |
| unblockCh := make(chan bool) |
| ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| gotReqCh <- true |
| <-unblockCh |
| w.Header().Set("Content-Length", "0") |
| w.WriteHeader(204) |
| })) |
| defer ts.Close() |
| |
| tr := &Transport{} |
| c := &Client{Transport: tr} |
| |
| n0 := runtime.NumGoroutine() |
| |
| const numReq = 25 |
| didReqCh := make(chan bool) |
| for i := 0; i < numReq; i++ { |
| go func() { |
| res, err := c.Get(ts.URL) |
| didReqCh <- true |
| if err != nil { |
| t.Errorf("client fetch error: %v", err) |
| return |
| } |
| res.Body.Close() |
| }() |
| } |
| |
| // Wait for all goroutines to be stuck in the Handler. |
| for i := 0; i < numReq; i++ { |
| <-gotReqCh |
| } |
| |
| nhigh := runtime.NumGoroutine() |
| |
| // Tell all handlers to unblock and reply. |
| for i := 0; i < numReq; i++ { |
| unblockCh <- true |
| } |
| |
| // Wait for all HTTP clients to be done. |
| for i := 0; i < numReq; i++ { |
| <-didReqCh |
| } |
| |
| tr.CloseIdleConnections() |
| time.Sleep(100 * time.Millisecond) |
| runtime.GC() |
| runtime.GC() // even more. |
| nfinal := runtime.NumGoroutine() |
| |
| growth := nfinal - n0 |
| |
| // We expect 0 or 1 extra goroutine, empirically. Allow up to 5. |
| // Previously we were leaking one per numReq. |
| if int(growth) > 5 { |
| t.Logf("goroutine growth: %d -> %d -> %d (delta: %d)", n0, nhigh, nfinal, growth) |
| t.Error("too many new goroutines") |
| } |
| } |
| |
| // golang.org/issue/4531: Transport leaks goroutines when |
| // request.ContentLength is explicitly short |
| func TestTransportPersistConnLeakShortBody(t *testing.T) { |
| if runtime.GOOS == "plan9" { |
| t.Skip("skipping test; see http://golang.org/issue/7237") |
| } |
| defer afterTest(t) |
| ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| })) |
| defer ts.Close() |
| |
| tr := &Transport{} |
| c := &Client{Transport: tr} |
| |
| n0 := runtime.NumGoroutine() |
| body := []byte("Hello") |
| for i := 0; i < 20; i++ { |
| req, err := NewRequest("POST", ts.URL, bytes.NewReader(body)) |
| if err != nil { |
| t.Fatal(err) |
| } |
| req.ContentLength = int64(len(body) - 2) // explicitly short |
| _, err = c.Do(req) |
| if err == nil { |
| t.Fatal("Expect an error from writing too long of a body.") |
| } |
| } |
| nhigh := runtime.NumGoroutine() |
| tr.CloseIdleConnections() |
| time.Sleep(400 * time.Millisecond) |
| runtime.GC() |
| nfinal := runtime.NumGoroutine() |
| |
| growth := nfinal - n0 |
| |
| // We expect 0 or 1 extra goroutine, empirically. Allow up to 5. |
| // Previously we were leaking one per numReq. |
| t.Logf("goroutine growth: %d -> %d -> %d (delta: %d)", n0, nhigh, nfinal, growth) |
| if int(growth) > 5 { |
| t.Error("too many new goroutines") |
| } |
| } |
| |
| // This used to crash; http://golang.org/issue/3266 |
| func TestTransportIdleConnCrash(t *testing.T) { |
| defer afterTest(t) |
| tr := &Transport{} |
| c := &Client{Transport: tr} |
| |
| unblockCh := make(chan bool, 1) |
| ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| <-unblockCh |
| tr.CloseIdleConnections() |
| })) |
| defer ts.Close() |
| |
| didreq := make(chan bool) |
| go func() { |
| res, err := c.Get(ts.URL) |
| if err != nil { |
| t.Error(err) |
| } else { |
| res.Body.Close() // returns idle conn |
| } |
| didreq <- true |
| }() |
| unblockCh <- true |
| <-didreq |
| } |
| |
| // Test that the transport doesn't close the TCP connection early, |
| // before the response body has been read. This was a regression |
| // which sadly lacked a triggering test. The large response body made |
| // the old race easier to trigger. |
| func TestIssue3644(t *testing.T) { |
| defer afterTest(t) |
| const numFoos = 5000 |
| ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| w.Header().Set("Connection", "close") |
| for i := 0; i < numFoos; i++ { |
| w.Write([]byte("foo ")) |
| } |
| })) |
| defer ts.Close() |
| tr := &Transport{} |
| c := &Client{Transport: tr} |
| res, err := c.Get(ts.URL) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer res.Body.Close() |
| bs, err := ioutil.ReadAll(res.Body) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if len(bs) != numFoos*len("foo ") { |
| t.Errorf("unexpected response length") |
| } |
| } |
| |
| // Test that a client receives a server's reply, even if the server doesn't read |
| // the entire request body. |
| func TestIssue3595(t *testing.T) { |
| defer afterTest(t) |
| const deniedMsg = "sorry, denied." |
| ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| Error(w, deniedMsg, StatusUnauthorized) |
| })) |
| defer ts.Close() |
| tr := &Transport{} |
| c := &Client{Transport: tr} |
| res, err := c.Post(ts.URL, "application/octet-stream", neverEnding('a')) |
| if err != nil { |
| t.Errorf("Post: %v", err) |
| return |
| } |
| got, err := ioutil.ReadAll(res.Body) |
| if err != nil { |
| t.Fatalf("Body ReadAll: %v", err) |
| } |
| if !strings.Contains(string(got), deniedMsg) { |
| t.Errorf("Known bug: response %q does not contain %q", got, deniedMsg) |
| } |
| } |
| |
| // From http://golang.org/issue/4454 , |
| // "client fails to handle requests with no body and chunked encoding" |
| func TestChunkedNoContent(t *testing.T) { |
| defer afterTest(t) |
| ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| w.WriteHeader(StatusNoContent) |
| })) |
| defer ts.Close() |
| |
| for _, closeBody := range []bool{true, false} { |
| c := &Client{Transport: &Transport{}} |
| const n = 4 |
| for i := 1; i <= n; i++ { |
| res, err := c.Get(ts.URL) |
| if err != nil { |
| t.Errorf("closingBody=%v, req %d/%d: %v", closeBody, i, n, err) |
| } else { |
| if closeBody { |
| res.Body.Close() |
| } |
| } |
| } |
| } |
| } |
| |
| func TestTransportConcurrency(t *testing.T) { |
| defer afterTest(t) |
| maxProcs, numReqs := 16, 500 |
| if testing.Short() { |
| maxProcs, numReqs = 4, 50 |
| } |
| defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(maxProcs)) |
| ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| fmt.Fprintf(w, "%v", r.FormValue("echo")) |
| })) |
| defer ts.Close() |
| |
| var wg sync.WaitGroup |
| wg.Add(numReqs) |
| |
| tr := &Transport{ |
| Dial: func(netw, addr string) (c net.Conn, err error) { |
| // Due to the Transport's "socket late |
| // binding" (see idleConnCh in transport.go), |
| // the numReqs HTTP requests below can finish |
| // with a dial still outstanding. So count |
| // our dials as work too so the leak checker |
| // doesn't complain at us. |
| wg.Add(1) |
| defer wg.Done() |
| return net.Dial(netw, addr) |
| }, |
| } |
| defer tr.CloseIdleConnections() |
| c := &Client{Transport: tr} |
| reqs := make(chan string) |
| defer close(reqs) |
| |
| for i := 0; i < maxProcs*2; i++ { |
| go func() { |
| for req := range reqs { |
| res, err := c.Get(ts.URL + "/?echo=" + req) |
| if err != nil { |
| t.Errorf("error on req %s: %v", req, err) |
| wg.Done() |
| continue |
| } |
| all, err := ioutil.ReadAll(res.Body) |
| if err != nil { |
| t.Errorf("read error on req %s: %v", req, err) |
| wg.Done() |
| continue |
| } |
| if string(all) != req { |
| t.Errorf("body of req %s = %q; want %q", req, all, req) |
| } |
| res.Body.Close() |
| wg.Done() |
| } |
| }() |
| } |
| for i := 0; i < numReqs; i++ { |
| reqs <- fmt.Sprintf("request-%d", i) |
| } |
| wg.Wait() |
| } |
| |
| func TestIssue4191_InfiniteGetTimeout(t *testing.T) { |
| if runtime.GOOS == "plan9" { |
| t.Skip("skipping test; see http://golang.org/issue/7237") |
| } |
| defer afterTest(t) |
| const debug = false |
| mux := NewServeMux() |
| mux.HandleFunc("/get", func(w ResponseWriter, r *Request) { |
| io.Copy(w, neverEnding('a')) |
| }) |
| ts := httptest.NewServer(mux) |
| timeout := 100 * time.Millisecond |
| |
| client := &Client{ |
| Transport: &Transport{ |
| Dial: func(n, addr string) (net.Conn, error) { |
| conn, err := net.Dial(n, addr) |
| if err != nil { |
| return nil, err |
| } |
| conn.SetDeadline(time.Now().Add(timeout)) |
| if debug { |
| conn = NewLoggingConn("client", conn) |
| } |
| return conn, nil |
| }, |
| DisableKeepAlives: true, |
| }, |
| } |
| |
| getFailed := false |
| nRuns := 5 |
| if testing.Short() { |
| nRuns = 1 |
| } |
| for i := 0; i < nRuns; i++ { |
| if debug { |
| println("run", i+1, "of", nRuns) |
| } |
| sres, err := client.Get(ts.URL + "/get") |
| if err != nil { |
| if !getFailed { |
| // Make the timeout longer, once. |
| getFailed = true |
| t.Logf("increasing timeout") |
| i-- |
| timeout *= 10 |
| continue |
| } |
| t.Errorf("Error issuing GET: %v", err) |
| break |
| } |
| _, err = io.Copy(ioutil.Discard, sres.Body) |
| if err == nil { |
| t.Errorf("Unexpected successful copy") |
| break |
| } |
| } |
| if debug { |
| println("tests complete; waiting for handlers to finish") |
| } |
| ts.Close() |
| } |
| |
| func TestIssue4191_InfiniteGetToPutTimeout(t *testing.T) { |
| if runtime.GOOS == "plan9" { |
| t.Skip("skipping test; see http://golang.org/issue/7237") |
| } |
| defer afterTest(t) |
| const debug = false |
| mux := NewServeMux() |
| mux.HandleFunc("/get", func(w ResponseWriter, r *Request) { |
| io.Copy(w, neverEnding('a')) |
| }) |
| mux.HandleFunc("/put", func(w ResponseWriter, r *Request) { |
| defer r.Body.Close() |
| io.Copy(ioutil.Discard, r.Body) |
| }) |
| ts := httptest.NewServer(mux) |
| timeout := 100 * time.Millisecond |
| |
| client := &Client{ |
| Transport: &Transport{ |
| Dial: func(n, addr string) (net.Conn, error) { |
| conn, err := net.Dial(n, addr) |
| if err != nil { |
| return nil, err |
| } |
| conn.SetDeadline(time.Now().Add(timeout)) |
| if debug { |
| conn = NewLoggingConn("client", conn) |
| } |
| return conn, nil |
| }, |
| DisableKeepAlives: true, |
| }, |
| } |
| |
| getFailed := false |
| nRuns := 5 |
| if testing.Short() { |
| nRuns = 1 |
| } |
| for i := 0; i < nRuns; i++ { |
| if debug { |
| println("run", i+1, "of", nRuns) |
| } |
| sres, err := client.Get(ts.URL + "/get") |
| if err != nil { |
| if !getFailed { |
| // Make the timeout longer, once. |
| getFailed = true |
| t.Logf("increasing timeout") |
| i-- |
| timeout *= 10 |
| continue |
| } |
| t.Errorf("Error issuing GET: %v", err) |
| break |
| } |
| req, _ := NewRequest("PUT", ts.URL+"/put", sres.Body) |
| _, err = client.Do(req) |
| if err == nil { |
| sres.Body.Close() |
| t.Errorf("Unexpected successful PUT") |
| break |
| } |
| sres.Body.Close() |
| } |
| if debug { |
| println("tests complete; waiting for handlers to finish") |
| } |
| ts.Close() |
| } |
| |
| func TestTransportResponseHeaderTimeout(t *testing.T) { |
| defer afterTest(t) |
| if testing.Short() { |
| t.Skip("skipping timeout test in -short mode") |
| } |
| inHandler := make(chan bool, 1) |
| mux := NewServeMux() |
| mux.HandleFunc("/fast", func(w ResponseWriter, r *Request) { |
| inHandler <- true |
| }) |
| mux.HandleFunc("/slow", func(w ResponseWriter, r *Request) { |
| inHandler <- true |
| time.Sleep(2 * time.Second) |
| }) |
| ts := httptest.NewServer(mux) |
| defer ts.Close() |
| |
| tr := &Transport{ |
| ResponseHeaderTimeout: 500 * time.Millisecond, |
| } |
| defer tr.CloseIdleConnections() |
| c := &Client{Transport: tr} |
| |
| tests := []struct { |
| path string |
| want int |
| wantErr string |
| }{ |
| {path: "/fast", want: 200}, |
| {path: "/slow", wantErr: "timeout awaiting response headers"}, |
| {path: "/fast", want: 200}, |
| } |
| for i, tt := range tests { |
| res, err := c.Get(ts.URL + tt.path) |
| select { |
| case <-inHandler: |
| case <-time.After(5 * time.Second): |
| t.Errorf("never entered handler for test index %d, %s", i, tt.path) |
| continue |
| } |
| if err != nil { |
| uerr, ok := err.(*url.Error) |
| if !ok { |
| t.Errorf("error is not an url.Error; got: %#v", err) |
| continue |
| } |
| nerr, ok := uerr.Err.(net.Error) |
| if !ok { |
| t.Errorf("error does not satisfy net.Error interface; got: %#v", err) |
| continue |
| } |
| if !nerr.Timeout() { |
| t.Errorf("want timeout error; got: %q", nerr) |
| continue |
| } |
| if strings.Contains(err.Error(), tt.wantErr) { |
| continue |
| } |
| t.Errorf("%d. unexpected error: %v", i, err) |
| continue |
| } |
| if tt.wantErr != "" { |
| t.Errorf("%d. no error. expected error: %v", i, tt.wantErr) |
| continue |
| } |
| if res.StatusCode != tt.want { |
| t.Errorf("%d for path %q status = %d; want %d", i, tt.path, res.StatusCode, tt.want) |
| } |
| } |
| } |
| |
| func TestTransportCancelRequest(t *testing.T) { |
| defer afterTest(t) |
| if testing.Short() { |
| t.Skip("skipping test in -short mode") |
| } |
| unblockc := make(chan bool) |
| ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| fmt.Fprintf(w, "Hello") |
| w.(Flusher).Flush() // send headers and some body |
| <-unblockc |
| })) |
| defer ts.Close() |
| defer close(unblockc) |
| |
| tr := &Transport{} |
| defer tr.CloseIdleConnections() |
| c := &Client{Transport: tr} |
| |
| req, _ := NewRequest("GET", ts.URL, nil) |
| res, err := c.Do(req) |
| if err != nil { |
| t.Fatal(err) |
| } |
| go func() { |
| time.Sleep(1 * time.Second) |
| tr.CancelRequest(req) |
| }() |
| t0 := time.Now() |
| body, err := ioutil.ReadAll(res.Body) |
| d := time.Since(t0) |
| |
| if err == nil { |
| t.Error("expected an error reading the body") |
| } |
| if string(body) != "Hello" { |
| t.Errorf("Body = %q; want Hello", body) |
| } |
| if d < 500*time.Millisecond { |
| t.Errorf("expected ~1 second delay; got %v", d) |
| } |
| // Verify no outstanding requests after readLoop/writeLoop |
| // goroutines shut down. |
| for tries := 3; tries > 0; tries-- { |
| n := tr.NumPendingRequestsForTesting() |
| if n == 0 { |
| break |
| } |
| time.Sleep(100 * time.Millisecond) |
| if tries == 1 { |
| t.Errorf("pending requests = %d; want 0", n) |
| } |
| } |
| } |
| |
| func TestTransportCancelRequestInDial(t *testing.T) { |
| defer afterTest(t) |
| if testing.Short() { |
| t.Skip("skipping test in -short mode") |
| } |
| var logbuf bytes.Buffer |
| eventLog := log.New(&logbuf, "", 0) |
| |
| unblockDial := make(chan bool) |
| defer close(unblockDial) |
| |
| inDial := make(chan bool) |
| tr := &Transport{ |
| Dial: func(network, addr string) (net.Conn, error) { |
| eventLog.Println("dial: blocking") |
| inDial <- true |
| <-unblockDial |
| return nil, errors.New("nope") |
| }, |
| } |
| cl := &Client{Transport: tr} |
| gotres := make(chan bool) |
| req, _ := NewRequest("GET", "http://something.no-network.tld/", nil) |
| go func() { |
| _, err := cl.Do(req) |
| eventLog.Printf("Get = %v", err) |
| gotres <- true |
| }() |
| |
| select { |
| case <-inDial: |
| case <-time.After(5 * time.Second): |
| t.Fatal("timeout; never saw blocking dial") |
| } |
| |
| eventLog.Printf("canceling") |
| tr.CancelRequest(req) |
| |
| select { |
| case <-gotres: |
| case <-time.After(5 * time.Second): |
| panic("hang. events are: " + logbuf.String()) |
| } |
| |
| got := logbuf.String() |
| want := `dial: blocking |
| canceling |
| Get = Get http://something.no-network.tld/: net/http: request canceled while waiting for connection |
| ` |
| if got != want { |
| t.Errorf("Got events:\n%s\nWant:\n%s", got, want) |
| } |
| } |
| |
| // golang.org/issue/3672 -- Client can't close HTTP stream |
| // Calling Close on a Response.Body used to just read until EOF. |
| // Now it actually closes the TCP connection. |
| func TestTransportCloseResponseBody(t *testing.T) { |
| defer afterTest(t) |
| writeErr := make(chan error, 1) |
| msg := []byte("young\n") |
| ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| for { |
| _, err := w.Write(msg) |
| if err != nil { |
| writeErr <- err |
| return |
| } |
| w.(Flusher).Flush() |
| } |
| })) |
| defer ts.Close() |
| |
| tr := &Transport{} |
| defer tr.CloseIdleConnections() |
| c := &Client{Transport: tr} |
| |
| req, _ := NewRequest("GET", ts.URL, nil) |
| defer tr.CancelRequest(req) |
| |
| res, err := c.Do(req) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| const repeats = 3 |
| buf := make([]byte, len(msg)*repeats) |
| want := bytes.Repeat(msg, repeats) |
| |
| _, err = io.ReadFull(res.Body, buf) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if !bytes.Equal(buf, want) { |
| t.Fatalf("read %q; want %q", buf, want) |
| } |
| didClose := make(chan error, 1) |
| go func() { |
| didClose <- res.Body.Close() |
| }() |
| select { |
| case err := <-didClose: |
| if err != nil { |
| t.Errorf("Close = %v", err) |
| } |
| case <-time.After(10 * time.Second): |
| t.Fatal("too long waiting for close") |
| } |
| select { |
| case err := <-writeErr: |
| if err == nil { |
| t.Errorf("expected non-nil write error") |
| } |
| case <-time.After(10 * time.Second): |
| t.Fatal("too long waiting for write error") |
| } |
| } |
| |
| type fooProto struct{} |
| |
| func (fooProto) RoundTrip(req *Request) (*Response, error) { |
| res := &Response{ |
| Status: "200 OK", |
| StatusCode: 200, |
| Header: make(Header), |
| Body: ioutil.NopCloser(strings.NewReader("You wanted " + req.URL.String())), |
| } |
| return res, nil |
| } |
| |
| func TestTransportAltProto(t *testing.T) { |
| defer afterTest(t) |
| tr := &Transport{} |
| c := &Client{Transport: tr} |
| tr.RegisterProtocol("foo", fooProto{}) |
| res, err := c.Get("foo://bar.com/path") |
| if err != nil { |
| t.Fatal(err) |
| } |
| bodyb, err := ioutil.ReadAll(res.Body) |
| if err != nil { |
| t.Fatal(err) |
| } |
| body := string(bodyb) |
| if e := "You wanted foo://bar.com/path"; body != e { |
| t.Errorf("got response %q, want %q", body, e) |
| } |
| } |
| |
| func TestTransportNoHost(t *testing.T) { |
| defer afterTest(t) |
| tr := &Transport{} |
| _, err := tr.RoundTrip(&Request{ |
| Header: make(Header), |
| URL: &url.URL{ |
| Scheme: "http", |
| }, |
| }) |
| want := "http: no Host in request URL" |
| if got := fmt.Sprint(err); got != want { |
| t.Errorf("error = %v; want %q", err, want) |
| } |
| } |
| |
| func TestTransportSocketLateBinding(t *testing.T) { |
| defer afterTest(t) |
| |
| mux := NewServeMux() |
| fooGate := make(chan bool, 1) |
| mux.HandleFunc("/foo", func(w ResponseWriter, r *Request) { |
| w.Header().Set("foo-ipport", r.RemoteAddr) |
| w.(Flusher).Flush() |
| <-fooGate |
| }) |
| mux.HandleFunc("/bar", func(w ResponseWriter, r *Request) { |
| w.Header().Set("bar-ipport", r.RemoteAddr) |
| }) |
| ts := httptest.NewServer(mux) |
| defer ts.Close() |
| |
| dialGate := make(chan bool, 1) |
| tr := &Transport{ |
| Dial: func(n, addr string) (net.Conn, error) { |
| if <-dialGate { |
| return net.Dial(n, addr) |
| } |
| return nil, errors.New("manually closed") |
| }, |
| DisableKeepAlives: false, |
| } |
| defer tr.CloseIdleConnections() |
| c := &Client{ |
| Transport: tr, |
| } |
| |
| dialGate <- true // only allow one dial |
| fooRes, err := c.Get(ts.URL + "/foo") |
| if err != nil { |
| t.Fatal(err) |
| } |
| fooAddr := fooRes.Header.Get("foo-ipport") |
| if fooAddr == "" { |
| t.Fatal("No addr on /foo request") |
| } |
| time.AfterFunc(200*time.Millisecond, func() { |
| // let the foo response finish so we can use its |
| // connection for /bar |
| fooGate <- true |
| io.Copy(ioutil.Discard, fooRes.Body) |
| fooRes.Body.Close() |
| }) |
| |
| barRes, err := c.Get(ts.URL + "/bar") |
| if err != nil { |
| t.Fatal(err) |
| } |
| barAddr := barRes.Header.Get("bar-ipport") |
| if barAddr != fooAddr { |
| t.Fatalf("/foo came from conn %q; /bar came from %q instead", fooAddr, barAddr) |
| } |
| barRes.Body.Close() |
| dialGate <- false |
| } |
| |
| // Issue 2184 |
| func TestTransportReading100Continue(t *testing.T) { |
| defer afterTest(t) |
| |
| const numReqs = 5 |
| reqBody := func(n int) string { return fmt.Sprintf("request body %d", n) } |
| reqID := func(n int) string { return fmt.Sprintf("REQ-ID-%d", n) } |
| |
| send100Response := func(w *io.PipeWriter, r *io.PipeReader) { |
| defer w.Close() |
| defer r.Close() |
| br := bufio.NewReader(r) |
| n := 0 |
| for { |
| n++ |
| req, err := ReadRequest(br) |
| if err == io.EOF { |
| return |
| } |
| if err != nil { |
| t.Error(err) |
| return |
| } |
| slurp, err := ioutil.ReadAll(req.Body) |
| if err != nil { |
| t.Errorf("Server request body slurp: %v", err) |
| return |
| } |
| id := req.Header.Get("Request-Id") |
| resCode := req.Header.Get("X-Want-Response-Code") |
| if resCode == "" { |
| resCode = "100 Continue" |
| if string(slurp) != reqBody(n) { |
| t.Errorf("Server got %q, %v; want %q", slurp, err, reqBody(n)) |
| } |
| } |
| body := fmt.Sprintf("Response number %d", n) |
| v := []byte(strings.Replace(fmt.Sprintf(`HTTP/1.1 %s |
| Date: Thu, 28 Feb 2013 17:55:41 GMT |
| |
| HTTP/1.1 200 OK |
| Content-Type: text/html |
| Echo-Request-Id: %s |
| Content-Length: %d |
| |
| %s`, resCode, id, len(body), body), "\n", "\r\n", -1)) |
| w.Write(v) |
| if id == reqID(numReqs) { |
| return |
| } |
| } |
| |
| } |
| |
| tr := &Transport{ |
| Dial: func(n, addr string) (net.Conn, error) { |
| sr, sw := io.Pipe() // server read/write |
| cr, cw := io.Pipe() // client read/write |
| conn := &rwTestConn{ |
| Reader: cr, |
| Writer: sw, |
| closeFunc: func() error { |
| sw.Close() |
| cw.Close() |
| return nil |
| }, |
| } |
| go send100Response(cw, sr) |
| return conn, nil |
| }, |
| DisableKeepAlives: false, |
| } |
| defer tr.CloseIdleConnections() |
| c := &Client{Transport: tr} |
| |
| testResponse := func(req *Request, name string, wantCode int) { |
| res, err := c.Do(req) |
| if err != nil { |
| t.Fatalf("%s: Do: %v", name, err) |
| } |
| if res.StatusCode != wantCode { |
| t.Fatalf("%s: Response Statuscode=%d; want %d", name, res.StatusCode, wantCode) |
| } |
| if id, idBack := req.Header.Get("Request-Id"), res.Header.Get("Echo-Request-Id"); id != "" && id != idBack { |
| t.Errorf("%s: response id %q != request id %q", name, idBack, id) |
| } |
| _, err = ioutil.ReadAll(res.Body) |
| if err != nil { |
| t.Fatalf("%s: Slurp error: %v", name, err) |
| } |
| } |
| |
| // Few 100 responses, making sure we're not off-by-one. |
| for i := 1; i <= numReqs; i++ { |
| req, _ := NewRequest("POST", "http://dummy.tld/", strings.NewReader(reqBody(i))) |
| req.Header.Set("Request-Id", reqID(i)) |
| testResponse(req, fmt.Sprintf("100, %d/%d", i, numReqs), 200) |
| } |
| |
| // And some other informational 1xx but non-100 responses, to test |
| // we return them but don't re-use the connection. |
| for i := 1; i <= numReqs; i++ { |
| req, _ := NewRequest("POST", "http://other.tld/", strings.NewReader(reqBody(i))) |
| req.Header.Set("X-Want-Response-Code", "123 Sesame Street") |
| testResponse(req, fmt.Sprintf("123, %d/%d", i, numReqs), 123) |
| } |
| } |
| |
| type proxyFromEnvTest struct { |
| req string // URL to fetch; blank means "http://example.com" |
| env string |
| noenv string |
| want string |
| wanterr error |
| } |
| |
| func (t proxyFromEnvTest) String() string { |
| var buf bytes.Buffer |
| if t.env != "" { |
| fmt.Fprintf(&buf, "http_proxy=%q", t.env) |
| } |
| if t.noenv != "" { |
| fmt.Fprintf(&buf, " no_proxy=%q", t.noenv) |
| } |
| req := "http://example.com" |
| if t.req != "" { |
| req = t.req |
| } |
| fmt.Fprintf(&buf, " req=%q", req) |
| return strings.TrimSpace(buf.String()) |
| } |
| |
| var proxyFromEnvTests = []proxyFromEnvTest{ |
| {env: "127.0.0.1:8080", want: "http://127.0.0.1:8080"}, |
| {env: "cache.corp.example.com:1234", want: "http://cache.corp.example.com:1234"}, |
| {env: "cache.corp.example.com", want: "http://cache.corp.example.com"}, |
| {env: "https://cache.corp.example.com", want: "https://cache.corp.example.com"}, |
| {env: "http://127.0.0.1:8080", want: "http://127.0.0.1:8080"}, |
| {env: "https://127.0.0.1:8080", want: "https://127.0.0.1:8080"}, |
| {want: "<nil>"}, |
| {noenv: "example.com", req: "http://example.com/", env: "proxy", want: "<nil>"}, |
| {noenv: ".example.com", req: "http://example.com/", env: "proxy", want: "<nil>"}, |
| {noenv: "ample.com", req: "http://example.com/", env: "proxy", want: "http://proxy"}, |
| {noenv: "example.com", req: "http://foo.example.com/", env: "proxy", want: "<nil>"}, |
| {noenv: ".foo.com", req: "http://example.com/", env: "proxy", want: "http://proxy"}, |
| } |
| |
| func TestProxyFromEnvironment(t *testing.T) { |
| ResetProxyEnv() |
| for _, tt := range proxyFromEnvTests { |
| os.Setenv("HTTP_PROXY", tt.env) |
| os.Setenv("NO_PROXY", tt.noenv) |
| ResetCachedEnvironment() |
| reqURL := tt.req |
| if reqURL == "" { |
| reqURL = "http://example.com" |
| } |
| req, _ := NewRequest("GET", reqURL, nil) |
| url, err := ProxyFromEnvironment(req) |
| if g, e := fmt.Sprintf("%v", err), fmt.Sprintf("%v", tt.wanterr); g != e { |
| t.Errorf("%v: got error = %q, want %q", tt, g, e) |
| continue |
| } |
| if got := fmt.Sprintf("%s", url); got != tt.want { |
| t.Errorf("%v: got URL = %q, want %q", tt, url, tt.want) |
| } |
| } |
| } |
| |
| func TestIdleConnChannelLeak(t *testing.T) { |
| var mu sync.Mutex |
| var n int |
| |
| ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| mu.Lock() |
| n++ |
| mu.Unlock() |
| })) |
| defer ts.Close() |
| |
| tr := &Transport{ |
| Dial: func(netw, addr string) (net.Conn, error) { |
| return net.Dial(netw, ts.Listener.Addr().String()) |
| }, |
| } |
| defer tr.CloseIdleConnections() |
| |
| c := &Client{Transport: tr} |
| |
| // First, without keep-alives. |
| for _, disableKeep := range []bool{true, false} { |
| tr.DisableKeepAlives = disableKeep |
| for i := 0; i < 5; i++ { |
| _, err := c.Get(fmt.Sprintf("http://foo-host-%d.tld/", i)) |
| if err != nil { |
| t.Fatal(err) |
| } |
| } |
| if got := tr.IdleConnChMapSizeForTesting(); got != 0 { |
| t.Fatalf("ForDisableKeepAlives = %v, map size = %d; want 0", disableKeep, got) |
| } |
| } |
| } |
| |
| // Verify the status quo: that the Client.Post function coerces its |
| // body into a ReadCloser if it's a Closer, and that the Transport |
| // then closes it. |
| func TestTransportClosesRequestBody(t *testing.T) { |
| defer afterTest(t) |
| ts := httptest.NewServer(http.HandlerFunc(func(w ResponseWriter, r *Request) { |
| io.Copy(ioutil.Discard, r.Body) |
| })) |
| defer ts.Close() |
| |
| tr := &Transport{} |
| defer tr.CloseIdleConnections() |
| cl := &Client{Transport: tr} |
| |
| closes := 0 |
| |
| res, err := cl.Post(ts.URL, "text/plain", countCloseReader{&closes, strings.NewReader("hello")}) |
| if err != nil { |
| t.Fatal(err) |
| } |
| res.Body.Close() |
| if closes != 1 { |
| t.Errorf("closes = %d; want 1", closes) |
| } |
| } |
| |
| func TestTransportTLSHandshakeTimeout(t *testing.T) { |
| defer afterTest(t) |
| if testing.Short() { |
| t.Skip("skipping in short mode") |
| } |
| ln := newLocalListener(t) |
| defer ln.Close() |
| testdonec := make(chan struct{}) |
| defer close(testdonec) |
| |
| go func() { |
| c, err := ln.Accept() |
| if err != nil { |
| t.Error(err) |
| return |
| } |
| <-testdonec |
| c.Close() |
| }() |
| |
| getdonec := make(chan struct{}) |
| go func() { |
| defer close(getdonec) |
| tr := &Transport{ |
| Dial: func(_, _ string) (net.Conn, error) { |
| return net.Dial("tcp", ln.Addr().String()) |
| }, |
| TLSHandshakeTimeout: 250 * time.Millisecond, |
| } |
| cl := &Client{Transport: tr} |
| _, err := cl.Get("https://dummy.tld/") |
| if err == nil { |
| t.Error("expected error") |
| return |
| } |
| ue, ok := err.(*url.Error) |
| if !ok { |
| t.Errorf("expected url.Error; got %#v", err) |
| return |
| } |
| ne, ok := ue.Err.(net.Error) |
| if !ok { |
| t.Errorf("expected net.Error; got %#v", err) |
| return |
| } |
| if !ne.Timeout() { |
| t.Errorf("expected timeout error; got %v", err) |
| } |
| if !strings.Contains(err.Error(), "handshake timeout") { |
| t.Errorf("expected 'handshake timeout' in error; got %v", err) |
| } |
| }() |
| select { |
| case <-getdonec: |
| case <-time.After(5 * time.Second): |
| t.Error("test timeout; TLS handshake hung?") |
| } |
| } |
| |
| // Trying to repro golang.org/issue/3514 |
| func TestTLSServerClosesConnection(t *testing.T) { |
| defer afterTest(t) |
| if runtime.GOOS == "windows" { |
| t.Skip("skipping flaky test on Windows; golang.org/issue/7634") |
| } |
| closedc := make(chan bool, 1) |
| ts := httptest.NewTLSServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| if strings.Contains(r.URL.Path, "/keep-alive-then-die") { |
| conn, _, _ := w.(Hijacker).Hijack() |
| conn.Write([]byte("HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\nfoo")) |
| conn.Close() |
| closedc <- true |
| return |
| } |
| fmt.Fprintf(w, "hello") |
| })) |
| defer ts.Close() |
| tr := &Transport{ |
| TLSClientConfig: &tls.Config{ |
| InsecureSkipVerify: true, |
| }, |
| } |
| defer tr.CloseIdleConnections() |
| client := &Client{Transport: tr} |
| |
| var nSuccess = 0 |
| var errs []error |
| const trials = 20 |
| for i := 0; i < trials; i++ { |
| tr.CloseIdleConnections() |
| res, err := client.Get(ts.URL + "/keep-alive-then-die") |
| if err != nil { |
| t.Fatal(err) |
| } |
| <-closedc |
| slurp, err := ioutil.ReadAll(res.Body) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if string(slurp) != "foo" { |
| t.Errorf("Got %q, want foo", slurp) |
| } |
| |
| // Now try again and see if we successfully |
| // pick a new connection. |
| res, err = client.Get(ts.URL + "/") |
| if err != nil { |
| errs = append(errs, err) |
| continue |
| } |
| slurp, err = ioutil.ReadAll(res.Body) |
| if err != nil { |
| errs = append(errs, err) |
| continue |
| } |
| nSuccess++ |
| } |
| if nSuccess > 0 { |
| t.Logf("successes = %d of %d", nSuccess, trials) |
| } else { |
| t.Errorf("All runs failed:") |
| } |
| for _, err := range errs { |
| t.Logf(" err: %v", err) |
| } |
| } |
| |
| // byteFromChanReader is an io.Reader that reads a single byte at a |
| // time from the channel. When the channel is closed, the reader |
| // returns io.EOF. |
| type byteFromChanReader chan byte |
| |
| func (c byteFromChanReader) Read(p []byte) (n int, err error) { |
| if len(p) == 0 { |
| return |
| } |
| b, ok := <-c |
| if !ok { |
| return 0, io.EOF |
| } |
| p[0] = b |
| return 1, nil |
| } |
| |
| // Verifies that the Transport doesn't reuse a connection in the case |
| // where the server replies before the request has been fully |
| // written. We still honor that reply (see TestIssue3595), but don't |
| // send future requests on the connection because it's then in a |
| // questionable state. |
| // golang.org/issue/7569 |
| func TestTransportNoReuseAfterEarlyResponse(t *testing.T) { |
| defer afterTest(t) |
| var sconn struct { |
| sync.Mutex |
| c net.Conn |
| } |
| var getOkay bool |
| closeConn := func() { |
| sconn.Lock() |
| defer sconn.Unlock() |
| if sconn.c != nil { |
| sconn.c.Close() |
| sconn.c = nil |
| if !getOkay { |
| t.Logf("Closed server connection") |
| } |
| } |
| } |
| defer closeConn() |
| |
| ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| if r.Method == "GET" { |
| io.WriteString(w, "bar") |
| return |
| } |
| conn, _, _ := w.(Hijacker).Hijack() |
| sconn.Lock() |
| sconn.c = conn |
| sconn.Unlock() |
| conn.Write([]byte("HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\nfoo")) // keep-alive |
| go io.Copy(ioutil.Discard, conn) |
| })) |
| defer ts.Close() |
| tr := &Transport{} |
| defer tr.CloseIdleConnections() |
| client := &Client{Transport: tr} |
| |
| const bodySize = 256 << 10 |
| finalBit := make(byteFromChanReader, 1) |
| req, _ := NewRequest("POST", ts.URL, io.MultiReader(io.LimitReader(neverEnding('x'), bodySize-1), finalBit)) |
| req.ContentLength = bodySize |
| res, err := client.Do(req) |
| if err := wantBody(res, err, "foo"); err != nil { |
| t.Errorf("POST response: %v", err) |
| } |
| donec := make(chan bool) |
| go func() { |
| defer close(donec) |
| res, err = client.Get(ts.URL) |
| if err := wantBody(res, err, "bar"); err != nil { |
| t.Errorf("GET response: %v", err) |
| return |
| } |
| getOkay = true // suppress test noise |
| }() |
| time.AfterFunc(5*time.Second, closeConn) |
| select { |
| case <-donec: |
| finalBit <- 'x' // unblock the writeloop of the first Post |
| close(finalBit) |
| case <-time.After(7 * time.Second): |
| t.Fatal("timeout waiting for GET request to finish") |
| } |
| } |
| |
| type errorReader struct { |
| err error |
| } |
| |
| func (e errorReader) Read(p []byte) (int, error) { return 0, e.err } |
| |
| type closerFunc func() error |
| |
| func (f closerFunc) Close() error { return f() } |
| |
| // Issue 6981 |
| func TestTransportClosesBodyOnError(t *testing.T) { |
| if runtime.GOOS == "plan9" { |
| t.Skip("skipping test; see http://golang.org/issue/7782") |
| } |
| defer afterTest(t) |
| readBody := make(chan error, 1) |
| ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { |
| _, err := ioutil.ReadAll(r.Body) |
| readBody <- err |
| })) |
| defer ts.Close() |
| fakeErr := errors.New("fake error") |
| didClose := make(chan bool, 1) |
| req, _ := NewRequest("POST", ts.URL, struct { |
| io.Reader |
| io.Closer |
| }{ |
| io.MultiReader(io.LimitReader(neverEnding('x'), 1<<20), errorReader{fakeErr}), |
| closerFunc(func() error { |
| select { |
| case didClose <- true: |
| default: |
| } |
| return nil |
| }), |
| }) |
| res, err := DefaultClient.Do(req) |
| if res != nil { |
| defer res.Body.Close() |
| } |
| if err == nil || !strings.Contains(err.Error(), fakeErr.Error()) { |
| t.Fatalf("Do error = %v; want something containing %q", err, fakeErr.Error()) |
| } |
| select { |
| case err := <-readBody: |
| if err == nil { |
| t.Errorf("Unexpected success reading request body from handler; want 'unexpected EOF reading trailer'") |
| } |
| case <-time.After(5 * time.Second): |
| t.Error("timeout waiting for server handler to complete") |
| } |
| select { |
| case <-didClose: |
| default: |
| t.Errorf("didn't see Body.Close") |
| } |
| } |
| |
| func wantBody(res *http.Response, err error, want string) error { |
| if err != nil { |
| return err |
| } |
| slurp, err := ioutil.ReadAll(res.Body) |
| if err != nil { |
| return fmt.Errorf("error reading body: %v", err) |
| } |
| if string(slurp) != want { |
| return fmt.Errorf("body = %q; want %q", slurp, want) |
| } |
| if err := res.Body.Close(); err != nil { |
| return fmt.Errorf("body Close = %v", err) |
| } |
| return nil |
| } |
| |
| func newLocalListener(t *testing.T) net.Listener { |
| ln, err := net.Listen("tcp", "127.0.0.1:0") |
| if err != nil { |
| ln, err = net.Listen("tcp6", "[::1]:0") |
| } |
| if err != nil { |
| t.Fatal(err) |
| } |
| return ln |
| } |
| |
| type countCloseReader struct { |
| n *int |
| io.Reader |
| } |
| |
| func (cr countCloseReader) Close() error { |
| (*cr.n)++ |
| return nil |
| } |
| |
| // rgz is a gzip quine that uncompresses to itself. |
| var rgz = []byte{ |
| 0x1f, 0x8b, 0x08, 0x08, 0x00, 0x00, 0x00, 0x00, |
| 0x00, 0x00, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, |
| 0x69, 0x76, 0x65, 0x00, 0x92, 0xef, 0xe6, 0xe0, |
| 0x60, 0x00, 0x83, 0xa2, 0xd4, 0xe4, 0xd2, 0xa2, |
| 0xe2, 0xcc, 0xb2, 0x54, 0x06, 0x00, 0x00, 0x17, |
| 0x00, 0xe8, 0xff, 0x92, 0xef, 0xe6, 0xe0, 0x60, |
| 0x00, 0x83, 0xa2, 0xd4, 0xe4, 0xd2, 0xa2, 0xe2, |
| 0xcc, 0xb2, 0x54, 0x06, 0x00, 0x00, 0x17, 0x00, |
| 0xe8, 0xff, 0x42, 0x12, 0x46, 0x16, 0x06, 0x00, |
| 0x05, 0x00, 0xfa, 0xff, 0x42, 0x12, 0x46, 0x16, |
| 0x06, 0x00, 0x05, 0x00, 0xfa, 0xff, 0x00, 0x05, |
| 0x00, 0xfa, 0xff, 0x00, 0x14, 0x00, 0xeb, 0xff, |
| 0x42, 0x12, 0x46, 0x16, 0x06, 0x00, 0x05, 0x00, |
| 0xfa, 0xff, 0x00, 0x05, 0x00, 0xfa, 0xff, 0x00, |
| 0x14, 0x00, 0xeb, 0xff, 0x42, 0x88, 0x21, 0xc4, |
| 0x00, 0x00, 0x14, 0x00, 0xeb, 0xff, 0x42, 0x88, |
| 0x21, 0xc4, 0x00, 0x00, 0x14, 0x00, 0xeb, 0xff, |
| 0x42, 0x88, 0x21, 0xc4, 0x00, 0x00, 0x14, 0x00, |
| 0xeb, 0xff, 0x42, 0x88, 0x21, 0xc4, 0x00, 0x00, |
| 0x14, 0x00, 0xeb, 0xff, 0x42, 0x88, 0x21, 0xc4, |
| 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, |
| 0x00, 0xff, 0xff, 0x00, 0x17, 0x00, 0xe8, 0xff, |
| 0x42, 0x88, 0x21, 0xc4, 0x00, 0x00, 0x00, 0x00, |
| 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, |
| 0x17, 0x00, 0xe8, 0xff, 0x42, 0x12, 0x46, 0x16, |
| 0x06, 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0x08, |
| 0x00, 0xf7, 0xff, 0x3d, 0xb1, 0x20, 0x85, 0xfa, |
| 0x00, 0x00, 0x00, 0x42, 0x12, 0x46, 0x16, 0x06, |
| 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0x08, 0x00, |
| 0xf7, 0xff, 0x3d, 0xb1, 0x20, 0x85, 0xfa, 0x00, |
| 0x00, 0x00, 0x3d, 0xb1, 0x20, 0x85, 0xfa, 0x00, |
| 0x00, 0x00, |
| } |