class NameServiceClientImplTest {

    @Mock
    private CIFSContext mockContext;

    @Mock
    private Configuration mockConfig;

    @Mock
    private NetbiosAddress mockNetbiosAddress;

    @Mock
    private Address mockAddress;

    private NameServiceClientImpl nameServiceClient;

    @BeforeEach
    void setUp() throws UnknownHostException {
        // Configure mock context with fast timeouts

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import jcifs.dcerpc.ndr.NdrBuffer;

class DcerpcSecurityProviderTest {

    @Mock
    private DcerpcSecurityProvider dcerpcSecurityProvider;

    @Mock
    private NdrBuffer mockNdrBuffer;

    @BeforeEach
    void setUp() {

@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class DfsTest {

    @Mock
    private NtlmPasswordAuthentication auth;

    @Mock
    private SmbTransport smbTransport;

    @Mock
    private UniAddress uniAddress;

    @Mock
    private DfsReferral dfsReferral;

    private Dfs dfs;
    private TestDfs testDfs;

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

@ExtendWith(MockitoExtension.class)
class SidResolverTest {

    @Mock
    private SidResolver sidResolver;

    @Mock
    private CIFSContext mockContext;

    @Mock
    private SID mockSid1;

    @Mock
    private SID mockSid2;

    @Mock
    private SID mockSid3;

    @Mock

        String content = "#INCLUDE \\\\server\\share\\lmhosts\n" + "192.168.1.100 MAINHOST\n";

        // Mock SmbFileInputStream to simulate include file
        try (MockedConstruction<SmbFileInputStream> mockedConstruction =
                Mockito.mockConstruction(SmbFileInputStream.class, (mock, context) -> {
                    // Mock the read method to return simple content

			Op:   "open",
			Path: path,
			Err:  syscall.EINVAL,
		}
	}

	lock := syscall.Flock_t{
		Start:  0,
		Len:    0,
		Pid:    0,
		Type:   lockType,
		Whence: 0,
	}

	f, err := os.OpenFile(path, flag, perm)
	if err != nil {
		return nil, err
	}

	if err = syscall.FcntlFlock(f.Fd(), rlockType, &lock); err != nil {
		f.Close()
		if err == syscall.EAGAIN {
			err = ErrAlreadyLocked
		}

import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import java.net.URLStreamHandler;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import jcifs.BufferCache;
import jcifs.CIFSContext;
import jcifs.CIFSException;

	return false
}

// Close closes the underlying socket file descriptor.
func (restClient *ReconnectRESTClient) Close() error {
	return nil
}

var (
	errLockConflict = errors.New("lock conflict")
	errLockNotFound = errors.New("lock not found")
)

func toLockError(err error) error {
	if err == nil {
		return nil
	}

	switch err.Error() {
	case errLockConflict.Error():
		return errLockConflict

    @Test
    void getAddressReturnsOriginalObject() {
        InetAddress dummy = mock(InetAddress.class);
        UniAddress ua = new UniAddress(dummy);
        assertSame(dummy, ua.getAddress(), "getAddress should return the wrapped address");
    }

    @Test
    void getHostNameDelegatesToWrappedInetAddress() {
        InetAddress dummy = mock(InetAddress.class);
        when(dummy.getHostName()).thenReturn("host.example.com");

			return
		}
	}
}

func (m *Monitor) updateMovingAvg() {
	m.mlock.Lock()
	defer m.mlock.Unlock()
	for _, bucketMeasurement := range m.bucketsMeasurement {
		bucketMeasurement.updateExponentialMovingAverage(time.Now())
	}
}

func (m *Monitor) init(opts BucketOptions) {
	m.mlock.Lock()
	defer m.mlock.Unlock()

	_, ok := m.bucketsMeasurement[opts]
	if !ok {