/**
     * Verify that encode invokes NdrBuffer.enc_ndr_short via a mocked
     * (spied) buffer.
     */
    @Test
    void encodeWithSpiedBufferCallsEncMethod() throws NdrException {
        NdrShort ns = new NdrShort(42);
        NdrBuffer spy = spy(new NdrBuffer(new byte[10], 0));
        ns.encode(spy);
        // NdrShort passes its value (already masked to 0xFF) to enc_ndr_short
        verify(spy).enc_ndr_short(42);
    }

import org.junit.jupiter.params.provider.MethodSource;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import jcifs.CIFSContext;
import jcifs.Configuration;
import jcifs.SmbConstants;
import jcifs.context.SingletonContext;

@ExtendWith(MockitoExtension.class)
class HandlerTest {

    @Mock
    CIFSContext mockCtx;

    @Mock
    Configuration mockCfg;

import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;

import jcifs.SmbSession;

/**
 * Tests for SmbTransportInternal interface using Mockito mocks to
 * exercise method contracts, checked exceptions, and interactions.
 */
@ExtendWith(MockitoExtension.class)
public class SmbTransportInternalTest {

    @Mock
    private SmbTransportInternal transport;

import org.junit.jupiter.params.provider.MethodSource;
import org.mockito.InOrder;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)
class FileEntryTest {

    @Mock
    FileEntry mockEntry;

    // Simple fake implementation to exercise the interface without mocks
    private static final class TestFileEntry implements FileEntry {
        private final String name;

        verify(handle).areSignaturesActive();
    }

    @Test
    @DisplayName("getSession(): returns the mocked SmbSession instance")
    void getSession_returnsMock() {
        // Arrange
        SmbSession session = mock(SmbSession.class);
        when(handle.getSession()).thenReturn(session);

        // Act
        SmbSession result = handle.getSession();

        @DisplayName("Should handle circular reference in root cause")
        void testCircularReferenceInRootCause() {
            // Create a mock exception that could have circular reference
            Exception rootCause = mock(Exception.class);
            when(rootCause.getMessage()).thenReturn("Mocked exception");

            TransportException exception = new TransportException("Test", rootCause);

        }
    }

    @Nested
    @DisplayName("Mock Interaction Tests")
    class MockInteractionTest {

        @Test
        @DisplayName("Should allow all methods to be mocked independently")
        void shouldAllowAllMethodsToBeMockedIndependently() throws Exception {
            SmbSession mockSession = mock(SmbSession.class);
            Configuration mockConfig = mock(Configuration.class);

    try:
        from python_multipart import __version__

        # Import an attribute that can be mocked/deleted in testing
        assert __version__ > "0.0.12"
    except (ImportError, AssertionError):
        try:
            # __version__ is available in both multiparts, and can be mocked
            from multipart import (  # type: ignore[no-redef,import-untyped]  # ty: ignore[unused-ignore-comment]

import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.junit.jupiter.MockitoExtension;

import jcifs.CIFSException;
import jcifs.spnego.NegTokenInit;

@ExtendWith(MockitoExtension.class)
class Kerb5ContextTest {

    @Mock
    private GSSManager gssManager;

    @Mock
    private GSSContext gssContext;

    @Mock
    private GSSName serviceName;

    @Mock

class DcerpcPipeHandleTest {

    @Mock
    private CIFSContext mockContext;
    @Mock
    private SmbNamedPipe mockSmbNamedPipe;
    @Mock
    private SmbPipeHandleInternal mockSmbPipeHandleInternal;
    @Mock
    private DcerpcBinding mockDcerpcBinding;
    @Mock
    private SmbResourceLocator mockSmbResourceLocator;
    @Mock
    private SmbPipeHandle mockSmbPipeHandle;
    @Mock
    private BufferCache mockBufferCache;