throw IOException(npe)
      }
    }
  }

  /**
   * Does all the work to build an HTTPS connection over a proxy tunnel. The catch here is that a
   * proxy server can issue an auth challenge and then close the connection.
   *
   * @return the next plan to attempt, or null if no further attempt should be made either because
   *     we've successfully connected or because no further attempts should be made.
   */

        assertEquals(mockPipe, pipe);
        verify(mockContext).getPipe(url, pipeType);
    }

    @Test
    @DisplayName("Should close context")
    void testClose() throws CIFSException {
        // When
        mockContext.close();

        // Then
        verify(mockContext).close();
    }

    @Test
    @DisplayName("Should get Configuration")
    void testGetConfig() {
        // Given

    /**
     * {@inheritDoc}
     *
     * @throws CIFSException if an error occurs closing the handle
     *
     * @see java.lang.AutoCloseable#close()
     */
    @Override
    void close() throws CIFSException;

    /**
     * Tests whether this file descriptor is open and valid.
     *
     * @return whether the FD is open and valid
     */
    boolean isOpen();

        }
        return delegate.unwrap(type);
    }

    @Override
    public void close() {
        try {
            disconnect(true, false);
        } catch (IOException e) {
            log.warn("Error during RDMA transport close: {}", e.getMessage());
        }
        delegate.close();
    }

    @Override
    public Address getRemoteAddress() {

     */
    @Override
    public SmbResource next() {
        return null;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.CloseableIterator#close()
     */
    @Override
    public void close() throws CIFSException {
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.CloseableIterator#remove()
     */
    @Override
    public void remove() {
    }

     * @return the active configuration
     */
    Configuration getConfig();

    /**
     * {@inheritDoc}
     *
     * @see java.lang.AutoCloseable#close()
     */
    @Override
    void close() throws CIFSException;

    /**
     * Checks whether the tree is currently connected
     * @return the tree is connected
     */
    boolean isConnected();

    /**

    int ERROR_REQ_NOT_ACCEP = 71;
    /** The pipe state is invalid */
    int ERROR_BAD_PIPE = 230;
    /** All pipe instances are busy */
    int ERROR_PIPE_BUSY = 231;
    /** The pipe is being closed */
    int ERROR_NO_DATA = 232;
    /** No process is on the other end of the pipe */
    int ERROR_PIPE_NOT_CONNECTED = 233;
    /** More data is available */
    int ERROR_MORE_DATA = 234;

    int ERROR_REQ_NOT_ACCEP = 71;
    /** The pipe state is invalid */
    int ERROR_BAD_PIPE = 230;
    /** All pipe instances are busy */
    int ERROR_PIPE_BUSY = 231;
    /** The pipe is being closed */
    int ERROR_NO_DATA = 232;
    /** No process is on the other end of the pipe */
    int ERROR_PIPE_NOT_CONNECTED = 233;
    /** More data is available */
    int ERROR_MORE_DATA = 234;

          }
        }
        assertEquals(TlsVersion.TLS_1_3, response.handshake?.tlsVersion)
      }
    } finally {
      Security.removeProvider("Conscrypt")
      client.close()
    }
  }

  @Test
  fun testConscryptRequestLocalhostInsecure() {
    try {
      Security.insertProviderAt(Conscrypt.newProviderBuilder().build(), 1)

      val clientCertificates =

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  private var client = clientTestRule.newClient()

  @AfterEach internal fun tearDown() {
    factory.close()
  }

  @Test fun nonRetryableIOException() {
    val exception = IOException("Non-handshake exception")
    assertThat(retryTlsHandshake(exception)).isFalse()
  }