*
     * @return the expiration time of this entry
     */
    long getExpiration();

    /**
     * Get the next referral in the chain
     *
     * @return pointer to next referral, points to self if there is no further referral
     */
    DfsReferralData next();

    /**
     * Get the complete UNC path link for this referral
     *
     * @return the link
     */
    String getLink();

            assertNull(copy.getSubject(), "Clone should still return null after refresh");
        }
    }

    @Test
    @DisplayName("renew: invokes getSubject and returns self")
    void testRenewInvokesGetSubjectAndReturnsSelf() {
        JAASAuthenticator auth = spy(new JAASAuthenticator());
        // Avoid real JAAS by stubbing getSubject
        doReturn(new Subject()).when(auth).getSubject();

        when(config.getPid()).thenReturn(12345);
        when(config.getSendBufferSize()).thenReturn(65536);

        target = new SmbPipeHandleImpl(pipe);
    }

    @Test
    @DisplayName("unwrap returns self for assignable type; throws for incompatible and null")
    void testUnwrap() {
        // Happy path: unwrap to concrete type
        SmbPipeHandleImpl unwrapped = target.unwrap(SmbPipeHandleImpl.class);

        @Test
        @DisplayName("Should handle self unwrap")
        void shouldHandleSelfUnwrap() {
            SmbSession mockSession = mock(SmbSession.class);
            when(mockSession.unwrap(SmbSession.class)).thenReturn(mockSession);

            SmbSession result = mockSession.unwrap(SmbSession.class);
            assertSame(mockSession, result, "unwrap should handle self unwrapping");
        }
    }

    @Nested

            return null;
        }
    }

    // Provide different implementation behaviors to a parameterized test
    static Stream<Arguments> implementations() {
        return Stream.of(Arguments.of("returns self", (Supplier<SmbRenewableCredentials>) SelfRenewingCreds::new, true, false),
                Arguments.of("returns new", (Supplier<SmbRenewableCredentials>) NewRenewingCreds::new, false, true),

        // Close of try-with-resources should call close on the mock
        verify(tree, times(1)).close();
    }

    @Test
    @DisplayName("unwrap: returns self for compatible type and throws for incompatible")
    @SuppressWarnings({ "rawtypes", "unchecked" })
    void testUnwrap() {
        SmbSessionImpl session = newSession();

        }

        @Override
        public NdrBuffer derive(int offset) {
            return this; // For simplicity, return self
        }

        // Note: getDeferred() method does not exist in NdrBuffer
        public NdrBuffer getDeferred() {
            return this; // For simplicity, return self
        }

        @Override
        public void enc_ndr_string(String s) {
            // Simulate encoding a string

        assertSame(mockFileEntry2, retrievedEntries[1]);
    }

    @Test
    @DisplayName("Test nextElement method")
    void testNextElement() {
        // First call returns self
        SmbComTransactionResponse result = response.nextElement();
        assertSame(response, result);
    }

    @Test
    @DisplayName("Test hasMoreElements method")
    void testHasMoreElements() {

        assertNotNull(result);
        assertEquals(disconnectRequest, result);
        verify(request, times(1)).ignoreDisconnect();
    }

    @Test
    @DisplayName("Test ignoreDisconnect returns self")
    void testIgnoreDisconnectReturnsSelf() {
        // Given
        when(request.ignoreDisconnect()).thenReturn(request);

        // When
        CommonServerMessageBlock result = request.ignoreDisconnect();

        assertTrue(hashCodes.size() > 1);
    }

    /**
     * Test compareTo method
     */
    public void test_compareTo() {
        // Compare with self
        assertEquals(0, CrawlerStatus.INITIALIZING.compareTo(CrawlerStatus.INITIALIZING));
        assertEquals(0, CrawlerStatus.RUNNING.compareTo(CrawlerStatus.RUNNING));