}

  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)
    }
  }

        // spec says that we may repeat the request without modifications. Modern browsers also
        // repeat the request (even non-idempotent ones.)
        if (!client.retryOnConnectionFailure) {
          // The application layer has directed us not to retry the request.
          return null
        }

        val requestBody = userResponse.request.body
        if (requestBody != null && requestBody.isOneShot()) {

		{
			Expression: "request.user == 'alice'",
		},
		{
			Expression: "request.uid == '1'",
		},
		{
			Expression: "('group1' in request.groups)",
		},
		{
			Expression: "('key1' in request.extra)",
		},
		{
			Expression: "!('key2' in request.extra)",
		},
		{
			Expression: "('a' in request.extra['key1'])",
		},
		{
			Expression: "!('z' in request.extra['key1'])",
		},

	}

	globalActiveCred = creds
	testCases := []struct {
		Request *http.Request
		ErrCode APIErrorCode
	}{
		{Request: mustNewRequest(http.MethodGet, "http://127.0.0.1:9000", 0, nil, t), ErrCode: ErrAccessDenied},
		{Request: mustNewSignedRequest(http.MethodGet, "http://127.0.0.1:9000", 0, nil, t), ErrCode: ErrNone},

			},
		},
		{
			name: "valid request",
			expressions: []string{
				"request.kind.group == 'example.com' && request.kind.version == 'v1' && request.kind.kind == 'Fake'",
				"request.resource.group == 'example.com' && request.resource.version == 'v1' && request.resource.resource == 'fake' && request.subResource == 'scale'",

        PluginResolutionResult result;
        try {
            result = resolver.resolve(request);
        } catch (Exception e) {
            throw new LocationAwareException(
                new GradleException(String.format("Error resolving plugin %s", request.getDisplayName()), e),
                request.getScriptDisplayName(), request.getLineNumber());
        }

        setProcessPlugins(request.isProcessPlugins());
        setTwoPhaseBuilding(request.isTwoPhaseBuilding());
        setLocationTracking(request.isLocationTracking());
        setProfiles(request.getProfiles());
        setActiveProfileIds(request.getActiveProfileIds());
        setInactiveProfileIds(request.getInactiveProfileIds());
        setSystemProperties(request.getSystemProperties());
        setUserProperties(request.getUserProperties());

        .build()
    val response = client.newCall(request).execute()
    assertThat(response.request.header("User-Agent")).isNotNull()
    assertThat(response.request.header("User-Agent")).isEqualTo("user request")
    assertThat(response.networkResponse!!.request.header("User-Agent")).isEqualTo(
      "intercepted request",
    )
  }

  @Test
  fun applicationInterceptorThrowsRuntimeExceptionAsynchronous() {

	// been timed out by the apiserver.
	PostTimeoutHandlerPanic = "panic"

	// The executing request handler has returned an error to the post-timeout
	// receiver after the request had been timed out by the apiserver.
	PostTimeoutHandlerError = "error"

	// The executing request handler has returned a result to the post-timeout
	// receiver after the request had been timed out by the apiserver.

	if knativeEnv != "" && firstRequest.Load() {
		// How scaling works in knative is the first request is the "loading" request. During
		// loading request, concurrency=1. Once that request is done, concurrency is enabled.
		// However, the XDS stream is long lived, so the first request would block all others. As a
		// result, we should exit the first request immediately; clients will retry.
		firstRequest.Store(false)