}

    @Override
    public TestLogging getLifecycle() {
        return perLevelTestLogging.get(LogLevel.LIFECYCLE);
    }

    @Override
    public void setLifecycle(TestLogging logging) {
        perLevelTestLogging.put(LogLevel.LIFECYCLE, logging);
    }

    @Override
    public void lifecycle(Action<TestLogging> action) {
        action.execute(getLifecycle());
    }

    @Override

        //   are not observable from eager configuration blocks, which would anyway be incompatible with
        //   Isolated Projects.
        if (isIsolatedProjects()) {
            gradle.getLifecycle().beforeProject(action::execute);
        } else {
            gradle.allprojects(action);
        }
    }

    private boolean isIsolatedProjects() {

     *
     * @return logging options for lifecycle level
     */
    TestLogging getLifecycle();

    /**
     * Sets logging options for lifecycle level.
     *
     * @param logging logging options for lifecycle level
     */
    void setLifecycle(TestLogging logging);

    /**
     * Configures logging options for lifecycle level.
     *

        delegate.gradleVersion

    override fun getGradleUserHomeDir(): File =
        delegate.gradleUserHomeDir

    override fun getGradleHomeDir(): File? =
        delegate.gradleHomeDir

    override fun getLifecycle(): GradleLifecycle =
        delegate.lifecycle

    override fun getParent(): Gradle? =
        delegate.parent

    override fun getRootProject(): Project =
        delegate.rootProject

                        final Dsl dsl = target.getExtensions().create("dsl", Dsl.class);
                        target.getGradle().getLifecycle().beforeProject(project -> {
                            project.getTasks().register("test", TestTask.class, task -> {
                                task.getTaskParameter().set(dsl.getParameter());

                new DefaultLookup(mockedPlexusContainer));

        assertThat(dl.getLifeCycles().get(0).getId(), is("clean"));
        assertThat(dl.getLifeCycles().get(1).getId(), is("default"));
        assertThat(dl.getLifeCycles().get(2).getId(), is("site"));
        assertThat(dl.getLifeCycles().get(3).getId(), is("wrapper"));
        assertThat(dl.getLifeCycles().get(4).getId(), is("etl"));
    }

     *
     * @param lifecycle a lifecycle object.
     */
    public void addLifecycle(Lifecycle lifecycle) {
        getLifecycles().add(lifecycle);
    } // -- void addLifecycle( Lifecycle )

    /**
     * Method getLifecycles.
     *
     * @return List
     */
    public java.util.List<Lifecycle> getLifecycles() {
        if (this.lifecycles == null) {
            this.lifecycles = new java.util.ArrayList<Lifecycle>();
        }

        // so that they don't interfere with internally defined lifecycles.

        Map<String, Lifecycle> phaseToLifecycleMap = new HashMap<>();

        for (Lifecycle lifecycle : getLifeCycles()) {
            logger.debug("Lifecycle {}", lifecycle);

            for (String phase : lifecycle.getPhases()) {
                // The first definition wins.

                }
            } else {
                /*
                 * NOTE: This is to provide a migration path for implementors of the legacy API which did not know about
                 * getLifecycles().
                 */

                String[] lifecycleIds = {"default", "clean", "site"};

                for (String lifecycleId : lifecycleIds) {

import java.util.Map;

/**
 * LifecycleMapping
 */
public interface LifecycleMapping {

    @Deprecated
    String ROLE = LifecycleMapping.class.getName();

    Map<String, Lifecycle> getLifecycles();

    @Deprecated
    List<String> getOptionalMojos(String lifecycle);

    @Deprecated
    Map<String, String> getPhases(String lifecycle);