*/
class Address(
  uriHost: String,
  uriPort: Int,
  /** Returns the service that will be used to resolve IP addresses for hostnames. */
  @get:JvmName("dns") val dns: Dns,
  /** Returns the socket factory for new connections. */
  @get:JvmName("socketFactory") val socketFactory: SocketFactory,
  /** Returns the SSL socket factory, or null if this is not an HTTPS address. */

   * can return other values to test HTTP edge cases, such as unhappy socket policies or throttled
   * request bodies.
   */
  open fun peek(): MockResponse {
    return MockResponse(socketPolicy = KeepOpen)
  }

  /**
   * Release any resources held by this dispatcher. Any requests that are currently being dispatched

    }

    /** Returns a strategy to use assuming the request can use the network. */
    private fun computeCandidate(): CacheStrategy {
      // No cached response.
      if (cacheResponse == null) {
        return CacheStrategy(request, null)
      }

      // Drop the cached response if it's missing a required handshake.
      if (request.isHttps && cacheResponse.handshake == null) {
        return CacheStrategy(request, null)

The [RuneLen] function returns the number of 16-bit words in
the UTF-16 encoding of the rune. It returns -1 if the rune

    get() {
      this.withLock {
        if (errorCode != null) {
          return false
        }
        if ((source.finished || source.closed) &&
          (sink.finished || sink.closed) &&
          hasResponseHeaders
        ) {
          return false
        }
        return true
      }
    }

  /** Returns true if this stream was created by this peer. */
  val isLocallyInitiated: Boolean

    val entry = lruEntries[key] ?: return null
    val snapshot = entry.snapshot() ?: return null

    redundantOpCount++
    journalWriter!!.writeUtf8(READ)
      .writeByte(' '.code)
      .writeUtf8(key)
      .writeByte('\n'.code)
    if (journalRebuildRequired()) {
      cleanupQueue.schedule(cleanupTask)
    }

    return snapshot
  }

  /**
   * Asserts that the current response was redirected and returns the prior response.
   */
  fun priorResponse(): RecordedResponse {
    val priorResponse = response!!.priorResponse!!
    return RecordedResponse(priorResponse.request, priorResponse, null, null, null)
  }

  /**
   * Asserts that the current response used the network and returns the network response.
   */
  fun networkResponse(): RecordedResponse {

  }

  fun idleConnectionCount(): Int {
    return connections.count {
      it.withLock { it.calls.isEmpty() }
    }
  }

  fun connectionCount(): Int {
    return connections.size
  }

  /**
   * Attempts to acquire a recycled connection to [address] for [connectionUser]. Returns the connection if it

    parameterNamesAndValues += value
    s = parameter.range.last + 1
  }

  return MediaType(this, type, subtype, parameterNamesAndValues.toTypedArray())
}

/** Returns a media type for this, or null if this is not a well-formed media type. */
fun String.commonToMediaTypeOrNull(): MediaType? {
  return try {
    commonToMediaType()
  } catch (_: IllegalArgumentException) {
    null
  }

The [Repeat] function returns a new slice that repeats the