}
}

func messWith(fileName string, corrupter func(b []byte)) (r io.ReaderAt, size int64) {
	data, err := os.ReadFile(filepath.Join("testdata", fileName))
	if err != nil {
		panic("Error reading " + fileName + ": " + err.Error())
	}
	corrupter(data)
	return bytes.NewReader(data), int64(len(data))
}

    expectedEvents += ConnectionReleased::class
    expectedEvents += CallEnd::class
    assertThat(eventRecorder.recordedEventTypes()).isEqualTo(expectedEvents)

    // Confirm that the connection pool was not corrupted by making another call.
    makeSimpleCall()
  }

  /**
   * If the server returns a full response, it doesn't really matter if the HTTP/2 stream is reset.
   * Attempts to write the request body fails fast.

# When we use Patchelf versions <0.12, those shared libraries end up with a
# corrupted PT_NOTE program header. This was fixed in v0.12, see https://github.com/NixOS/patchelf/commit/43a33482b501b0f5ee9da312aabfca3806570cc9.

        return
      } catch (journalIsCorrupt: IOException) {
        Platform.get().log(
          "DiskLruCache $directory is corrupt: ${journalIsCorrupt.message}, removing",
          WARN,
          journalIsCorrupt,
        )
      }

      // The cache is corrupted, attempt to delete the contents of the directory. This can throw and

    Hints’.

 *  Fix: Honor interceptors' changes to connect and read timeouts.

 *  Fix: Recover gracefully when a cached response is corrupted on disk.

 *  Fix: Don't leak file handles when a cache disk write fails.

 *  Fix: Don't hang when the public suffix database cannot be loaded. We had a bug where a failure

        |100
        |2
        |
        |CLEAN k1 1 1
        """.trimMargin(),
      )
    }
    createNewCache()
    assertThat(cache["k1"]).isNull()

    // The journal is not corrupt when editing after a truncated line.
    set("k1", "C", "D")
    cache.close()
    createNewCache()
    assertValue("k1", "C", "D")
  }

  @Test
  fun openWithTooManyFileSizesClearsDirectory() {

        "TYPE_GOAWAY unexpected error code: $errorCodeInt",
      )
    var debugData = ByteString.EMPTY
    if (opaqueDataLength > 0) { // Must read debug data in order to not corrupt the connection.
      debugData = source.readByteString(opaqueDataLength.toLong())
    }
    handler.goAway(lastStreamId, errorCode, debugData)
  }

        for (i in 0 until length) {
          val line = source.readUtf8LineStrict()
          val bytes = Buffer()
          val certificateBytes = line.decodeBase64() ?: throw IOException("Corrupt certificate in cache entry")
          bytes.write(certificateBytes)
          result.add(certificateFactory.generateCertificate(bytes.inputStream()))
        }
        return result

     *
     * <p>Since the last element of the array is actually in the middle of the sorted structure, a
     * childless aunt node could be smaller, which would corrupt the invariant if this element
     * becomes the new parent of the aunt node. In that case, we first switch the last element with
     * its aunt node, before returning.
     */

     *
     * <p>Since the last element of the array is actually in the middle of the sorted structure, a
     * childless aunt node could be smaller, which would corrupt the invariant if this element
     * becomes the new parent of the aunt node. In that case, we first switch the last element with
     * its aunt node, before returning.
     */