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.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.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.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.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;

 /**

  * 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

     protected List<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 = "" )

     protected String classpathDependencyScopeExclude;

     /**

      * Additional elements to be appended to the classpath.

      *

      * @since 2.4

      */

     @Parameter

     protected List<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>.

      *

      * @since 2.2

      */

     @Parameter( property = "parallel" )

     protected String parallel;

     /**

      * 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;

     /**

      *

      */

     @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 = scanDirectories();

             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 scanDirectories()

     {

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

                                      getSpecificTests() ).scan();

     }

     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() )

         {

             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 result =

             SurefireProperties.calculateEffectiveProperties( getSystemProperties(), getSystemPropertiesFile(),

                                                              getSystemPropertyVariables(), getUserProperties(),

                                                              getLog() );

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

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

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

         result.verifyLegalSystemProperties( getLog() );

         if ( getLog().isDebugEnabled() )

         {

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

         }

         return result;

     }

     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 );

                 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( 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()

     {

         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() );

         }

     }

     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()

     {

         if ( this.getParallel() != null )

         {

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

         }

         if ( this.getThreadCount() > 0 )

         {

             getProperties().setProperty( ProviderParameterNames.THREADCOUNT_PROP,

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

         }

         getProperties().setProperty( "reuseForks", Boolean.toString( reuseForks ) );

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

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

     }

     private boolean isJunit47Compatible( Artifact artifact )

     {

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

     }

     private boolean isAnyJunit4( Artifact artifact )

     {

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

     }

     static boolean isForkModeNever( String forkMode )

     {

         return ForkConfiguration.FORK_NEVER.equals( forkMode );

     }

     boolean isForking()

     {

         return 0 < getEffectiveForkCount();

     }

     String getEffectiveForkMode()

     {

         String forkMode1 = getForkMode();

         if ( toolchain != null && isForkModeNever( forkMode1 ) )

         {

             return ForkConfiguration.FORK_ONCE;

         }

         return ForkConfiguration.getEffectiveForkMode( forkMode1 );

     }

     private List<RunOrder> getRunOrders()

     {

         String runOrderString = getRunOrder();

         RunOrder[] runOrder = runOrderString == null ? RunOrder.DEFAULT : RunOrder.valueOfMulti( runOrderString );

         return Arrays.asList( runOrder );

     }

     private boolean requiresRunHistory()

     {

         final List<RunOrder> runOrders = getRunOrders();

         return runOrders.contains( RunOrder.BALANCED ) || runOrders.contains( RunOrder.FAILEDFIRST );

     }

     private boolean getEffectiveFailIfNoTests()

     {

         if ( isSpecificTestSpecified() )

         {

             if ( getFailIfNoSpecifiedTests() != null )

             {

                 return getFailIfNoSpecifiedTests();

             }

             else if ( getFailIfNoTests() != null )

             {

                 return getFailIfNoTests();

             }

             else

             {

                 return true;

             }

         }

         else

         {

             return getFailIfNoTests() != null && getFailIfNoTests();

         }

     }

     private ProviderConfiguration createProviderConfiguration( RunOrderParameters runOrderParameters )

         throws MojoExecutionException, MojoFailureException

     {

         ReporterConfiguration reporterConfiguration =

             new ReporterConfiguration( getReportsDirectory(), isTrimStackTrace() );

         Artifact testNgArtifact;

         testNgArtifact = getTestNgArtifact();

         DirectoryScannerParameters directoryScannerParameters = null;

         final boolean isTestNg = testNgArtifact != null;

         TestArtifactInfo testNg =

             isTestNg ? new TestArtifactInfo( testNgArtifact.getVersion(), testNgArtifact.getClassifier() ) : null;

         List<File> testXml = getSuiteXmlFiles() != null ? Arrays.asList( getSuiteXmlFiles() ) : null;

         TestRequest testSuiteDefinition =

             new TestRequest( testXml, getTestSourceDirectory(), getTest(), getTestMethod() );

         final boolean failIfNoTests;

         if ( isValidSuiteXmlFileConfig() && getTest() == null )

         {

             failIfNoTests = getFailIfNoTests() != null && getFailIfNoTests();

             if ( !isTestNg )

             {

                 throw new MojoExecutionException( "suiteXmlFiles is configured, but there is no TestNG dependency" );

             }

         }

         else

         {

             if ( isSpecificTestSpecified() )

             {

                 failIfNoTests = getEffectiveFailIfNoTests();

                 setFailIfNoTests( failIfNoTests );

             }

             else

             {

                 failIfNoTests = getFailIfNoTests() != null && getFailIfNoTests();

             }

             List<String> includes = getIncludeList();

             List<String> excludes = getExcludeList();

             List<String> specificTests = getSpecificTests();

             directoryScannerParameters =

                 new DirectoryScannerParameters( getTestClassesDirectory(), includes, excludes, specificTests,

                                                 failIfNoTests, getRunOrder() );

         }

         Properties providerProperties = getProperties();

         return new ProviderConfiguration( directoryScannerParameters, runOrderParameters, failIfNoTests,

                                           reporterConfiguration, testNg, testSuiteDefinition, providerProperties, null,

                                           false );

     }

     public String getStatisticsFileName( String configurationHash )

     {

         return getReportsDirectory().getParentFile().getParentFile() + File.separator + ".surefire-"

             + configurationHash;

     }

     StartupConfiguration createStartupConfiguration( ProviderInfo provider,

                                                      ClassLoaderConfiguration classLoaderConfiguration )

         throws MojoExecutionException, MojoFailureException

     {

         try

         {

             provider.addProviderProperties();

             // cache the provider lookup

             String providerName = provider.getProviderName();

             Classpath providerClasspath = ClasspathCache.getCachedClassPath( providerName );

             if ( providerClasspath == null )

             {

                 providerClasspath = provider.getProviderClasspath();

                 ClasspathCache.setCachedClasspath( providerName, providerClasspath );

             }

             Classpath inprocClassPath = new Classpath( providerClasspath );

             Artifact surefireArtifact = getCommonArtifact();

             inprocClassPath.addClassPathElementUrl( surefireArtifact.getFile().getAbsolutePath() );

             final Classpath testClasspath = generateTestClasspath();

             logClasspath( testClasspath, "test classpath" );

             logClasspath( providerClasspath, "provider classpath" );

             final ClasspathConfiguration classpathConfiguration =

                 new ClasspathConfiguration( testClasspath, providerClasspath, inprocClassPath,

                                             effectiveIsEnableAssertions(), isChildDelegation() );

             return new StartupConfiguration( providerName, classpathConfiguration, classLoaderConfiguration,

                                              isForking(), false );

         }

         catch ( ArtifactResolutionException e )

         {

             throw new MojoExecutionException( "Unable to generate classpath: " + e, e );

         }

         catch ( ArtifactNotFoundException e )

         {

             throw new MojoExecutionException( "Unable to generate classpath: " + e, e );

         }

         catch ( InvalidVersionSpecificationException e )

         {

             throw new MojoExecutionException( "Unable to generate classpath: " + e, e );

         }

     }

     private Artifact getCommonArtifact()

     {

         return getPluginArtifactMap().get( "org.apache.maven.surefire:maven-surefire-common" );

     }

     private StartupReportConfiguration getStartupReportConfiguration( String configChecksum )

     {

         return new StartupReportConfiguration( isUseFile(), isPrintSummary(), getReportFormat(),

                                                isRedirectTestOutputToFile(), isDisableXmlReport(),

                                                getReportsDirectory(), isTrimStackTrace(), getReportNameSuffix(),

                                                configChecksum, requiresRunHistory() );

     }

     void logClasspath( Classpath classpath, String descriptor )

     {

         getLog().debug( descriptor + " classpath:" );

         @SuppressWarnings( "unchecked" ) final List<String> classPath = classpath.getClassPath();

         for ( String classpathElement : classPath )

         {

             if ( classpathElement == null )

             {

                 getLog().warn( "The test classpath contains a null element." );

             }

             else

             {

                 getLog().debug( "  " + classpathElement );

             }

         }

     }

     private boolean isSpecificTestSpecified()

     {

         return getTest() != null;

     }

     private boolean isValidSuiteXmlFileConfig()

     {

         return getSuiteXmlFiles() != null && getSuiteXmlFiles().length > 0;

     }

     private List<String> readListFromFile( final File file )

     {

         List<String> list;

         getLog().debug( "Reading list from: " + file );

         if ( !file.exists() )

         {

             throw new RuntimeException( "Failed to load list from file: " + file );

         }

         try

         {

             list = FileUtils.loadFile( file );

         }

         catch ( IOException e )

         {

             throw new RuntimeException( "Failed to load list from file: " + file, e );

         }

         if ( getLog().isDebugEnabled() )

         {

             getLog().debug( "List contents:" );

             for ( String entry : list )

             {

                 getLog().debug( "  " + entry );

             }

         }

         return list;

     }

     private void maybeAppendList( final List<String> base, final List<String> list )

     {

         if ( list != null )

         {

             base.addAll( list );

         }

     }

     private List<String> getExcludeList()

     {

         List<String> excludes = null;

         if ( isSpecificTestSpecified() )

         {

             // Check to see if we are running a single test. The raw parameter will

             // come through if it has not been set.

             // FooTest -> **/FooTest.java

             excludes = new ArrayList<String>();

         }

         else

         {

             if ( getExcludesFile() != null )

             {

                 excludes = readListFromFile( getExcludesFile() );

             }

             // If we have excludesFile, and we have excludes, then append excludes to excludesFile content

             if ( excludes == null )

             {

                 excludes = this.getExcludes();

             }

             else

             {

                 maybeAppendList( excludes, this.getExcludes() );

             }

             // defaults here, qdox doesn't like the end javadoc value

             // Have to wrap in an ArrayList as surefire expects an ArrayList instead of a List for some reason

             if ( excludes == null || excludes.size() == 0 )

             {

                 excludes = Arrays.asList( new String[]{ "**/*$*" } );

             }

         }

         return filterNulls( excludes );

     }

     private List<String> getIncludeList()

     {

         List<String> includes = null;

         if ( isSpecificTestSpecified() && !isMultipleExecutionBlocksDetected() )

         {

             includes = getSpecificTests();

         }

         else

         {

             if ( getIncludesFile() != null )

             {

                 includes = readListFromFile( getIncludesFile() );

             }

             // If we have includesFile, and we have includes, then append includes to includesFile content

             if ( includes == null )

             {

                 includes = this.getIncludes();

             }

             else

             {

                 maybeAppendList( includes, this.getIncludes() );

             }

         }

         // defaults here, qdox doesn't like the end javadoc value

         // Have to wrap in an ArrayList as surefire expects an ArrayList instead of a List for some reason

         if ( includes == null || includes.size() == 0 )

         {

             includes = Arrays.asList( getDefaultIncludes() );

         }

         return filterNulls( includes );

     }

     private List<String> filterNulls( List<String> toFilter )

     {

         List<String> result = new ArrayList<String>( toFilter.size() );

         for ( String item : toFilter )

         {

             if ( item != null )

             {

                 result.add( item );

             }

         }

         return result;

     }

     private boolean isMultipleExecutionBlocksDetected()

     {

         MavenProject project = getProject();

         if ( project != null )

         {

             String key = getPluginDescriptor().getPluginLookupKey();

             Plugin plugin = (Plugin) project.getBuild().getPluginsAsMap().get( key );

             if ( plugin != null )

             {

                 @SuppressWarnings( "rawtypes" ) List executions = plugin.getExecutions();

                 return executions != null && executions.size() > 1;