~hduran-8/+junk/caddy

        serverLogBuf   bytes.Buffer // logger for httptest.Server

        logFilter      []string     // substrings to filter out

        scMu           sync.Mutex   // guards sc

        // If http2debug!=2, then we capture Frame debug logs that will be written

        // to t.Log after a test fails. The read and write logs use separate locks

        // and buffers so we don't accidentally introduce synchronization between

        // the read and write goroutines, which may hide data races.

        frameReadLogMu   sync.Mutex

        frameReadLogBuf  bytes.Buffer

        frameWriteLogMu  sync.Mutex

        frameWriteLogBuf bytes.Buffer

 

                NextProtos:         []string{NextProtoTLS},

        h2server := new(Server)

                case func(*Server):

                        v(h2server)

        ConfigureServer(ts.Config, h2server)

                t:  t,

                ts: ts,

                ts.Config.ErrorLog = log.New(io.MultiWriter(stderrv(), twriter{t: t, st: st}, &st.serverLogBuf), "", log.LstdFlags)

                if !logFrameReads && !logFrameWrites {

                        st.fr.debugReadLoggerf = func(m string, v ...interface{}) {

                                m = time.Now().Format("2006-01-02 15:04:05.999999999 ") + strings.TrimPrefix(m, "http2: ") + "\n"

                                st.frameReadLogMu.Lock()

                                fmt.Fprintf(&st.frameReadLogBuf, m, v...)

                                st.frameReadLogMu.Unlock()

                        }

                        st.fr.debugWriteLoggerf = func(m string, v ...interface{}) {

                                m = time.Now().Format("2006-01-02 15:04:05.999999999 ") + strings.TrimPrefix(m, "http2: ") + "\n"

                                st.frameWriteLogMu.Lock()

                                fmt.Fprintf(&st.frameWriteLogBuf, m, v...)

                                st.frameWriteLogMu.Unlock()

                        }

                        st.fr.logReads = true

                        st.fr.logWrites = true

                }

                st.frameReadLogMu.Lock()

                if st.frameReadLogBuf.Len() > 0 {

                        st.t.Logf("Framer read log:\n%s", st.frameReadLogBuf.String())

                }

                st.frameReadLogMu.Unlock()

 

                st.frameWriteLogMu.Lock()

                if st.frameWriteLogBuf.Len() > 0 {

                        st.t.Logf("Framer write log:\n%s", st.frameWriteLogBuf.String())

                }

                st.frameWriteLogMu.Unlock()

 

func (st *serverTester) writePriority(id uint32, p PriorityParam) {

        if err := st.fr.WritePriority(id, p); err != nil {

                st.t.Fatalf("Error writing PRIORITY: %v", err)

        }

}

 

// :scheme headers default to GET, / and https. The :authority header

// defaults to st.ts.Listener.Addr().

        defaultAuthority := st.ts.Listener.Addr().String()

                st.encodeHeaderField(":scheme", "https")

                st.encodeHeaderField(":authority", defaultAuthority)

                st.encodeHeaderField(":scheme", "https")

                st.encodeHeaderField(":authority", defaultAuthority)

        keys := []string{":method", ":scheme", ":authority", ":path"}

                ":method":    {"GET"},

                ":scheme":    {"https"},

                ":authority": {defaultAuthority},

                ":path":      {"/"},

}

