fun redactQueryParams(vararg name: String) {
      val newQueryParamsNameToRedact = TreeSet(String.CASE_INSENSITIVE_ORDER)
      newQueryParamsNameToRedact += queryParamsNameToRedact
      newQueryParamsNameToRedact.addAll(name)
      queryParamsNameToRedact = newQueryParamsNameToRedact
    }

    /**
     * Sets the level and returns this.
     *

    body: String = "",
    inTunnel: Boolean = false,
    socketPolicy: SocketPolicy = KeepOpen,
  ) : this(
    Builder()
      .apply {
        this.code = code
        this.headers.addAll(headers)
        if (inTunnel) inTunnel()
        this.body(body)
        this.socketPolicy = socketPolicy
      },
  )

  private constructor(builder: Builder) {
    this.status = builder.status

      value: String,
    ) = apply {
      headersCheckName(name)
      addLenient(name, value)
    }

    /**
     * Adds all headers from an existing collection.
     */
    fun addAll(headers: Headers) = commonAddAll(headers)

    /**
     * Add a header with the specified name and formatted date. Does validation of header names and
     * value.
     */
    fun add(
      name: String,

  fun headersBuilder() {
    var builder: Headers.Builder = Headers.Builder()
    builder = builder.add("")
    builder = builder.add("", "")
    builder = builder.addUnsafeNonAscii("", "")
    builder = builder.addAll(headersOf())
    builder = builder.add("", Date(0L))
    builder = builder.add("", Instant.EPOCH)
    builder = builder.set("", "")
    builder = builder.set("", Date(0L))
    builder = builder.set("", Instant.EPOCH)

    builder.interceptors().addAll(listOf(null) as List<Interceptor>)
    assertFailsWith<IllegalStateException> {
      builder.build()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Null interceptor: [null]")
    }
  }

  @Test fun nullNetworkInterceptorInList() {
    val builder = OkHttpClient.Builder()
    builder.networkInterceptors().addAll(listOf(null) as List<Interceptor>)

    val expectedEvents2 =
      mutableListOf<String>().apply {
        add("CallStart")
        if (connectionType != H2) {
          addAll(listOf("ConnectStart", "ConnectEnd"))
        }
        addAll(listOf("ConnectionAcquired", "ConnectionReleased", "CallEnd"))
      }

    assertThat(events2).isEqualTo(expectedEvents2)
  }

  private fun isConnectionEvent(it: CallEvent?) =

    results: MutableList<InetAddress>,
    failures: MutableList<Exception>,
  ) {
    try {
      val addresses = readResponse(hostname, response)
      synchronized(results) {
        results.addAll(addresses)
      }
    } catch (e: Exception) {
      synchronized(failures) {
        failures.add(e)
      }
    }
  }

  @Throws(UnknownHostException::class)
  private fun throwBestFailure(