log.trace("Currently " + this.sessions.size() + " session(s) active for " + this);
        }

        if (targetHost != null) {
            targetHost = targetHost.toLowerCase(Locale.ROOT);
        }

        if (targetDomain != null) {
            targetDomain = targetDomain.toUpperCase(Locale.ROOT);
        }

        ListIterator<SmbSessionImpl> iter = this.sessions.listIterator();

        assertArrayEquals(blob, resp.getBlob(), "Security blob should match");
        assertEquals(sessionFlags, resp.getSessionFlags(), "Session flags should decode");
        assertTrue(resp.isLoggedInAsGuest(), "Guest/anonymous should be detected");

        // prepare should propagate session id when received
        CIFSContext mockCtx = mock(CIFSContext.class);
        when(mockCtx.getConfig()).thenReturn(mock(Configuration.class));

    }

    // Test session ID generation
    @Test
    public void test_sessionIdGeneration() {
        assertNull(suggestJob.sessionId);

        mockProcessHelper.setExitValue(0);
        suggestJob.execute();

        assertNotNull(suggestJob.sessionId);
        assertEquals(15, suggestJob.sessionId.length());
        // Check that session ID contains only alphabetic characters

        SmbSession ssn;
        long now;

        ListIterator iter = sessions.listIterator();
        while (iter.hasNext()) {
            ssn = (SmbSession) iter.next();
            if (ssn.matches(auth)) {
                ssn.auth = auth;
                return ssn;
            }
        }

        /* logoff old sessions */
        if (SO_TIMEOUT > 0 && sessionExpiration < (now = System.currentTimeMillis())) {

        session.setDependencyTraverser(getDependencyTraverser());
        session.setDependencyManager(getDependencyManager());
        session.setDependencySelector(getDependencySelector());
        session.setDependencyGraphTransformer(getDependencyGraphTransformer());
        session.setArtifactTypeRegistry(getArtifactTypeRegistry());

        boolean parallel = nThreads > 1;
        // Propagate the parallel flag to the root session and all the cloned sessions in each project segment
        session.setParallel(parallel);
        for (ProjectSegment segment : projectBuilds) {
            segment.getSession().setParallel(parallel);
        }
        ExecutorService executor = Executors.newFixedThreadPool(nThreads, new BuildThreadFactory());

     *
     * @param parentUrl the parent URL to get encoding for
     * @param sessionId the session ID for the crawling session
     * @return the character encoding, or null if not found
     */
    default String getParentEncoding(final String parentUrl, final String sessionId) {
        final String key = sessionId + ":" + parentUrl;
        String enc = parentEncodingMap.get(key);
        if (enc != null) {

                .setLocalRepository(getLocalRepository());

        DefaultRepositorySystemSession session = new DefaultRepositorySystemSession();
        LocalRepository localRepo =
                new LocalRepository(request.getLocalRepository().getBasedir());
        session.setLocalRepositoryManager(new SimpleLocalRepositoryManagerFactory().newInstance(session, localRepo));
        LegacySupport legacySupport = container.lookup(LegacySupport.class);

        return this;
    }

    /**
     * Sets the session ID for this job execution.
     *
     * @param sessionId the unique session identifier
     * @return this ExecJob instance for method chaining
     */
    public ExecJob sessionId(final String sessionId) {
        this.sessionId = sessionId;
        return this;
    }

    /**

        if (sessionId == null) { // create session id
            sessionId = RandomStringUtils.randomAlphabetic(15);
        }
        resultBuf.append("Session Id: ").append(sessionId).append("\n");
        if (jobExecutor != null) {
            jobExecutor.addShutdownListener(() -> ComponentUtil.getProcessHelper().destroyProcess(sessionId));
        }