@Nested
    @DisplayName("Interaction – verify that file methods are invoked")
    class Interaction {
        @Test
        void verifiesPathInvocation() throws Exception {
            SmbFile mockFile = mock(SmbFile.class);
            when(mockFile.getPath()).thenReturn("/share/dir/");
            RecordingFilter filter = new RecordingFilter();
            filter.accept(mockFile);
            // Verify the filter stored the reference

        int bytesWritten = netServerEnum2.writeParametersWireFormat(dst, dstIndex);

        // Verify bytes written
        assertTrue(bytesWritten > 0);

        // Verify subcommand
        assertEquals(SmbComTransaction.NET_SERVER_ENUM2, dst[0]);
        assertEquals(0, dst[1]);

        // Verify descriptor (WrLehDO\0B16BBDz\0 in ASCII)
        String expectedDescr = "WrLehDO\u0000B16BBDz\u0000";

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

        // When handle is valid, expect close()
        target.ensureOpen();
        target.close();
        verify(fileHandle, times(1)).close();
        verify(fileHandle, never()).release();
        verify(tree, atLeastOnce()).release();

        // Re-prepare state for second branch: not open but handle set
        when(fileHandle.isValid()).thenReturn(false);

  }

  /**
   * Verify that the listener completes in a reasonable amount of time, and Asserts that the future
   * returns the expected data.
   *
   * @throws Throwable if the listener isn't called or if it resulted in a throwable or if the
   *     result doesn't match the expected value.
   */
  public void assertSuccess(Object expectedData) throws Throwable {

        when(mockRequest.getCommand()).thenReturn((int) ServerMessageBlock.SMB_COM_WRITE);

        digest.sign(data, 0, data.length, mockRequest, mockResponse);

        verify(mockRequest).setSignSeq(10);
        verify(mockResponse).setSignSeq(11);
    }

    @Test
    @DisplayName("Test sign method with bypass enabled")
    void testSignWithBypass() {

        verify(mockDelegate).getLanManCompatibility();
        verify(mockDelegate).isAllowNTLMFallback();
        verify(mockDelegate).isUseRawNTLM();
        verify(mockDelegate).isDisablePlainTextPasswords();
        verify(mockDelegate).getGuestUsername();
        verify(mockDelegate).getGuestPassword();
        verify(mockDelegate).isAllowGuestFallback();
    }

    @Test

        assertArrayEquals(testKey.getKey(), encodedKey);

        // Verify lease state at offset 40 (24 + 16 for key)
        assertEquals(testState, SMBUtil.readInt4(buffer, 40));

        // Verify lease flags at offset 44 (40 + 4 for state)
        assertEquals(0, SMBUtil.readInt4(buffer, 44));

        // Verify lease duration at offset 48 (44 + 4 for flags) - should be 0 (reserved)

    void testConstructorInitialization() {
        // Verify level is set to 200 for DFS root enumeration
        assertEquals(200, dfsRootEnum.level);

        // Verify DCE/RPC message properties
        assertEquals(0, dfsRootEnum.getPtype());
        assertEquals(DcerpcConstants.DCERPC_FIRST_FRAG | DcerpcConstants.DCERPC_LAST_FRAG, dfsRootEnum.getFlags());

        // Verify DFS enumeration structure
        assertNotNull(dfsRootEnum.info);

        // Verify filter interactions: not called for '.' and '..', called for others
        verify(nameFilter, never()).accept(parent, ".");
        verify(nameFilter, never()).accept(parent, "..");
        ArgumentCaptor<String> nameCaptor = ArgumentCaptor.forClass(String.class);
        verify(nameFilter, atLeast(1)).accept(eq(parent), nameCaptor.capture());

            entry.encode(mockNdrBuffer);

            // Then: Should encode all fields
            verify(mockNdrBuffer).align(4);
            verify(mockNdrBuffer).enc_ndr_long(1);
            verify(mockNdrBuffer).enc_ndr_short((short) 4);
            verify(mockNdrBuffer).enc_ndr_short((short) 6);
            verify(mockNdrBuffer).enc_ndr_referent(entry.name.buffer, 1);
        }

        @Test