*
     * @param session The session, never {@code null}.
     * @param result The artifact descriptor result, never {@code null}.
     * @param model The artifact model, never {@code null}.
     * @return The {@link Artifact} to relocate to, or {@code null} if no relocation wanted.
     */
    Artifact relocatedTarget(RepositorySystemSession session, ArtifactDescriptorResult result, Model model)

        eps.setProperty("jre.home", new File(pom.getParentFile(), "jdk/jre").getPath());

        MavenSession session = createMavenSession(pom, eps);
        MavenProject project = session.getCurrentProject();

        project.setArtifacts(resolver.resolve(project, Collections.singleton(Artifact.SCOPE_COMPILE), session));

        List<String> elements = project.getCompileClasspathElements();
        assertEquals(2, elements.size());

     * @param project         The project whose dependencies should be resolved, must not be {@code null}.
     * @param scopesToResolve The dependency scopes that should be resolved, may be {@code null}.
     * @param session         The current build session, must not be {@code null}.
     * @return The transitive dependencies of the specified project that match the requested scopes, never {@code null}.
     * @throws ArtifactResolutionException in case of resolution issue

        TransferEvent transferInitiatedEvent = event(session, resource, TransferEvent.EventType.INITIATED);
        TransferEvent transferStartedEvent = event(session, resource, TransferEvent.EventType.STARTED);
        TransferEvent transferProgressedEvent = event(session, resource, TransferEvent.EventType.PROGRESSED);
        TransferEvent transferSucceededEvent = event(session, resource, TransferEvent.EventType.SUCCEEDED);

        when(rootProject.getBasedir()).thenReturn(basedir);
        MavenSession session = mock(MavenSession.class);
        when(session.getTopLevelProject()).thenReturn(rootProject);
        when(session.getTopDirectory()).thenReturn(basedir.toPath());
        when(event.getSession()).thenReturn(session);

        // execute
        executionEventLogger.projectStarted(event);

        // verify

            MavenSession session, MavenProject project, MojoExecution mojoExecution, Mojo mojo, Throwable cause) {
        this.session = session;
        this.project = project;
        this.mojoExecution = mojoExecution;
        this.mojo = mojo;
        this.cause = cause;
    }

    public MavenSession getSession() {
        return session;
    }

    public MavenProject getProject() {
        return project;
    }

            ArtifactRepository repository, RepositorySystemSession session, RepositorySystem system) {
        if (repository == null || repository.getBasedir() == null) {
            return session;
        }

        DefaultRepositorySystemSession newSession;
        if (session != null) {
            LocalRepositoryManager lrm = session.getLocalRepositoryManager();

@Typed
@SessionScoped
public class DefaultProjectManager implements ProjectManager {

    private final InternalMavenSession session;
    private final ArtifactManager artifactManager;

    @Inject
    public DefaultProjectManager(InternalMavenSession session, ArtifactManager artifactManager) {
        this.session = session;
        this.artifactManager = artifactManager;
    }

    @Nonnull
    @Override

            }
        }

        return results;
    }

    public ArtifactResult resolveArtifact(RepositorySystemSession session, ArtifactRequest request)
            throws ArtifactResolutionException {
        return resolveArtifacts(session, Collections.singleton(request)).get(0);
    }

        DefaultRepositorySystemSession session = new DefaultRepositorySystemSession(h -> false);
        session.setScopeManager(new ScopeManagerImpl(Maven4ScopeManagerConfiguration.INSTANCE));
        session.setArtifactDescriptorPolicy(new SimpleArtifactDescriptorPolicy(true, true));
        DependencyTraverser depTraverser = new FatArtifactTraverser();
        session.setDependencyTraverser(depTraverser);