public void execute(List<MojoExecution> mojos, MavenSession session, MojoExecutionRunner mojoRunner)
            throws LifecycleExecutionException {
        for (MojoExecution mojoExecution : mojos) {
            mojoRunner.run(mojoExecution);
        }
    }

     *
     * @param mojos             list of mojos representing a project build
     * @param session           current session
     * @param mojoExecutionRunner mojo execution task which must be invoked by a strategy to actually run it
     * @throws LifecycleExecutionException
     */
    void execute(List<MojoExecution> mojos, MavenSession session, MojoExecutionRunner mojoExecutionRunner)
            throws LifecycleExecutionException;

                    || actualOsName.contains("98")
                    || actualOsName.contains("me")
                    // wince isn't really 9x, but crippled enough to
                    // be a muchness. Maven doesnt run on CE, anyway.
                    || actualOsName.contains("ce"));
            isNT = !is9x;
        }
        switch (family) {
            case FAMILY_WINDOWS:
                return isWindows;

        thread.join();
        assertNull(myRunnable.getSession());
    }

    class MyRunnable implements Runnable {

        private volatile MavenSession session;

        public void run() {
            try {
                latch.await();
            } catch (InterruptedException ignore) {
                // Test may fail if we get interrupted
            }

        echo "OS: ${os} JDK: ${jdk} => Label: ${osLabel} JDK: ${jdkName} Arch: s390x"

        String stageId = "${os}-jdk${jdk}-s390x"
        String stageLabel = "Run ITs ${os.capitalize()} Java ${jdk} on s390x"
        runITsTasks[stageId] = {
            node('s390x') {
                stage("${stageLabel}") {
                    echo "NODE_NAME = ${env.NODE_NAME}"

    private final Executor executor;

    public DefaultArtifactResolver() {
        int threads = Integer.getInteger("maven.artifact.threads", 5);
        if (threads <= 1) {
            executor = Runnable::run;
        } else {
            executor = new ThreadPoolExecutor(
                    threads, threads, 3, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), new DaemonThreadCreator());
        }
    }

    }

    /**
     * All dependencies that this project has, including transitive ones. Contents are lazily populated, so depending on
     * what phases have run dependencies in some scopes won't be included. e.g. if only compile phase has run,
     * dependencies with scope test won't be included.
     *
     * @return {@link Set} < {@link Artifact} >
     * @see #getDependencyArtifacts() to get only direct dependencies

          <description>
            A set of dependencies which the plugin requires in order to function. This enables the plugin to function
            independently of its POM (or at least to declare the libraries it needs to run).
          </description>
        </field>
      </fields>
      <codeSegments>
        <codeSegment>
          <version>2.0.0+</version>
          <code><![CDATA[
    public String getPluginLookupKey() {

        } catch (MavenExecutionException e) {
            return addExceptionToResult(result, e);
        }

        //
        // The projects need to be topologically after the participants have run their afterProjectsRead(session)
        // because the participant is free to change the dependencies of a project which can potentially change the

        mojosExecutionStrategy.get().execute(mojoExecutions, session, new MojoExecutionRunner() {
            @Override
            public void run(MojoExecution mojoExecution) throws LifecycleExecutionException {
                MojoExecutor.this.execute(session, mojoExecution, dependencyContext, phaseRecorder);
            }
        });
    }