return
		}

		streamCh := make(chan httpstream.Stream)

		responseUpgrader := NewResponseUpgrader()
		spdyConn := responseUpgrader.UpgradeResponse(w, req, func(s httpstream.Stream, replySent <-chan struct{}) error {
			streamCh <- s
			return nil
		})
		if spdyConn == nil {
			t.Fatal("unexpected nil spdyConn")
		}
		defer spdyConn.Close()

		stream := <-streamCh
		io.Copy(stream, stream)
	}
}

	}

	upgrader := spdy.NewResponseUpgrader()
	streamCh := make(chan streamAndReply)
	conn := upgrader.UpgradeResponse(w, req, func(stream httpstream.Stream, replySent <-chan struct{}) error {
		streamCh <- streamAndReply{Stream: stream, replySent: replySent}
		return nil
	})
	ctx := &streamContext{
		conn: conn,
	}

	// wait for stream
	replyChan := make(chan struct{}, 5)
	defer close(replyChan)

  }

  /**
   * Returns a {@link Stream} containing the elements of the first stream, followed by the elements
   * of the second stream, and so on.
   *
   * <p>This is equivalent to {@code Stream.of(streams).flatMap(stream -> stream)}, but the returned
   * stream may perform better.
   *
   * @see Stream#concat(Stream, Stream)
   */

    peer.acceptFrame() // HEADERS STREAM 3
    peer.acceptFrame() // DATA STREAM 3 "abcde"
    peer.acceptFrame() // HEADERS STREAM 3
    peer.play()

    // Play it back.
    val connection = connect(peer)
    val stream = connection.newStream(headerEntries("a", "android"), true)
    stream.enqueueTrailers(headersOf("foo", "bar"))
    val sink = stream.getSink().buffer()
    sink.writeUtf8("abcdefghi")

	c := &connection{streams: make(map[uint32]httpstream.Stream)}
	stream0 := &fakeStream{id: 0}
	stream1 := &fakeStream{id: 1}
	stream2 := &fakeStream{id: 2}

	c.registerStream(stream0)
	c.registerStream(stream1)

	if len(c.streams) != 2 {
		t.Fatalf("should have two streams, has %d", len(c.streams))
	}

	// not exists
	c.RemoveStreams(stream2)

	if len(c.streams) != 2 {

        given:
        stream1.forCurrentCaller()

        expect:
        !stream1.forCurrentCaller().stack.empty

        !stream2.forCurrentCaller().stack.empty
        !stream2.forCurrentCaller().stack.empty
        stream2.forCurrentCaller().stack.empty

        stream1.forCurrentCaller().stack.empty
    }

    def "keeps stack trace after limit has been reached when diagnostics constructed from exception"() {

        file.writeInt(456)

        expect:
        def stream = input.start(0)
        stream.readInt() == 123
        stream.readInt() == 321
        input.done()

        def stream2 = input.start(4)
        stream2.readInt() == 321
        stream2.readInt() == 456
        input.done()

        def stream3 = input.start(0)
        stream3.readInt() == 123
        input.done()
    }

//
// For each element:
// 1. Bool. If false at end of stream.
// 2. String. Name of object. Directories contains a trailing slash.
// 3. Binary. Blob of metadata. Length 0 on directories.
// ... Next element.
//
// Streams can be assumed to be sorted in ascending order.
// If the stream ends before a false boolean it can be assumed it was truncated.

const metacacheStreamVersion = 2

 */
@ExperimentalOkHttpApi
interface Stream {
  val requestBody: BufferedSource
  val responseBody: BufferedSink

  /**
   * Terminate the stream so that no further data is transmitted or received. Note that
   * [requestBody] may return data after this call; that is the buffered data received before this
   * stream was canceled.
   *

// the exact bytes written to the stream. Zero byte messages are possible.
const binaryWebSocketProtocol = "binary.k8s.io"

// The WebSocket subprotocol "base64.binary.k8s.io" will only send messages to the
// client and ignore messages sent to the server. The received messages are
// a base64 version of the bytes written to the stream. Zero byte messages are
// possible.