Checksums  map[string]string `json:"crc,omitempty" msg:"crc,omitempty"`   // Content Checksums
	Error      string            `json:"error,omitempty" msg:"err,omitempty"` // only set while reading part meta from drive.
}

// ChecksumInfo - carries checksums of individual scattered parts per disk.
type ChecksumInfo struct {
	PartNumber int
	Algorithm  BitrotAlgorithm
	Hash       []byte
}

   *
   * If this is a [cacheResponse], [networkResponse], or [priorResponse], the server's response body
   * is not available, and it is always an error to attempt read its streamed content. Reading from
   * [ResponseBody.source] always throws on such instances.
   *
   * It is safe and supported to call [ResponseBody.contentType] and [ResponseBody.contentLength] on
   * all instances of [ResponseBody].
   */

	}
	testFileMode(t, f, wt.Mode)
	rc, err := f.Open()
	if err != nil {
		t.Fatalf("opening %s: %v", f.Name, err)
	}
	b, err := io.ReadAll(rc)
	if err != nil {
		t.Fatalf("reading %s: %v", f.Name, err)
	}
	err = rc.Close()
	if err != nil {
		t.Fatalf("closing %s: %v", f.Name, err)
	}
	if !bytes.Equal(b, wt.Data) {
		t.Errorf("File contents %q, want %q", b, wt.Data)
	}
}

    frame.writeInt(expectedStreamId and 0x7fffffff)
    frame.writeAll(headerBlock)

    // Check writer sends the same bytes.
    assertThat(sendHeaderFrames(false, sentHeaders)).isEqualTo(frame)

    // Reading the above frames should result in a concatenated headerBlock.
    reader.nextFrame(
      requireSettings = false,
      object : BaseTestHandler() {
        override fun headers(
          inFinished: Boolean,

  /** Reconstitutes the instance from a stream (that is, deserializes it). */
  private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
    s.defaultReadObject();

    int length = s.readInt();
    ImmutableLongArray.Builder builder = ImmutableLongArray.builder();
    for (int i = 0; i < length; i++) {
      builder.add(doubleToRawLongBits(s.readDouble()));
    }

   * body. This was misleading for tracing because it was too early.
   */
  open fun responseBodyStart(call: Call) {
  }

  /**
   * Invoked immediately after receiving a response body and completing reading it.
   *
   * Will only be invoked for requests having a response body e.g. won't be invoked for a web socket
   * upgrade.
   *

### Asynchronous Get ([.kt][AsynchronousGetKotlin], [.java][AsynchronousGetJava])

Download a file on a worker thread, and get called back when the response is readable. The callback is made after the response headers are ready. Reading the response body may still block. OkHttp doesn't currently offer asynchronous APIs to receive a response body in parts.

=== ":material-language-kotlin: Kotlin"
    ```kotlin
      private val client = OkHttpClient()

    HTTP 408 Request Timeout. If retries are enabled, OkHttp will retry exactly
    once in response to a 408.
 *  Fix: Don't crash when reading the empty `HEAD` response body if it specifies
    a `Content-Length`.
 *  Fix: Don't crash if the thread is interrupted while reading the public
    suffix database.
 *  Fix: Use relative resource path when loading the public suffix database.

       * use the `endpoint` field, compareTo() and endpoint(). Additionally, the main implementation
       * of Cut.compareTo checks for belowAll before reading accessing `endpoint` on another Cut
       * instance.
       */
      super("");
    }

    @Override
    Comparable<?> endpoint() {
      throw new IllegalStateException("range unbounded on this side");

 *   ... // Handle the failure.
 *   }
 * });
 * ```
 *
 * These examples will not work if you're consuming the response body on another thread. In such
 * cases the consuming thread must call [close] when it has finished reading the response
 * body.
 *
 * ### The response body can be consumed only once.
 *
 * This class may be used to stream very large responses. For example, it is possible to use this