nextOutFrame = outFramesIterator.next()
      }

      if (nextOutFrame != null && nextOutFrame.sequence == i) {
        val start = nextOutFrame.start
        var truncated: Boolean
        var end: Long
        if (outFramesIterator.hasNext()) {
          nextOutFrame = outFramesIterator.next()
          end = nextOutFrame.start
          truncated = false
        } else {

    assertRoute(selection.next(), address, Proxy.NO_PROXY, dns.lookup(uriHost, 0), uriPort)
    assertThat(selection.hasNext()).isFalse()
    assertFailsWith<NoSuchElementException> {
      selection.next()
    }
    assertThat(routeSelector.hasNext()).isFalse()
    assertFailsWith<NoSuchElementException> {
      routeSelector.next()
    }
  }

  @Test fun explicitProxyTriesThatProxysAddressesOnly() {
    val address =

 */
fun interface Dns {
  /**
   * Returns the IP addresses of `hostname`, in the order they will be attempted by OkHttp. If a
   * connection to an address fails, OkHttp will retry the connection with the next address until
   * either a connection is made, the set of IP addresses is exhausted, or a limit is exceeded.
   */
  @Throws(UnknownHostException::class)
  fun lookup(hostname: String): List<InetAddress>

  interface Callback {
    fun onEvent(
      id: String?,
      type: String?,
      data: String,
    )

    fun onRetryChange(timeMs: Long)
  }

  /**
   * Process the next event. This will result in a single call to [Callback.onEvent] *unless* the
   * data section was empty. Any number of calls to [Callback.onRetryChange] may occur while
   * processing an event.
   *

        }
      }
    } catch (e: NoSuchElementException) {
      throw AssertionError("full event sequence: $fullEventSequence", e)
    }
  }

  /**
   * Remove and return the next event from the recorded sequence.
   *
   * @param eventClass a class to assert that the returned event is an instance of, or null to
   *     take any event class.

  // These properties are only accessed by the thread executing the call.

  /** Initialized in [callStart]. */
  private var callStackTrace: Any? = null

  /** Finds an exchange to send the next request and receive the next response. */
  private var exchangeFinder: ExchangeFinder? = null

  var connection: RealConnection? = null
    private set
  private var timeoutEarlyExit = false

  /**

import okhttp3.internal.platform.Platform
import okhttp3.logging.HttpLoggingInterceptor
import okhttp3.logging.LoggingEventListener

class Main : CliktCommand(name = NAME, help = "A curl for the next-generation web.") {
  val method: String? by option("-X", "--request", help = "Specify request command to use")

  val data: String? by option("-d", "--data", help = "HTTP POST data")

6. Prepare for ongoing development and push to GitHub.

    ```
    sed -i "" \
      "s/version = \".*\"/version = \"$NEXT_VERSION\"/g" \
      build.gradle.kts
    git commit -am "Prepare next development version."
    git push
    ```

7. Confirm the [GitHub Actions][github_actions] publish job succeeded.

[github_actions]: https://github.com/square/okhttp/actions

 * ----------
 *
 * Tasks control their recurrence schedule. The [runOnce] function returns -1L to signify that the
 * task should not be executed again. Otherwise it returns a delay until the next execution.
 *
 * A task has at most one next execution. If the same task instance is scheduled multiple times, the
 * earliest one wins. This applies to both executions scheduled with [TaskRunner.Queue.schedule] and

 * (like 0030..0039).
 *
 * The second element on each line is a mapping type, like `valid` or `mapped`.
 *
 * For lines that contain a mapping target, the next thing is a sequence of hex code points (like
 * 0031 2044 0034).
 *
 * All other data is ignored.
 */
fun BufferedSource.readPlainTextIdnaMappingTable(): SimpleIdnaMappingTable {
  val mappedTo = Buffer()