func (st *serverTester) wantPushPromise() *PushPromiseFrame {

        f, err := st.readFrame()

        if err != nil {

                st.t.Fatal(err)

        }

        ppf, ok := f.(*PushPromiseFrame)

        if !ok {

                st.t.Fatalf("Wanted PushPromise, received %T", ppf)

        }

        return ppf

                        BlockFragment: st.encodeHeader(":authority", "", "host", host),

                t.Error("server request made it to handler; should've been rejected")

func testRejectRequestWithProtocolError(t *testing.T, send func(*serverTester)) {

        st := newServerTester(t, func(w http.ResponseWriter, r *http.Request) {

                t.Error("server request made it to handler; should've been rejected")

        }, optQuiet)

        defer st.Close()

 

        st.greet()

        send(st)

        gf := st.wantGoAway()

        if gf.ErrCode != ErrCodeProtocol {

                t.Errorf("err code = %v; want %v", gf.ErrCode, ErrCodeProtocol)

        }

}

 

// Section 5.1, on idle connections: "Receiving any frame other than

// HEADERS or PRIORITY on a stream in this state MUST be treated as a

// connection error (Section 5.4.1) of type PROTOCOL_ERROR."

func TestRejectFrameOnIdle_WindowUpdate(t *testing.T) {

        testRejectRequestWithProtocolError(t, func(st *serverTester) {

                st.fr.WriteWindowUpdate(123, 456)

        })

}

func TestRejectFrameOnIdle_Data(t *testing.T) {

        testRejectRequestWithProtocolError(t, func(st *serverTester) {

                st.fr.WriteData(123, true, nil)

        })

}

func TestRejectFrameOnIdle_RSTStream(t *testing.T) {

        testRejectRequestWithProtocolError(t, func(st *serverTester) {

                st.fr.WriteRSTStream(123, ErrCodeCancel)

        })

}

 

        if st.serverLogBuf.Len() != 0 {

                t.Errorf("unexpected server output: %.500s\n", st.serverLogBuf.Bytes())

        defer st.Close()

// No PRIORITY on stream 0.

func TestServer_Rejects_Priority0(t *testing.T) {

        testServerRejectsConn(t, func(st *serverTester) {

                st.fr.AllowIllegalWrites = true

                st.writePriority(0, PriorityParam{StreamDep: 1})

        })

}

 

// No HEADERS frame with a self-dependence.

func TestServer_Rejects_HeadersSelfDependence(t *testing.T) {

        testServerRejectsStream(t, ErrCodeProtocol, func(st *serverTester) {

                st.fr.AllowIllegalWrites = true

                st.writeHeaders(HeadersFrameParam{

                        StreamID:      1,

                        BlockFragment: st.encodeHeader(),

                        EndStream:     true,

                        EndHeaders:    true,

                        Priority:      PriorityParam{StreamDep: 1},

                })

        })

}

 

// No PRIORTY frame with a self-dependence.

func TestServer_Rejects_PrioritySelfDependence(t *testing.T) {

        testServerRejectsStream(t, ErrCodeProtocol, func(st *serverTester) {

                st.fr.AllowIllegalWrites = true

                st.writePriority(1, PriorityParam{StreamDep: 1})

        })

}

 

                // Consume the (empty) body from th peer before replying, otherwise

                // the server will sometimes (depending on scheduling) send the peer a

                // a RST_STREAM with the CANCEL error code.

                if n, err := io.Copy(ioutil.Discard, r.Body); n != 0 || err != nil {

                        b.Errorf("Copy error; got %v, %v; want 0, nil", n, err)

                }

                h    http.Header

                        h:    http.Header{"Te": {"trailers"}},

                        h:    http.Header{"Te": {"trailers", "bogus"}},

                        h:    http.Header{"Foo": {""}},

                        h:    http.Header{"Connection": {""}},

                        h:    http.Header{"Proxy-Connection": {""}},

                        h:    http.Header{"Keep-Alive": {""}},

                        h:    http.Header{"Upgrade": {""}},

                got := checkValidHTTP2RequestHeaders(tt.h)

 

func TestServerIdleTimeout(t *testing.T) {

        if testing.Short() {

                t.Skip("skipping in short mode")

        }

 

        st := newServerTester(t, func(w http.ResponseWriter, r *http.Request) {

        }, func(h2s *Server) {

                h2s.IdleTimeout = 500 * time.Millisecond

        })

        defer st.Close()

 

        st.greet()

        ga := st.wantGoAway()

        if ga.ErrCode != ErrCodeNo {

                t.Errorf("GOAWAY error = %v; want ErrCodeNo", ga.ErrCode)

        }

}

 

func TestServerIdleTimeout_AfterRequest(t *testing.T) {

        if testing.Short() {

                t.Skip("skipping in short mode")

        }

        const timeout = 250 * time.Millisecond

 

        st := newServerTester(t, func(w http.ResponseWriter, r *http.Request) {

                time.Sleep(timeout * 2)

        }, func(h2s *Server) {

                h2s.IdleTimeout = timeout

        })

        defer st.Close()

 

        st.greet()

 

        // Send a request which takes twice the timeout. Verifies the

        // idle timeout doesn't fire while we're in a request:

        st.bodylessReq1()

        st.wantHeaders()

 

        // But the idle timeout should be rearmed after the request

        // is done:

        ga := st.wantGoAway()

        if ga.ErrCode != ErrCodeNo {

                t.Errorf("GOAWAY error = %v; want ErrCodeNo", ga.ErrCode)

        }

}

 

// grpc-go closes the Request.Body currently with a Read.

// Verify that it doesn't race.

// See https://github.com/grpc/grpc-go/pull/938

func TestRequestBodyReadCloseRace(t *testing.T) {

        for i := 0; i < 100; i++ {

                body := &requestBody{

                        pipe: &pipe{

                                b: new(bytes.Buffer),

                        },

                }

                body.pipe.CloseWithError(io.EOF)

 

                done := make(chan bool, 1)

                buf := make([]byte, 10)

                go func() {

                        time.Sleep(1 * time.Millisecond)

                        body.Close()

                        done <- true

                }()

                body.Read(buf)

                <-done

        }

}

 

func TestServerGracefulShutdown(t *testing.T) {

        shutdownCh := make(chan struct{})

        defer func() { testh1ServerShutdownChan = nil }()

        testh1ServerShutdownChan = func(*http.Server) <-chan struct{} { return shutdownCh }

 

        var st *serverTester

        handlerDone := make(chan struct{})

        st = newServerTester(t, func(w http.ResponseWriter, r *http.Request) {

                defer close(handlerDone)

                close(shutdownCh)

 

                ga := st.wantGoAway()

                if ga.ErrCode != ErrCodeNo {

                        t.Errorf("GOAWAY error = %v; want ErrCodeNo", ga.ErrCode)

                }

                if ga.LastStreamID != 1 {

                        t.Errorf("GOAWAY LastStreamID = %v; want 1", ga.LastStreamID)

                }

 

                w.Header().Set("x-foo", "bar")

        })

        defer st.Close()

 

        st.greet()

        st.bodylessReq1()

 

        <-handlerDone

        hf := st.wantHeaders()

        goth := st.decodeHeader(hf.HeaderBlockFragment())

        wanth := [][2]string{

                {":status", "200"},

                {"x-foo", "bar"},

                {"content-type", "text/plain; charset=utf-8"},

                {"content-length", "0"},

        }

        if !reflect.DeepEqual(goth, wanth) {

                t.Errorf("Got headers %v; want %v", goth, wanth)

        }

 

        n, err := st.cc.Read([]byte{0})

        if n != 0 || err == nil {

                t.Errorf("Read = %v, %v; want 0, non-nil", n, err)

        }

}