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

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

    /**

`TryRead` and `TryWrite` are still available for non-blocking reads and writes.

To signify the end of the stream, close the ring buffer from the writer side with `rb.CloseWriter()`

Either side can use `rb.CloseWithError(err error)` to signal an error and close the ring buffer. 
Any reads or writes will return the error on next call.

   *     method
   * @throws IOException if {@code swallowIOException} is false and {@link Flushable#flush} throws
   *     an {@code IOException}.
   * @see Closeables#close
   */
  @SuppressWarnings("IdentifierName") // See Closeables.close
  public static void flush(Flushable flushable, boolean swallowIOException) throws IOException {
    try {
      flushable.flush();
    } catch (IOException e) {

    /**
     * {@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();

  fun shutdown() {
    delegate.close()
  }

  @Synchronized override fun after() {
    try {
      shutdown()
    } catch (e: IOException) {
      logger.log(Level.WARNING, "MockWebServer shutdown failed", e)
    }
  }

  override fun toString(): String = delegate.toString()

  @Throws(IOException::class)
  override fun close() = delegate.close()

  companion object {

          for (int i = 2; i <= 997; i++) {
            System.out.println(i);
            Thread.sleep(10);
            sink.writeUtf8(String.format(" * %s = %s\n", i, factor(i)));
          }
          sink.close();
        } catch (IOException | InterruptedException e) {
          e.printStackTrace();
        }
      }

      private String factor(int n) {
        for (int i = 2; i < n; i++) {
          int x = n / i;

                fos = null; // Successfully wrapped, no need to close explicitly
            } catch (final Exception e) {
                if (fos != null) {
                    try {
                        fos.close();
                    } catch (final IOException ioe) {
                        // Ignore close exception
                    }
                }
                if (newFile != null) {

                                                </h4>
                                                <button type="button" class="close" data-dismiss="modal"
                                                        aria-label="Close">
                                                    <span aria-hidden="true">&times;</span>
                                                </button>

        final String content = "Small content";
        final FileOutputStream out = new FileOutputStream(file);
        try {
            out.write(content.getBytes("UTF-8"));
        } finally {
            out.close();
        }

        // Set maxSize larger than file size
        final byte[] bytes = FileUtil.readBytes(file, 1024);
        assertThat(new String(bytes, "UTF-8"), is(content));
    }

    /**