VersionResult result = new VersionResult(request);

        Key cacheKey = null;
        RepositoryCache cache = session.getCache();
        if (cache != null && !ConfigUtils.getBoolean(session, false, "aether.versionResolver.noCache")) {
            cacheKey = new Key(session, request);

            Object obj = cache.get(session, cacheKey);
            if (obj instanceof Record record) {

  ) {
    logWithTime("satisfactionFailure")
  }

  override fun cacheMiss(call: Call) {
    logWithTime("cacheMiss")
  }

  override fun cacheHit(
    call: Call,
    response: Response,
  ) {
    logWithTime("cacheHit")
  }

  override fun cacheConditionalHit(
    call: Call,
    cachedResponse: Response,
  ) {
    logWithTime("cacheConditionalHit")
  }

import kotlin.reflect.KClass
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.junit5.StartStop
import okhttp3.Cache
import okhttp3.CallEvent
import okhttp3.CallEvent.CacheHit
import okhttp3.CallEvent.CacheMiss
import okhttp3.Dns
import okhttp3.EventRecorder
import okhttp3.OkHttpClient
import okhttp3.Protocol
import okhttp3.testing.PlatformRule
import okio.Buffer

document's age at the time it was served based on "Last-Modified". Default expiration dates aren't used for URIs
containing a query.

 - CallStart
 - **CacheHit**
 - CallEnd

### Cache Miss

Under a cache miss the normal request events are seen but an additional event shows the presence of the cache.

    listener.cacheConditionalHit(call, response)
    listener.cacheHit(call, response)
    listener.cacheMiss(call)
    listener.satisfactionFailure(call, response)
    logRecorder
      .assertLogMatch(Regex("""cacheConditionalHit: Response\{protocol=h2, code=200, message=, url=$url\}"""))
      .assertLogMatch(Regex("""cacheHit: Response\{protocol=h2, code=200, message=, url=$url\}"""))

    ) {
      for (delegate in eventListeners) {
        delegate.satisfactionFailure(call, response)
      }
    }

    override fun cacheHit(
      call: Call,
      response: Response,
    ) {
      for (delegate in eventListeners) {
        delegate.cacheHit(call, response)
      }
    }

    override fun cacheMiss(call: Call) {
      for (delegate in eventListeners) {

  private inner class RealCacheRequest(
    private val editor: DiskLruCache.Editor,
  ) : CacheRequest {
    private val cacheOut: Sink = editor.newSink(ENTRY_BODY)
    private val body: Sink
    var done = false

    init {
      this.body =
        object : ForwardingSink(cacheOut) {
          @Throws(IOException::class)
          override fun close() {
            synchronized(this@Cache) {

    if (networkRequest == null) {
      return cacheResponse!!
        .newBuilder()
        .cacheResponse(cacheResponse.stripBody())
        .build()
        .also {
          chain.eventListener.cacheHit(call, it)
        }
    }

    if (cacheResponse != null) {
      chain.eventListener.cacheConditionalHit(call, cacheResponse)
    } else if (cache != null) {
      chain.eventListener.cacheMiss(call)
    }

	public synthetic fun <init> (Lokhttp3/logging/HttpLoggingInterceptor$Logger;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
	public fun cacheConditionalHit (Lokhttp3/Call;Lokhttp3/Response;)V
	public fun cacheHit (Lokhttp3/Call;Lokhttp3/Response;)V
	public fun cacheMiss (Lokhttp3/Call;)V
	public fun callEnd (Lokhttp3/Call;)V
	public fun callFailed (Lokhttp3/Call;Ljava/io/IOException;)V
	public fun callStart (Lokhttp3/Call;)V

    val ioe: IOException,
  ) : CallEvent()

  data class SatisfactionFailure(
    override val timestampNs: Long,
    override val call: Call,
  ) : CallEvent()

  data class CacheHit(
    override val timestampNs: Long,
    override val call: Call,
  ) : CallEvent()

  data class CacheMiss(
    override val timestampNs: Long,
    override val call: Call,
  ) : CallEvent()