void testSetResolveInDfs() {
        // Test with mock
        doNothing().when(requestWithPath).setResolveInDfs(true);
        requestWithPath.setResolveInDfs(true);
        verify(requestWithPath, times(1)).setResolveInDfs(true);

        doNothing().when(requestWithPath).setResolveInDfs(false);
        requestWithPath.setResolveInDfs(false);

        assertTrue(shorter.equals(longer), "Shorter equals longer when prefix matches (implementation behavior)");

        // In the opposite direction, an out-of-bounds occurs internally and is caught as false
        assertFalse(longer.equals(shorter), "Longer does not equal shorter (implementation behavior)");
    }

    // Confirms equals() returns false when content differs
    @Test

    public String name;

    /**
     * The target class for the scheduled job.
     */
    @Required
    @Size(max = 100)
    public String target;

    /**
     * The cron expression defining when the job should run.
     */
    @Size(max = 100)
    @CronExpression
    public String cronExpression;

    /**
     * The type of script for the scheduled job.
     */
    @Required
    @Size(max = 100)

        this.listener = listener;
    }

    /**
     * Interface for listening to request lifecycle events.
     */
    public interface RequestListener {

        /**
         * Called when a request starts.
         *
         * @param client the fault-tolerant client
         * @param request the request data
         */
        void onRequestStart(FaultTolerantClient client, RequestData request);

        SID mockSid2 = mock(SID.class);

        // Mock the unwrap method to return a sid_t instance
        sid_t sidT1 = new sid_t();
        sid_t sidT2 = new sid_t();
        when(mockSid1.unwrap(sid_t.class)).thenReturn(sidT1);
        when(mockSid2.unwrap(sid_t.class)).thenReturn(sidT2);

        jcifs.SID[] sids = { mockSid1, mockSid2 };
        LsarSidArrayX lsarSidArrayX = new LsarSidArrayX(sids);

        // Verify num_sids

        @Test
        @DisplayName("readn should throw IOException when buffer too short")
        void shouldThrowWhenBufferTooShort() {
            InputStream is = new ByteArrayInputStream("test".getBytes());
            assertThrows(IOException.class, () -> Transport.readn(is, new byte[5], 0, 10));
        }

        @Test
        @DisplayName("readn should return 0 when no more bytes available")

    @BeforeEach
    void setUp() {
        mockConfig = mock(Configuration.class);
        mockContext = mock(CIFSContext.class);
        when(mockContext.getConfig()).thenReturn(mockConfig);
        when(mockConfig.getMaximumBufferSize()).thenReturn(65536);
        when(mockConfig.getListSize()).thenReturn(65536);

        testFileId = new byte[16];
        for (int i = 0; i < 16; i++) {
            testFileId[i] = (byte) i;

    @DisplayName("Should define close method")
    void testCloseMethod() throws CIFSException {
        // When
        mockIterator.close();

        // Then
        verify(mockIterator).close();
    }

    @Test
    @DisplayName("Should extend Iterator and AutoCloseable")
    void testInterfaceInheritance() {
        // Then
        assertTrue(java.util.Iterator.class.isAssignableFrom(CloseableIterator.class));

        // Act: create wrapper using delegate, then acquire and release once
        SmbTreeConnectionTrace wrapper = new SmbTreeConnectionTrace(delegate);
        wrapper.acquire();
        wrapper.release();

        // Assert: delegate interactions occur when usage transitions happen
        verify(delegate, times(1)).acquire();
        verify(delegate, times(1)).release();

            ACE directAce = mock(ACE.class);
            when(inheritedAce.isInherited()).thenReturn(true);
            when(directAce.isInherited()).thenReturn(false);

            assertTrue(inheritedAce.isInherited());
            assertFalse(directAce.isInherited());
            verify(inheritedAce).isInherited();
            verify(directAce).isInherited();
        }

        @Test