if (networkRequest == null && cacheResponse == null) {
      return Response
        .Builder()
        .request(chain.request())
        .protocol(Protocol.HTTP_1_1)
        .code(HTTP_GATEWAY_TIMEOUT)
        .message("Unsatisfiable Request (only-if-cached)")
        .sentRequestAtMillis(-1L)
        .receivedResponseAtMillis(System.currentTimeMillis())
        .build()
        .also {

            throws MavenExecutionException {
        List<MavenProject> result = projects;

        if (request.getResumeFrom() != null && !request.getResumeFrom().isEmpty()) {
            File reactorDirectory = projectSelector.getBaseDirectoryFromRequest(request);

            String selector = request.getResumeFrom();

    server.enqueue(MockResponse(body = "b"))
    val request = Request(server.url("/"))
    assertConnectionReused(request, request)
  }

  @Test
  fun connectionsAreReusedForPosts() {
    server.enqueue(MockResponse(body = "a"))
    server.enqueue(MockResponse(body = "b"))
    val request =
      Request(
        url = server.url("/"),
        body = "request body".toRequestBody("text/plain".toMediaType()),
      )

        .header("User-Agent", "user request")
        .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

    void testSequentialOperations() {
        // Given
        request.setNotifyFlags(0);
        request.setCompletionFilter(0);

        // When - first write
        byte[] buffer1 = new byte[512];
        request.writeBytesWireFormat(buffer1, 0);

        // Update values
        request.setNotifyFlags(Smb2ChangeNotifyRequest.SMB2_WATCH_TREE);
        request.setCompletionFilter(0xFFF);

        // Second write

        assertEquals(1024, request.size());
        assertEquals(Integer.valueOf(5000), request.getOverrideTimeout());

        verify(request, times(1)).isResponseAsync();
        verify(request, times(1)).getNext();
        verify(request, times(1)).split();
        verify(request, times(1)).allowChain(nextRequest);
        verify(request, times(1)).createCancel();
        verify(request, times(1)).size();

}

// LDAPIdentityResult - contains credentials for a successful
// AssumeRoleWithLDAPIdentity request.
type LDAPIdentityResult struct {
	Credentials auth.Credentials `xml:",omitempty"`
}

// AssumeRoleWithCertificateResponse contains the result of
// a successful AssumeRoleWithCertificate request.
type AssumeRoleWithCertificateResponse struct {

   * the response; it only means we have to validate the response with the origin server before
   * returning it. We can do this with a conditional GET.
   *
   * In a request, it means do not use a cache to satisfy the request.
   */
  @get:JvmName("noCache") val noCache: Boolean,
  /** If true, this response should not be cached. */
  @get:JvmName("noStore") val noStore: Boolean,

import jcifs.internal.smb2.create.CreateContextRequest;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Durable Handle V2 Request Create Context (DH2Q)
 *
 * MS-SMB2 Section 2.2.13.2.4
 */
public class DurableHandleV2Request implements CreateContextRequest {

    /**
     * Context name for durable handle V2 request
     */
    public static final String CONTEXT_NAME = "DH2Q";

    // TODO test jdk.tls.client.enableSessionTicketExtension
    // TODO check debugging information

    enableTls()

    server.enqueue(MockResponse(body = "abc"))

    val request = Request(server.url("/"))

    val response = client.newCall(request).execute()

    response.use {
      assertEquals(200, response.code)
      if (PlatformVersion.majorVersion > 11) {