package org.apache.maven.plugin.surefire;

 /*

  * Licensed to the Apache Software Foundation (ASF) under one

  * or more contributor license agreements.  See the NOTICE file

  * distributed with this work for additional information

  * regarding copyright ownership.  The ASF licenses this file

  * to you under the Apache License, Version 2.0 (the

  * "License"); you may not use this file except in compliance

  * with the License.  You may obtain a copy of the License at

  *

  *     http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing,

  * software distributed under the License is distributed on an

  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

  * KIND, either express or implied.  See the License for the

  * specific language governing permissions and limitations

  * under the License.

  */

 import java.io.File;

 import java.io.IOException;

 import java.lang.reflect.Method;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.LinkedHashSet;

 import java.util.List;

 import java.util.Map;

 import java.util.Map.Entry;

 import java.util.Properties;

 import java.util.Set;

 import org.apache.maven.artifact.Artifact;

 import org.apache.maven.artifact.factory.ArtifactFactory;

 import org.apache.maven.artifact.metadata.ArtifactMetadataSource;

 import org.apache.maven.artifact.repository.ArtifactRepository;

 import org.apache.maven.artifact.resolver.ArtifactNotFoundException;

 import org.apache.maven.artifact.resolver.ArtifactResolutionException;

 import org.apache.maven.artifact.resolver.ArtifactResolutionResult;

 import org.apache.maven.artifact.resolver.ArtifactResolver;

 import org.apache.maven.artifact.resolver.filter.ArtifactFilter;

 import org.apache.maven.artifact.resolver.filter.ExcludesArtifactFilter;

 import org.apache.maven.artifact.resolver.filter.ScopeArtifactFilter;

 import org.apache.maven.artifact.versioning.ArtifactVersion;

 import org.apache.maven.artifact.versioning.DefaultArtifactVersion;

 import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;

 import org.apache.maven.artifact.versioning.VersionRange;

 import org.apache.maven.execution.MavenSession;

 import org.apache.maven.model.Plugin;

 import org.apache.maven.plugin.AbstractMojo;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.plugin.MojoFailureException;

 import org.apache.maven.plugin.descriptor.PluginDescriptor;

 import org.apache.maven.plugin.logging.Log;

 import org.apache.maven.plugin.surefire.booterclient.ChecksumCalculator;

 import org.apache.maven.plugin.surefire.booterclient.ForkConfiguration;

 import org.apache.maven.plugin.surefire.booterclient.ForkStarter;

 import org.apache.maven.plugin.surefire.util.DependencyScanner;

 import org.apache.maven.plugin.surefire.util.DirectoryScanner;

 import org.apache.maven.plugins.annotations.Component;

 import org.apache.maven.plugins.annotations.Parameter;

 import org.apache.maven.project.MavenProject;

 import org.apache.maven.shared.artifact.filter.PatternIncludesArtifactFilter;

 import org.apache.maven.shared.utils.StringUtils;

 import org.apache.maven.shared.utils.io.FileUtils;

 import org.apache.maven.surefire.booter.ClassLoaderConfiguration;

 import org.apache.maven.surefire.booter.Classpath;

 import org.apache.maven.surefire.booter.ClasspathConfiguration;

 import org.apache.maven.surefire.booter.KeyValueSource;

 import org.apache.maven.surefire.booter.ProviderConfiguration;

 import org.apache.maven.surefire.booter.ProviderParameterNames;

 import org.apache.maven.surefire.booter.StartupConfiguration;

 import org.apache.maven.surefire.booter.SurefireBooterForkException;

 import org.apache.maven.surefire.booter.SurefireExecutionException;

 import org.apache.maven.surefire.report.ReporterConfiguration;

 import org.apache.maven.surefire.suite.RunResult;

 import org.apache.maven.surefire.testset.DirectoryScannerParameters;

 import org.apache.maven.surefire.testset.RunOrderParameters;

 import org.apache.maven.surefire.testset.TestArtifactInfo;

 import org.apache.maven.surefire.testset.TestRequest;

 import org.apache.maven.surefire.testset.TestSetFailedException;

 import org.apache.maven.surefire.util.DefaultScanResult;

 import org.apache.maven.surefire.util.NestedCheckedException;

 import org.apache.maven.surefire.util.NestedRuntimeException;

 import org.apache.maven.surefire.util.RunOrder;

 import org.apache.maven.toolchain.Toolchain;

 import org.apache.maven.toolchain.ToolchainManager;

 import javax.annotation.Nonnull;

 /**

  * Abstract base class for running tests using Surefire.

  *

  * @author Stephen Connolly

  * @version $Id: SurefirePlugin.java 945065 2010-05-17 10:26:22Z stephenc $

  */

 public abstract class AbstractSurefireMojo

     extends AbstractMojo

     implements SurefireExecutionParameters

 {

     // common mojo parameters

     /**

      * Information about this plugin, mainly used to lookup this plugin's configuration from the currently executing

      * project.

      *

      * @since 2.12

      */

     @Parameter( defaultValue = "${plugin}", readonly = true )

     protected PluginDescriptor pluginDescriptor;

     /**

      * Set this to "true" to skip running tests, but still compile them. Its use is NOT RECOMMENDED, but quite

      * convenient on occasion.

      *

      * @since 2.4

      */

     @Parameter( property = "skipTests", defaultValue = "false" )

     protected boolean skipTests;

     /**

      * This old parameter is just like <code>skipTests</code>, but bound to the old property "maven.test.skip.exec".

      *

      * @since 2.3

      * @deprecated Use skipTests instead.

      */

     @Parameter( property = "maven.test.skip.exec" )

     protected boolean skipExec;

     /**

      * Set this to "true" to bypass unit tests entirely. Its use is NOT RECOMMENDED, especially if you enable it using

      * the "maven.test.skip" property, because maven.test.skip disables both running the tests and compiling the tests.

      * Consider using the <code>skipTests</code> parameter instead.

      */

     @Parameter( property = "maven.test.skip", defaultValue = "false" )

     protected boolean skip;

     /**

      * The Maven Project Object.

      */

     @Component

     protected MavenProject project;

     /**

      * The base directory of the project being tested. This can be obtained in your integration test via

      * System.getProperty("basedir").

      */

     @Parameter( defaultValue = "${basedir}" )

     protected File basedir;

     /**

      * The directory containing generated test classes of the project being tested. This will be included at the

      * beginning of the test classpath. *

      */

     @Parameter( defaultValue = "${project.build.testOutputDirectory}" )

     protected File testClassesDirectory;

     /**

      * The directory containing generated classes of the project being tested. This will be included after the test

      * classes in the test classpath.

      */

     @Parameter( defaultValue = "${project.build.outputDirectory}" )

     protected File classesDirectory;

     /**

      * List of dependencies to exclude from the test classpath. Each dependency string must follow the format

      * <i>groupId:artifactId</i>. For example: <i>org.acme:project-a</i>

      *

      * @since 2.6

      */

     @Parameter( property = "maven.test.dependency.excludes" )

     private String[] classpathDependencyExcludes;

     /**

      * A dependency scope to exclude from the test classpath. The scope should be one of the scopes defined by

      * org.apache.maven.artifact.Artifact. This includes the following:

      * <p/>

      * <ul>

      * <li><i>compile</i> - system, provided, compile

      * <li><i>runtime</i> - compile, runtime

      * <li><i>compile+runtime</i> - system, provided, compile, runtime

      * <li><i>runtime+system</i> - system, compile, runtime

      * <li><i>test</i> - system, provided, compile, runtime, test

      * </ul>

      *

      * @since 2.6

      */

     @Parameter( defaultValue = "" )

     private String classpathDependencyScopeExclude;

     /**

      * Additional elements to be appended to the classpath.

      *

      * @since 2.4

      */

     @Parameter( property = "maven.test.additionalClasspath" )

     private String[] additionalClasspathElements;

     /**

      * The test source directory containing test class sources.

      *

      * @since 2.2

      */

     @Parameter( defaultValue = "${project.build.testSourceDirectory}", required = true )

     protected File testSourceDirectory;

     /**

      * A file containing include patterns.

      * Blank lines, or lines starting with # are ignored.  If {@code includes} are also specified these patterns are appended.

      */

     @Parameter

     protected File includesFile;

     /**

      * A list of <exclude> elements specifying the tests (by pattern) that should be excluded in testing. When not

      * specified and when the <code>test</code> parameter is not specified, the default excludes will be <code><br/>

      * &lt;excludes><br/>

      * &nbsp;&lt;exclude>**&#47;*$*&lt;/exclude><br/>

      * &lt;/excludes><br/>

      * </code> (which excludes all inner classes).<br>

      * This parameter is ignored if the TestNG <code>suiteXmlFiles</code> parameter is specified.

      * <p/>

      * Each exclude item may also contain a comma-separated sublist of items, which will be treated as multiple

      * &nbsp;&lt;exclude> entries.<br/>

      */

     @Parameter

     protected List<String> excludes;

     /**

      * A file containing exclude patterns.

      * Blank lines, or lines starting with # are ignored.  If {@code excludes} are also specified these patterns are appended.

      */

     @Parameter

     protected File excludesFile;

     /**

      * ArtifactRepository of the localRepository. To obtain the directory of localRepository in unit tests use

      * System.getProperty("localRepository").

      */

     @Parameter( defaultValue = "${localRepository}", required = true, readonly = true )

     protected ArtifactRepository localRepository;

     /**

      * List of System properties to pass to the JUnit tests.

      *

      * @deprecated Use systemPropertyVariables instead.

      */

     @Parameter

     protected Properties systemProperties;

     /**

      * List of System properties to pass to the JUnit tests.

      *

      * @since 2.5

      */

     @Parameter

     protected Map<String, String> systemPropertyVariables;

     /**

      * List of System properties, loaded from a file, to pass to the JUnit tests.

      *

      * @since 2.8.2

      */

     @Parameter

     protected File systemPropertiesFile;

     /**

      * List of properties for configuring all TestNG related configurations. This is the new preferred method of

      * configuring TestNG.

      *

      * @since 2.4

      */

     @Parameter

     protected Properties properties;

     /**

      * Map of plugin artifacts.

      */

     // olamy: would make more sense using defaultValue but doesn't work with maven 2.x

     @Parameter( property = "plugin.artifactMap", required = true, readonly = true )

     protected Map<String, Artifact> pluginArtifactMap;

     /**

      * Map of project artifacts.

      */

     // olamy: would make more sense using defaultValue but doesn't work with maven 2.x

     @Parameter( property = "project.artifactMap", readonly = true, required = true )

     protected Map<String, Artifact> projectArtifactMap;

     /**

      * Add custom text into report filename: TEST-testClassName-reportNameSuffix.xml,

      * testClassName-reportNameSuffix.txt and testClassName-reportNameSuffix-output.txt.

      * File TEST-testClassName-reportNameSuffix.xml has changed attributes 'testsuite'--'name'

      * and 'testcase'--'classname' - reportNameSuffix is added to the attribute value.

      */

     @Parameter( property = "surefire.reportNameSuffix", defaultValue = "" )

     protected String reportNameSuffix;

     /**

      * Set this to "true" to redirect the unit test standard output to a file (found in

      * reportsDirectory/testName-output.txt).

      *

      * @since 2.3

      */

     @Parameter( property = "maven.test.redirectTestOutputToFile", defaultValue = "false" )

     protected boolean redirectTestOutputToFile;

     /**

      * Set this to "true" to cause a failure if there are no tests to run. Defaults to "false".

      *

      * @since 2.4

      */

     @Parameter( property = "failIfNoTests" )

     protected Boolean failIfNoTests;

     /**

      * <strong>DEPRECATED</strong> since version 2.14. Use <code>forkCount</code> and <code>reuseForks</code> instead.<br/>

      * <br/>

      * Option to specify the forking mode. Can be "never", "once", "always", "perthread". "none" and "pertest" are also accepted

      * for backwards compatibility. "always" forks for each test-class. "perthread" will create <code>threadCount</code>

      * parallel forks, each executing one test-class. See also parameter <code>reuseForks</code>.<br/>

      *

      * @since 2.1

      */

     @Parameter( property = "forkMode", defaultValue = "once" )

     protected String forkMode;

     /**

      * Option to specify the jvm (or path to the java executable) to use with the forking options. For the default, the

      * jvm will be a new instance of the same VM as the one used to run Maven. JVM settings are not inherited from

      * MAVEN_OPTS.

      *

      * @since 2.1

      */

     @Parameter( property = "jvm" )

     protected String jvm;

     /**

      * Arbitrary JVM options to set on the command line.

      *

      * @since 2.1

      */

     @Parameter( property = "argLine" )

     protected String argLine;

     /**

      * Additional environment variables to set on the command line.

      *

      * @since 2.1.3

      */

     @Parameter

     protected Map<String, String> environmentVariables = new HashMap<String, String>();

     /**

      * Command line working directory.

      *

      * @since 2.1.3

      */

     @Parameter( property = "basedir" )

     protected File workingDirectory;

     /**

      * When false it makes tests run using the standard classloader delegation instead of the default Maven isolated

      * classloader. Only used when forking (forkMode is not "none").<br/>

      * Setting it to false helps with some problems caused by conflicts between xml parsers in the classpath and the

      * Java 5 provider parser.

      *

      * @since 2.1

      */

     @Parameter( property = "childDelegation", defaultValue = "false" )

     protected boolean childDelegation;

     /**

      * (TestNG/JUnit47 provider with JUnit4.8+ only) Groups for this test. Only classes/methods/etc decorated with one of the groups specified here will

      * be included in test run, if specified.<br/>For JUnit, this parameter forces the use of the 4.7 provider<br/>

      * This parameter is ignored if the <code>suiteXmlFiles</code> parameter is specified.

      *

      * @since 2.2

      */

     @Parameter( property = "groups" )

     protected String groups;

     /**

      * (TestNG/JUnit47 provider with JUnit4.8+ only) Excluded groups. Any methods/classes/etc with one of the groups specified in this list will

      * specifically not be run.<br/>For JUnit, this parameter forces the use of the 4.7 provider<br/>

      * This parameter is ignored if the <code>suiteXmlFiles</code> parameter is specified.

      *

      * @since 2.2

      */

     @Parameter( property = "excludedGroups" )

     protected String excludedGroups;

     /**

      * (TestNG) List of <suiteXmlFile> elements specifying TestNG suite xml file locations. Note that

      * <code>suiteXmlFiles</code> is incompatible with several other parameters of this plugin, like

      * <code>includes/excludes</code>.<br/>

      * This parameter is ignored if the <code>test</code> parameter is specified (allowing you to run a single test

      * instead of an entire suite).

      *

      * @since 2.2

      */

     @Parameter

     protected File[] suiteXmlFiles;

     /**

      * Allows you to specify the name of the JUnit artifact. If not set, <code>junit:junit</code> will be used.

      *

      * @since 2.3.1

      */

     @Parameter( property = "junitArtifactName", defaultValue = "junit:junit" )

     protected String junitArtifactName;

     /**

      * Allows you to specify the name of the TestNG artifact. If not set, <code>org.testng:testng</code> will be used.

      *

      * @since 2.3.1

      */

     @Parameter( property = "testNGArtifactName", defaultValue = "org.testng:testng" )

     protected String testNGArtifactName;

     /**

      * (TestNG/JUnit 4.7 provider) The attribute thread-count allows you to specify how many threads should be

      * allocated for this execution. Only makes sense to use in conjunction with the <code>parallel</code> parameter.

      *

      * @since 2.2

      */

     @Parameter( property = "threadCount" )

     protected int threadCount;

     /**

      * Option to specify the number of VMs to fork in parallel in order to execute the tests.

      * When terminated with "C", the number part is multiplied with the number of CPU cores. Floating point value are only accepted together with "C".

      * If set to "0", no VM is forked and all tests are executed within the main process.<br/>

      * <br/>

      * Example values: "1.5C", "4"<br/>

      * <br/>

      * The system properties and the <code>argLine</code> of the forked processes may contain the place holder string <code>${surefire.forkNumber}</code>,

      * which is replaced with a fixed number for each of the parallel forks, ranging from <code>1</code> to the effective value of <code>forkCount</code>

      * times the maximum number of parallel Surefire executions in maven parallel builds, i.e. the effective value of the <code>-T</code> command line

      * argument of maven core.

      *

      * @since 2.14

      */

     @Parameter( property = "forkCount", defaultValue = "1" )

     private String forkCount;

     /**

      * Indicates if forked VMs can be reused. If set to "false", a new VM is forked for each test class to be executed.

      * If set to "true", up to <code>forkCount</code> VMs will be forked and then reused to execute all tests.

      *

      * @since 2.13

      */

     @Parameter( property = "reuseForks", defaultValue = "true" )

     private boolean reuseForks;

     /**

      * (JUnit 4.7 provider) Indicates that threadCount is per cpu core.

      *

      * @since 2.5

      */

     @Parameter( property = "perCoreThreadCount", defaultValue = "true" )

     protected boolean perCoreThreadCount;

     /**

      * (JUnit 4.7 provider) Indicates that the thread pool will be unlimited. The <code>parallel</code> parameter and

      * the actual number of classes/methods will decide. Setting this to "true" effectively disables

      * <code>perCoreThreadCount</code> and <code>threadCount</code>. Defaults to "false".

      *

      * @since 2.5

      */

     @Parameter( property = "useUnlimitedThreads", defaultValue = "false" )

     protected boolean useUnlimitedThreads;

     /**

      * (TestNG only) When you use the <code>parallel</code> attribute, TestNG will try to run all your test methods in

      * separate threads, except for methods that depend on each other, which will be run in the same thread in order to

      * respect their order of execution.

      * <p/>

      * (JUnit 4.7 provider) Supports values "classes"/"methods"/"both" to run in separate threads, as controlled by

      * <code>threadCount</code>.<br/>

      * <br/>

      * Since version 2.16 (JUnit 4.7 provider), the value "both" is <strong>DEPRECATED</strong>.

      * Use <strong>"classesAndMethods"</strong> instead.<br/>

      * <br/>

      * Since version 2.16 (JUnit 4.7 provider), additional vales are available

      * "suites"/"suitesAndClasses"/"suitesAndMethods"/"classesAndMethods"/"all".

      *

      * @since 2.2

      */

     @Parameter( property = "parallel" )

     protected String parallel;

     /**

      * (JUnit 4.7 provider) The attribute thread-count-suites allows you to specify the concurrency in test suites, i.e.:

      * <ul>

      *  <li>number of threads executing JUnit test suites if <code>threadCount</code> is 0 or unspecified</li>

      *  <li>In a special case <code>threadCountSuites</code> and <code>threadCount</code> are specified

      *      without <code>threadCountMethods</code> for <code>parallel</code>=<code>suitesAndMethods</code>.

      *      <br/>Example1: threadCount=8 and threadCountSuites=3, the number of parallel methods is varying from 5 to 7 in your tests.

      *      <br/>In another special case when <code>parallel</code>=<code>all</code> and the only <code>threadCountMethods</code>

      *      is unspecified, then threads from suites and classes are reused in favor of methods.

      *      <br/>Example2: parallel=all, threadCount=16 , threadCountSuites=2 , threadCountClasses=5,

      *      the number of parallel methods is varying from 9 to 14 in your tests.

      *  </li>

      *  <li>integer number which represents the weight in ratio between

      *      <em>threadCountSuites</em>:<code>threadCountClasses</code>:<code>threadCountMethods</code>.

      *      As an example 2 is 20% of <code>threadCount</code> if the ratio is <em>2</em>:3:5</li>

      *  <li>You can impose limitation on parallel suites if <code>useUnlimitedThreads</code> is specified.</li>

      * </ul>

      *

      * Only makes sense to use in conjunction with the <code>parallel</code> parameter.

      * The default value <code>0</code> behaves same as unspecified one.

      *

      * @since 2.16

      */

     @Parameter( property = "threadCountSuites", defaultValue = "0" )

     protected int threadCountSuites;

     /**

      * (JUnit 4.7 provider) The attribute thread-count-classes allows you to specify the concurrency in test classes, i.e.:

      * <ul>

      *  <li>number of threads executing JUnit test classes if <code>threadCount</code> is 0 or unspecified</li>

      *  <li>In a special case <code>threadCountClasses</code> and <code>threadCount</code> are specified

      *      without <code>threadCountMethods</code> for <code>parallel</code>=<code>classesAndMethods</code>.

      *      <br/>Example1: threadCount=8 and threadCountClasses=3, the number of parallel methods is varying from 5 to 7 in your tests.

      *      <br/>In another special case when <code>parallel</code>=<code>all</code> and the only <code>threadCountMethods</code>

      *      is unspecified, then threads from suites and classes are reused in favor of methods.

      *      <br/>Example2: parallel=all, threadCount=16 , threadCountSuites=2 , threadCountClasses=5,

      *      the number of parallel methods is varying from 9 to 14 in your tests.

      *  </li>

      *  <li>integer number which represents the weight in ratio between

      *      <code>threadCountSuites</code>:<em>threadCountClasses</em>:<code>threadCountMethods</code>.

      *      As an example 3 is 30% of <code>threadCount</code> if the ratio is 2:<em>3</em>:5</li>

      *  <li>You can impose limitation on parallel classes if <code>useUnlimitedThreads</code> is specified.</li>

      * </ul>

      *

      * Only makes sense to use in conjunction with the <code>parallel</code> parameter.

      * The default value <code>0</code> behaves same as unspecified one.

      *

      * @since 2.16

      */

     @Parameter( property = "threadCountClasses", defaultValue = "0" )

     protected int threadCountClasses;

     /**

      * (JUnit 4.7 provider) The attribute thread-count-methods allows you to specify the concurrency in test methods, i.e.:

      * <ul>

      *  <li>number of threads executing JUnit test methods if <code>threadCount</code> is 0 or unspecified;</li>

      *  <li>integer number which represents the weight in ratio between <code>threadCountSuites</code>:<code>threadCountClasses</code>:<em>threadCountMethods</em>.

      *      As an example 5 is 50% of <code>threadCount</code> if the ratio is 2:3:<em>5</em>.</li>

      *  <li>You can impose limitation on parallel methods if <code>useUnlimitedThreads</code> is specified.</li>

      * </ul>

      *

      * Only makes sense to use in conjunction with the <code>parallel</code> parameter.

      * The default value <code>0</code> behaves same as unspecified one.

      *

      * @since 2.16

      */

     @Parameter( property = "threadCountMethods", defaultValue = "0" )

     protected int threadCountMethods;

     /**

      * Whether to trim the stack trace in the reports to just the lines within the test, or show the full trace.

      *

      * @since 2.2

      */

     @Parameter( property = "trimStackTrace", defaultValue = "true" )

     protected boolean trimStackTrace;

     /**

      * Resolves the artifacts needed.

      */

     @Component

     protected ArtifactResolver artifactResolver;

     /**

      * Creates the artifact.

      */

     @Component

     protected ArtifactFactory artifactFactory;

     /**

      * The remote plugin repositories declared in the POM.

      *

      * @since 2.2

      */

     @Parameter( defaultValue = "${project.pluginArtifactRepositories}" )

     protected List<ArtifactRepository> remoteRepositories;

     /**

      * For retrieval of artifact's metadata.

      */

     @Component

     protected ArtifactMetadataSource metadataSource;

     /**

      * Flag to disable the generation of report files in xml format.

      *

      * @since 2.2

      */

     @Parameter( property = "disableXmlReport", defaultValue = "false" )

     protected boolean disableXmlReport;

     /**

      * By default, Surefire enables JVM assertions for the execution of your test cases. To disable the assertions, set

      * this flag to "false".

      *

      * @since 2.3.1

      */

     @Parameter( property = "enableAssertions", defaultValue = "true" )

     protected boolean enableAssertions;

     /**

      * The current build session instance.

      */

     @Component

     protected MavenSession session;

     /**

      * (TestNG only) Define the factory class used to create all test instances.

      *

      * @since 2.5

      */

     @Parameter( property = "objectFactory" )

     protected String objectFactory;

     /**

      *

      */

     @Parameter( defaultValue = "${session.parallel}", readonly = true )

     protected Boolean parallelMavenExecution;

     /**

      * Defines the order the tests will be run in. Supported values are "alphabetical", "reversealphabetical", "random",

      * "hourly" (alphabetical on even hours, reverse alphabetical on odd hours), "failedfirst", "balanced" and "filesystem".

      * <p/>

      * <p/>

      * Odd/Even for hourly is determined at the time the of scanning the classpath, meaning it could change during a

      * multi-module build.

      * <p/>

      * Failed first will run tests that failed on previous run first, as well as new tests for this run.

      * <p/>

      * Balanced is only relevant with parallel=classes, and will try to optimize the run-order of the tests to

      * make all tests complete at the same time, reducing the overall execution time.

      * <p/>

      * Note that the statistics are stored in a file named .surefire-XXXXXXXXX beside pom.xml, and should not

      * be checked into version control. The "XXXXX" is the SHA1 checksum of the entire surefire configuration,

      * so different configurations will have different statistics files, meaning if you change any config

      * settings you will re-run once before new statistics data can be established.

      *

      * @since 2.7

      */

     @Parameter( defaultValue = "filesystem" )

     protected String runOrder;

     /**

      * List of dependencies to scan for test classes to include in the test run. Each dependency string must follow the format

      * <i>groupId:artifactId</i>. For example: <i>org.acme:project-a</i>

      *

      * @since 2.15

      */

     @Parameter( property = "dependenciesToScan" )

     private String[] dependenciesToScan;

     /**

      *

      */

     @Component

     protected ToolchainManager toolchainManager;

     private Artifact surefireBooterArtifact;

     private Toolchain toolchain;

     private int effectiveForkCount = -1;

     /**

      * The placeholder that is replaced by the executing thread's running number. The thread number

      * range starts with 1

      * Deprecated.

      */

     public static final String THREAD_NUMBER_PLACEHOLDER = "${surefire.threadNumber}";

     /**

      * The placeholder that is replaced by the executing fork's running number. The fork number

      * range starts with 1

      */

     public static final String FORK_NUMBER_PLACEHOLDER = "${surefire.forkNumber}";

     protected abstract String getPluginName();

     private SurefireDependencyResolver dependencyResolver;

     public void execute()

         throws MojoExecutionException, MojoFailureException

     {

         // Stuff that should have been final

         setupStuff();

         if ( verifyParameters() && !hasExecutedBefore() )

         {

             DefaultScanResult scan = scanForTestClasses();

             if ( !isValidSuiteXmlFileConfig() && scan.isEmpty() )

             {

                 if ( getEffectiveFailIfNoTests() )

                 {

                     throw new MojoFailureException(

                         "No tests were executed!  (Set -DfailIfNoTests=false to ignore this error.)" );

                 }

                 handleSummary( RunResult.noTestsRun(), null );

                 return;

             }

             logReportsDirectory();

             executeAfterPreconditionsChecked( scan );

         }

     }

     private void setupStuff()

     {

         createDependencyResolver();

         surefireBooterArtifact = getSurefireBooterArtifact();

         toolchain = getToolchain();

     }

     private DefaultScanResult scanForTestClasses()

     {

         DefaultScanResult scan = scanDirectories();

         DefaultScanResult scanDeps = scanDependencies();

         return scan.append( scanDeps );

     }

     private DefaultScanResult scanDirectories()

     {

         return new DirectoryScanner( getTestClassesDirectory(), getIncludeList(), getExcludeList(),

                                      getSpecificTests() ).scan();

     }

     private DefaultScanResult scanDependencies()

     {

         if ( getDependenciesToScan() == null )

         {

             return null;

         }

         else

         {

             try

             {

                 // noinspection unchecked

                 return new DependencyScanner( DependencyScanner.filter( project.getTestArtifacts(),

                                                                         Arrays.asList( getDependenciesToScan() ) ),

                                               getIncludeList(), getExcludeList(), getSpecificTests() ).scan();

             }

             catch ( Exception e )

             {

                 throw new RuntimeException( e );

             }

         }

     }

     boolean verifyParameters()

         throws MojoFailureException, MojoExecutionException

     {

         setProperties( new SurefireProperties( getProperties() ) );

         if ( isSkipExecution() )

         {

             getLog().info( "Tests are skipped." );

             return false;

         }

         String jvmToUse = getJvm();

         if ( toolchain != null )

         {

             getLog().info( "Toolchain in " + getPluginName() + "-plugin: " + toolchain );

             if ( jvmToUse != null )

             {

                 getLog().warn( "Toolchains are ignored, 'executable' parameter is set to " + jvmToUse );

             }

         }

         if ( !getTestClassesDirectory().exists()

             && ( getDependenciesToScan() == null || getDependenciesToScan().length == 0 ) )

         {

             if ( Boolean.TRUE.equals( getFailIfNoTests() ) )

             {

                 throw new MojoFailureException( "No tests to run!" );

             }

             getLog().info( "No tests to run." );

         }

         else

         {

             convertDeprecatedForkMode();

             ensureWorkingDirectoryExists();

             ensureParallelRunningCompatibility();

             ensureThreadCountWithPerThread();

             warnIfUselessUseSystemClassLoaderParameter();

             warnIfDefunctGroupsCombinations();

         }

         return true;

     }

     protected abstract boolean isSkipExecution();

     protected void executeAfterPreconditionsChecked( DefaultScanResult scanResult )

         throws MojoExecutionException, MojoFailureException

     {

         List<ProviderInfo> providers = createProviders();

         RunResult current = RunResult.noTestsRun();

         NestedCheckedException firstForkException = null;

         for ( ProviderInfo provider : providers )

         {

             try

             {

                 current = current.aggregate( executeProvider( provider, scanResult ) );

             }

             catch ( SurefireBooterForkException e )

             {

                 if ( firstForkException == null )

                 {

                     firstForkException = e;

                 }

             }

             catch ( SurefireExecutionException e )

             {

                 if ( firstForkException == null )

                 {

                     firstForkException = e;

                 }

             }

             catch ( TestSetFailedException e )

             {

                 if ( firstForkException == null )

                 {

                     firstForkException = e;

                 }

             }

         }

         if ( firstForkException != null )

         {

             current = RunResult.failure( current, firstForkException );

         }

         handleSummary( current, firstForkException );

     }

     private void createDependencyResolver()

     {

         dependencyResolver =

             new SurefireDependencyResolver( getArtifactResolver(), getArtifactFactory(), getLog(), getLocalRepository(),

                                             getRemoteRepositories(), getMetadataSource(), getPluginName() );

     }

     protected List<ProviderInfo> createProviders()

         throws MojoFailureException, MojoExecutionException

     {

         final Artifact junitDepArtifact = getJunitDepArtifact();

         ProviderList wellKnownProviders =

             new ProviderList( new DynamicProviderInfo( null ), new TestNgProviderInfo( getTestNgArtifact() ),

                               new JUnitCoreProviderInfo( getJunitArtifact(), junitDepArtifact ),

                               new JUnit4ProviderInfo( getJunitArtifact(), junitDepArtifact ),

                               new JUnit3ProviderInfo() );

         return wellKnownProviders.resolve( getLog() );

     }

     private SurefireProperties setupProperties()

     {

         SurefireProperties sysProps = null;

         try {

             sysProps = SurefireProperties.loadProperties( systemPropertiesFile );

         }

         catch ( IOException e )

         {

             String msg = "The system property file '" + systemPropertiesFile.getAbsolutePath() + "' can't be read.";

             if ( getLog().isDebugEnabled() )

             {

                 getLog().warn( msg, e );

             }

             else

             {

                 getLog().warn( msg );

             }

         }

         SurefireProperties result =

             SurefireProperties.calculateEffectiveProperties( getSystemProperties(), getSystemPropertyVariables(),

                                                              getUserProperties(), sysProps );

         result.setProperty( "basedir", getBasedir().getAbsolutePath() );

         result.setProperty( "user.dir", getWorkingDirectory().getAbsolutePath() );

         result.setProperty( "localRepository", getLocalRepository().getBasedir() );

         for ( Object o : result.propertiesThatCannotBeSetASystemProperties() )

         {

             getLog().warn( o + " cannot be set as system property, use <argLine>-D" + o + "=...<argLine> instead" );

         }

         if ( getLog().isDebugEnabled() )

         {

             showToLog( result, getLog(), "system property" );

         }

         return result;

     }

     public void showToLog( SurefireProperties props, org.apache.maven.plugin.logging.Log log, String setting )

     {

         for ( Object key : props.getStringKeySet() )

         {

             String value = props.getProperty( (String) key );

             log.debug( "Setting " + setting + " [" + key + "]=[" + value + "]" );

         }

     }

     private RunResult executeProvider( ProviderInfo provider, DefaultScanResult scanResult )

         throws MojoExecutionException, MojoFailureException, SurefireExecutionException, SurefireBooterForkException,

         TestSetFailedException

     {

         SurefireProperties effectiveProperties = setupProperties();

         ClassLoaderConfiguration classLoaderConfiguration = getClassLoaderConfiguration( isForking() );

         RunOrderParameters runOrderParameters =

             new RunOrderParameters( getRunOrder(), getStatisticsFileName( getConfigChecksum() ) );

         final RunResult result;

         if ( isNotForking() )

         {

             createCopyAndReplaceForkNumPlaceholder( effectiveProperties, 1 ).copyToSystemProperties();

             InPluginVMSurefireStarter surefireStarter =

                 createInprocessStarter( provider, classLoaderConfiguration, runOrderParameters );

             result = surefireStarter.runSuitesInProcess( scanResult );

         }

         else

         {

             ForkConfiguration forkConfiguration = getForkConfiguration();

             if ( getLog().isDebugEnabled() )

             {

                 showMap( getEnvironmentVariables(), "environment variable" );

             }

             Properties originalSystemProperties = (Properties) System.getProperties().clone();

             try

             {

                 ForkStarter forkStarter =

                     createForkStarter( provider, forkConfiguration, classLoaderConfiguration, runOrderParameters,

                                        getLog() );

                 result = forkStarter.run( effectiveProperties, scanResult );

             }

             finally

             {

                 System.setProperties( originalSystemProperties );

                 cleanupForkConfiguration( forkConfiguration );

             }

         }

         return result;

     }

     public static SurefireProperties createCopyAndReplaceForkNumPlaceholder(

         SurefireProperties effectiveSystemProperties, int threadNumber )

     {

         SurefireProperties filteredProperties = new SurefireProperties( ( KeyValueSource) effectiveSystemProperties );

         String threadNumberString = String.valueOf( threadNumber );

         for ( Entry<Object, Object> entry : effectiveSystemProperties.entrySet() )

         {

             if ( entry.getValue() instanceof String )

             {

                 String value = (String) entry.getValue();

                 value = value.replace( THREAD_NUMBER_PLACEHOLDER, threadNumberString );

                 value = value.replace( FORK_NUMBER_PLACEHOLDER, threadNumberString );

                 filteredProperties.put( entry.getKey(), value );

             }

         }

         return filteredProperties;

     }

     protected void cleanupForkConfiguration( ForkConfiguration forkConfiguration )

     {

         if ( !getLog().isDebugEnabled() && forkConfiguration != null )

         {

             File tempDirectory = forkConfiguration.getTempDirectory();

             try

             {

                 FileUtils.deleteDirectory( tempDirectory );

             }

             catch ( IOException ioe )

             {

                 getLog().warn( "Could not delete temp direcotry " + tempDirectory + " because " + ioe.getMessage() );

             }

         }

     }

     protected abstract void handleSummary( RunResult summary, NestedCheckedException firstForkException )

         throws MojoExecutionException, MojoFailureException;

     protected void logReportsDirectory()

     {

         getLog().info(

             StringUtils.capitalizeFirstLetter( getPluginName() ) + " report directory: " + getReportsDirectory() );

     }

     final Toolchain getToolchain()

     {

         Toolchain tc = null;

         if ( getToolchainManager() != null )

         {

             tc = getToolchainManager().getToolchainFromBuildContext( "jdk", getSession() );

         }

         return tc;

     }

     /**

      * Converts old TestNG configuration parameters over to new properties based configuration

      * method. (if any are defined the old way)

      */

     private void convertTestNGParameters() throws MojoExecutionException

     {

         if ( this.getParallel() != null )

         {

             getProperties().setProperty( ProviderParameterNames.PARALLEL_PROP, this.getParallel() );

         }

         convertGroupParameters();

         if ( this.getThreadCount() > 0 )

         {

             getProperties().setProperty( ProviderParameterNames.THREADCOUNT_PROP,

                                          Integer.toString( this.getThreadCount() ) );

         }

         if ( this.getObjectFactory() != null )

         {

             getProperties().setProperty( "objectfactory", this.getObjectFactory() );

         }

         if ( this.getTestClassesDirectory() != null )

         {

             getProperties().setProperty( "testng.test.classpath", getTestClassesDirectory().getAbsolutePath() );

         }

         Artifact testNgArtifact = getTestNgArtifact();

         if ( testNgArtifact != null){

             DefaultArtifactVersion defaultArtifactVersion = new DefaultArtifactVersion( testNgArtifact.getVersion() );

             getProperties().setProperty( "testng.configurator", getConfiguratorName( defaultArtifactVersion ) );

         }

     }

     private static String getConfiguratorName( ArtifactVersion version )

         throws MojoExecutionException

     {

         try

         {

             VersionRange range = VersionRange.createFromVersionSpec( "[4.7,5.1]" );

             if ( range.containsVersion( version ) )

             {

                 return "org.apache.maven.surefire.testng.conf.TestNG4751Configurator";

             }

             range = VersionRange.createFromVersionSpec( "[5.2]" );

             if ( range.containsVersion( version ) )

             {

                 return "org.apache.maven.surefire.testng.conf.TestNG52Configurator";

             }

             range = VersionRange.createFromVersionSpec( "[5.3,6.4]" );

             if ( range.containsVersion( version ) )

             {

                 return "org.apache.maven.surefire.testng.conf.TestNGMapConfigurator";

             }

             range = VersionRange.createFromVersionSpec( "[6.5,)" );

             if ( range.containsVersion( version ) )

             {

                 return "org.apache.maven.surefire.testng.conf.TestNG652Configurator";

             }

             throw new MojoExecutionException( "Unknown TestNG version " + version );

         }

         catch ( InvalidVersionSpecificationException invsex )

         {

             throw new MojoExecutionException( "Bug in plugin. Please report it with the attached stacktrace", invsex );

         }

     }

     private void convertGroupParameters()

     {

         if ( this.getExcludedGroups() != null )

         {

             getProperties().setProperty( ProviderParameterNames.TESTNG_EXCLUDEDGROUPS_PROP, this.getExcludedGroups() );

         }

         if ( this.getGroups() != null )

         {

             getProperties().setProperty( ProviderParameterNames.TESTNG_GROUPS_PROP, this.getGroups() );

         }

     }

     protected boolean isAnyConcurrencySelected()

     {

         return this.getParallel() != null && this.getParallel().trim().length() > 0;

     }

     protected boolean isAnyGroupsSelected()

     {

         return this.getGroups() != null || this.getExcludedGroups() != null;

     }

     /**

      * Converts old JUnit configuration parameters over to new properties based configuration

      * method. (if any are defined the old way)

      */

     private void convertJunitCoreParameters() throws MojoExecutionException

     {

         checkThreadCountEntity( getThreadCountSuites(), "suites" );

         checkThreadCountEntity( getThreadCountClasses(), "classes" );

         checkThreadCountEntity( getThreadCountMethods(), "methods" );

         String usedParallel = ( getParallel() != null ) ? getParallel() : "none";

         if ( !"none".equals( usedParallel ))

         {

             checkNonForkedThreads( parallel );

         }

         String usedThreadCount = Integer.toString( getThreadCount() );

         getProperties().setProperty( ProviderParameterNames.PARALLEL_PROP, usedParallel );

         getProperties().setProperty( ProviderParameterNames.THREADCOUNT_PROP, usedThreadCount );

         getProperties().setProperty( "perCoreThreadCount", Boolean.toString( getPerCoreThreadCount() ) );

         getProperties().setProperty( "useUnlimitedThreads", Boolean.toString( getUseUnlimitedThreads() ) );

         getProperties().setProperty( ProviderParameterNames.THREADCOUNTSUITES_PROP, Integer.toString( getThreadCountSuites() ) );

         getProperties().setProperty( ProviderParameterNames.THREADCOUNTCLASSES_PROP, Integer.toString( getThreadCountClasses() ) );

         getProperties().setProperty( ProviderParameterNames.THREADCOUNTMETHODS_PROP, Integer.toString( getThreadCountMethods() ) );

         getProperties().setProperty( ProviderParameterNames.PARALLEL_TIMEOUT_PROP,

                 Integer.toString( getParallelTestsTimeoutInSeconds() ) );

         getProperties().setProperty( ProviderParameterNames.PARALLEL_TIMEOUTFORCED_PROP,

                 Integer.toString( getParallelTestsTimeoutForcedInSeconds() ) );

         String message =

             "parallel='" + usedParallel + '\'' + ", perCoreThreadCount=" + getPerCoreThreadCount() + ", threadCount="

                 + usedThreadCount + ", useUnlimitedThreads=" + getUseUnlimitedThreads() +

                     ", threadCountSuites=" + getThreadCountSuites() + ", threadCountClasses=" + getThreadCountClasses() +

                     ", threadCountMethods=" + getThreadCountMethods();

         getLog().info( message );

     }

     private void checkNonForkedThreads( String parallel ) throws MojoExecutionException

     {

         if ( "suites".equals( parallel ) )

         {

             if ( !( getUseUnlimitedThreads() || getThreadCount() > 0 ^ getThreadCountSuites() > 0 ) )

             {

                 throw new MojoExecutionException( "Use threadCount or threadCountSuites > 0 or useUnlimitedThreads=true " +

                         "for parallel='suites'" );

             }

             setThreadCountClasses( 0 );

             setThreadCountMethods( 0 );

         }

         else if ( "classes".equals( parallel ) )

         {

             if ( !( getUseUnlimitedThreads() || getThreadCount() > 0 ^ getThreadCountClasses() > 0 ) )

             {

                 throw new MojoExecutionException( "Use threadCount or threadCountClasses > 0 or useUnlimitedThreads=true " +

                         "for parallel='classes'" );

             }

             setThreadCountSuites( 0 );

             setThreadCountMethods( 0 );

         }

         else if ( "methods".equals( parallel ) )

         {

             if ( !( getUseUnlimitedThreads() || getThreadCount() > 0 ^ getThreadCountMethods() > 0 ) )

             {

                 throw new MojoExecutionException( "Use threadCount or threadCountMethods > 0 or useUnlimitedThreads=true " +

                         "for parallel='methods'" );

             }

             setThreadCountSuites( 0 );

             setThreadCountClasses( 0 );

         }

         else if ( "suitesAndClasses".equals( parallel ) )

         {

             if ( !( getUseUnlimitedThreads()

                     || onlyThreadCount()

                     || getThreadCountSuites() > 0 && getThreadCountClasses() > 0

                         && getThreadCount() == 0 && getThreadCountMethods() == 0

                     || getThreadCount() > 0 && getThreadCountSuites() > 0 && getThreadCountClasses() > 0

                         && getThreadCountMethods() == 0

                     || getThreadCount() > 0 && getThreadCountSuites() > 0 && getThreadCount() > getThreadCountSuites()

                         && getThreadCountClasses() == 0 && getThreadCountMethods() == 0 ) )

             {

                 throw new MojoExecutionException( "Use useUnlimitedThreads=true, " +

                         "or only threadCount > 0, " +

                         "or (threadCountSuites > 0 and threadCountClasses > 0), " +

                         "or (threadCount > 0 and threadCountSuites > 0 and threadCountClasses > 0) " +

                         "or (threadCount > 0 and threadCountSuites > 0 and threadCount > threadCountSuites) " +

                         "for parallel='suitesAndClasses' or 'both'" );

             }

             setThreadCountMethods( 0 );

         }

         else if ( "suitesAndMethods".equals( parallel ) )

         {

             if ( !( getUseUnlimitedThreads()

                     || onlyThreadCount()

                     || getThreadCountSuites() > 0 && getThreadCountMethods() > 0

                         && getThreadCount() == 0 && getThreadCountClasses() == 0

                     || getThreadCount() > 0 && getThreadCountSuites() > 0 && getThreadCountMethods() > 0

                         && getThreadCountClasses() == 0

                     || getThreadCount() > 0 && getThreadCountSuites() > 0 && getThreadCount() > getThreadCountSuites()

                         && getThreadCountClasses() == 0 && getThreadCountMethods() == 0 ) )

             {

                 throw new MojoExecutionException( "Use useUnlimitedThreads=true, " +

                         "or only threadCount > 0, " +

                         "or (threadCountSuites > 0 and threadCountMethods > 0), " +

                         "or (threadCount > 0 and threadCountSuites > 0 and threadCountMethods > 0), " +

                         "or (threadCount > 0 and threadCountSuites > 0 and threadCount > threadCountSuites) " +

                         "for parallel='suitesAndMethods'" );

             }

             setThreadCountClasses( 0 );

         }

         else if ( "both".equals( parallel ) || "classesAndMethods".equals( parallel ) )

         {

             if ( !( getUseUnlimitedThreads()

                     || onlyThreadCount()

                     || getThreadCountClasses() > 0 && getThreadCountMethods() > 0

                         && getThreadCount() == 0 && getThreadCountSuites() == 0

                     || getThreadCount() > 0 && getThreadCountClasses() > 0 && getThreadCountMethods() > 0

                         && getThreadCountSuites() == 0

                     || getThreadCount() > 0 && getThreadCountClasses() > 0 && getThreadCount() > getThreadCountClasses()

                         && getThreadCountSuites() == 0 && getThreadCountMethods() == 0 ) )

             {

                 throw new MojoExecutionException( "Use useUnlimitedThreads=true, " +

                         "or only threadCount > 0, " +

                         "or (threadCountClasses > 0 and threadCountMethods > 0), " +

                         "or (threadCount > 0 and threadCountClasses > 0 and threadCountMethods > 0), " +

                         "or (threadCount > 0 and threadCountClasses > 0 and threadCount > threadCountClasses) " +

                         "for parallel='both' or parallel='classesAndMethods'" );

             }

             setThreadCountSuites( 0 );

         }

         else if ( "all".equals( parallel ) )

         {

             if ( !( getUseUnlimitedThreads()

                     || onlyThreadCount()

                     || getThreadCountSuites() > 0 && getThreadCountClasses() > 0 && getThreadCountMethods() > 0

                     || getThreadCount() > 0 && getThreadCountSuites() > 0 && getThreadCountClasses() > 0

                         && getThreadCountMethods() == 0

                         && getThreadCount() > ( getThreadCountSuites() + getThreadCountClasses() ) ) )

             {

                 throw new MojoExecutionException( "Use useUnlimitedThreads=true, " +

                         "or only threadCount > 0, " +

                         "or (threadCountSuites > 0 and threadCountClasses > 0 and threadCountMethods > 0), " +

                         "or every thread-count is specified, " +

                         "or (threadCount > 0 and threadCountSuites > 0 and threadCountClasses > 0 " +

                             "and threadCount > threadCountSuites + threadCountClasses) " +

                         "for parallel='all'" );

             }

         }

         else

         {

             throw new MojoExecutionException( "Illegal parallel='" + parallel + "'" );

         }

     }

     private boolean onlyThreadCount()

     {

         return getThreadCount() > 0 && getThreadCountSuites() == 0 && getThreadCountClasses() == 0

                 && getThreadCountMethods() == 0;

     }

     private static void checkThreadCountEntity(int count, String entity) throws MojoExecutionException

     {

         if ( count < 0 )

         {

             throw new MojoExecutionException("parallel maven execution does not allow negative thread-count" + entity);

         }

     }

     private boolean isJunit47Compatible( Artifact artifact )

     {

         return dependencyResolver.isWithinVersionSpec( artifact, "[4.7,)" );

     }

     private boolean isAnyJunit4( Artifact artifact )

     {

         return dependencyResolver.isWithinVersionSpec( artifact, "[4.0,)" );