assertThat(Striped.lock(100).size()).isAtLeast(100);
    assertTrue(Striped.lock(256).size() == 256);
    assertThat(Striped.lazyWeakLock(100).size()).isAtLeast(100);
    assertTrue(Striped.lazyWeakLock(256).size() == 256);
  }

  public void testWeakImplementations() {
    for (Striped<?> striped : weakImplementations()) {

    assertThat(Striped.lock(100).size()).isAtLeast(100);
    assertTrue(Striped.lock(256).size() == 256);
    assertThat(Striped.lazyWeakLock(100).size()).isAtLeast(100);
    assertTrue(Striped.lazyWeakLock(256).size() == 256);
  }

  public void testWeakImplementations() {
    for (Striped<?> striped : weakImplementations()) {

        // Test with binary data containing all byte values
        byte[] data = new byte[256];
        for (int i = 0; i < 256; i++) {
            data[i] = (byte) i;
        }

        ContentCache cache = new ContentCache(data);

        try (InputStream stream = cache.getInputStream()) {
            for (int i = 0; i < 256; i++) {
                int byteValue = stream.read();

  }

  // goodFastHash(256) uses Murmur3_128. Use the same epsilon bounds.
  public void testGoodFastHash256() {
    HashTestUtils.check2BitAvalanche(Hashing.goodFastHash(256), 250, 0.20);
    HashTestUtils.checkAvalanche(Hashing.goodFastHash(256), 500, 0.17);
    HashTestUtils.checkNo2BitCharacteristics(Hashing.goodFastHash(256));
    HashTestUtils.checkNoFunnels(Hashing.goodFastHash(256));

  private static final int CRC32C_GENERATOR_FLIPPED = Integer.reverse(CRC32C_GENERATOR);

  public void testCrc32cByteTable() {
    // See Hacker's Delight 2nd Edition, Figure 14-7.
    int[] expected = new int[256];
    for (int i = 0; i < expected.length; i++) {
      int crc = i;
      for (int j = 7; j >= 0; j--) {
        int mask = -(crc & 1);
        crc = (crc >>> 1) ^ (CRC32C_GENERATOR_FLIPPED & mask);
      }

package okhttp3.internal.http1

import okhttp3.Headers
import okhttp3.internal.HEADER_LIMIT
import okio.BufferedSource

/**
 * Parse all headers delimited by "\r\n" until an empty line. This throws if headers exceed 256 KiB.
 */
class HeadersReader(
  val source: BufferedSource,
) {
  private var headerLimit = HEADER_LIMIT

  /** Read a single line counted against the header size limit. */
  fun readLine(): String {

    assertEquals(8581389452482819506L, fingerprint("test".getBytes(UTF_8)));
    // 32 characters long
    assertEquals(-4196240717365766262L, fingerprint(Strings.repeat("test", 8).getBytes(UTF_8)));
    // 256 characters long
    assertEquals(3500507768004279527L, fingerprint(Strings.repeat("test", 64).getBytes(UTF_8)));
  }

  public void testStringsConsistency() {

  }

  public void testGrowBuffer() { // need to grow past an initial 1024 byte buffer
    StringBuilder input = new StringBuilder();
    StringBuilder expected = new StringBuilder();
    for (int i = 256; i < 1024; i++) {
      input.append((char) i);
      expected.append("[" + i + "]");
    }
    assertThat(SIMPLE_ESCAPER.escape(input.toString())).isEqualTo(expected.toString());
  }

@NullUnmarked
enum HashFunctionEnum {
  ADLER32(adler32()),
  CRC32(crc32()),
  GOOD_FAST_HASH_32(goodFastHash(32)),
  GOOD_FAST_HASH_64(goodFastHash(64)),
  GOOD_FAST_HASH_128(goodFastHash(128)),
  GOOD_FAST_HASH_256(goodFastHash(256)),
  MD5(md5()),
  MURMUR3_128(murmur3_128()),
  MURMUR3_32(murmur3_32()),
  MURMUR3_32_FIXED(murmur3_32_fixed()),
  SHA1(sha1()),
  SHA256(sha256()),
  SHA384(sha384()),
  SHA512(sha512()),

@NullUnmarked
enum HashFunctionEnum {
  ADLER32(adler32()),
  CRC32(crc32()),
  GOOD_FAST_HASH_32(goodFastHash(32)),
  GOOD_FAST_HASH_64(goodFastHash(64)),
  GOOD_FAST_HASH_128(goodFastHash(128)),
  GOOD_FAST_HASH_256(goodFastHash(256)),
  MD5(md5()),
  MURMUR3_128(murmur3_128()),
  MURMUR3_32(murmur3_32()),
  MURMUR3_32_FIXED(murmur3_32_fixed()),
  SHA1(sha1()),
  SHA256(sha256()),
  SHA384(sha384()),
  SHA512(sha512()),