fun secondCallEventSequence() {
    enableTls()
    server.protocols = listOf(Protocol.HTTP_2, Protocol.HTTP_1_1)
    server.enqueue(MockResponse())
    server.enqueue(MockResponse())

    client
      .newCall(Request(server.url("/")))
      .execute()
      .close()

    client
      .newCall(Request(server.url("/")))
      .execute()
      .close()

			t.Fatalf("Case %v: server.Addrs: expected: %v, got: %v", (i + 1), testCase.addrs, server.Addrs)
		}

		if testCase.certFn == nil {
			if server.TLSConfig != nil {
				t.Fatalf("Case %v: server.TLSConfig: expected: <nil>, got: %v", (i + 1), server.TLSConfig)
			}
		} else {
			if server.TLSConfig == nil {
				t.Fatalf("Case %v: server.TLSConfig: expected: <non-nil>, got: <nil>", (i + 1))
			}
		}

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

        .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()

install --set tls.enabled=true,tls.certSecret=tls-ssl-minio minio/minio ``` ### Installing certificates from third party CAs MinIO can connect to other servers, including MinIO nodes or other server types such as NATs and Redis. If these servers use certificates that were not registered with a known CA, add trust for these certificates to MinIO Server by bundling these certificates into a Kubernetes secret and providing it to Helm via the `trustedCertsSecret` value. If `.Values.tls.enabled` is `true`...

install --set tls.enabled=true,tls.certSecret=tls-ssl-minio minio/minio ``` ### Installing certificates from third party CAs MinIO can connect to other servers, including MinIO nodes or other server types such as NATs and Redis. If these servers use certificates that were not registered with a known CA, add trust for these certificates to MinIO Server by bundling these certificates into a Kubernetes secret and providing it to Helm via the `trustedCertsSecret` value. If `.Values.tls.enabled` is `true`...

        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());

    public static final String PROXY_HTTP = "HTTP";

    /**
     * Proxy server host
     */
    private String host;

    /**
     * Username used to access the proxy server
     */
    private String userName;

    /**
     * Password associated with the proxy server
     */
    private String password;

    /**
     * Proxy server port
     */
    private int port;

    /**

	// and positive values indicating number of read locks
	lockMap map[string]int64

	// Refresh returns lock not found if set to true
	lockNotFound bool

	// Set to true if you want peers servers to do not respond
	responseDelay int64
}

func (l *lockServer) setRefreshReply(refreshed bool) {
	l.mutex.Lock()
	defer l.mutex.Unlock()
	l.lockNotFound = !refreshed
}