*/
  @get:JvmName("sMaxAgeSeconds") val sMaxAgeSeconds: Int,
  val isPrivate: Boolean,
  val isPublic: Boolean,
  @get:JvmName("mustRevalidate") val mustRevalidate: Boolean,
  @get:JvmName("maxStaleSeconds") val maxStaleSeconds: Int,
  @get:JvmName("minFreshSeconds") val minFreshSeconds: Int,
  /**

  builder: Builder,
) {
  @get:JvmName("url")
  val url: HttpUrl = checkNotNull(builder.url) { "url == null" }

  @get:JvmName("method")
  val method: String = builder.method

  @get:JvmName("headers")
  val headers: Headers = builder.headers.build()

  @get:JvmName("body")
  val body: RequestBody? = builder.body

  @get:JvmName("cacheUrlOverride")
  val cacheUrlOverride: HttpUrl? = builder.cacheUrlOverride

      headersOf("", "OkHttp")
    }
  }

  @Test fun ofAcceptsEmptyValue() {
    val headers = headersOf("User-Agent", "")
    assertThat(headers.value(0)).isEqualTo("")
  }

  @Test fun ofMakesDefensiveCopy() {
    val namesAndValues =
      arrayOf(
        "User-Agent",
        "OkHttp",
      )
    val headers = headersOf(*namesAndValues)
    namesAndValues[1] = "Chrome"

    val generatedBucketsJson = File(System.getProperty("outputBucketSplitJson", "./test-buckets.json"))

    FunctionalTestBucketGenerator(model, testClassDataJson).generate(generatedBucketsJson)
}

class FunctionalTestBucketGenerator(
    private val model: CIBuildModel,
    testTimeDataJson: File,
) {
    private val gson: Gson = GsonBuilder().setPrettyPrinting().create()

@Tag("Slowish")
class DispatcherTest {
  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()
  private val executor = RecordingExecutor(this)
  val callback = RecordingCallback()
  val webSocketListener =
    object : WebSocketListener() {
    }
  val dispatcher = Dispatcher(executor)
  val listener = RecordingEventListener()
  var client =
    clientTestRule
      .newClientBuilder()

internal const val QUERY_COMPONENT_REENCODE_SET = " \"'<>#&="
internal const val QUERY_COMPONENT_ENCODE_SET = " !\"#$&'(),/:;<=>?@[]\\^`{|}~"
internal const val QUERY_COMPONENT_ENCODE_SET_URI = "\\^`{|}"
internal const val FORM_ENCODE_SET = " !\"#$&'()+,/:;<=>?@[\\]^`{|}~"
internal const val FRAGMENT_ENCODE_SET = ""
internal const val FRAGMENT_ENCODE_SET_URI = " \"#<>\\^`{|}"

internal fun Buffer.writeCanonicalized(
  input: String,
  pos: Int,

    val actual = component.encodedValue(url)
    if (actual != expected) {
      fail("Encoding $component $codePoint using $encoding: '$actual' != '$expected'")
    }
  }

  private fun testEncodeAndDecode(
    codePoint: Int,
    codePointString: String,
    component: Component,
  ) {
    val builder = "http://host/".toHttpUrl().newBuilder()
    component[builder] = codePointString

  /** 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. */
  @get:JvmName("sslSocketFactory") val sslSocketFactory: SSLSocketFactory?,

 */
class DnsOverHttps internal constructor(
  @get:JvmName("client") val client: OkHttpClient,
  @get:JvmName("url") val url: HttpUrl,
  @get:JvmName("includeIPv6") val includeIPv6: Boolean,
  @get:JvmName("post") val post: Boolean,
  @get:JvmName("resolvePrivateAddresses") val resolvePrivateAddresses: Boolean,
  @get:JvmName("resolvePublicAddresses") val resolvePublicAddresses: Boolean,
) : Dns {
  @Throws(UnknownHostException::class)

  }

  @Test @Ignore
  fun pushPromise() {
    val pushPromise: PushPromise = PushPromise("", "", headersOf(), MockResponse())
    val method: String = pushPromise.method
    val path: String = pushPromise.path
    val headers: Headers = pushPromise.headers
    val response: MockResponse = pushPromise.response
  }

  @Test @Ignore
  fun queueDispatcher() {
    val queueDispatcher: QueueDispatcher = QueueDispatcher()