assertFalse(Arrays.equals(signingKey300, signingKey311));
    }

    @Test
    @DisplayName("Should handle different session key sizes")
    void testDeriveKeys_DifferentSessionKeySizes() {
        // Test with various session key sizes
        int[] keySizes = { 8, 16, 24, 32, 64, 128 };
        int dialect = Smb2Constants.SMB2_DIALECT_0311;

        for (int size : keySizes) {

import org.apache.maven.api.Session;
import org.apache.maven.execution.ExecutionEvent;

public class DefaultEvent implements Event {
    private final InternalMavenSession session;
    private final ExecutionEvent delegate;
    private final EventType eventType;

    public DefaultEvent(InternalMavenSession session, ExecutionEvent delegate, EventType eventType) {
        this.session = session;
        this.delegate = delegate;

    }

    static InternalMavenSession from(org.eclipse.aether.RepositorySystemSession session) {
        return cast(InternalMavenSession.class, session.getData().get(InternalSession.class), "session");
    }

    List<Project> getProjects(List<org.apache.maven.project.MavenProject> projects);

    /**
     * May return null if the input project is null or is not part of the reactor.
     */

@SessionScoped
public class DefaultArtifactManager implements ArtifactManager {

    @Nonnull
    private final InternalMavenSession session;

    private final Map<String, Path> paths = new ConcurrentHashMap<>();

    @Inject
    public DefaultArtifactManager(@Nonnull InternalMavenSession session) {
        this.session = session;
    }

    @Nonnull
    @Override
    public Optional<Path> getPath(@Nonnull Artifact artifact) {

     *
     * @param sessionId unique identifier for the process session
     * @return exit code of the destroyed process, or -1 if the process was not found
     */
    public synchronized int destroyProcess(final String sessionId) {
        final JobProcess jobProcess = runningProcessMap.remove(sessionId);
        return destroyProcess(sessionId, jobProcess);
    }

    /**

import jcifs.internal.smb1.ServerMessageBlock;
import jcifs.internal.util.SMBUtil;
import jcifs.smb.NtlmPasswordAuthenticator;
import jcifs.smb.SmbException;

/**
 * SMB1 Session Setup AndX request message.
 *
 * This command is used to authenticate a user session and
 * establish security context for subsequent operations.
 */
public class SmbComSessionSetupAndX extends AndXServerMessageBlock {

    const Graph& graph = session->graph->graph;

    const string& mutation_warning = session->graph->sessions[session];
    if (!mutation_warning.empty()) {
      // TODO(b/74949947): turn this back into an error status
      LOG(WARNING) << mutation_warning;
      session->graph->sessions[session].clear();
    }

    const auto num_nodes = graph.num_node_ids();

        if (options.sessionId != null) {
            options.sessionId = options.sessionId.replaceAll("-", "_");
        }

        // Check that sessionId was sanitized (hyphens replaced with underscores)
        assertEquals("test_session_123", options.sessionId);
    }

    @Test
    public void test_process_withPropertiesPath() throws Exception {

    int writeParameterWordsWireFormat(final byte[] dst, int dstIndex) {

        if (session.transport.server.security == SECURITY_SHARE && (session.auth.hashesExternal || session.auth.password.length() > 0)) {

            if (session.transport.server.encryptedPasswords) {
                // encrypted
                password = session.auth.getAnsiHash(session.transport.server.encryptionKey);
                passwordLength = password.length;

        }

        return result;
    }

    @Override
    public void add(RepositorySystemSession session, LocalArtifactRegistration request) {
        // noop
    }

    @Override
    public LocalMetadataResult find(RepositorySystemSession session, LocalMetadataRequest request) {
        LocalMetadataResult result = new LocalMetadataResult(request);

        String path;