private byte[] signingKey;
        private boolean established;
        private String nbName;
        private ASN1ObjectIdentifier[] supportedMechs;
        private int flags;
        private boolean integrity;
        private boolean disposed;

        DummySSPContext(byte[] signingKey, boolean established, String nbName, ASN1ObjectIdentifier[] supportedMechs, int flags,

        }
    }

    @Override
    public void send(ByteBuffer data, RdmaMemoryRegion region) throws IOException {
        if (state != RdmaConnectionState.ESTABLISHED && state != RdmaConnectionState.CONNECTED) {
            throw new IOException("Connection not established");
        }

        try {
            // In real implementation, this would send using DiSNI:

        } else {
            throw new SmbException("Invalid token");
        }

        if (spToken instanceof final NegTokenTarg targ && this.mechContext.isEstablished()) {
            // already established, but server hasn't completed yet
            if (targ.getResult() == NegTokenTarg.ACCEPT_INCOMPLETE && targ.getMechanismToken() == null
                    && targ.getMechanismListMIC() != null) {

    }

    @Test
    @DisplayName("isEstablished reflects underlying context state")
    void isEstablished_behavior() throws Exception {
        when(gssContext.isEstablished()).thenReturn(true);
        assertTrue(ctx.isEstablished());

        // When gssContext is null, isEstablished returns false
        setPrivateField(ctx, "gssContext", null);
        assertFalse(ctx.isEstablished());
        // Put it back for subsequent tests

     * Set channel state
     *
     * @param state new state
     */
    public void setState(ChannelState state) {
        this.state = state;
    }

    /**
     * Get the time when channel was established
     *
     * @return establishment time in milliseconds
     */
    public long getEstablishedTime() {
        return establishedTime;
    }

    /**
     * Get the last activity time
     *

        // Assert
        assertNotNull(ctx, "createContext returns an SSPContext");
        assertFalse(ctx.isEstablished(), "stub context initially not established");

        // Verify interactions with dependency are meaningful and ordered
        InOrder order = inOrder(mockContext);
        order.verify(mockContext, times(1)).getConfig();

        
        // Establish connection
        channel.setState(ChannelState.CONNECTING);
        transport.connect();
        
        // Perform channel binding
        performChannelBinding(channel);
        
        // Add to active channels
        channels.put(channelId, channel);
        channel.setState(ChannelState.ESTABLISHED);
        

import java.util.Vector;

import jcifs.smb1.Config;
import jcifs.smb1.UniAddress;
import jcifs.smb1.netbios.NbtAddress;
import jcifs.smb1.util.LogStream;

/**
 * The SmbSession class represents an SMB session established with a server.
 * It provides methods for authentication and session management.
 */
public final class SmbSession {

   *
   * This method is safe to be called concurrently, but provides limited guarantees. If a transport
   * layer connection has been established (such as a HTTP/2 stream) that is terminated. Otherwise,
   * if a socket connection is being established, that is terminated.
   */
  override fun cancel() {
    if (canceled) return // Already canceled.

    canceled = true
    exchange?.cancel()

    protected int maxFragmentedSize;
    protected int maxReadWriteSize;
    
    public enum RdmaConnectionState {
        DISCONNECTED,
        CONNECTING,
        CONNECTED,
        ESTABLISHED,
        ERROR,
        CLOSING,
        CLOSED
    }
    
    public RdmaConnection(InetSocketAddress remote, InetSocketAddress local) {
        this.remoteAddress = remote;