try {
      byte[] readBytes = ByteStreams.toByteArray(in);
      assertExpectedBytes(readBytes);
    } finally {
      in.close();
    }
  }

  public void testOpenBufferedStream() throws IOException {
    InputStream in = source.openBufferedStream();
    try {
      byte[] readBytes = ByteStreams.toByteArray(in);
      assertExpectedBytes(readBytes);
    } finally {
      in.close();

        final byte[] result = FileUtil.readBytes(emptyFile);
        assertThat(result.length, is(0));
    }

    /**
     * Test readBytes with null file throws exception
     */
    @Test
    public void testReadBytes_NullFile() {
        try {
            FileUtil.readBytes(null);
            fail("Expected IllegalArgumentException");

    try {
      byte[] readBytes = ByteStreams.toByteArray(in);
      assertExpectedBytes(readBytes);
    } finally {
      in.close();
    }
  }

  public void testOpenBufferedStream() throws IOException {
    InputStream in = source.openBufferedStream();
    try {
      byte[] readBytes = ByteStreams.toByteArray(in);
      assertExpectedBytes(readBytes);
    } finally {
      in.close();

	}

	// after successful read
	if _, err := b.ReadBytes('m'); err != nil {
		t.Fatalf("ReadBytes: %v", err)
	}
	if err := b.UnreadByte(); err != nil {
		t.Fatalf("UnreadByte: %v", err)
	}
	c, err := b.ReadByte()
	if err != nil {
		t.Fatalf("ReadByte: %v", err)
	}
	if c != 'm' {
		t.Errorf("ReadByte = %q; want %q", c, 'm')
	}
}

     * @return A byte array containing the contents of the file.
     * @throws IORuntimeException if the file is larger than {@value #MAX_BUF_SIZE} bytes
     */
    public static byte[] readBytes(final File file) {
        return readBytes(file, MAX_BUF_SIZE);
    }

    /**
     * Reads the contents of a file into a byte array and returns it with a custom size limit.
     * <p>

	if b.off > 0 {
		b.off--
	}
	return nil
}

// ReadBytes reads until the first occurrence of delim in the input,
// returning a slice containing the data up to and including the delimiter.
// If ReadBytes encounters an error before finding a delimiter,
// it returns the data read before the error and the error itself (often [io.EOF]).
// ReadBytes returns err != nil if and only if the returned data does not end in
// delim.

	totalLen += len(frag)
	return fullBuffers, frag, totalLen, err
}

// ReadBytes reads until the first occurrence of delim in the input,
// returning a slice containing the data up to and including the delimiter.
// If ReadBytes encounters an error before finding a delimiter,
// it returns the data read before the error and the error itself (often io.EOF).
// ReadBytes returns err != nil if and only if the returned data does not end in
// delim.

    withLock {
      readBytes.update(total = read)
      val readBytesToAcknowledge = readBytes.unacknowledged
      if (readBytesToAcknowledge >= okHttpSettings.initialWindowSize / 2) {
        writeWindowUpdateLater(0, readBytesToAcknowledge)
        readBytes.update(acknowledged = readBytesToAcknowledge)
      }
      flowControlListener.receivingConnectionWindowChanged(readBytes)
    }
  }

  /**

      imports = "com.google.common.io.Files")
  @CanIgnoreReturnValue // some processors won't return a useful result
  @ParametricNullness
  public
  static <T extends @Nullable Object> T readBytes(File file, ByteProcessor<T> processor)
      throws IOException {
    return asByteSource(file).read(processor);
  }

  /**
   * Computes the hash code of the {@code file} using {@code hashFunction}.
   *

      try {
        return input.readBoolean();
      } catch (IOException e) {
        throw new IllegalStateException(e);
      }
    }

    @Override
    public byte readByte() {
      try {
        return input.readByte();
      } catch (EOFException e) {
        throw new IllegalStateException(e);
      } catch (IOException impossible) {
        throw new AssertionError(impossible);
      }
    }