@DisplayName("Type1Message Tests")
class Type1MessageTest {

    @Mock
    private CIFSContext mockContext;

    @Mock
    private Configuration mockConfig;

    @Mock
    private NameServiceClient mockNameServiceClient;

    @Mock
    private NetbiosAddress mockLocalHost;

    @BeforeEach
    void setUp() {
        // Setup mock context with lenient stubbing to avoid UnnecessaryStubbingException

import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
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

import jcifs.internal.smb1.com.SmbComClose;
import jcifs.internal.smb2.create.Smb2CloseRequest;

@ExtendWith(MockitoExtension.class)
class SmbFileHandleImplTest {

    @Mock
    Configuration cfg;

    @Mock
    SmbTreeHandleImpl tree;

    private void stubValidTree(long treeId, boolean connected, boolean smb2) {
        lenient().when(tree.acquire()).thenReturn(tree);
        lenient().when(tree.getTreeId()).thenReturn(treeId);

  /**
   * The current state of the service. This should be written with the lock held but can be read
   * without it because it is an immutable object in a volatile field. This is desirable so that
   * methods like {@link #state}, {@link #failureCause} and notably {@link #toString} can be run
   * without grabbing the lock.
   *
   * <p>To update this field correctly the lock must be held to guarantee that the state is
   * consistent.
   */

        final int[] searchLogDeletedDays = { 0 };
        final int[] jobLogDeletedDays = { 0 };
        final int[] userInfoDeletedDays = { 0 };
        final long[] expectedTime = { 0 };

        // Create mock services
        CrawlingInfoService crawlingInfoService = new CrawlingInfoService() {
            @Override
            public void deleteBefore(long time) {
                deleteCrawlingInfoCalled[0] = true;

 * package‑private members are visible if required.
 */
@ExtendWith(MockitoExtension.class)
class SmbComNTCreateAndXTest {
    @Mock
    Configuration mockConfig;
    @Mock
    ServerMessageBlock mockAndX;
    @Mock
    CIFSContext mockContext;

    /**
     * Helper that creates a request instance with the supplied flags.
     * The other arguments are simple constants.
     */

						</c:set>
						<la:password property="oldPassword" class="form-control"
									 placeholder="${ph_old_password}" />
						<div class="input-group-append">
							<span class="input-group-text"><em class="fa fa-lock fa-fw"></span>
						</div>
					</div>
					<div class="input-group mb-3">
						<c:set var="ph_new_password">
							<la:message key="labels.profile.placeholder_new_password" />
						</c:set>

	registerPeerRESTHandlers(router, commonGrid)

	// Register bootstrap REST router for distributed setups.
	registerBootstrapRESTHandlers(commonGrid)

	// Register distributed namespace lock routers.
	registerLockRESTHandlers(lockGrid)

	// Add lock grid to router
	router.Handle(grid.RouteLockPath, adminMiddleware(lockGrid.Handler(storageServerRequestValidate), noGZFlag, noObjLayerFlag))

	// Add grid to router

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

import jcifs.CIFSContext;
import jcifs.DialectVersion;
import jcifs.util.transport.Response;

/**
 * Test class for SmbNegotiationResponse interface
 */
class SmbNegotiationResponseTest {

    @Mock
    private SmbNegotiationResponse negotiationResponse;

    @Mock
    private CIFSContext cifsContext;

    @Mock

    private byte[] testMachineId = new byte[16];
    private byte[] testSalt = new byte[32];

    @BeforeEach
    void setUp() {
        mockConfig = mock(Configuration.class);
        mockContext = mock(CIFSContext.class);
        mockRandom = mock(SecureRandom.class);

        // Initialize test data
        for (int i = 0; i < 16; i++) {
            testMachineId[i] = (byte) (i + 1);
        }