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 {

        assertNotNull(capabilities, "Capabilities should not be null");
        assertEquals(1, capabilities.size(), "TCP provider should only support send/receive");
        assertTrue(capabilities.contains(RdmaCapability.RDMA_SEND_RECEIVE), "Should support send/receive");
        assertFalse(capabilities.contains(RdmaCapability.RDMA_READ), "Should not support RDMA read");

If a client tries to send some **extra cookies**, they will receive an **error** response.

Poor cookie banners with all their effort to get your consent for the <dfn title="This is another joke. Don't pay attention to me. Have some coffee for your cookie. ☕">API to reject it</dfn>. 🍪

     *
     * Operations larger than this size will use RDMA read/write
     * instead of send/receive.
     *
     * @return threshold in bytes
     */
    int getRdmaReadWriteThreshold();

    /**
     * Get maximum RDMA send size
     *
     * @return max send size in bytes
     */
    int getRdmaMaxSendSize();

    /**
     * Get maximum RDMA receive size
     *

---
name: Feature request
about: Suggest an idea
title: ''
labels: enhancement
assignees: ''

---

Start by telling us what problem you’re trying to solve. Often a solution already exists!

            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
        }

        // Send FSCTL_QUERY_NETWORK_INTERFACE_INFO
        Smb2IoctlRequest request = new Smb2IoctlRequest();
        request.setCtlCode(FSCTL_QUERY_NETWORK_INTERFACE_INFO);
        request.setFileId(new byte[16]);  // Use session ID
        request.setMaxOutputResponse(65536);
        
        Smb2IoctlResponse response = (Smb2IoctlResponse) session.send(request);
        

            request.flags2 &= ~SmbConstants.FLAGS2_RESOLVE_PATHS_IN_DFS;
        }
    }

    void send(final ServerMessageBlock request, final ServerMessageBlock response) throws SmbException {
        for (;;) {
            resolveDfs(request);
            try {
                tree.send(request, response);
                break;
            } catch (final DfsReferral dre) {

from tests.utils import workdir_lock

client = TestClient(app)


@workdir_lock
def test():
    log = Path("log.txt")
    if log.is_file():
        os.remove(log)  # pragma: no cover
    response = client.post("/send-notification/******@****.***")
    assert response.status_code == 200, response.text
    assert response.json() == {"message": "Notification sent in the background"}
    with open("./log.txt") as f:

            assertEquals("Test IO Exception", thrown.getMessage());
        }
    }

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

        @Test
        @DisplayName("Should handle basic send/receive fragment methods")
        void testSendReceiveFragmentMethods() throws IOException {
            // Given: Test handle with configured return values