if (this.phases == null) {
            this.phases = new java.util.ArrayList<Phase>();
        }

        return this.phases;
    } // -- java.util.List<Phase> getPhases()

    /**
     * Method removePhase.
     *
     * @param phase a phase object.
     */
    public void removePhase(Phase phase) {
        getPhases().remove(phase);
    } // -- void removePhase( Phase )

    /**

        assertEquals("default", lifecycle.getId());
        assertEquals(54, lifecycle.getPhases().size());
    }

    @Test
    void testCleanLifecycle() {
        final Lifecycle lifecycle = getLifeCycleById("clean");
        assertEquals("clean", lifecycle.getId());
        assertEquals(3, lifecycle.getPhases().size());
    }

    @Test
    void testSiteLifecycle() {

         * is interested in, i.e. all phases up to and including the specified phase.
         */

        Map<String, Map<PhaseId, List<MojoExecution>>> mappings =
                new TreeMap<>(new PhaseComparator(lifecycle.getPhases()));

        Map<String, String> aliases = lifecycle.getDelegate().aliases().stream()
                .collect(Collectors.toMap(a -> a.v3Phase(), a -> a.v4Phase()));

        if (aliases.containsKey(lifecyclePhase)) {

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

        for (Lifecycle lifecycle : getLifeCycles()) {
            for (String phase : lifecycle.getPhases()) {
                // The first definition wins.
                Lifecycle original = phaseToLifecycleMap.put(phase, lifecycle);
                if (original != null && logger.isWarnEnabled()) {

    String ROLE = LifecycleMapping.class.getName();

    Map<String, Lifecycle> getLifecycles();

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

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

    }

    @Override
    public String id() {
        return lifecycleOverlay.getId();
    }

    @Override
    public Collection<Phase> phases() {
        return lifecycleOverlay.getPhases().stream()
                .map(phase -> new Phase() {
                    @Override
                    public String name() {
                        return phase.getId();
                    }

    public String getId() {
        return id;
    }

    public org.apache.maven.api.Lifecycle getDelegate() {
        return lifecycle;
    }

    public List<String> getPhases() {
        return phases;
    }

    static Map<String, LifecyclePhase> getDefaultPhases(org.apache.maven.api.Lifecycle lifecycle) {
        Map<String, List<String>> goals = new HashMap<>();

     */
    public void setLifecyclePhases(Map<String, LifecyclePhase> lifecyclePhases) {
        this.lifecyclePhases = lifecyclePhases;
    }

    @Deprecated
    public Map<String, String> getPhases() {
        Map<String, LifecyclePhase> lphases = getLifecyclePhases();
        if (lphases == null) {
            return null;
        }

        if (lphases.isEmpty()) {
            return Collections.emptyMap();

        } else if ("default".equals(lifecycle)) {
            return phases;
        } else {
            return null;
        }
    }

    @Deprecated
    @Override
    public Map<String, String> getPhases(String lifecycle) {
        return LifecyclePhase.toLegacyMap(getLifecyclePhases(lifecycle));
    }

                final Lifecycle lifecycle = defaultLifecycles.get(phase);
                if (lifecycle != null) {
                    totalPhaseSet.addAll(lifecycle.getPhases());
                }
            }
        }
        this.phasesInExecutionPlan = new ArrayList<>(totalPhaseSet);

        Map<String, ExecutionPlanItem> lastInExistingPhases = new HashMap<>();