*     helpful predefined constants
   * @return the buffered reader
   */
  public static BufferedReader newReader(File file, Charset charset) throws FileNotFoundException {
    checkNotNull(file);
    checkNotNull(charset);
    return new BufferedReader(new InputStreamReader(new FileInputStream(file), charset));
  }

  /**
   * Returns a buffered writer that writes to a file using the given character set.
   *

    void availableReturnsUnderlyingWhenNoMessage() throws IOException {
        // Mock input stream that reports available bytes
        InputStream mockIn = mock(InputStream.class);
        when(mockIn.available()).thenReturn(42);

        SocketInputStream sis = new SocketInputStream(mockIn);

        // When no message is buffered, should return underlying stream's available

   *
   * @throws IOException if an I/O error occurs while opening the writer
   */
  public abstract Writer openStream() throws IOException;

  /**
   * Opens a new buffered {@link Writer} for writing to this sink. The returned stream is not
   * required to be a {@link BufferedWriter} in order to allow implementations to simply delegate to

	setEventStreamHeaders(w)

	// Listen Publisher and peer-listen-client uses nonblocking send and hence does not wait for slow receivers.
	// Use buffered channel to take care of burst sends or slow w.Write()
	mergeCh := make(chan []byte, globalAPIConfig.getRequestsPoolCapacity()*len(globalEndpoints.Hostnames()))

 * Fix: Support SPDY header blocks with trailing bytes.
 * Fix: Allow `;` as separator for `Cache-Control` header.
 * Fix: Correct bug where HTTPS POST requests were always automatically buffered.
 * Fix: Honor read timeout when parsing SPDY headers.


## Version 1.2.1

_2013-08-23_

 * Resolve issue with 'jar-with-dependencies' artifact creation.
 * Fix: Support empty SPDY header values.

   * doesn't include framing overhead. If compression is enabled, uncompressed messages size
   * is used to calculate this value. It also doesn't include any bytes buffered by the operating
   * system or network intermediaries. This method returns 0 if no messages are waiting in the
   * queue. If may return a nonzero value after the web socket has been canceled; this indicates

     * Captures output from command execution with configurable line buffering.
     */
    protected static class InputStreamThread extends Thread {

        /** Buffered reader for input stream. */
        private BufferedReader br;

        /** List to store captured output lines. */
        private final List<String> list = new LinkedList<>();

   * [trailers], this doesn't block if the trailers are not immediately available, and instead
   * returns null.
   *
   * This will typically return null until [ResponseBody.source] has buffered the last byte of the
   * response body. Call `body.source().request(1024 * 1024)` to block until either that's done, or
   * 1 MiB of response data is loaded into memory. (You could use any size here, though large values

  /**
   * Report and attempt to recover from a failure to communicate with a server. Returns true if
   * `e` is recoverable, or false if the failure is permanent. Requests with a body can only
   * be recovered if the body is buffered or if the failure occurred before the request has been
   * sent.
   */
  private fun recover(
    e: IOException,
    call: RealCall,
    userRequest: Request,
  ): Boolean {

	}
	return n, err
}

// diskHealthReader provides a wrapper that will update disk health on
// ctx, on every successful read.
// This should only be used directly at the os/syscall level,
// otherwise buffered operations may return false health checks.
func diskHealthReader(ctx context.Context, r io.Reader) io.Reader {
	// Check if context has a disk health check.
	tracker, ok := ctx.Value(healthDiskCtxKey{}).(*healthDiskCtxValue)