void close_doesNothing() throws Exception {
        // Arrange
        SmbPipeOutputStream out = newStream();
        // constructor already calls handle.getPipe(); clear interactions to focus on close()
        clearInvocations(handle);

        // Act
        out.close();

        // Assert
        verifyNoInteractions(handle);
    }

    @Nested

            when(mockInfo.getLastWriteTime()).thenReturn(2000000L);

            // Use the mock
            response.info = mockInfo;

            // Verify interactions
            assertEquals(0x20, response.info.getAttributes());
            assertEquals(1024L, response.info.getSize());
            assertEquals(1000000L, response.info.getCreateTime());

        assertIterableEquals(Arrays.asList(0x00000000, 0xc0000022, 0xc0000033), ntCaptor.getAllValues());

        // And ensure no further interactions happened
        verifyNoMoreInteractions(consumer);
    }

        assertTrue(r.getName().startsWith("OKSERVER"), "Expected valid entry to be adapted");
        assertFalse(itr.hasNext());
    }

    @Test
    @DisplayName("Filter rejects first, accepts second; interactions verified")
    void filterRejectsThenAccepts_nextYieldsAccepted() throws Exception {
        // Arrange: two entries; filter rejects first, accepts second
        setupParentForUrlCreation();

        void shouldHandleResponseMapOperations() {
            assertEquals(0, transport.getResponseMapSize());
            // Response map is accessible through protected field for testing
            // but we avoid complex interactions here for performance
        }
    }

import jcifs.CIFSException;
import jcifs.SmbTransport;
import jcifs.SmbTree;

/**
 * Tests for SmbSessionInternal interface using Mockito to exercise
 * method contracts, checked exceptions, and interactions with collaborators.
 */
@ExtendWith(MockitoExtension.class)
public class SmbSessionInternalTest {

    @Mock
    private SmbSessionInternal session;

    @Mock
    private SmbTransport transport;

        int encoded = mockFileInfo.encode(dst, 0);
        assertEquals(8, encoded);

        // Test size
        int size = mockFileInfo.size();
        assertEquals(8, size);

        // Verify interactions
        verify(mockFileInfo).encode(dst, 0);
        verify(mockFileInfo).size();
    }

    /**
     * Test concrete implementation with FileEndOfFileInformation
     */
    @Test

        wrapper.release();

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

    @Test
    @DisplayName("finalize() invokes checkRelease exactly once")
    void finalize_invokes_checkRelease() throws Throwable {
        // Arrange: spy to verify internal interaction with checkRelease()

import jcifs.internal.smb1.trans2.Trans2SetFileInformationResponse;
import jcifs.internal.smb2.info.Smb2SetInfoRequest;

/**
 * Tests for SmbRandomAccessFile covering happy paths, edge cases, and interactions.
 */
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
public class SmbRandomAccessFileTest {

    // Helper: build a minimally wired instance with mocks; avoids real I/O

        when(cfg.getBufferCacheSize()).thenReturn(2);
        when(cfg.getMaximumBufferSize()).thenReturn(5);

        BufferCacheImpl impl = new BufferCacheImpl(cfg);

        // Verify interactions happen exactly once during construction
        verify(cfg, times(1)).getBufferCacheSize();
        verify(cfg, times(1)).getMaximumBufferSize();
        verifyNoMoreInteractions(cfg);