/**
   * @since 28.0
   */
  @Override
  public final void awaitRunning(Duration timeout) throws TimeoutException {
    Service.super.awaitRunning(timeout);
  }

  @Override
  public final void awaitRunning(long timeout, TimeUnit unit) throws TimeoutException {
    if (monitor.enterWhenUninterruptibly(hasReachedRunning, timeout, unit)) {
      try {
        checkCurrentState(RUNNING);
      } finally {

		return err
	}

	// Wait for opened connection to be closed up to Shutdown timeout.
	return nil
}

// UseIdleTimeout configure idle connection timeout
func (srv *Server) UseIdleTimeout(d time.Duration) *Server {
	srv.IdleTimeout = d
	return srv
}

// UseReadTimeout configure connection request read timeout.
func (srv *Server) UseReadTimeout(d time.Duration) *Server {
	srv.ReadTimeout = d

    void testThrowableConstructor() {
        // Test the constructor with a cause
        Throwable cause = new RuntimeException("Root cause of timeout");
        ConnectionTimeoutException exception = new ConnectionTimeoutException(cause);
        assertEquals("java.lang.RuntimeException: Root cause of timeout", exception.getMessage(),
                "Message should be derived from the cause");

   * TimeoutException} wrapped in an {@link ExecutionException}) if the specified timeout expires.
   * If the timeout expires, not only will the output future finish, but also the input future
   * ({@code this}) will be cancelled and interrupted.
   *
   * @param timeout when to time out the future
   * @param scheduledExecutor The executor service to enforce the timeout.
   * @since 33.4.0 (but since 28.0 in the JRE flavor)
   */

        // After update, should not be expired with long timeout
        assertFalse(registration.isExpired(60000));

        // Verify heartbeat was actually updated
        assertTrue(registration.getLastHeartbeat() > initialTime);
    }

    @Test
    void testExpiration() throws InterruptedException {
        // Registration should not be expired initially with long timeout
        assertFalse(registration.isExpired(60000));

    /**
     * Sets the tree ID.
     *
     * @param t the tree ID to set
     */
    void setTid(int t);

    /**
     * Gets the custom response timeout for this request.
     *
     * @return custom response timeout for this request
     */
    Integer getOverrideTimeout();

    val displayName: String,
    val timeout: Int,
    val defaultBaselines: String = "",
    val channel: String,
    val extraParameters: String = "",
) {
    PER_COMMIT(
        displayName = "Performance Regression Test",
        timeout = 420,
        channel = "commits",
    ),
    PER_DAY(
        displayName = "Slow Performance Regression Test",
        timeout = 420,
        channel = "commits",

    /** Timeout in seconds for process destruction */
    protected int processDestroyTimeout = 10;

    /** Timeout in seconds for stream closing operations */
    protected int streamCloseTimeout = 10;

    /**
     * Default constructor for ProcessHelper.
     * Initializes the process management system with default timeout values.
     */
    public ProcessHelper() {

        .url(server.url("/"))
        .post(AsyncRequestBody())
        .build()
    val call = client.newCall(request)
    call.timeout().timeout(250, TimeUnit.MILLISECONDS)
    assertFailsWith<IOException> {
      call.execute()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("timeout")
      assertTrue(call.isCanceled())
    }
  }

  @Test
  fun fullCallTimeoutDoesNotApplyOnceConnected() {

                    .setInterval(interval)
                    .setThreads(threads)
                    .setTimeout(timeout)
                    .setType(type)
                    .execute()
                    .actionGet(timeout);
            append(buf, "cluster_name", () -> response.getClusterName().value()).append(',');