* this class offers:
 *
 *  * **Read/write:** read and write using the same operator.
 *  * **Random access:** access any position within the file.
 *  * **Shared channels:** read and write a file channel that's shared between
 * multiple operators. Note that although the underlying [FileChannel] may be shared,
 * each [FileOperator] should not be.
 */
internal class FileOperator(

      if (result == null) result = ArrayList(2)
      result.add(value(i))
    }
  }
  return result?.toList().orEmpty()
}

internal fun Headers.commonIterator(): Iterator<Pair<String, String>> {
  return Array(size) { name(it) to value(it) }.iterator()
}

internal fun Headers.commonNewBuilder(): Headers.Builder {
  val result = Headers.Builder()
  result.namesAndValues += namesAndValues
  return result
}

  fun assertJobs(vararg expectedUrls: String) {
    val actualUrls = calls.map { it.request.url.toString() }
    assertThat(actualUrls).containsExactly(*expectedUrls)
  }

  fun finishJob(url: String) {
    val i = calls.iterator()
    while (i.hasNext()) {
      val call = i.next()
      if (call.request.url.toString() == url) {
        i.remove()
        dispatcherTest.dispatcher.finishedAccessor(call)
        return
      }
    }

cache.delete()
```
 
## Pruning the Cache

Pruning the entire Cache to clear space temporarily can be done using evictAll.

```kotlin
cache.evictAll()
```

Removing individual items can be done using the urls iterator.
This would be typical after a user initiates a force refresh by a pull to refresh type action.

```java
    val urlIterator = cache.urls()
    while (urlIterator.hasNext()) {

        continue
      }

      // Search for the certificate in the chain that signed this certificate. This is typically
      // the next element in the chain, but it could be any element.
      val i = queue.iterator()
      while (i.hasNext()) {
        val signingCert = i.next() as X509Certificate
        if (verifySignature(toVerify, signingCert, result.size - 1)) {
          i.remove()
          result.add(signingCert)

 * a single section.
 */
internal fun withoutSectionSpans(mappings: List<Mapping>): List<Mapping> {
  val result = mutableListOf<Mapping>()

  val i = mappings.iterator()
  var current = i.next()

  while (true) {
    if (current.spansSections) {
      result +=
        Mapping(
          current.sourceCodePoint0,
          current.section + 0x7f,

   */
  private fun promoteAndExecute(): Boolean {
    lock.assertNotHeld()

    val executableCalls = mutableListOf<AsyncCall>()
    val isRunning: Boolean
    this.withLock {
      val i = readyAsyncCalls.iterator()
      while (i.hasNext()) {
        val asyncCall = i.next()

        if (runningAsyncCalls.size >= this.maxRequests) break // Max capacity.

) : Cloneable {
  val headersList: List<Header>
    get() {
      val result = mutableListOf<Header>()
      for (inputHeader in headers) {
        val (key, value) = inputHeader.entries.iterator().next()
        result.add(Header(key, value))
      }
      return result
    }

  public override fun clone() = Case(seqno, this.wire, headers)