/**
 * Test class for CommonServerMessageBlockRequest interface
 */
@ExtendWith(MockitoExtension.class)
class CommonServerMessageBlockRequestTest {

    @Mock
    private CommonServerMessageBlockRequest request;

    @Mock
    private CommonServerMessageBlockRequest nextRequest;

    @Mock
    private CommonServerMessageBlockRequest splitRequest;

    @Mock

        List<FileNotifyInformation> result = sut.watch();

        assertSame(info, result, "Should return response notify information");
        ArgumentCaptor<CommonServerMessageBlockRequest> reqCap = ArgumentCaptor.forClass(CommonServerMessageBlockRequest.class);
        verify(tree).send(reqCap.capture(), any(), any(), any());
        assertTrue(reqCap.getValue() instanceof Smb2ChangeNotifyRequest, "SMB2 request must be used");

    @Test
    @DisplayName("Test Request interface extends CommonServerMessageBlockRequest")
    void testRequestExtendsCommonServerMessageBlockRequest() {
        // Then
        assertTrue(CommonServerMessageBlockRequest.class.isAssignableFrom(Request.class));
    }

    @Test
    @DisplayName("Test Request methods inherited from CommonServerMessageBlockRequest")
    void testInheritedMethods() {
        // Given

    @DisplayName("Test allowChain returns false")
    void testAllowChain() {
        // Given
        Smb2CancelRequest request = new Smb2CancelRequest(mockConfig, 1L, 0L);
        CommonServerMessageBlockRequest nextRequest = mock(CommonServerMessageBlockRequest.class);

        // When
        boolean allowChain = request.allowChain(nextRequest);

        // Then

            throws CIFSException {
        return send((CommonServerMessageBlockRequest) request, request.getResponse(),
                params != null && params.length > 0 ? EnumSet.copyOf(Arrays.asList(params)) : EnumSet.noneOf(RequestParam.class));
    }

    <T extends CommonServerMessageBlockResponse> T send(final CommonServerMessageBlockRequest request, final T response)
            throws CIFSException {

    void testPrepareWithDifferentRequestTypes() {
        // Given
        CommonServerMessageBlockRequest regularRequest = mock(CommonServerMessageBlockRequest.class);
        CommonServerMessageBlockRequest asyncRequest = mock(CommonServerMessageBlockRequest.class);

        when(asyncRequest.isResponseAsync()).thenReturn(true);
        when(regularRequest.isResponseAsync()).thenReturn(false);

        when(treeConnection.send(eq(resourceLoc), any(CommonServerMessageBlockRequest.class), isNull(), any(RequestParam[].class)))
                .thenReturn(resp);

        CommonServerMessageBlockResponse out = handle.send(req, RequestParam.NO_RETRY);
        assertSame(resp, out);

        verify(treeConnection, times(1)).send(eq(resourceLoc), eq((CommonServerMessageBlockRequest) req), isNull(),
                any(RequestParam[].class));

        resp.decode(packet, 0, false); // marks as received

        // Create a request that implements both CommonServerMessageBlockRequest and RequestWithFileId
        CommonServerMessageBlockRequest next =
                mock(CommonServerMessageBlockRequest.class, withSettings().extraInterfaces(RequestWithFileId.class));

        resp.prepare(next);

        // Setup a tree that will fail with transport error first, then succeed
        SmbTreeImpl tree = mock(SmbTreeImpl.class);
        when(tree.acquire(false)).thenReturn(tree);

        CommonServerMessageBlockRequest req = mock(CommonServerMessageBlockRequest.class);
        CommonServerMessageBlockResponse resp = mock(CommonServerMessageBlockResponse.class);

        // Configure the tree to throw transport error on first call, succeed on second

        long lastWrite = 123456789L;
        h.close(lastWrite);

        // Verify SMB1 close path uses request + response overload
        ArgumentCaptor<CommonServerMessageBlockRequest> reqCap = ArgumentCaptor.forClass(CommonServerMessageBlockRequest.class);
        ArgumentCaptor<SmbComBlankResponse> respCap = ArgumentCaptor.forClass(SmbComBlankResponse.class);