testRequest.setOverrideTimeout(timeout);
            assertEquals(timeout, testRequest.getOverrideTimeout());
        }

        @Test
        @DisplayName("setOverrideTimeout should handle null value")
        void testSetOverrideTimeoutNull() {
            testRequest.setOverrideTimeout(5000);
            testRequest.setOverrideTimeout(null);
            assertNull(testRequest.getOverrideTimeout());

                + ",maxParameterCount=" + maxParameterCount + ",maxDataCount=" + maxDataCount + ",maxSetupCount=" + (int) maxSetupCount
                + ",flags=0x" + Hexdump.toHexString(flags, 2) + ",timeout=" + timeout + ",parameterCount=" + parameterCount
                + ",parameterOffset=" + parameterOffset + ",parameterDisplacement=" + parameterDisplacement + ",dataCount=" + dataCount

            // RdmaCompletionEvent event = endpoint.getCqProcessor().getCqEvent(timeout);
            // if (event != null) {
            //     return event.getBuffer();
            // }
            // return null;

            // For skeleton implementation, return null (timeout)
            return null;

        } catch (Exception e) {
            state = RdmaConnectionState.ERROR;

        ports:
          - 9910:3306
        options: >-
          --health-cmd "mysqladmin ping -ugorm -pgorm"
          --health-interval 10s
          --health-start-period 10s
          --health-timeout 5s
          --health-retries 10

    steps:
    - name: Set up Go 1.x
      uses: actions/setup-go@v4
      with:
        go-version: ${{ matrix.go }}

    - name: Check out code into the Go module directory

  public boolean isTerminated() {
    synchronized (lock) {
      return shutdown && runningTasks == 0;
    }
  }

  @Override
  public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
    long nanos = unit.toNanos(timeout);
    synchronized (lock) {
      while (true) {
        if (shutdown && runningTasks == 0) {
          return true;
        } else if (nanos <= 0) {
          return false;

     */
    void error();

    /**
     * Gets the expiration time for this response.
     *
     * @return the message timeout
     */
    Long getExpiration();

    /**
     * Sets the expiration time for this response.
     *
     * @param exp the message timeout to set
     */
    void setExpiration(Long exp);

    /**
     * Resets this response to its initial state.
     */

  val connectTimeout: Int by option(
    "--connect-timeout",
  ).help(
    "Maximum time allowed for connection (seconds)",
  ).int()
    .default(DEFAULT_TIMEOUT)

  val readTimeout: Int by option("--read-timeout")
    .help("Maximum time allowed for reading data (seconds)")
    .int()
    .default(DEFAULT_TIMEOUT)

  val callTimeout: Int by option(
    "--call-timeout",
  ).help(

     * @param priority The priority.
     */
    public void setPriority(final int priority) {
        this.priority = priority;
    }

    /**
     * Sets the request timeout.
     * @param bulkRequestTimeout The request timeout.
     */
    public void setRequestTimeout(final String bulkRequestTimeout) {
        requestTimeout = bulkRequestTimeout;
    }

    /**
     * Sets the request cache size.

     */
    public int getHeartbeatFailures() {
        return heartbeatFailures;
    }

    /**
     * Checks if this registration has expired based on the timeout.
     *
     * @param timeoutMs the timeout in milliseconds
     * @return true if the registration is expired
     */
    public boolean isExpired(long timeoutMs) {
        return System.currentTimeMillis() - lastHeartbeat > timeoutMs;

    // This class can make no hard guarantees.  The methods in this class are inherently flaky, but
    // we try hard to make them robust in practice.  We could additionally try to add in a system
    // load timeout multiplier.  Or we could try to use a CPU time bound instead of wall clock time
    // bound.  But these ideas are harder to implement.  We do not try to detect or handle a
    // user-specified -XX:+DisableExplicitGC.
    //