}

    public String getReactorFailureBehavior() {
        return request.getReactorFailureBehavior();
    }

    @Override
    public MavenSession clone() {
        try {
            MavenSession clone = (MavenSession) super.clone();
            // the default must become the current project of the thread that clones this
            MavenProject current = getCurrentProject();

    protected Session newSession(RepositorySystemSession repoSession, List<RemoteRepository> repositories) {
        final MavenSession ms = nonNull(mavenSession);
        final MavenSession mss;
        if (repoSession != ms.getRepositorySession()) {
            mss = new MavenSession(repoSession, ms.getRequest(), ms.getResult());
        } else {
            mss = ms;
        }
        return newSession(mss, repositories);
    }

            IssueLocality locality, MavenSession mavenSession, MojoDescriptor mojoDescriptor, String issue) {
        String pluginKey = pluginKey(mojoDescriptor);
        if (validationPluginExcludes(mavenSession.getRepositorySession()).contains(pluginKey)) {
            return;
        }
        PluginValidationIssues pluginIssues = pluginIssues(mavenSession.getRepositorySession())

        factories.put("rare", toolchainFactory_rareType);
        toolchainManager = new DefaultToolchainManager(factories, logger);
    }

    @Test
    void testNoModels() {
        MavenSession session = mock(MavenSession.class);
        MavenExecutionRequest executionRequest = new DefaultMavenExecutionRequest();
        when(session.getRequest()).thenReturn(executionRequest);

        Path path = Paths.get("").toAbsolutePath();

        MavenSession mavenSession = createMavenSession(null);
        mavenSession.getRequest().setTopDirectory(path);
        mavenSession.getRequest().setRootDirectory(path);

        Object result = new PluginParameterExpressionEvaluator(mavenSession, new MojoExecution(null))
                .evaluate("${session.rootDirectory.uri}");

        toolchainManager = new DefaultToolchainManagerPrivate(factories, logger);
    }

    @Test
    void testToolchainsForAvailableType() throws Exception {
        // prepare
        MavenSession session = mock(MavenSession.class);
        MavenExecutionRequest req = new DefaultMavenExecutionRequest();
        when(session.getRequest()).thenReturn(req);

        ToolchainPrivate basicToolchain = mock(ToolchainPrivate.class);

 */
@Named
@Singleton
public class DefaultLegacySupport implements LegacySupport {

    private static final ThreadLocal<AtomicReference<MavenSession>> SESSION = new InheritableThreadLocal<>();

    public void setSession(MavenSession session) {
        AtomicReference<MavenSession> reference = DefaultLegacySupport.SESSION.get();
        if (reference != null) {
            reference.set(null);
        }

        MavenSession m1 = new MavenSession(null, null, mavenExecutionRequest, null);
        defaultLegacySupport.setSession(m1);

        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();

        MavenSession m2 = new MavenSession(null, null, mavenExecutionRequest, null);
        defaultLegacySupport.setSession(m2);

        try (CloseableSession closeableSession = newCloseableSession(request, chainedWorkspaceReader)) {
            MavenSession session = new MavenSession(closeableSession, request, result);
            session.setSession(defaultSessionFactory.newSession(session));

            sessionScope.seed(MavenSession.class, session);
            sessionScope.seed(Session.class, session.getSession());

        return false;
    }

    @Override
    public final void validate(
            MavenSession mavenSession,
            MojoDescriptor mojoDescriptor,
            Class<?> mojoClass,
            PlexusConfiguration pomConfiguration,
            ExpressionEvaluator expressionEvaluator) {
        doValidate(mavenSession, mojoDescriptor, mojoClass, pomConfiguration, expressionEvaluator);
    }