}
        response =
          responseBuilder
            .request(request)
            .handshake(exchange.connection.handshake())
            .sentRequestAtMillis(sentRequestMillis)
            .receivedResponseAtMillis(System.currentTimeMillis())
            .build()
        code = response.code
      }

      exchange.responseHeadersEnd(response)

            // Both should create valid responses
            Smb2EchoResponse response1 = request1.createResponse(mockContext, request1);
            Smb2EchoResponse response2 = request2.createResponse(mockContext, request2);

            assertNotNull(response1);
            assertNotNull(response2);
            assertNotSame(response1, response2);
        }
    }

    @Nested

    }
    val request =
      Request
        .Builder()
        .url(server.url("/"))
        .build()
    val response = client.newCall(request).execute()
    assertThat(response.body.string()).isEqualTo("ABC")
    assertThat(response.header("OkHttp-Intercepted")).isEqualTo("yep")
    assertThat(response.header("Original-Header")).isEqualTo("foo")
  }

  @Test
  fun multipleApplicationInterceptors() {

    hostname: String,
    response: Response,
  ): List<InetAddress> {
    if (response.cacheResponse == null && response.protocol !== Protocol.HTTP_2 && response.protocol !== Protocol.QUIC) {
      Platform.get().log("Incorrect protocol: ${response.protocol}", Platform.WARN)
    }

    response.use {
      if (!response.isSuccessful) {
        throw IOException("response: " + response.code + " " + response.message)

          .build(),
      )
    call.execute().use { response ->
      assertThat(response.headers)
        .isEqualTo(headersOf("h1", "v1", "h2", "v2"))
      val responseBody = response.body.source()
      assertThat(responseBody.readUtf8(2)).isEqualTo("ok")
      assertThat(responseBody.exhausted()).isTrue()
      assertThat(response.trailers()).isEqualTo(headersOf("trailers", "boom"))
    }

  }

  /**
   * Invoked immediately after receiving response headers.
   *
   * This method is always invoked after [responseHeadersStart].
   *
   * @param response the response received over the network. It is an error to access the body of
   *     this response.
   */
  open fun responseHeadersEnd(
    call: Call,
    response: Response,
  ) {
  }

  /**

                SmbComReadAndXResponse response = invocation.getArgument(1);
                response.dataLength = 1;
                // The response buffer points to the internal tmp buffer
                if (response.b != null && response.off < response.b.length) {
                    response.b[response.off] = 42; // Return byte value 42
                }
                return null;

    route: Route?,
    response: Response,
  ): Request? {
    if (route == null) throw NullPointerException("route == null")
    responses += response
    routes += route
    if (!schemeMatches(response) || credential == null) return null
    val header =
      when (response.code) {
        407 -> "Proxy-Authorization"
        else -> "Authorization"
      }
    return response.request
      .newBuilder()

    private TransTransactNamedPipeResponse response;
    private byte[] outputBuffer;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        outputBuffer = new byte[1024];
        response = new TransTransactNamedPipeResponse(mockConfig, outputBuffer);
    }

    @Test
    void testConstructor() {
        // Verify that the response is created with correct configuration and buffer

import org.codelibs.fess.dict.kuromoji.KuromojiFile;
import org.codelibs.fess.dict.kuromoji.KuromojiItem;
import org.lastaflute.web.Execute;
import org.lastaflute.web.response.JsonResponse;
import org.lastaflute.web.response.StreamResponse;

import jakarta.annotation.Resource;

/**
 * API action for admin Kuromoji dictionary management.