log.debug("TCP RDMA connection established to {}", remoteAddress);

        } catch (IOException e) {
            state = RdmaConnectionState.ERROR;
            throw new IOException("TCP RDMA connection failed", e);
        }
    }

    @Override
    public void send(ByteBuffer data, RdmaMemoryRegion region) throws IOException {
        if (state != RdmaConnectionState.ESTABLISHED && state != RdmaConnectionState.CONNECTED) {

     */
    public enum RdmaConnectionState {
        /** Connection is not established */
        DISCONNECTED,
        /** Connection is being established */
        CONNECTING,
        /** Connection is established but not ready for RDMA operations */
        CONNECTED,
        /** Connection is fully established and ready for RDMA operations */
        ESTABLISHED,
        /** Connection encountered an error */
        ERROR,

  open fun connectStart(
    route: Route,
    call: Call,
  ) {}

  /**
   * Invoked when a connection fails to be established.
   */
  open fun connectFailed(
    route: Route,
    call: Call,
    failure: IOException,
  ) {}

  /**
   * Invoked as soon as a connection is successfully established.
   */
  open fun connectEnd(
    connection: Connection,
    route: Route,
    call: Call,
  ) {}

  /**

    void testStateTransitions() {
        assertEquals(ChannelState.DISCONNECTED, channelInfo.getState());
        assertFalse(channelInfo.isHealthy());

        channelInfo.setState(ChannelState.ESTABLISHED);
        assertEquals(ChannelState.ESTABLISHED, channelInfo.getState());
        assertTrue(channelInfo.isHealthy());

        channelInfo.setState(ChannelState.ACTIVE);
        assertTrue(channelInfo.isHealthy());

import jcifs.internal.smb1.ServerMessageBlock;
import jcifs.internal.util.SMBUtil;

/**
 * SMB1 Session Setup AndX Response message.
 *
 * This response contains information about the established session,
 * including native OS, LAN manager, and primary domain information.
 */
public class SmbComSessionSetupAndXResponse extends AndXServerMessageBlock {

    private String nativeOs = "";

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

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

    /**
     * Channel is established and ready for use
     */
    ESTABLISHED(3),

    /**
     * Channel binding in progress
     */
    BINDING(4),

    /**
     * Channel is actively transferring data
     */
    ACTIVE(5),

    /**

    }

    @Test
    @DisplayName("calculateMIC throws when context not established")
    void testCalculateMICRequiresEstablished() throws Exception {
        SpnegoContext ctx = newContext();
        CIFSException ex = assertThrows(CIFSException.class, () -> ctx.calculateMIC(new byte[] { 1 }));
        assertEquals("Context is not established", ex.getMessage());
        verify(this.mechContext, never()).calculateMIC(any());
    }

        }
        ret.append("]");
        return ret.toString();
    }

    /**
     * Checks whether the security context is established.
     * @return true if the context is established, false otherwise
     */
    public boolean isEstablished() {
        return isEstablished;
    }

    /**
     * Gets the server's NTLM challenge bytes.

        channel1 = new ChannelInfo("channel1", mockTransport1, local, remote1);
        channel1.setState(ChannelState.ESTABLISHED);

        channel2 = new ChannelInfo("channel2", mockTransport2, local, remote2);
        channel2.setState(ChannelState.ESTABLISHED);
    }

    @Test
    void testSingleChannelSelection() {

        channel.setState(ChannelState.ESTABLISHED);

        // Verify channel properties
        assertEquals("test-channel", channel.getChannelId());
        assertEquals(mockTransport, channel.getTransport());
        assertEquals(localNic, channel.getLocalInterface());
        assertEquals(remoteNic, channel.getRemoteInterface());
        assertEquals(ChannelState.ESTABLISHED, channel.getState());