func foo8001(w http.ResponseWriter, _ *http.Request) {
	w.Write([]byte("Listening on 8001: foo "))
}

func bar8001(w http.ResponseWriter, _ *http.Request) {
	w.Write([]byte("Listening on 8001: bar "))
}

func foo8002(w http.ResponseWriter, _ *http.Request) {
	w.Write([]byte("Listening on 8002: foo "))
}

func bar8002(w http.ResponseWriter, _ *http.Request) {
	w.Write([]byte("Listening on 8002: bar "))

// executes at least one write operation if it is closed.
//
// This can be useful within the context of HTTP. At least
// one write operation must happen to send the HTTP headers
// to the peer.
type WriteOnCloser struct {
	io.Writer
	hasWritten bool
}

func (w *WriteOnCloser) Write(p []byte) (int, error) {
	w.hasWritten = true
	return w.Writer.Write(p)
}

	if err != nil {
		return 0
	}
	_, err = certFile.Write(certFileBytes)
	if err != nil {
		return 0
	}

	privKeyFile, err := os.Create("privKeyFile")
	if err != nil {
		return 0
	}
	defer privKeyFile.Close()
	defer os.Remove("privKeyFile")

	privKeyFileBytes, err := f.GetBytes()
	if err != nil {
		return 0
	}
	_, err = privKeyFile.Write(privKeyFileBytes)
	if err != nil {
		return 0
	}

// license that can be found in the LICENSE file.

package pkg1

type A interface {
	Write() error
}

type B interface {
	Hello()
	world()
}

type C struct{}

func (c C) Write() error { return nil }

var T = struct{ A }{nil}
var U = struct{ B }{nil}
var V A = struct{ *C }{nil}
var W = interface {
	Write() error
	Hello()

		rval += uint32(len(stw.tmp)) + uint32(slen)
	}
	return rval
}

// Write writes the string table in serialized form to the specified
// io.Writer.
func (stw *Writer) Write(w io.Writer) error {
	wr128 := func(v uint) error {
		stw.tmp = stw.tmp[:0]
		stw.tmp = uleb128.AppendUleb128(stw.tmp, v)
		if nw, err := w.Write(stw.tmp); err != nil {
			return fmt.Errorf("writing string table: %v", err)

    // Verify the peer's settings were read and applied.
    assertThat(connection.peerSettings.headerTableSize).isEqualTo(0)
    val writer = connection.writer
    assertThat(writer.hpackWriter.dynamicTableByteCount).isEqualTo(0)
    assertThat(writer.hpackWriter.headerTableSizeSetting).isEqualTo(0)
  }

  @Test fun peerHttp2ClientDisablesPush() {
    val client = false // Peer is client, so we are server.

	conn *Conn
	num  byte
	r    io.Reader
	w    io.WriteCloser

	read, write bool
}

// newWebsocketChannel creates a pipe for writing to a websocket. Do not write to this pipe
// prior to the connection being opened. It may be no, half, or full duplex depending on
// read and write.
func newWebsocketChannel(conn *Conn, num byte, read, write bool) *websocketChannel {
	r, w := io.Pipe()

class DummyBinaryStore implements BinaryStore {

    private final ByteArrayOutputStream bytes = new ByteArrayOutputStream()
    private Encoder output = new OutputStreamBackedEncoder(bytes)

    void write(WriteAction write) {
        write.write(output)
    }

    BinaryData done() {
        new BinaryData() {
            Decoder decoder
            def <T> T read(ReadAction<T> readAction) {
                if (decoder == null) {

  /*
   * Implemented by entries that use write order. Write entries are maintained in a doubly-linked
   * list. New entries are added at the tail of the list at write time and stale entries are
   * expired from the head of the list.
   */

  @SuppressWarnings("GoodTime")
  /** Returns the time that this entry was last written, in ns. */
  long getWriteTime();

  /** Sets the entry write time in ns. */

	if len(w.buf) > 0 {
		_, err := w.w.Write(w.buf)
		if err != nil {
			return err
		}
	}
	return nil
}

// Writer returns a new writer that implements Write(b)
// by writing f(b) to w. The returned writer may use an
// internal buffer to maintain state across Write calls.
// Calling its Close method writes any buffered data to w.
func (f Form) Writer(w io.Writer) io.WriteCloser {