public U call(DeferredCloser closer, Peeker peeker) throws Exception {
              return function.apply(
                  closer,
                  peeker.getDone(future1),
                  peeker.getDone(future2),
                  peeker.getDone(future3),
                  peeker.getDone(future4),
                  peeker.getDone(future5));
            }

            @Override

                    peeker.getDone(input2Failed);
                    fail("Peeker.getDone() should fail for failed inputs");
                  } catch (ExecutionException expected) {
                  }
                  try {
                    peeker.getDone(nonInput);
                    fail("Peeker should not be able to peek into non-input ClosingFuture.");
                  } catch (IllegalArgumentException expected) {

                    peeker.getDone(input2Failed);
                    fail("Peeker.getDone() should fail for failed inputs");
                  } catch (ExecutionException expected) {
                  }
                  try {
                    peeker.getDone(nonInput);
                    fail("Peeker should not be able to peek into non-input ClosingFuture.");
                  } catch (IllegalArgumentException expected) {

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

package bytes

import (
	"errors"
	"io"
	"unicode/utf8"
)

// A Reader implements the [io.Reader], [io.ReaderAt], [io.WriterTo], [io.Seeker],
// [io.ByteScanner], and [io.RuneScanner] interfaces by reading from
// a byte slice.
// Unlike a [Buffer], a Reader is read-only and supports seeking.
// The zero value for Reader operates like a Reader of an empty slice.

	}

	for i, tt := range tests {
		pos, err := r.Seek(tt.off, tt.seek)
		if err == nil && tt.seekerr != "" {
			t.Errorf("%d. want seek error %q", i, tt.seekerr)
			continue
		}
		if err != nil && err.Error() != tt.seekerr {
			t.Errorf("%d. seek error = %q; want %q", i, err.Error(), tt.seekerr)
			continue
		}
		if tt.wantpos != 0 && tt.wantpos != pos {
			t.Errorf("%d. pos = %d, want %d", i, pos, tt.wantpos)

 */

package com.google.common.io;

import org.jspecify.annotations.NullUnmarked;

/**
 * Options controlling the behavior of sources/sinks/streams for testing.
 *
 * @author Colin Decker
 */
@NullUnmarked
public enum TestOption {
  OPEN_THROWS,
  SKIP_THROWS,
  READ_THROWS,
  WRITE_THROWS,
  CLOSE_THROWS,
  AVAILABLE_ALWAYS_ZERO

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import org.jspecify.annotations.NullUnmarked;

/**
 * A char source for testing that has configurable options.
 *
 * @author Colin Decker
 */
@NullUnmarked
public class TestCharSource extends CharSource implements TestStreamSupplier {

  private final TestByteSource byteSource;

  public TestCharSource(String content, TestOption... options) {

   * a modest limit on `byteCount`, such as 1 MiB.
   */
  @Throws(IOException::class)
  fun peekBody(byteCount: Long): ResponseBody {
    val peeked = body.source().peek()
    val buffer = Buffer()
    peeked.request(byteCount)
    buffer.write(peeked, minOf(byteCount, peeked.buffer.size))
    return buffer.asResponseBody(body.contentType(), buffer.size)
  }

  @JvmName("-deprecated_body")
  @Deprecated(

import java.io.ByteArrayInputStream;
import java.io.FilterReader;
import java.io.IOException;
import java.io.InputStreamReader;
import org.jspecify.annotations.NullUnmarked;

/**
 * @author Colin Decker
 */
@NullUnmarked
public class TestReader extends FilterReader {

  private final TestInputStream in;

  public TestReader(TestOption... options) throws IOException {

setting [Transport.DisableKeepAlives] to `true` will disable connection reuse.
However, such performance degradation usually indicates improper configuration
or usage of [Transport] or [Client] in the first place, and a deeper look would