when(tree.isSMB2()).thenReturn(true);
        when(tree.getConfig()).thenReturn(mock(Configuration.class));
        when(handle.getFileId()).thenReturn(fileId);
        when(tree.send(any(CommonServerMessageBlockRequest.class), any(), any(), any())).thenReturn(resp);
    }

    // Prepare SMB1 flow with a given response
    private void setupSmb1(NotifyResponse resp, int fid) throws Exception {

        this.streamCloseTimeout = streamCloseTimeout;
    }

    /**
     * Sends a command to the process associated with the given session ID.
     * Uses finer-grained locking to avoid blocking other operations during I/O.
     *
     * @param sessionId unique identifier for the process session
     * @param command the command to send to the process
     * @throws JobNotFoundException if no process is found for the given session ID

        }).when(transport).send(any(ServerMessageBlock.class), any(ServerMessageBlock.class));

        session.send(req, resp);
        // Response state should be reset
        assertFalse(resp.received, "Response flag should be reset");
        // transport.send should be called at least once (for sessionSetup and the actual request)

            when(existsResponse.getAttributes()).thenReturn(0); // Not found
            when(mockTreeHandle.send(any(), any(SmbComQueryInformationResponse.class))).thenReturn(existsResponse);

            // Mock the actual mkdir call
            when(mockTreeHandle.send(any(SmbComCreateDirectory.class), any(SmbComBlankResponse.class)))
                    .thenReturn(mock(SmbComBlankResponse.class));

        when(fileHandle.acquire()).thenReturn(fileHandle);
        when(fileHandle.getTree()).thenReturn(tree);

        // Mock response and send behavior
        Smb2IoctlResponse resp = mock(Smb2IoctlResponse.class);
        when(resp.getOutputLength()).thenReturn(42);
        when(tree.send(any(Smb2IoctlRequest.class), any())).thenReturn(resp);

        byte[] out = new byte[10];

            assertThrows(CIFSException.class, handle::getSessionKey);
        }
    }

    @Nested
    @DisplayName("Send/Receive Fragment Tests")
    class SendReceiveFragmentTests {

        @Test
        @DisplayName("Should send and receive fragment successfully")
        void testDoSendReceiveFragment_Success() throws Exception {

     * @throws CIFSException if an error occurs checking capabilities
     */
    boolean hasCapability(int cap) throws CIFSException;

    /**
     * Gets the send buffer size of the underlying SMB connection
     * @return the send buffer size of the underlying connection
     * @throws CIFSException if an error occurs retrieving the buffer size
     */
    int getSendBufferSize() throws CIFSException;

    /**

            RdmaMemoryRegion sendRegion = bufferManager.getSendRegion(4096);
            assertNotNull(sendRegion, "Send region should not be null");
            assertTrue(sendRegion.getSize() >= 4096, "Send region should be at least 4KB");
            assertNotNull(sendRegion.getBuffer(), "Send region buffer should not be null");

            RdmaMemoryRegion recvRegion = bufferManager.getReceiveRegion();

            setTree(c, tree);
            return handle;
        }).when(c).connectHost(any(), anyString());

        // Execute send - should retry after transport error
        try {
            c.send(loc, req, resp, EnumSet.noneOf(RequestParam.class));
        } catch (Exception e) {
            // It's ok if it fails, we just want to verify reset was called
        }

                    final Smb2WriteResponse resp = th.send(request, RequestParam.NO_RETRY);
                    cnt = resp.getCount();
                } else {
                    final SmbComWriteAndX request =
                            new SmbComWriteAndX(th.getConfig(), fh.getFid(), this.fp, len - w - off, b, off, w, null);
                    th.send(request, this.write_andx_resp, RequestParam.NO_RETRY);