assertThrows(OutOfScopeException.class, () -> bean.myBean.getSession());

        sessionScope.enter();
        sessionScope.seed(Session.class, this.session);
        assertNotNull(bean.myBean.getSession());
        assertNotNull(bean.myBean.getAnotherBean());
        assertSame(bean.myBean.getAnotherBean().getClass(), AnotherBean.class);

    protected void configure() {
        bindScope(SessionScoped.class, scope);
        // bindScope(org.apache.maven.api.di.SessionScoped.class, scope);
        bind(SessionScope.class).toInstance(scope);

        bind(MavenSession.class)
                .toProvider(SessionScope.seededKeyProvider(MavenSession.class))
                .in(scope);
        bind(Session.class)
                .toProvider(SessionScope.seededKeyProvider(Session.class))

                .distinct()
                .forEach(key -> {
                    Class<?> clazz = key.getRawType();
                    Class<Object> itf = (clazz.isInterface()
                            ? null
                            : (Class<Object>) (clazz.getInterfaces().length > 0 ? clazz.getInterfaces()[0] : clazz));
                    if (itf != null) {

        return new ProjectModelResolver(
                repoSession,
                null,
                getContainer().lookup(RepositorySystem.class),
                getContainer().lookup(RemoteRepositoryManager.class),
                this.getRemoteRepositories(),
                ProjectBuildingRequest.RepositoryMerging.REQUEST_DOMINANT,
                null,
                null);
    }

    /**
     * Create a key using the given class as an identifier and as the type of the object.
     */
    static <T> Key<T> key(Class<T> clazz) {
        return new Key<>(clazz, clazz);
    }

    /**
     * Create a key using the given class and id.
     */
    static <T> Key<T> key(Class<T> clazz, Object id) {
        return new Key<>(clazz, id);
    }

    /**

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;

class ConsumerPomArtifactTransformerTest {

    @Test
    void transform() throws Exception {
        RepositorySystemSession systemSessionMock = Mockito.mock(RepositorySystemSession.class);
        SessionData sessionDataMock = Mockito.mock(SessionData.class);
        when(systemSessionMock.getData()).thenReturn(sessionDataMock);

import org.apache.maven.SessionScoped;
import org.apache.maven.api.*;
import org.apache.maven.api.services.*;
import org.apache.maven.api.spi.*;

public class ExtensibleEnumRegistries {

    @Named
    @SessionScoped
    public static class DefaultPathScopeRegistry extends DefaultExtensibleEnumRegistry<PathScope, PathScopeProvider>
            implements PathScopeRegistry {

        @Inject

    static InternalSession from(Session session) {
        return cast(InternalSession.class, session, "session should be an " + InternalSession.class);
    }

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

    }

    @Test
    void testArtifactInstallation() throws Exception {
        sessionScope.enter();
        try {
            sessionScope.seed(MavenSession.class, mock(MavenSession.class));

            String artifactBasedir = new File(getBasedir(), "src/test/resources/artifact-install").getAbsolutePath();

            Artifact artifact = createArtifact("artifact", "1.0");

//      from the plugin archive.
// TODO this will be the class that people get in IDEs to modify

/**
 * MavenExecutionPlan
 */
public class MavenExecutionPlan implements Iterable<ExecutionPlanItem> {

    /*
      At the moment, this class is totally immutable, and this is in line with thoughts about the