assertThrows(ArithmeticException.class, () -> InputValidator.safeMultiply(Integer.MIN_VALUE, 2));
    }

    @Test
    @DisplayName("Test credits validation")
    void testCreditsValidation() {
        assertDoesNotThrow(() -> InputValidator.validateCredits(0));
        assertDoesNotThrow(() -> InputValidator.validateCredits(100));

- [ ] Implement RDMA capability detection
- [ ] Create RDMA negotiation context
- [ ] Implement RDMA transport layer
- [ ] Add RDMA buffer registration
- [ ] Create RDMA read/write operations
- [ ] Implement RDMA credits management
- [ ] Add fallback to TCP when RDMA unavailable

#### 5.3 Integration Points
- Create new transport type alongside TCP
- Modify negotiation to include RDMA contexts
- Update read/write operations for RDMA

            CommonServerMessageBlockRequest nextRequest = mock(CommonServerMessageBlockRequest.class);
            testBlock.prepare(nextRequest);
        }

        @Test
        @DisplayName("Test set request credits")
        void testSetRequestCredits() {
            testBlock.setRequestCredits(10);
        }

        @Test
        @DisplayName("Test set session ID")
        void testSetSessionId() {

     */
    protected int rdmaMaxSendSize;
    /**
     * Maximum size in bytes for RDMA receive operations
     */
    protected int rdmaMaxReceiveSize;
    /**
     * Number of RDMA credits to request during negotiation
     */
    protected int rdmaCredits;
    /**
     * Flag indicating whether RDMA is currently enabled and available
     */
    protected boolean rdmaEnabled = false;
    /**

        return 1;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.util.transport.Request#setRequestCredits(int)
     */
    @Override
    public void setRequestCredits(final int credits) {

    }

    /**
     * @return the command
     */
    @Override
    public final int getCommand() {
        return this.command;
    }

    /**
     * @param command

    }

    /**
     * Gets the credit count for this message.
     *
     * @return the credit
     */
    public final int getCredit() {
        return this.credit;
    }

    /**
     * Sets the credit count for this message.
     *
     * @param credit
     *            the credit to set
     */
    public final void setCredit(final int credit) {
        this.credit = credit;
    }

        TestCredentials creds = new TestCredentials("A", true, false, subject, false);

        // Act
        TestCredentials copy = creds.clone();

        // Assert
        assertNotSame(creds, copy, "clone must return a new instance");
        assertEquals(creds.getUserDomain(), copy.getUserDomain());
        assertEquals(creds.isAnonymous(), copy.isAnonymous());
        assertEquals(creds.isGuest(), copy.isGuest());

    private Credentials creds;

    /**
     * Constructs a CIFS context wrapper with custom credentials.
     *
     * @param delegate the context to wrap
     * @param creds
     *            Credentials to use
     */
    public CIFSContextCredentialWrapper(final AbstractCIFSContext delegate, final Credentials creds) {
        super(delegate);
        this.creds = creds;
    }

    /**
     *

     */
    public static final int SMB2_GLOBAL_CAP_DFS = 0x1;

    /**
     * Server supports leasing
     */
    public static final int SMB2_GLOBAL_CAP_LEASING = 0x2;

    /**
     * Server supports multi-credit operations
     */
    public static final int SMB2_GLOBAL_CAP_LARGE_MTU = 0x4;

    /**
     * Server supports multi-channel connections
     */
    public static final int SMB2_GLOBAL_CAP_MULTI_CHANNEL = 0x8;

        Runtime.getRuntime().addShutdownHook(this);
    }

    /**
     * @param creds the credentials to use
     * @return a wrapped context with the given credentials
     */
    @Override
    public CIFSContext withCredentials(final Credentials creds) {
        return new CIFSContextCredentialWrapper(this, creds);
    }

    /**
     *
     * {@inheritDoc}
     *