new FinalizablePhantomReference<MyServerExampleWithFrq>(myServer, frq) {
            @Override
            public void finalizeReferent() {
              references.remove(this);
              if (!serverSocket.isClosed()) {
                try {
                  serverSocket.close();
                  finalizeReferentRan.set(true);
                } catch (IOException e) {
                  throw new UncheckedIOException(e);

  @Synchronized
  @Throws(IOException::class)
  override fun flush() {
    if (!initialized) return

    checkNotClosed()
    trimToSize()
    journalWriter!!.flush()
  }

  @Synchronized fun isClosed(): Boolean = closed

  /** Closes this cache. Stored values will remain on the filesystem. */
  @Synchronized
  @Throws(IOException::class)
  override fun close() {
    if (!initialized || closed) {

        assertFalse(auth.isClosed());

        // Close multiple times
        auth.close();
        assertTrue(auth.isClosed());

        auth.close(); // Should not throw
        assertTrue(auth.isClosed());

        auth.close(); // Should still not throw
        assertTrue(auth.isClosed());
    }

    /**

    }

    /**
     * Stop the mock witness service
     */
    public void stop() {
        running.set(false);

        if (serverSocket != null && !serverSocket.isClosed()) {
            try {
                serverSocket.close();
            } catch (IOException e) {
                log.debug("Error closing server socket", e);
            }
        }

  fun sleepWhileOpen(nanos: Long) {
    var ms = nanos / 1_000_000L
    val ns = nanos - (ms * 1_000_000L)

    while (ms > 100) {
      Thread.sleep(100)
      if (javaNetSocket.isClosed) throw InterruptedIOException("socket closed")
      ms -= 100L
    }

    if (ms > 0L || ns > 0) {
      Thread.sleep(ms, ns.toInt())
    }
  }

  override fun cancel() {
    delegate.cancel()

 *     Reference<?> reference = new FinalizablePhantomReference<MyServer>(myServer, frq) {
 *       @Override
 *       public void finalizeReferent() {
 *         references.remove(this):
 *         if (!serverSocket.isClosed()) {
 *           ...log a message about how nobody called close()...
 *           try {
 *             serverSocket.close();
 *           } catch (IOException e) {
 *             ...
 *           }
 *         }

        Socket s = mock(Socket.class);
        when(s.isClosed()).thenReturn(false);
        setField(transport, "socket", s);

        // Act & Assert
        assertFalse(transport.isDisconnected());
        assertFalse(transport.isFailed());

        // Close socket -> both should be true
        when(s.isClosed()).thenReturn(true);
        assertTrue(transport.isDisconnected());

  fun isHealthy(doExtensiveChecks: Boolean): Boolean {
    assertLockNotHeld()

    val nowNs = System.nanoTime()

    if (rawSocket.isClosed ||
      javaNetSocket.isClosed ||
      javaNetSocket.isInputShutdown ||
      javaNetSocket.isOutputShutdown
    ) {
      return false
    }

    val http2Connection = this.http2Connection

 *     Reference<?> reference = new FinalizablePhantomReference<MyServer>(myServer, frq) {
 *       @Override
 *       public void finalizeReferent() {
 *         references.remove(this):
 *         if (!serverSocket.isClosed()) {
 *           ...log a message about how nobody called close()...
 *           try {
 *             serverSocket.close();
 *           } catch (IOException e) {
 *             ...
 *           }
 *         }

		defer c.connMu.Unlock()
		c.clientPingInterval, _ = args[0].(time.Duration)
	case debugAddToDeadline:
		c.addDeadline, _ = args[0].(time.Duration)
	case debugIsOutgoingClosed:
		// params: muxID uint64, isClosed func(bool)
		muxID, _ := args[0].(uint64)
		resp, _ := args[1].(func(b bool))
		mid, ok := c.outgoing.Load(muxID)
		if !ok || mid == nil {
			resp(true)
			return
		}
		mid.respMu.Lock()