}

  /**
   * Returns a new {@code Future} whose result is asynchronously derived from the result of this
   * {@code Future}. If the input {@code Future} fails, the returned {@code Future} fails with the
   * same exception (and the function is not invoked).
   *
   * <p>More precisely, the returned {@code Future} takes its result from a {@code Future} produced

        is SSLHandshakeException -> {
          // On Android, the handshake fails before the certificate pinner runs.
          assertThat(expected.message!!).contains("Could not validate certificate")
        }
        is SSLPeerUnverifiedException -> {
          // On OpenJDK, the handshake succeeds but the certificate pinner fails.
          assertThat(expected.message!!).startsWith("Certificate pinning failure!")
        }

    /**
     * Creates a new witness RPC client.
     *
     * @param serverAddress the witness server address
     * @param context the CIFS context
     * @throws IOException if connection fails
     */
    public WitnessRpcClient(InetAddress serverAddress, CIFSContext context) throws IOException {
        this.serverAddress = serverAddress;
        this.context = context;

        try {

        // Verify GCS Storage client is not initialized before connect() is called
        assertNull(getField(conn, "storage"));
    }

    /**
     * Test that connect() method fails when GCS_PROJECT_ID is not set.
     */
    public void test_connect_failsWithoutProjectId() throws Exception {
        URL url = new URL("gcs://mybucket/object.txt");
        Handler handler = new Handler();

            }
        }
    }

    /**
     * Decodes MIME-encoded text.
     *
     * @param value the encoded text to decode
     * @return the decoded text or empty string if decoding fails
     */
    protected String getDecodeText(final String value) {
        if (value == null) {
            return StringUtil.EMPTY;
        }
        try {
            return MimeUtility.decodeText(value);

     *
     * @param target The object to convert to JSON.
     * @return The XContentBuilder containing the JSON representation of the target.
     * @throws OpenSearchAccessException if the conversion fails.
     */
    protected XContentBuilder getXContentBuilder(final Object target) {
        try {
            final XContentBuilder builder = jsonBuilder().value(target);
            builder.flush();

  /**
   * Simulate some of the races that can happen on add. We can't easily simulate the race that
   * happens when an {@link AtomicInteger#compareAndSet} fails, but we can simulate the case where
   * the putIfAbsent returns a non-null value, and the case where the replace() of an observed zero
   * fails.
   */
  public void testAdd_withFailures() {
    AtomicInteger existing = new AtomicInteger(12);

     * Gets the map of trusted domains for DFS resolution
     * @param auth the authentication credentials
     * @return a map of trusted domain names to domain controllers
     * @throws SmbAuthException if authentication fails
     */
    public HashMap getTrustedDomains(final NtlmPasswordAuthentication auth) throws SmbAuthException {
        if (DISABLED || auth.domain == "?") {
            return null;
        }

   */
  open fun connectEnd(
    call: Call,
    inetSocketAddress: InetSocketAddress,
    proxy: Proxy,
    protocol: Protocol?,
  ) {
  }

  /**
   * Invoked when a connection attempt fails. This failure is not terminal if further routes are
   * available and failure recovery is enabled.
   *
   * If the `call` uses HTTPS, this will be invoked after [secureConnectStart], otherwise it will

     * @param salt the preauth salt from negotiation
     * @param hashAlgorithm the selected hash algorithm
     * @return the created context
     * @throws CIFSException if initialization fails
     */
    public PreauthIntegrityContext initializeSession(String sessionId, byte[] salt, int hashAlgorithm) throws CIFSException {
        if (sessionId == null || sessionId.isEmpty()) {