*
     * @param tc the CIFS context containing configuration
     */
    public NameServiceClientImpl(final CIFSContext tc) {
        this(tc.getConfig().getNetbiosLocalPort(), tc.getConfig().getNetbiosLocalAddress(), tc);
    }

    NameServiceClientImpl(final int lport, final InetAddress laddr, final CIFSContext tc) {
        this.lport = lport;
        this.laddr = laddr;
        this.transportContext = tc;

import java.net.URLStreamHandlerFactory;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.CIFSContext;

/**
 * A <code>URLStreamHandler</code> used to provide NTLM authentication
 * capabilities to the default HTTP handler. This acts as a wrapper,
 * handling authentication and passing control to the underlying

import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import jcifs.CIFSContext;
import jcifs.Configuration;
import jcifs.internal.CommonServerMessageBlockRequest;
import jcifs.internal.CommonServerMessageBlockResponse;

class ServerMessageBlock2RequestTest {

    @Mock
    private Configuration mockConfig;

    @Mock
    private CIFSContext mockContext;

    @Mock
    private Smb2SigningDigest mockDigest;

            // Use default local port (0 means system assigns)
            int localPort = 0;

            // Get CIFSContext from configuration - this is a simplified approach
            // In a real implementation, this should be passed from the session context
            jcifs.CIFSContext context = createDefaultContext();

            // Create transport with multi-channel specific settings

import org.mockito.junit.jupiter.MockitoExtension;

import jcifs.CIFSContext;

/**
 * Test class for Request interface
 */
@ExtendWith(MockitoExtension.class)
class RequestTest {

    @Mock
    private Request<CommonServerMessageBlockResponse> request;

    @Mock
    private CommonServerMessageBlockResponse response;

    @Mock
    private CIFSContext context;

    @Mock

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import jcifs.CIFSContext;
import jcifs.Configuration;
import jcifs.internal.smb2.lease.LeaseManager.LeaseEntry;

@DisplayName("LeaseManager Tests")
class LeaseManagerTest {

    private LeaseManager leaseManager;
    private CIFSContext mockContext;
    private Configuration mockConfig;

    @BeforeEach
    void setUp() {

    }

    /**
     * Test the resolve method.
     *
     * @throws IOException if an I/O error occurs
     */
    @Test
    void testResolve() throws IOException {
        CIFSContext mockContext = mock(CIFSContext.class);
        SidResolver mockResolver = mock(SidResolver.class);
        when(mockContext.getSIDResolver()).thenReturn(mockResolver);

        SID sid = new SID(adminSidString);

import jcifs.dcerpc.rpc.*;
import java.util.concurrent.*;

public class WitnessClient implements AutoCloseable {
    private final InetAddress witnessServer;
    private final int port;
    private final CIFSContext context;
    private final ConcurrentHashMap<String, WitnessRegistration> registrations;
    private final ConcurrentHashMap<String, WitnessNotificationListener> listeners;
    private final ScheduledExecutorService scheduler;

 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.internal;

import jcifs.CIFSContext;

/**
 * Generic interface for typed SMB request messages.
 * Extends the common request interface with type-safe response handling,
 * allowing requests to specify their expected response type.
 *

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.CIFSContext;
import jcifs.internal.witness.WitnessRegistration.WitnessRegistrationState;

/**
 * SMB Witness Protocol client implementation as defined in MS-SWN specification.