private val handshakeCertificates = platform.localhostHandshakeCertificates()

  @StartStop
  private val server = MockWebServer()

  @Test
  fun legalToExecuteTwiceCloning() {
    server.enqueue(MockResponse(body = "abc"))
    server.enqueue(MockResponse(body = "def"))

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

    val call = client.newCall(request)
    val response1 = call.execute()

    val cloned = call.clone()

class InterceptorTest {
  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  @StartStop
  private val server = MockWebServer()

  private var client = clientTestRule.newClient()
  private val callback = RecordingCallback()

  @Test
  fun applicationInterceptorsCanShortCircuitResponses() {
    server.close() // Accept no connections.
    val request =
      Request
        .Builder()

      ),
    )
    server.enqueue(MockResponse(body = "This is the new location!"))
    val call = client.newCall(Request(server.url("/")))
    val response = call.execute()
    assertThat(response.body.string()).isEqualTo("This is the new location!")
    val request1 = server.takeRequest()
    assertThat(request1.url.encodedPath).isEqualTo("/")
    val request2 = server.takeRequest()

        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .code(HttpURLConnection.HTTP_MOVED_TEMP)
        .setHeader("Location", "/f")
        .headersDelay(100, TimeUnit.MILLISECONDS)
        .build(),
    )
    server.enqueue(MockResponse())
    val request =
      Request
        .Builder()
        .url(server.url("/a"))
        .build()

    /**
     * Server supports leasing
     */
    public static final int SMB2_GLOBAL_CAP_LEASING = 0x2;

    /**
     * Server supports multi-credit operations
     */
    public static final int SMB2_GLOBAL_CAP_LARGE_MTU = 0x4;

    /**
     * Server supports multi-channel connections
     */
    public static final int SMB2_GLOBAL_CAP_MULTI_CHANNEL = 0x8;

    /**
     * Server supports persistent handles

            assertEquals(null, new SmbFile("smb1://server/").getShare());
        }

        @Test
        public void testGetServer() throws MalformedURLException {
            assertEquals("server", new SmbFile("smb1://server/share/file.txt").getServer());
            assertEquals("server", new SmbFile("smb1://server/").getServer());
            assertEquals(null, new SmbFile("smb1://").getServer());
        }

        requestWithPath.setFullUNCPath(domain, server, fullPath);

        verify(requestWithPath, times(1)).setFullUNCPath(domain, server, fullPath);

        // Test with implementation
        testImplementation.setFullUNCPath(domain, server, fullPath);
        assertEquals(domain, testImplementation.getDomain());
        assertEquals(server, testImplementation.getServer());

     * @param server the server name (null defaults to local server)
     * @param access the desired access rights
     * @throws IOException if an I/O error occurs during handle creation
     */
    public SamrPolicyHandle(final DcerpcHandle handle, String server, final int access) throws IOException {
        this.handle = handle;
        if (server == null) {
            server = "\\\\";
        }

  }

  @Test
  fun upgradesOnReusedConnection() {
    server.enqueue(MockResponse(body = "normal request"))
    client.newCall(Request(server.url("/"))).execute().use { response ->
      assertThat(response.body.string()).isEqualTo("normal request")
    }

    upgrade()

    assertThat(server.takeRequest().connectionIndex).isEqualTo(0)
    assertThat(server.takeRequest().connectionIndex).isEqualTo(0)
  }

  @Test

        .Builder()
        .heldCertificate(heldCertificate)
        .build()
    server.useHttps(serverCertificates.sslSocketFactory())
    server.enqueue(MockResponse())

    val clientCertificates =
      HandshakeCertificates
        .Builder()
        .addPlatformTrustedCertificates()
        .addInsecureHost(server.hostName)
        .build()

    val client =
      clientTestRule