// If the request context is canceled, the stream will no longer process requests.
	// Requests sent cannot be used any further by the called.
	Requests chan<- []byte

	muxID uint64
	ctx   context.Context
}

// Send a payload to the remote server.
func (s *Stream) Send(b []byte) error {
	if s.Requests == nil {
		return errors.New("stream does not accept requests")
	}
	select {

 */
@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.

	return string(d)
}

// Token returns the next JSON token in the input stream.
// At the end of the input stream, Token returns nil, [io.EOF].
//
// Token guarantees that the delimiters [ ] { } it returns are
// properly nested and matched: if Token encounters an unexpected
// delimiter in the input, it will return an error.
//
// The input stream consists of basic JSON values—bool, string,

	"github.com/tinylib/msgp/msgp"
	"github.com/valyala/bytebufferpool"
)

// metadata stream format:
//
// The stream is s2 compressed.
// https://github.com/klauspost/compress/tree/master/s2#s2-compression
// This ensures integrity and reduces the size typically by at least 50%.
//
// All stream elements are msgpack encoded.
//
// 1 Integer, metacacheStreamVersion of the writer.

  }

  /**
   * 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)
   */

    }

    public static class StreamOf<T> {

        private final Supplier<Stream<T>> supplier;

        public StreamOf(final Supplier<Stream<T>> supplier) {
            this.supplier = supplier;
        }

        public void of(final Consumer<Stream<T>> stream) {
            try (Stream<T> s = supplier.get()) {
                stream.accept(s);

    val task = serviceStreamTask(stream)
    results.add(task)
    task.run()
  }

  /** Returns a task that processes both request and response from [stream]. */
  private fun serviceStreamTask(stream: Stream): FutureTask<Void> {
    return FutureTask<Void> {
      stream.requestBody.use {
        stream.responseBody.use {
          while (true) {
            val action = actions.poll() ?: break

    public void println(boolean x) {
        PrintStream stream = getStream();
        synchronized (this) {
            stream.print(x);
            stream.print(lineSeparator);
        }
    }

    @Override
    public void println(char x) {
        PrintStream stream = getStream();
        synchronized (this) {
            stream.print(x);
            stream.print(lineSeparator);
        }
    }

            stream.received(bytes)
        }

        then:
        1 * dispatch.onOutput({ it instanceof ReadStdInEvent }) >> { instant.requested }
    }

    def "read byte returns when stream is closed"() {
        def dispatch = Mock(OutputEventListener)
        def stream = new StdInStream(dispatch)

        when:
        async {
            start {
                def b1 = stream.read()