ArtifactRepository localRepo = repositorySystem.createLocalRepository(localRepoDir);

        String basedir = localRepo.getBasedir();

        assertFalse(basedir.endsWith("/"));
        assertFalse(basedir.endsWith("\\"));

        assertEquals(localRepoDir, new File(basedir));

        assertEquals(localRepoDir.getPath(), basedir);
    }

    @Inject

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

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

/**

        // Initially not open (isStale returns false when handle is null, not true)
        assertFalse(target.isOpen());
        assertFalse(target.isStale());

        // After ensureOpen, handle valid -> open
        SmbFileHandleImpl fh = target.ensureOpen();
        assertSame(fileHandle, fh);
        assertTrue(target.isOpen());
        assertFalse(target.isStale());

        // If handle becomes invalid, reflect stale

        processHelper.destroy();
        super.tearDown(testInfo);
    }

    @Test
    public void test_isProcessRunning_empty() {
        assertFalse(processHelper.isProcessRunning());
    }

    @Test
    public void test_isProcessRunning_withSessionId_notExists() {
        assertFalse(processHelper.isProcessRunning("nonexistent"));
    }

    @Test
    public void test_getRunningSessionIdSet_empty() {

package jcifs.smb;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

        testParams.conditions.put(SearchRequestParams.AS_Q, new String[] { "" });
        assertFalse(searchRequestParams.hasConditionQuery());
    }

    @Test
    public void test_hasConditionQuery_withBlankQuery() {
        // Test with blank query parameter
        testParams.conditions.put(SearchRequestParams.AS_Q, new String[] { "   " });
        assertFalse(searchRequestParams.hasConditionQuery());
    }

    @Test

        synonymPager.clear();

        assertNull(synonymPager.id);
        assertEquals(0, synonymPager.getAllRecordCount());
        assertEquals(0, synonymPager.getAllPageCount());
        assertFalse(synonymPager.isExistPrePage());
        assertFalse(synonymPager.isExistNextPage());
    }

            // Initially false
            assertFalse(init.getContextFlag(flag));

            // Set to true
            init.setContextFlag(flag, true);
            assertTrue(init.getContextFlag(flag));
            assertEquals(flag, init.getContextFlags());

            // Set to false
            init.setContextFlag(flag, false);
            assertFalse(init.getContextFlag(flag));

        assertNull(stemmerOverridePager.id);
        assertEquals(0, stemmerOverridePager.getAllRecordCount());
        assertEquals(0, stemmerOverridePager.getAllPageCount());
        assertFalse(stemmerOverridePager.isExistPrePage());
        assertFalse(stemmerOverridePager.isExistNextPage());
    }

        queryContext.addSorts();

        assertFalse(queryContext.hasSorts());
        assertTrue(queryContext.sortBuilders().isEmpty());
    }

    // Test hasSorts
    @Test
    public void test_hasSorts() {
        queryContext = new QueryContext("test", false);
        assertFalse(queryContext.hasSorts());

        queryContext.addSorts(SortBuilders.fieldSort("field"));