@Throws(IOException::class)
internal fun BufferedSource.skipAll() {
  while (!exhausted()) {
    skip(buffer.size)
  }
}

/**
 * Attempts to exhaust this, returning true if successful. This is useful when reading a complete
 * source is helpful, such as when doing so completes a cache body or frees a socket connection for
 * reuse.
 */
internal fun Source.discard(
  timeout: Int,
  timeUnit: TimeUnit,
): Boolean =

       * 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");

	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "v":
			z.Version, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Version")
				return
			}
		case "brs":
			var zb0002 uint32
			zb0002, err = dc.ReadMapHeader()
			if err != nil {

         */
        @Nonnull
        String getName();

        /**
         * Returns the file extension to be used for given checksum file (without leading dot), never {@code null}. The
         * extension should be file and URL path friendly, and may differ from algorithm name.
         * The checksum extension SHOULD NOT contain dot (".") character.
         * Example: "sha1".

      return null // Another edit is in progress.
    }

    if (entry != null && entry.lockingSourceCount != 0) {
      return null // We can't write this file because a reader is still reading it.
    }

    if (mostRecentTrimFailed || mostRecentRebuildFailed) {
      // The OS has become our enemy! If the trim job failed, it means we are storing more data than

				return
			}
		case "PoolIndex":
			z.PoolIndex, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "PoolIndex")
				return
			}
		case "SetIndex":
			z.SetIndex, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "SetIndex")
				return
			}
		case "DiskIndex":
			z.DiskIndex, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "DiskIndex")
				return

 *
 * Exchanges that do not have a request body may skip creating and closing the request body.
 * Exchanges that do not have a response body can call
 * [newFixedLengthSource(0)][newFixedLengthSource] and may skip reading and closing that source.
 */
class Http1ExchangeCodec(
  /** The client that configures this stream. May be null for HTTPS proxy tunnels. */
  private val client: OkHttpClient?,
  override val carrier: ExchangeCodec.Carrier,

Dann können wir testen, ob das verwendet wird.

## Lesen einer `.env`-Datei { #reading-a-env-file }

				if err != nil {
					err = msgp.WrapError(err, "Purge")
					return
				}
				switch msgp.UnsafeString(field) {
				case "RetainVersions":
					z.Purge.RetainVersions, err = dc.ReadInt()
					if err != nil {
						err = msgp.WrapError(err, "Purge", "RetainVersions")
						return
					}
				default:
					err = dc.Skip()
					if err != nil {
						err = msgp.WrapError(err, "Purge")

    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,