client.dispatcher.executorService.shutdownNow()

    val exception = callFailure.get(5, TimeUnit.SECONDS)
    assertThat(exception.message).isEqualTo("canceled due to java.lang.InterruptedException")
    assertThat(exception).isInstanceOf<IOException>()
    assertThat(exception.cause)
      .isNotNull()
      .isInstanceOf<InterruptedException>()
  }

	public fun cacheMiss (Lokhttp3/Call;)V
	public fun callEnd (Lokhttp3/Call;)V
	public fun callFailed (Lokhttp3/Call;Ljava/io/IOException;)V
	public fun callStart (Lokhttp3/Call;)V
	public fun canceled (Lokhttp3/Call;)V
	public fun connectEnd (Lokhttp3/Call;Ljava/net/InetSocketAddress;Ljava/net/Proxy;Lokhttp3/Protocol;)V

  private val webSocketCloseTimeout: Long,
) : WebSocket,
  WebSocketReader.FrameCallback,
  Lockable {
  private val key: String

  /** Non-null for client web sockets. These can be canceled. */
  internal var call: Call? = null

  /** This task processes the outgoing queues. Call [runWriter] to after enqueueing. */
  private var writerTask: Task? = null

			api,
		)
	}

	for api, value := range httpStats.TotalS3Canceled.APIStats {
		ch <- prometheus.MustNewConstMetric(
			prometheus.NewDesc(
				prometheus.BuildFQName(s3Namespace, "canceled", "total"),
				"Total number of client canceled s3 request in current MinIO server instance",
				[]string{"api"}, nil),
			prometheus.CounterValue,
			float64(value),
			api,
		)
	}
}

      fail("Should have timed out trying to get the value.");
    } catch (TimeoutException expected) {
    } finally {
      latch.countDown();
    }
  }

  /**
   * Tests that a canceled future throws a cancellation exception.
   *
   * <p>This method checks the cancel, isCancelled, and isDone methods.
   */
  public void testCanceledFutureThrowsCancellation() throws Exception {

			if errors.As(err, &cerr) {
				logger.FatalIf(err, "Unable to initialize the server")
			}

			// If context was canceled
			if errors.Is(err, context.Canceled) {
				logger.FatalIf(err, "Server startup canceled upon user request")
			}

			bootLogIf(GlobalContext, err)
		}

		if !globalServerCtxt.StrictS3Compat {

     *
     * If the server does not respond to each ping with a pong within `interval`, this client will
     * assume that connectivity has been lost. When this happens on a web socket the connection is
     * canceled and its listener is [notified][WebSocketListener.onFailure]. When it happens on an
     * HTTP/2 connection the connection is closed and any calls it is carrying
     * [will fail with an IOException][java.io.IOException].

      .await(server.url("/a"))
      .assertFailure("canceled", "Canceled", "Socket closed", "Socket is closed")
  }

  @Test
  fun cancelAll() {
    val call = client.newCall(Request(server.url("/")))
    call.enqueue(callback)
    client.dispatcher.cancelAll()
    callback
      .await(server.url("/"))
      .assertFailure("canceled", "Canceled", "Socket closed", "Socket is closed")
  }

  @Test

		// Remove failed listings after 5 minutes.
		return time.Since(cache.lastUpdate) > 5*time.Minute
	}
	return true
}

// keepAlive will continuously update lastHandout until ctx is canceled.
func (m metacache) keepAlive(ctx context.Context, rpc *peerRESTClient) {
	// we intentionally operate on a copy of m, so we can update without locks.
	t := time.NewTicker(metacacheMaxClientWait / 10)
	defer t.Stop()

    override val call: Call,
    val ioe: IOException,
  ) : CallEvent() {
    override fun closes(event: CallEvent): Boolean = event is CallStart && call == event.call
  }

  data class Canceled(
    override val timestampNs: Long,
    override val call: Call,
  ) : CallEvent()

  data class RequestHeadersStart(
    override val timestampNs: Long,
    override val call: Call,
  ) : CallEvent()