} else if (data instanceof ArtifactDescriptorRequest request) {
                return "artifact descriptor request for " + request.getArtifact();
            } else if (data instanceof ArtifactRequest request) {
                return "artifact request for " + request.getArtifact();
            } else if (data instanceof Plugin plugin) {
                return "plugin request " + plugin.getId();
            }

        throw IOException(e.message)
      }
    }

    fun matches(
      request: Request,
      response: Response,
    ): Boolean {
      return url == request.url &&
        requestMethod == request.method &&
        varyMatches(response, varyHeaders, request)
    }

    fun response(snapshot: DiskLruCache.Snapshot): Response {

        ":status",
        "200 OK",
        ":version",
        "HTTP/1.1",
        "connection",
        "close",
      )
    val request = Request.Builder().url("http://square.com/").build()
    val response = readHttp2HeadersList(headerBlock, Protocol.HTTP_2).request(request).build()
    val headers = response.headers
    assertThat(headers.size).isEqualTo(1)
    assertThat(headers.name(0)).isEqualTo(":version")

        Set<Artifact> artifacts = request.getArtifactDependencies();
        Map<String, Artifact> managedVersions = request.getManagedVersionMap();
        List<ResolutionListener> listeners = request.getListeners();
        ArtifactFilter collectionFilter = request.getCollectionFilter();
        ArtifactFilter resolutionFilter = request.getResolutionFilter();
        RepositorySystemSession session = getSession(request.getLocalRepository());

        MetadataResolutionRequest request = new DefaultMetadataResolutionRequest();
        injectSession(request);
        request.setArtifact(artifact);
        request.setLocalRepository(localRepository);
        request.setRemoteRepositories(remoteRepositories);
        request.setResolveManagedVersions(resolveManagedVersions);
        return retrieve(request);
    }

    @Override

        ),
      )
      .assertNoMoreLogs()
  }

  @Test
  fun testCacheEvents() {
    val request = Request.Builder().url(url).build()
    val call = client.newCall(request)
    val response =
      Response.Builder().request(request).code(200).message("").protocol(Protocol.HTTP_2)
        .build()
    val listener = loggingEventListenerFactory.create(call)

        request.setNoSnapshotUpdates(options.suppressSnapshotUpdates().orElse(false));
        request.setGoals(options.goals().orElse(List.of()));
        request.setReactorFailureBehavior(determineReactorFailureBehaviour(context));
        request.setRecursive(!options.nonRecursive().orElse(!request.isRecursive()));
        request.setOffline(options.offline().orElse(request.isOffline()));

      MockResponse.Builder()
        .socketPolicy(DisconnectDuringRequestBody)
        .build(),
    )
    val request = NonCompletingRequestBody()
    val call =
      client.newCall(
        Request.Builder()
          .url(server.url("/"))
          .post(request)
          .build(),
      )
    assertFailsWith<IOException> {
      call.execute()
    }

        void onRequestStart(FaultTolerantClient client, RequestData request);

        void onRequest(FaultTolerantClient client, RequestData request, int count);

        void onRequestEnd(FaultTolerantClient client, RequestData request, List<Exception> exceptionList);

        void onException(FaultTolerantClient client, RequestData request, int count, Exception e);

    }

  }

  private fun executeSynchronously(request: Request): RecordedResponse {
    val call = client.newCall(request)
    return try {
      val response = call.execute()
      val bodyString = response.body.string()
      RecordedResponse(request, response, null, bodyString, null)
    } catch (e: IOException) {
      RecordedResponse(request, null, null, null, e)
    }
  }