policy:

```java
HandshakeCertificates serverCertificates = new HandshakeCertificates.Builder()
    .heldCertificate(localhostCertificate)
    .build();
MockWebServer server = new MockWebServer();
server.useHttps(serverCertificates.sslSocketFactory(), false);
```

`HandshakeCertificates` also works for clients where its job is to define which root certificates

          handshakeCertificates.trustManager,
        )
        .hostnameVerifier(RecordingHostnameVerifier())
        .build()
    server1.useHttps(handshakeCertificates.sslSocketFactory())
    server2.useHttps(handshakeCertificates.sslSocketFactory())
  }

  private fun executeSynchronously(request: Request): RecordedResponse {
    val call = client.newCall(request)
    return try {

    noRecoverWhenRetryOnConnectionFailureIsFalse()
  }

  @Test
  fun tlsHandshakeFailure_noFallbackByDefault() {
    platform.assumeNotBouncyCastle()

    server.useHttps(handshakeCertificates.sslSocketFactory())
    server.enqueue(MockResponse(socketPolicy = FailHandshake))
    server.enqueue(MockResponse(body = "response that will never be received"))

    client =
      client.newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        )
        .build()
    server.useHttps(handshakeCertificates.sslSocketFactory())
  }

      OkHttpClient.Builder()
        .dns(AsyncDns.toDns(AndroidAsyncDns.IPv4, AndroidAsyncDns.IPv6))
        .sslSocketFactory(localhost.sslSocketFactory(), localhost.trustManager)
        .build()

    serverRule.server.useHttps(localhost.sslSocketFactory())
  }

  @Test
  @Ignore("java.net.UnknownHostException: No results for localhost, in CI.")
  fun testRequest() {
    serverRule.server.enqueue(MockResponse())

        }

      fileSystem.write(metadataFile) {
        writeUtf8(corruptor(contents))
      }
    }
  }

  private fun testCorruptingCache(corruptor: () -> Unit): Response {
    server.useHttps(handshakeCertificates.sslSocketFactory())
    server.enqueue(
      MockResponse(
        headers =
          headersOf(
            "Last-Modified",
            formatDate(-1, TimeUnit.HOURS)!!,

    this.sslContext = sslContext;
    this.root = root;
    this.port = port;
  }

  public void run() throws IOException {
    MockWebServer server = new MockWebServer();
    server.useHttps(sslContext.getSocketFactory(), false);
    server.setDispatcher(this);
    server.start(port);
  }

  @Override public MockResponse dispatch(RecordedRequest request) {
    String path = request.getPath();
    try {

                              }
                            },
                          )
                      }
                  }
                }
              }
            server.useHttps(serverSslSocketFactory)
          } else if (socketMode == Channel) {
            socketFactory(ChannelSocketFactory())
          }
        }
        .build()

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

    client =
      client.newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        )
        .build()
    server.useHttps(handshakeCertificates.sslSocketFactory())
  }

    client =
      client.newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        )
        .build()
    server.useHttps(handshakeCertificates.sslSocketFactory())
  }