}
        }
      }

      ImportResults(sortedRules, sortedExceptionRules, totalRuleBytes, totalExceptionRuleBytes)
    }

  private fun String.toRule(): ByteString? {
    if (trim { it <= ' ' }.isEmpty() || startsWith("//")) return null
    if (contains(WILDCARD_CHAR)) {
      assertWildcardRule(this)
    }
    return encodeUtf8()
  }

  data class ImportResults(

          FILE_HEADER_SIZE + upstreamPos,
          upstreamBuffer.clone(),
          upstreamBytesRead,
        )

        synchronized(this@Relay) {
          // Append new upstream bytes into the buffer. Trim it to its max size.
          buffer.write(upstreamBuffer, upstreamBytesRead)
          if (buffer.size > bufferMaxSize) {
            buffer.skip(buffer.size - bufferMaxSize)
          }

      throw noMoreExchanges(e) as Throwable
    } finally {
      if (!calledNoMoreExchanges) {
        noMoreExchanges(null)
      }
    }
  }

  /**
   * Prepare for a potential trip through all of this call's network interceptors. This prepares to
   * find an exchange to carry the request.
   *
   * Note that an exchange will not be needed if the request is satisfied by the cache.
   *

        if (contentLength == -1L && lowercaseHeader.startsWith("content-length:")) {
          contentLength = header.substring(15).trim().toLong()
        }
        if (lowercaseHeader.startsWith("transfer-encoding:") &&
          lowercaseHeader.substring(18).trim() == "chunked"
        ) {
          chunked = true
        }
      }

      val peek = dispatcher.peek()

  @get:Synchronized @set:Synchronized
  var maxSize: Long = maxSize
    set(value) {
      field = value
      if (initialized) {
        cleanupQueue.schedule(cleanupTask) // Trim the existing store if necessary.
      }
    }

  /*
   * This cache uses a journal file named "journal". A typical journal file looks like this:
   *
   *     libcore.io.DiskLruCache
   *     1

root = true

[*]
indent_size = 2
ij_continuation_indent_size = 2
charset = utf-8
trim_trailing_whitespace = true
insert_final_newline = true

[*.{kt, kts}]

internal fun Map<String, String>.commonToHeaders(): Headers {
  // Make a defensive copy and clean it up.
  val namesAndValues = arrayOfNulls<String>(size * 2)
  var i = 0
  for ((k, v) in this) {
    val name = k.trim()
    val value = v.trim()
    headersCheckName(name)
    headersCheckValue(value, name)
    namesAndValues[i] = name
    namesAndValues[i + 1] = value
    i += 2
  }

      }
    }

    var pos = 0
    while (pos < value.length) {
      val tokenStart = pos
      pos = value.indexOfElement("=,;", pos)
      val directive = value.substring(tokenStart, pos).trim()
      val parameter: String?

      if (pos == value.length || value[pos] == ',' || value[pos] == ';') {
        pos++ // Consume ',' or ';' (if necessary).
        parameter = null
      } else {

  val mimeType =
    headers?.let {
      for (header in it) {
        val parts = header.split(':', limit = 2)
        if ("Content-Type".equals(parts[0], ignoreCase = true)) {
          return@let parts[1].trim()
        }
      }
      return@let null
    } ?: "application/x-www-form-urlencoded"

  return mimeType.toMediaTypeOrNull()
}

private fun isSpecialHeader(s: String): Boolean {

    set("b", "bb", "bbb")

    // Cause the cache trim job to fail.
    filesystem.setFaultyDelete(cacheDir / "a.0", true)
    taskFaker.runNextTask()

    // An edit should now add a job to clean up if the most recent trim failed.
    assertThat(cache.edit("b")).isNull()
    taskFaker.runNextTask()

    // Confirm a successful cache trim now allows edits.
    filesystem.setFaultyDelete(cacheDir / "a.0", false)