}

      return when {
        tcpConnectThrowable != null -> {
          events += "plan $id TCP connect failed"
          ConnectResult(this, nextPlan = connectTcpNextPlan, throwable = tcpConnectThrowable)
        }

        canceled -> {
          events += "plan $id TCP connect canceled"
          ConnectResult(this, nextPlan = connectTcpNextPlan, throwable = IOException("canceled"))
        }

   *
   * <p>For example,
   *
   * <ul>
   *   <li>{@code [2, 4)} and {@code [5, 7)} are not connected
   *   <li>{@code [2, 4)} and {@code [3, 5)} are connected, because both enclose {@code [3, 4)}
   *   <li>{@code [2, 4)} and {@code [4, 6)} are connected, because both enclose the empty range
   *       {@code [4, 4)}
   * </ul>
   *

    }

    /**
     * Check if connection is established and ready for use
     *
     * @return true if connection is connected/established, false otherwise
     */
    public boolean isConnected() {
        return state == RdmaConnectionState.CONNECTED || state == RdmaConnectionState.ESTABLISHED;
    }

    /**
     * Read data from RDMA connection
     *

/**
 * A set comprising zero or more {@linkplain Range#isEmpty nonempty}, {@linkplain
 * Range#isConnected(Range) disconnected} ranges of type {@code C}.
 *
 * <p>Implementations that choose to support the {@link #add(Range)} operation are required to
 * ignore empty ranges and coalesce connected ranges. For example:
 *
 * {@snippet :
 * RangeSet<Integer> rangeSet = TreeRangeSet.create();

/**
 * A set comprising zero or more {@linkplain Range#isEmpty nonempty}, {@linkplain
 * Range#isConnected(Range) disconnected} ranges of type {@code C}.
 *
 * <p>Implementations that choose to support the {@link #add(Range)} operation are required to
 * ignore empty ranges and coalesce connected ranges. For example:
 *
 * {@snippet :
 * RangeSet<Integer> rangeSet = TreeRangeSet.create();

 */
package jcifs.internal.smb2.multichannel;

/**
 * SMB3 Multi-Channel connection states
 */
public enum ChannelState {
    /**
     * Channel is not connected
     */
    DISCONNECTED(0),

    /**
     * Connection establishment in progress
     */
    CONNECTING(1),

    /**
     * Authentication in progress
     */
    AUTHENTICATING(2),

     */
    boolean disconnect(boolean hard, boolean inuse) throws IOException;

    /**
     * Ensures the transport is connected to the remote server.
     *
     * @return whether the transport was connected
     * @throws SmbException if an SMB error occurs
     * @throws IOException if an I/O error occurs
     */
    boolean ensureConnected() throws IOException;

    /**

# Vulnerability Management Policy

This document formally describes the process of addressing and managing a
reported vulnerability that has been found in the MinIO server code base,
any directly connected ecosystem component or a direct / indirect dependency
of the code base.

## Scope

The vulnerability management policy described in this document covers the
process of investigating, assessing and resolving a vulnerability report

        this.connection = connection;
        requestProperties = new HashMap();
    }

    @Override
    public void connect() throws IOException {
        if (connected) {
            return;
        }
        connection.connect();
        connected = true;
    }

    private void handshake() throws IOException {
        if (handshakeComplete) {
            return;
        }

        doReturn(true).when(trace).isConnected();
        trace.acquire(); // usageCount becomes 1

        // Act & Assert: checkRelease should call isConnected() and not throw
        assertDoesNotThrow(trace::checkRelease);
        verify(trace, atLeastOnce()).isConnected();
    }

    @Test
    @DisplayName("release() below zero usage throws RuntimeCIFSException")