*/
package org.apache.maven.plugin.lifecycle;

/**
 * A phase mapping definition.
 *
 * @version $Revision$ $Date$
 */
@SuppressWarnings("all")
public class Phase implements java.io.Serializable {

    // --------------------------/
    // - Class/Member Variables -/
    // --------------------------/

    /**
     * The ID of this phase, e.g., <code>generate-sources</code>.
     */
    private String id;

public class Lifecycles {

    static Lifecycle.Phase phase(String name) {
        return new DefaultPhase(name, Collections.emptyList(), Collections.emptyList(), Collections.emptyList());
    }

    static Lifecycle.Phase phase(String name, Lifecycle.Phase... phases) {
        return new DefaultPhase(name, Collections.emptyList(), Collections.emptyList(), asList(phases));
    }

     * the phase. Any {@link #AFTER} phases will still be executed.
     */
    AT(""),
    /**
     * Guaranteed execution dynamic phases on completion of the static phase. All {@code #AFTER} dynamic phases will
     * be executed provided at least one {@link #BEFORE} or {@link #AT} dynamic phase has started execution.
     */
    AFTER("after:");

        return lifecycleOverlay.getId();
    }

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

                    @Override

                // if the phase is specified then I don't have to go fetch the plugin yet and pull it down
                // to examine the phase it is associated to.
                String phase = execution.getPhase();
                if (aliases.containsKey(phase)) {
                    phase = aliases.get(phase);
                }
                if (phase != null) {

        return phases();
    }

    /**
     * Stream of phases containing all child phases recursively.
     *
     * @return a stream of all phases in this lifecycle, including nested phases
     */
    default Stream<Phase> allPhases() {
        return phases().stream().flatMap(Phase::allPhases);
    }

    /**
     * Collection of aliases for this lifecycle.

     */
    public java.util.List<Phase> getPhases() {
        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);

        this.id = lifecycle.id();
        this.phases = registry.computePhases(lifecycle);
        this.defaultPhases = getDefaultPhases(lifecycle);
    }

    // <lifecycle>
    //   <id>clean</id>
    //   <phases>
    //     <phase>pre-clean</phase>
    //     <phase>clean</phase>
    //     <phase>post-clean</phase>
    //   </phases>
    //   <default-phases>

        </field>
        <field>
          <name>phases</name>
          <version>1.0.0+</version>
          <description>The phase mappings for this lifecycle.</description>
          <association>
            <type>Phase</type>
            <multiplicity>*</multiplicity>
          </association>
        </field>
      </fields>
    </class>
    <class>
      <name>Phase</name>
      <version>1.0.0+</version>

    }

    @Test
    void testSet() {
        LifecyclePhase phase = new LifecyclePhase();
        assertNull(phase.getMojos());

        phase.set("");
        assertNotNull(phase.getMojos());
        assertEquals(0, phase.getMojos().size());

        phase.set("jar:jar, war:war");

        List<LifecycleMojo> mojos = phase.getMojos();
        assertNotNull(mojos);