List<PluginExecution> executions =
                (List<PluginExecution>) pom.getValue("build/plugins[@artifactId='maven-resources-plugin']/executions");
        assertNotNull(executions);
        assertEquals(4, executions.size());
        assertEquals("default-resources", executions.get(0).getId());
        assertEquals("default-testResources", executions.get(1).getId());

          <description>If specified, identifies a within phase prioritization of executions.</description>
        </field>
        <field>
          <name>executions</name>
          <version>1.0.0+</version>
          <description>The goals to execute within the phase.</description>
          <association>
            <type>Execution</type>
            <multiplicity>*</multiplicity>
          </association>

import org.apache.maven.project.MavenProject;

/**
 */
public class MojoExecutorStub extends MojoExecutor { // This is being lazy instead of making interface

    protected final List<MojoExecution> executions = Collections.synchronizedList(new ArrayList<>());

    public MojoExecutorStub() {
        super(null, null, null, null, null, null);
    }

    public MojoExecutorStub(

 * #startUp} and {@link #shutDown}) will never run concurrently. Notably, if any execution of {@link
 * #runOneIteration} takes longer than its schedule defines, then subsequent executions may start
 * late. Also, all life cycle methods are executed with a lock held, so subclasses can safely modify
 * shared state without additional synchronization necessary for visibility to later executions of
 * the life cycle methods.
 *
 * <h3>Usage Example</h3>
 *

          </models>
        </configuration>
        <executions>
          <execution>
            <id>modello</id>
            <goals>
              <goal>java</goal>
              <goal>xpp3-reader</goal>
              <goal>xpp3-writer</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>

   * known limitations are notably that:

     1. plugin goal execution in a child is usually simply appended (at end): you can't try to insert in the middle of pre-existing inherited executions,

     2. append happens at plugin level first, then goal level, independently from phases.

        plugin.setLocation("version", new InputLocation(12, 34, defaultBindings));
        MojoExecution result = new MojoExecution(plugin, goal, executionId);
        result.setConfiguration(XmlNode.newInstance(executionId + "-" + goal));
        result.setMojoDescriptor(mojoDescriptor);
        result.setLifecyclePhase(mojoDescriptor.getPhase());

        return result;
    }

 * This class coordinates the execution of data store crawling processes,
 * managing multiple concurrent crawling threads and handling the indexing
 * of crawled documents into the search engine.
 *
 * <p>The DataIndexHelper supports:</p>
 * <ul>
 *   <li>Concurrent crawling of multiple data configurations</li>
 *   <li>Thread pool management for crawler execution</li>

It is important to keep TensorFlow up to date with the latest security patches
and follow the sandboxing guideline above to protect against these types of
vulnerabilities.

## Security properties of execution modes

TensorFlow has several execution modes, with Eager-mode being the default in v2.
Eager mode lets users write imperative-style statements that can be easily
inspected and debugged and it is intended to be used during the development
phase.

import org.apache.maven.classrealm.ClassRealmManager;
import org.apache.maven.di.Injector;
import org.apache.maven.di.Key;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.execution.scope.internal.MojoExecutionScope;
import org.apache.maven.execution.scope.internal.MojoExecutionScopeModule;
import org.apache.maven.internal.impl.DefaultLog;
import org.apache.maven.internal.impl.DefaultMojoExecution;