plan = this,
        nextPlan = retryTlsConnection,
        throwable = e,
      )
    } finally {
      call.plansToCancel -= this
      if (!success) {
        javaNetSocket?.closeQuietly()
        rawSocket.closeQuietly()
      }
    }
  }

  /** Does all the work necessary to build a full HTTP or HTTPS connection on a raw socket. */
  @Throws(IOException::class)
  private fun connectSocket() {

        closeQuietly(viewPath);
        final Path imagePath = ResourceUtil.getImagePath(themeName);
        closeQuietly(imagePath);
        final Path cssPath = ResourceUtil.getCssPath(themeName);
        closeQuietly(cssPath);
        final Path jsPath = ResourceUtil.getJavaScriptPath(themeName);
        closeQuietly(jsPath);
    }

    /**

        connection.start()
      } catch (e: IOException) {
        logger.log(Level.INFO, "Http2Server connection failure: $e")
        socket?.closeQuietly()
      } catch (e: Exception) {
        logger.log(Level.WARNING, "Http2Server unexpected failure", e)
        socket?.closeQuietly()
      }
    }
  }

  private fun doSsl(socket: Socket): SSLSocket {
    val sslSocket =
      sslSocketFactory.createSocket(

        inFrames.add(inFrame)
      }
    }
  }

  fun openSocket(): Socket = Socket("localhost", port)

  @Synchronized override fun close() {
    executor.shutdown()
    socket?.closeQuietly()
    serverSocket?.closeQuietly()
  }

  override fun toString(): String = "MockHttp2Peer[$port]"

  private class OutFrame(
    val sequence: Int,
    val start: Long,
    val truncated: Boolean,
  )

            try {
              checkUpgradeSuccess(response)
            } catch (e: IOException) {
              failWebSocket(e, response)
              response.closeQuietly()
              response.socket?.sink?.closeQuietly()
              response.socket?.source?.closeQuietly()
              return
            }

          // Apply the extensions. If they're unacceptable initiate a graceful shut down.

   *
   * @param inputStream the input stream to be closed, or {@code null} in which case this method
   *     does nothing
   * @since 17.0
   */
  public static void closeQuietly(@Nullable InputStream inputStream) {
    try {
      close(inputStream, true);
    } catch (IOException impossible) {
      throw new AssertionError(impossible);
    }
  }

  /**

package okhttp3.internal.cache

import java.io.Closeable
import java.io.EOFException
import java.io.Flushable
import java.io.IOException
import okhttp3.internal.cache.DiskLruCache.Editor
import okhttp3.internal.closeQuietly
import okhttp3.internal.concurrent.Lockable
import okhttp3.internal.concurrent.Task
import okhttp3.internal.concurrent.TaskRunner
import okhttp3.internal.concurrent.assertLockHeld
import okhttp3.internal.deleteContents

        }
    }

    /**
     * Closes a {@link Closeable} quietly, suppressing any {@link IOException}.
     *
     * @param closeable the closeable object
     */
    public static void closeQuietly(final Closeable closeable) {
        if (closeable == null) {
            return;
        }
        try {
            closeable.close();
        } catch (final IOException e) {
            // ignore
        }

        maskCursor.close()
      }
    }

    sinkBuffer.write(messageBuffer, dataSize)
    sink.flush()
  }

  override fun close() {
    messageDeflater?.closeQuietly()
    sink.closeQuietly()
  }

import javax.net.SocketFactory
import javax.net.ssl.SSLSocket
import okhttp3.Handshake
import okhttp3.Handshake.Companion.handshake
import okhttp3.TestUtil.threadFactory
import okhttp3.internal.closeQuietly
import okhttp3.testing.PlatformRule
import okio.ByteString.Companion.toByteString
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test