*/
internal sealed class Tags {
  /**
   * Returns a tags instance that maps [key] to [value]. If [value] is null, this returns a tags
   * instance that does not have any mapping for [key].
   */
  abstract fun <T : Any> plus(
    key: KClass<T>,
    value: T?,
  ): Tags

  abstract operator fun <T : Any> get(key: KClass<T>): T?
}

  override fun <T : Any> tag(type: KClass<T>): T? = error("unexpected")

  override fun <T> tag(type: Class<out T>): T? = error("unexpected")

  override fun <T : Any> tag(
    type: KClass<T>,
    computeIfAbsent: () -> T,
  ): T = error("unexpected")

  override fun <T : Any> tag(
    type: Class<T>,
    computeIfAbsent: () -> T,
  ): T = error("unexpected")

import kotlin.reflect.KClass
import okhttp3.internal.concurrent.TaskRunner
import okhttp3.internal.http2.Http2

object OkHttpDebugLogging {
  // Keep references to loggers to prevent their configuration from being GC'd.
  private val configuredLoggers = CopyOnWriteArraySet<Logger>()

  fun enableHttp2() = enable(Http2::class)

  fun enableTaskRunner() = enable(TaskRunner::class)

  fun logHandler() =

//
// Rules
// 1. an extension should either require no type parameters, a single reifeid type parameter, at call site
// 2. all type parameters must all be reifeid or values (TypeOf, KClass or Class)
// 3. when overloading, prefer TypeOf over Class
// 4. in case the policy forbids your overloads, discuss
private
fun kotlinExtensionFunctionsFor(type: ApiType, sinceSupplier: (String) -> String?): Sequence<KotlinExtensionFunction> =

    }

    private
    inline fun <reified Receiver> groovyReceiverAccessors(): String {
        return groovyReceiverAccessors(Receiver::class)
    }

    private
    fun groovyReceiverAccessors(receiverType: KClass<*>): String {
        val objectMethods = Any::class.java.declaredMethods.toList()
        return receiverType
            .memberFunctions
            .asSequence()

   * val copy = original.clone()
   *
   * val myTag = original.tag(MyTag::class)
   * if (myTag != null) {
   *   copy.tag(MyTag::class) { myTag }
   * }
   * ```
   *
   * ```java
   * Call copy = original.clone();
   *
   * MyTag myTag = original.tag(MyTag.class);
   * if (myTag != null) {
   *   copy.tag(MyTag.class, () -> myTag);
   * }
   * ```
   *

    }

    val expectedEvents = mutableListOf<KClass<out CallEvent>>()
    // Start out with standard events...
    expectedEvents += CallStart::class
    expectedEvents += ProxySelectStart::class
    expectedEvents += ProxySelectEnd::class
    expectedEvents += DnsStart::class
    expectedEvents += DnsEnd::class
    expectedEvents += ConnectStart::class
    if (https) {
      expectedEvents += SecureConnectStart::class

  @JvmName("reifiedTag")
  inline fun <reified T : Any> tag(): T? = tag(T::class)

  /** Returns the tag attached with [type] as a key, or null if no tag is attached with that key. */
  fun <T : Any> tag(type: KClass<T>): T? = type.java.cast(tags[type])

  /**
   * Returns the tag attached with `Object.class` as a key, or null if no tag is attached with
   * that key.
   *

    assertThat(recordedRequest.url.encodedQuery)
      .isEqualTo("ct&dns=AAABAAABAAAAAAAABmdvb2dsZQNjb20AAAEAAQ")

    assertThat(cacheEvents()).containsExactly(CacheMiss::class)
  }

  private fun cacheEvents(): List<KClass<out CallEvent>> =
    eventRecorder
      .recordedEventTypes()
      .filter { "Cache" in it.simpleName!! }
      .also { eventRecorder.clearAllEvents() }

  }

  override fun <T : Any> tag(type: KClass<T>): T? = type.java.cast(tags.get()[type])

  override fun <T> tag(type: Class<out T>): T? = tag(type.kotlin)

  override fun <T : Any> tag(
    type: KClass<T>,
    computeIfAbsent: () -> T,
  ): T = tags.computeIfAbsent(type, computeIfAbsent)

  override fun <T : Any> tag(
    type: Class<T>,
    computeIfAbsent: () -> T,