View Javadoc

1   package org.apache.maven.plugin.surefire;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *     http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import java.io.File;
23  import java.util.HashMap;
24  import java.util.List;
25  import java.util.Map;
26  import java.util.Properties;
27  
28  import org.apache.maven.artifact.factory.ArtifactFactory;
29  import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
30  import org.apache.maven.artifact.repository.ArtifactRepository;
31  import org.apache.maven.artifact.resolver.ArtifactResolver;
32  import org.apache.maven.execution.MavenSession;
33  import org.apache.maven.plugin.MojoExecutionException;
34  import org.apache.maven.plugin.MojoFailureException;
35  import org.apache.maven.plugin.surefire.booterclient.ChecksumCalculator;
36  import org.apache.maven.project.MavenProject;
37  import org.apache.maven.surefire.suite.RunResult;
38  import org.apache.maven.toolchain.ToolchainManager;
39  import org.codehaus.plexus.util.StringUtils;
40  
41  /**
42   * Run tests using Surefire.
43   *
44   * @author Jason van Zyl
45   * @version $Id: SurefirePlugin.java 1143207 2011-07-05 21:37:57Z pgier $
46   * @requiresDependencyResolution test
47   * @goal test
48   * @phase test
49   * @threadSafe
50   * @noinspection JavaDoc
51   */
52  public class SurefirePlugin
53      extends AbstractSurefireMojo
54      implements SurefireReportParameters
55  {
56  
57      /**
58       * Set this to "true" to skip running tests, but still compile them. Its use is NOT RECOMMENDED, but quite
59       * convenient on occasion.
60       *
61       * @parameter default-value="false" expression="${skipTests}"
62       * @since 2.4
63       */
64      private boolean skipTests;
65  
66      /**
67       * This old parameter is just like <code>skipTests</code>, but bound to the old property "maven.test.skip.exec".
68       *
69       * @parameter expression="${maven.test.skip.exec}"
70       * @since 2.3
71       * @deprecated Use skipTests instead.
72       */
73      private boolean skipExec;
74  
75      /**
76       * Set this to "true" to bypass unit tests entirely. Its use is NOT RECOMMENDED, especially if you enable it using
77       * the "maven.test.skip" property, because maven.test.skip disables both running the tests and compiling the tests.
78       * Consider using the <code>skipTests</code> parameter instead.
79       *
80       * @parameter default-value="false" expression="${maven.test.skip}"
81       */
82      private boolean skip;
83  
84      /**
85       * Set this to "true" to ignore a failure during testing. Its use is NOT RECOMMENDED, but quite convenient on
86       * occasion.
87       *
88       * @parameter default-value="false" expression="${maven.test.failure.ignore}"
89       */
90      private boolean testFailureIgnore;
91  
92      /**
93       * The base directory of the project being tested. This can be obtained in your unit test via
94       * System.getProperty("basedir").
95       *
96       * @parameter default-value="${basedir}"
97       */
98      private File basedir;
99  
100     /**
101      * The directory containing generated test classes of the project being tested. This will be included at the
102      * beginning of the test classpath. *
103      *
104      * @parameter default-value="${project.build.testOutputDirectory}"
105      */
106     private File testClassesDirectory;
107 
108     /**
109      * The directory containing generated classes of the project being tested. This will be included after the test
110      * classes in the test classpath.
111      *
112      * @parameter default-value="${project.build.outputDirectory}"
113      */
114     private File classesDirectory;
115 
116     /**
117      * The Maven Project Object.
118      *
119      * @parameter default-value="${project}"
120      * @readonly
121      */
122     private MavenProject project;
123 
124     /**
125      * List of dependencies to exclude from the test classpath. Each dependency string must follow the format
126      * <i>groupId:artifactId</i>. For example: <i>org.acme:project-a</i>
127      *
128      * @parameter
129      * @since 2.6
130      */
131     private List classpathDependencyExcludes;
132 
133     /**
134      * A dependency scope to exclude from the test classpath. The scope can be one of the following scopes:
135      * <p/>
136      * <ul>
137      * <li><i>compile</i> - system, provided, compile
138      * <li><i>runtime</i> - compile, runtime
139      * <li><i>test</i> - system, provided, compile, runtime, test
140      * </ul>
141      *
142      * @parameter default-value=""
143      * @since 2.6
144      */
145     private String classpathDependencyScopeExclude;
146 
147     /**
148      * Additional elements to be appended to the classpath.
149      *
150      * @parameter
151      * @since 2.4
152      */
153     private List additionalClasspathElements;
154 
155     /**
156      * Base directory where all reports are written to.
157      *
158      * @parameter default-value="${project.build.directory}/surefire-reports"
159      */
160     private File reportsDirectory;
161 
162     /**
163      * The test source directory containing test class sources.
164      *
165      * @parameter default-value="${project.build.testSourceDirectory}"
166      * @required
167      * @since 2.2
168      */
169     private File testSourceDirectory;
170 
171     /**
172      * Specify this parameter to run individual tests by file name, overriding the <code>includes/excludes</code>
173      * parameters. Each pattern you specify here will be used to create an include pattern formatted like
174      * <code>**&#47;${test}.java</code>, so you can just type "-Dtest=MyTest" to run a single test called
175      * "foo/MyTest.java".<br/>
176      * This parameter overrides the <code>includes/excludes</code> parameters, and the TestNG <code>suiteXmlFiles</code>
177      * parameter.
178      * <p/>
179      * since 2.7.3 You can execute a limited number of method in the test with adding #myMethod or #my*ethod. Si type
180      * "-Dtest=MyTest#myMethod" <b>supported for junit 4.x and testNg</b>
181      *
182      * @parameter expression="${test}"
183      */
184     private String test;
185 
186     /**
187      * A list of &lt;include> elements specifying the tests (by pattern) that should be included in testing. When not
188      * specified and when the <code>test</code> parameter is not specified, the default includes will be <code><br/>
189      * &lt;includes><br/>
190      * &nbsp;&lt;include>**&#47;Test*.java&lt;/include><br/>
191      * &nbsp;&lt;include>**&#47;*Test.java&lt;/include><br/>
192      * &nbsp;&lt;include>**&#47;*TestCase.java&lt;/include><br/>
193      * &lt;/includes><br/>
194      * </code> This parameter is ignored if the TestNG <code>suiteXmlFiles</code> parameter is specified.
195      *
196      * @parameter
197      */
198     private List includes;
199 
200     /**
201      * A list of &lt;exclude> elements specifying the tests (by pattern) that should be excluded in testing. When not
202      * specified and when the <code>test</code> parameter is not specified, the default excludes will be <code><br/>
203      * &lt;excludes><br/>
204      * &nbsp;&lt;exclude>**&#47;*$*&lt;/exclude><br/>
205      * &lt;/excludes><br/>
206      * </code> (which excludes all inner classes).<br>
207      * This parameter is ignored if the TestNG <code>suiteXmlFiles</code> parameter is specified.
208      *
209      * @parameter
210      */
211     private List excludes;
212 
213     /**
214      * ArtifactRepository of the localRepository. To obtain the directory of localRepository in unit tests use
215      * System.getProperty("localRepository").
216      *
217      * @parameter expression="${localRepository}"
218      * @required
219      * @readonly
220      */
221     private ArtifactRepository localRepository;
222 
223     /**
224      * List of System properties to pass to the JUnit tests.
225      *
226      * @parameter
227      * @deprecated Use systemPropertyVariables instead.
228      */
229     private Properties systemProperties;
230 
231     /**
232      * List of System properties to pass to the JUnit tests.
233      *
234      * @parameter
235      * @since 2.5
236      */
237     private Map systemPropertyVariables;
238 
239     /**
240      * List of System properties, loaded from a file, to pass to the JUnit tests.
241      *
242      * @parameter
243      * @since 2.8.2
244      */
245     private File systemPropertiesFile;
246 
247     /**
248      * List of properties for configuring all TestNG related configurations. This is the new preferred method of
249      * configuring TestNG.
250      *
251      * @parameter
252      * @since 2.4
253      */
254     private Properties properties;
255 
256     /**
257      * Map of plugin artifacts.
258      *
259      * @parameter expression="${plugin.artifactMap}"
260      * @required
261      * @readonly
262      */
263     private Map pluginArtifactMap;
264 
265     /**
266      * Map of project artifacts.
267      *
268      * @parameter expression="${project.artifactMap}"
269      * @required
270      * @readonly
271      */
272     private Map projectArtifactMap;
273 
274     /**
275      * Option to print summary of test suites or just print the test cases that have errors.
276      *
277      * @parameter expression="${surefire.printSummary}" default-value="true"
278      */
279     private boolean printSummary;
280 
281     /**
282      * Selects the formatting for the test report to be generated. Can be set as "brief" or "plain".
283      *
284      * @parameter expression="${surefire.reportFormat}" default-value="brief"
285      */
286     private String reportFormat;
287 
288     /**
289      * Add custom text into report filename: TEST-testClassName-reportNameSuffix.xml,
290      * testClassName-reportNameSuffix.txt and testClassName-reportNameSuffix-output.txt.
291      * File TEST-testClassName-reportNameSuffix.xml has changed attributes 'testsuite'--'name'
292      * and 'testcase'--'classname' - reportNameSuffix is added to the attribute value.
293      *
294      * @parameter expression="${surefire.reportNameSuffix}" default-value=""
295      */
296     private String reportNameSuffix;
297 
298     /**
299      * Option to generate a file test report or just output the test report to the console.
300      *
301      * @parameter expression="${surefire.useFile}" default-value="true"
302      */
303     private boolean useFile;
304 
305     /**
306      * Set this to "true" to redirect the unit test standard output to a file (found in
307      * reportsDirectory/testName-output.txt).
308      *
309      * @parameter expression="${maven.test.redirectTestOutputToFile}" default-value="false"
310      * @since 2.3
311      */
312     private boolean redirectTestOutputToFile;
313 
314     /**
315      * Set this to "true" to cause a failure if there are no tests to run. Defaults to "false".
316      *
317      * @parameter expression="${failIfNoTests}"
318      * @since 2.4
319      */
320     private Boolean failIfNoTests;
321 
322     /**
323      * Option to specify the forking mode. Can be "never", "once" or "always". "none" and "pertest" are also accepted
324      * for backwards compatibility. "always" forks for each test-class.
325      *
326      * @parameter expression="${forkMode}" default-value="once"
327      * @since 2.1
328      */
329     private String forkMode;
330 
331     /**
332      * Option to specify the jvm (or path to the java executable) to use with the forking options. For the default, the
333      * jvm will be a new instance of the same VM as the one used to run Maven. JVM settings are not inherited from
334      * MAVEN_OPTS.
335      *
336      * @parameter expression="${jvm}"
337      * @since 2.1
338      */
339     private String jvm;
340 
341     /**
342      * Arbitrary JVM options to set on the command line.
343      *
344      * @parameter expression="${argLine}"
345      * @since 2.1
346      */
347     private String argLine;
348 
349     /**
350      * Attach a debugger to the forked JVM. If set to "true", the process will suspend and wait for a debugger to attach
351      * on port 5005. If set to some other string, that string will be appended to the argLine, allowing you to configure
352      * arbitrary debuggability options (without overwriting the other options specified through the <code>argLine</code>
353      * parameter).
354      *
355      * @parameter expression="${maven.surefire.debug}"
356      * @since 2.4
357      */
358     private String debugForkedProcess;
359 
360     /**
361      * Kill the forked test process after a certain number of seconds. If set to 0, wait forever for the process, never
362      * timing out.
363      *
364      * @parameter expression="${surefire.timeout}"
365      * @since 2.4
366      */
367     private int forkedProcessTimeoutInSeconds;
368 
369     /**
370      * Additional environment variables to set on the command line.
371      *
372      * @parameter
373      * @since 2.1.3
374      */
375     private Map environmentVariables = new HashMap();
376 
377     /**
378      * Command line working directory.
379      *
380      * @parameter expression="${basedir}"
381      * @since 2.1.3
382      */
383     private File workingDirectory;
384 
385     /**
386      * When false it makes tests run using the standard classloader delegation instead of the default Maven isolated
387      * classloader. Only used when forking (forkMode is not "none").<br/>
388      * Setting it to false helps with some problems caused by conflicts between xml parsers in the classpath and the
389      * Java 5 provider parser.
390      *
391      * @parameter expression="${childDelegation}" default-value="false"
392      * @since 2.1
393      */
394     private boolean childDelegation;
395 
396     /**
397      * (TestNG only) Groups for this test. Only classes/methods/etc decorated with one of the groups specified here will
398      * be included in test run, if specified.<br/>
399      * This parameter is ignored if the <code>suiteXmlFiles</code> parameter is specified.
400      *
401      * @parameter expression="${groups}"
402      * @since 2.2
403      */
404     private String groups;
405 
406     /**
407      * (TestNG only) Excluded groups. Any methods/classes/etc with one of the groups specified in this list will
408      * specifically not be run.<br/>
409      * This parameter is ignored if the <code>suiteXmlFiles</code> parameter is specified.
410      *
411      * @parameter expression="${excludedGroups}"
412      * @since 2.2
413      */
414     private String excludedGroups;
415 
416     /**
417      * (TestNG only) List of &lt;suiteXmlFile> elements specifying TestNG suite xml file locations. Note that
418      * <code>suiteXmlFiles</code> is incompatible with several other parameters of this plugin, like
419      * <code>includes/excludes</code>.<br/>
420      * This parameter is ignored if the <code>test</code> parameter is specified (allowing you to run a single test
421      * instead of an entire suite).
422      *
423      * @parameter
424      * @since 2.2
425      */
426     private File[] suiteXmlFiles;
427 
428     /**
429      * Allows you to specify the name of the JUnit artifact. If not set, <code>junit:junit</code> will be used.
430      *
431      * @parameter expression="${junitArtifactName}" default-value="junit:junit"
432      * @since 2.3.1
433      */
434     private String junitArtifactName;
435 
436     /**
437      * Allows you to specify the name of the TestNG artifact. If not set, <code>org.testng:testng</code> will be used.
438      *
439      * @parameter expression="${testNGArtifactName}" default-value="org.testng:testng"
440      * @since 2.3.1
441      */
442     private String testNGArtifactName;
443 
444     /**
445      * (TestNG/JUnit 4.7 provider only) The attribute thread-count allows you to specify how many threads should be
446      * allocated for this execution. Only makes sense to use in conjunction with the <code>parallel</code> parameter.
447      *
448      * @parameter expression="${threadCount}"
449      * @since 2.2
450      */
451     private int threadCount;
452 
453     /**
454      * (JUnit 4.7 provider) Indicates that threadCount is per cpu core.
455      *
456      * @parameter expression="${perCoreThreadCount}" default-value="true"
457      * @since 2.5
458      */
459     private boolean perCoreThreadCount;
460 
461     /**
462      * (JUnit 4.7 provider) Indicates that the thread pool will be unlimited. The <code>parallel</code> parameter and
463      * the actual number of classes/methods will decide. Setting this to "true" effectively disables
464      * <code>perCoreThreadCount</code> and <code>threadCount</code>. Defaults to "false".
465      *
466      * @parameter expression="${useUnlimitedThreads}" default-value="false"
467      * @since 2.5
468      */
469     private boolean useUnlimitedThreads;
470 
471     /**
472      * (TestNG only) When you use the <code>parallel</code> attribute, TestNG will try to run all your test methods in
473      * separate threads, except for methods that depend on each other, which will be run in the same thread in order to
474      * respect their order of execution.
475      * <p/>
476      * (JUnit 4.7 provider) Supports values "classes"/"methods"/"both" to run in separate threads, as controlled by
477      * <code>threadCount</code>.
478      *
479      * @parameter expression="${parallel}"
480      * @since 2.2
481      */
482     private String parallel;
483 
484     /**
485      * Whether to trim the stack trace in the reports to just the lines within the test, or show the full trace.
486      *
487      * @parameter expression="${trimStackTrace}" default-value="true"
488      * @since 2.2
489      */
490     private boolean trimStackTrace;
491 
492     /**
493      * Resolves the artifacts needed.
494      *
495      * @component
496      */
497     private ArtifactResolver artifactResolver;
498 
499     /**
500      * Creates the artifact.
501      *
502      * @component
503      */
504     private ArtifactFactory artifactFactory;
505 
506     /**
507      * The remote plugin repositories declared in the POM.
508      *
509      * @parameter expression="${project.pluginArtifactRepositories}"
510      * @since 2.2
511      */
512     private List remoteRepositories;
513 
514     /**
515      * For retrieval of artifact's metadata.
516      *
517      * @component
518      */
519     private ArtifactMetadataSource metadataSource;
520 
521     private Properties originalSystemProperties;
522 
523     /**
524      * systemPropertyVariables + systemProperties
525      */
526     private Properties internalSystemProperties = new Properties();
527 
528     /**
529      * Flag to disable the generation of report files in xml format.
530      *
531      * @parameter expression="${disableXmlReport}" default-value="false"
532      * @since 2.2
533      */
534     private boolean disableXmlReport;
535 
536     /**
537      * Option to pass dependencies to the system's classloader instead of using an isolated class loader when forking.
538      * Prevents problems with JDKs which implement the service provider lookup mechanism by using the system's
539      * classloader.
540      *
541      * @parameter expression="${surefire.useSystemClassLoader}" default-value="true"
542      * @since 2.3
543      */
544     private boolean useSystemClassLoader;
545 
546     /**
547      * By default, Surefire forks your tests using a manifest-only JAR; set this parameter to "false" to force it to
548      * launch your tests with a plain old Java classpath. (See
549      * http://maven.apache.org/plugins/maven-surefire-plugin/examples/class-loading.html for a more detailed explanation
550      * of manifest-only JARs and their benefits.)
551      * <p/>
552      * Beware, setting this to "false" may cause your tests to fail on Windows if your classpath is too long.
553      *
554      * @parameter expression="${surefire.useManifestOnlyJar}" default-value="true"
555      * @since 2.4.3
556      */
557     private boolean useManifestOnlyJar;
558 
559     /**
560      * By default, Surefire enables JVM assertions for the execution of your test cases. To disable the assertions, set
561      * this flag to "false".
562      *
563      * @parameter expression="${enableAssertions}" default-value="true"
564      * @since 2.3.1
565      */
566     private boolean enableAssertions;
567 
568     /**
569      * The current build session instance.
570      *
571      * @parameter expression="${session}"
572      * @required
573      * @readonly
574      */
575     private MavenSession session;
576 
577     /**
578      * (TestNG only) Define the factory class used to create all test instances.
579      *
580      * @parameter expression="${objectFactory}"
581      * @since 2.5
582      */
583     private String objectFactory;
584 
585     /**
586      * @parameter default-value="${session.parallel}"
587      * @readonly
588      * @noinspection UnusedDeclaration
589      */
590     private Boolean parallelMavenExecution;
591 
592     /**
593      * Defines the order the tests will be run in. Supported values are "alphabetical", "reversealphabetical", "random",
594      * "hourly" (alphabetical on even hours, reverse alphabetical on odd hours) and "filesystem".
595      * <p/>
596      * <p/>
597      * Odd/Even for hourly is determined at the time the of scanning the classpath, meaning it could change during a
598      * multi-module build.
599      *
600      * @parameter default-value="filesystem"
601      * @since 2.7
602      */
603     private String runOrder;
604 
605     /**
606      * @component
607      */
608     private ToolchainManager toolchainManager;
609 
610     protected void handleSummary( Summary summary )
611         throws MojoExecutionException, MojoFailureException
612     {
613         assertNoException( summary );
614         assertNoFailureOrTimeout( summary );
615         writeSummary( summary );
616     }
617 
618     private void assertNoException( Summary summary )
619         throws MojoExecutionException
620     {
621         if ( !summary.isErrorFree() )
622         {
623             Exception cause = summary.getFirstException();
624             throw new MojoExecutionException( cause.getMessage(), cause );
625         }
626     }
627 
628     private void assertNoFailureOrTimeout( Summary summary )
629         throws MojoExecutionException
630     {
631         if ( summary.isFailureOrTimeout() )
632         {
633             throw new MojoExecutionException( "Failure or timeout" );
634         }
635     }
636 
637     private void writeSummary( Summary summary )
638         throws MojoFailureException
639     {
640         RunResult result = summary.getResultOfLastSuccessfulRun();
641         SurefireHelper.reportExecution( this, result, getLog() );
642     }
643 
644     protected boolean isSkipExecution()
645     {
646         return isSkip() || isSkipTests() || isSkipExec();
647     }
648 
649     protected String getPluginName()
650     {
651         return "surefire";
652     }
653 
654     protected String[] getDefaultIncludes()
655     {
656         return new String[]{"**/Test*.java", "**/*Test.java", "**/*TestCase.java"};
657     }
658 
659     // now for the implementation of the field accessors
660 
661     public boolean isSkipTests()
662     {
663         return skipTests;
664     }
665 
666     public void setSkipTests( boolean skipTests )
667     {
668         this.skipTests = skipTests;
669     }
670 
671     /**
672      * @noinspection deprecation
673      */
674     public boolean isSkipExec()
675     {
676         return skipExec;
677     }
678 
679     /**
680      * @noinspection deprecation
681      */
682     public void setSkipExec( boolean skipExec )
683     {
684         this.skipExec = skipExec;
685     }
686 
687     public boolean isSkip()
688     {
689         return skip;
690     }
691 
692     public void setSkip( boolean skip )
693     {
694         this.skip = skip;
695     }
696 
697     public boolean isTestFailureIgnore()
698     {
699         return testFailureIgnore;
700     }
701 
702     public void setTestFailureIgnore( boolean testFailureIgnore )
703     {
704         this.testFailureIgnore = testFailureIgnore;
705     }
706 
707     public File getBasedir()
708     {
709         return basedir;
710     }
711 
712     public void setBasedir( File basedir )
713     {
714         this.basedir = basedir;
715     }
716 
717     public File getTestClassesDirectory()
718     {
719         return testClassesDirectory;
720     }
721 
722     public void setTestClassesDirectory( File testClassesDirectory )
723     {
724         this.testClassesDirectory = testClassesDirectory;
725     }
726 
727     public File getClassesDirectory()
728     {
729         return classesDirectory;
730     }
731 
732     public void setClassesDirectory( File classesDirectory )
733     {
734         this.classesDirectory = classesDirectory;
735     }
736 
737     public MavenProject getProject()
738     {
739         return project;
740     }
741 
742     public void setProject( MavenProject project )
743     {
744         this.project = project;
745     }
746 
747     public List getClasspathDependencyExcludes()
748     {
749         return classpathDependencyExcludes;
750     }
751 
752     public void setClasspathDependencyExcludes( List classpathDependencyExcludes )
753     {
754         this.classpathDependencyExcludes = classpathDependencyExcludes;
755     }
756 
757     public String getClasspathDependencyScopeExclude()
758     {
759         return classpathDependencyScopeExclude;
760     }
761 
762     public void setClasspathDependencyScopeExclude( String classpathDependencyScopeExclude )
763     {
764         this.classpathDependencyScopeExclude = classpathDependencyScopeExclude;
765     }
766 
767     public List getAdditionalClasspathElements()
768     {
769         return additionalClasspathElements;
770     }
771 
772     public void setAdditionalClasspathElements( List additionalClasspathElements )
773     {
774         this.additionalClasspathElements = additionalClasspathElements;
775     }
776 
777     public File getReportsDirectory()
778     {
779         return reportsDirectory;
780     }
781 
782     public void setReportsDirectory( File reportsDirectory )
783     {
784         this.reportsDirectory = reportsDirectory;
785     }
786 
787     public File getTestSourceDirectory()
788     {
789         return testSourceDirectory;
790     }
791 
792     public void setTestSourceDirectory( File testSourceDirectory )
793     {
794         this.testSourceDirectory = testSourceDirectory;
795     }
796 
797     public String getTest()
798     {
799         if ( StringUtils.isBlank( test ) )
800         {
801             return null;
802         }
803         int index = test.indexOf( '#' );
804         if ( index >= 0 )
805         {
806             return test.substring( 0, index );
807         }
808         return test;
809     }
810 
811     /**
812      * @since 2.7.3
813      */
814     public String getTestMethod()
815     {
816         if ( StringUtils.isBlank( test ) )
817         {
818             return null;
819         }
820         int index = this.test.indexOf( '#' );
821         if ( index >= 0 )
822         {
823             return this.test.substring( index + 1, this.test.length() );
824         }
825         return null;
826     }
827 
828     public void setTest( String test )
829     {
830         this.test = test;
831     }
832 
833     public List getIncludes()
834     {
835         return includes;
836     }
837 
838     public void setIncludes( List includes )
839     {
840         this.includes = includes;
841     }
842 
843     public List getExcludes()
844     {
845         return excludes;
846     }
847 
848     public void setExcludes( List excludes )
849     {
850         this.excludes = excludes;
851     }
852 
853     public ArtifactRepository getLocalRepository()
854     {
855         return localRepository;
856     }
857 
858     public void setLocalRepository( ArtifactRepository localRepository )
859     {
860         this.localRepository = localRepository;
861     }
862 
863     /**
864      * @noinspection deprecation
865      */
866     public Properties getSystemProperties()
867     {
868         return systemProperties;
869     }
870 
871     /**
872      * @noinspection deprecation
873      */
874     public void setSystemProperties( Properties systemProperties )
875     {
876         this.systemProperties = systemProperties;
877     }
878 
879     public Map getSystemPropertyVariables()
880     {
881         return systemPropertyVariables;
882     }
883 
884     public void setSystemPropertyVariables( Map systemPropertyVariables )
885     {
886         this.systemPropertyVariables = systemPropertyVariables;
887     }
888 
889     public File getSystemPropertiesFile()
890     {
891         return systemPropertiesFile;
892     }
893 
894     public void setSystemPropertiesFile( File systemPropertiesFile )
895     {
896         this.systemPropertiesFile = systemPropertiesFile;
897     }
898 
899     public Properties getProperties()
900     {
901         return properties;
902     }
903 
904     public void setProperties( Properties properties )
905     {
906         this.properties = properties;
907     }
908 
909     public Map getPluginArtifactMap()
910     {
911         return pluginArtifactMap;
912     }
913 
914     public void setPluginArtifactMap( Map pluginArtifactMap )
915     {
916         this.pluginArtifactMap = pluginArtifactMap;
917     }
918 
919     public Map getProjectArtifactMap()
920     {
921         return projectArtifactMap;
922     }
923 
924     public void setProjectArtifactMap( Map projectArtifactMap )
925     {
926         this.projectArtifactMap = projectArtifactMap;
927     }
928 
929     public boolean isPrintSummary()
930     {
931         return printSummary;
932     }
933 
934     public void setPrintSummary( boolean printSummary )
935     {
936         this.printSummary = printSummary;
937     }
938 
939     public String getReportFormat()
940     {
941         return reportFormat;
942     }
943 
944     public void setReportFormat( String reportFormat )
945     {
946         this.reportFormat = reportFormat;
947     }
948 
949     public String getReportNameSuffix()
950     {
951         return reportNameSuffix;
952     }
953 
954     public void setReportNameSuffix( String reportNameSuffix )
955     {
956         this.reportNameSuffix = reportNameSuffix;
957     }
958 
959     public boolean isUseFile()
960     {
961         return useFile;
962     }
963 
964     public void setUseFile( boolean useFile )
965     {
966         this.useFile = useFile;
967     }
968 
969     public boolean isRedirectTestOutputToFile()
970     {
971         return redirectTestOutputToFile;
972     }
973 
974     public void setRedirectTestOutputToFile( boolean redirectTestOutputToFile )
975     {
976         this.redirectTestOutputToFile = redirectTestOutputToFile;
977     }
978 
979     public Boolean getFailIfNoTests()
980     {
981         return failIfNoTests;
982     }
983 
984     public void setFailIfNoTests( Boolean failIfNoTests )
985     {
986         this.failIfNoTests = failIfNoTests;
987     }
988 
989     public String getForkMode()
990     {
991         return forkMode;
992     }
993 
994     public void setForkMode( String forkMode )
995     {
996         this.forkMode = forkMode;
997     }
998 
999     public String getJvm()
1000     {
1001         return jvm;
1002     }
1003 
1004     public void setJvm( String jvm )
1005     {
1006         this.jvm = jvm;
1007     }
1008 
1009     public String getArgLine()
1010     {
1011         return argLine;
1012     }
1013 
1014     public void setArgLine( String argLine )
1015     {
1016         this.argLine = argLine;
1017     }
1018 
1019     public String getDebugForkedProcess()
1020     {
1021         return debugForkedProcess;
1022     }
1023 
1024     public void setDebugForkedProcess( String debugForkedProcess )
1025     {
1026         this.debugForkedProcess = debugForkedProcess;
1027     }
1028 
1029     public int getForkedProcessTimeoutInSeconds()
1030     {
1031         return forkedProcessTimeoutInSeconds;
1032     }
1033 
1034     public void setForkedProcessTimeoutInSeconds( int forkedProcessTimeoutInSeconds )
1035     {
1036         this.forkedProcessTimeoutInSeconds = forkedProcessTimeoutInSeconds;
1037     }
1038 
1039     public Map getEnvironmentVariables()
1040     {
1041         return environmentVariables;
1042     }
1043 
1044     public void setEnvironmentVariables( Map environmentVariables )
1045     {
1046         this.environmentVariables = environmentVariables;
1047     }
1048 
1049     public File getWorkingDirectory()
1050     {
1051         return workingDirectory;
1052     }
1053 
1054     public void setWorkingDirectory( File workingDirectory )
1055     {
1056         this.workingDirectory = workingDirectory;
1057     }
1058 
1059     public boolean isChildDelegation()
1060     {
1061         return childDelegation;
1062     }
1063 
1064     public void setChildDelegation( boolean childDelegation )
1065     {
1066         this.childDelegation = childDelegation;
1067     }
1068 
1069     public String getGroups()
1070     {
1071         return groups;
1072     }
1073 
1074     public void setGroups( String groups )
1075     {
1076         this.groups = groups;
1077     }
1078 
1079     public String getExcludedGroups()
1080     {
1081         return excludedGroups;
1082     }
1083 
1084     public void setExcludedGroups( String excludedGroups )
1085     {
1086         this.excludedGroups = excludedGroups;
1087     }
1088 
1089     public File[] getSuiteXmlFiles()
1090     {
1091         return suiteXmlFiles;
1092     }
1093 
1094     public void setSuiteXmlFiles( File[] suiteXmlFiles )
1095     {
1096         this.suiteXmlFiles = suiteXmlFiles;
1097     }
1098 
1099     public String getJunitArtifactName()
1100     {
1101         return junitArtifactName;
1102     }
1103 
1104     public void setJunitArtifactName( String junitArtifactName )
1105     {
1106         this.junitArtifactName = junitArtifactName;
1107     }
1108 
1109     public String getTestNGArtifactName()
1110     {
1111         return testNGArtifactName;
1112     }
1113 
1114     public void setTestNGArtifactName( String testNGArtifactName )
1115     {
1116         this.testNGArtifactName = testNGArtifactName;
1117     }
1118 
1119     public int getThreadCount()
1120     {
1121         return threadCount;
1122     }
1123 
1124     public void setThreadCount( int threadCount )
1125     {
1126         this.threadCount = threadCount;
1127     }
1128 
1129     public boolean getPerCoreThreadCount()
1130     {
1131         return perCoreThreadCount;
1132     }
1133 
1134     public void setPerCoreThreadCount( boolean perCoreThreadCount )
1135     {
1136         this.perCoreThreadCount = perCoreThreadCount;
1137     }
1138 
1139     public boolean getUseUnlimitedThreads()
1140     {
1141         return useUnlimitedThreads;
1142     }
1143 
1144     public void setUseUnlimitedThreads( boolean useUnlimitedThreads )
1145     {
1146         this.useUnlimitedThreads = useUnlimitedThreads;
1147     }
1148 
1149     public String getParallel()
1150     {
1151         return parallel;
1152     }
1153 
1154     public void setParallel( String parallel )
1155     {
1156         this.parallel = parallel;
1157     }
1158 
1159     public boolean isTrimStackTrace()
1160     {
1161         return trimStackTrace;
1162     }
1163 
1164     public void setTrimStackTrace( boolean trimStackTrace )
1165     {
1166         this.trimStackTrace = trimStackTrace;
1167     }
1168 
1169     public ArtifactResolver getArtifactResolver()
1170     {
1171         return artifactResolver;
1172     }
1173 
1174     public void setArtifactResolver( ArtifactResolver artifactResolver )
1175     {
1176         this.artifactResolver = artifactResolver;
1177     }
1178 
1179     public ArtifactFactory getArtifactFactory()
1180     {
1181         return artifactFactory;
1182     }
1183 
1184     public void setArtifactFactory( ArtifactFactory artifactFactory )
1185     {
1186         this.artifactFactory = artifactFactory;
1187     }
1188 
1189     public List getRemoteRepositories()
1190     {
1191         return remoteRepositories;
1192     }
1193 
1194     public void setRemoteRepositories( List remoteRepositories )
1195     {
1196         this.remoteRepositories = remoteRepositories;
1197     }
1198 
1199     public ArtifactMetadataSource getMetadataSource()
1200     {
1201         return metadataSource;
1202     }
1203 
1204     public void setMetadataSource( ArtifactMetadataSource metadataSource )
1205     {
1206         this.metadataSource = metadataSource;
1207     }
1208 
1209     public Properties getOriginalSystemProperties()
1210     {
1211         return originalSystemProperties;
1212     }
1213 
1214     public void setOriginalSystemProperties( Properties originalSystemProperties )
1215     {
1216         this.originalSystemProperties = originalSystemProperties;
1217     }
1218 
1219     public Properties getInternalSystemProperties()
1220     {
1221         return internalSystemProperties;
1222     }
1223 
1224     public void setInternalSystemProperties( Properties internalSystemProperties )
1225     {
1226         this.internalSystemProperties = internalSystemProperties;
1227     }
1228 
1229     public boolean isDisableXmlReport()
1230     {
1231         return disableXmlReport;
1232     }
1233 
1234     public void setDisableXmlReport( boolean disableXmlReport )
1235     {
1236         this.disableXmlReport = disableXmlReport;
1237     }
1238 
1239     public boolean isUseSystemClassLoader()
1240     {
1241         return useSystemClassLoader;
1242     }
1243 
1244     public void setUseSystemClassLoader( boolean useSystemClassLoader )
1245     {
1246         this.useSystemClassLoader = useSystemClassLoader;
1247     }
1248 
1249     public boolean isUseManifestOnlyJar()
1250     {
1251         return useManifestOnlyJar;
1252     }
1253 
1254     public void setUseManifestOnlyJar( boolean useManifestOnlyJar )
1255     {
1256         this.useManifestOnlyJar = useManifestOnlyJar;
1257     }
1258 
1259     public boolean isEnableAssertions()
1260     {
1261         return enableAssertions;
1262     }
1263 
1264     public void setEnableAssertions( boolean enableAssertions )
1265     {
1266         this.enableAssertions = enableAssertions;
1267     }
1268 
1269     public MavenSession getSession()
1270     {
1271         return session;
1272     }
1273 
1274     public void setSession( MavenSession session )
1275     {
1276         this.session = session;
1277     }
1278 
1279     public String getObjectFactory()
1280     {
1281         return objectFactory;
1282     }
1283 
1284     public void setObjectFactory( String objectFactory )
1285     {
1286         this.objectFactory = objectFactory;
1287     }
1288 
1289     public ToolchainManager getToolchainManager()
1290     {
1291         return toolchainManager;
1292     }
1293 
1294     public void setToolchainManager( ToolchainManager toolchainManager )
1295     {
1296         this.toolchainManager = toolchainManager;
1297     }
1298 
1299     public boolean isMavenParallel()
1300     {
1301         return parallelMavenExecution != null && parallelMavenExecution.booleanValue();
1302     }
1303 
1304     public String getRunOrder()
1305     {
1306         return runOrder;
1307     }
1308 
1309     public void setRunOrder( String runOrder )
1310     {
1311         this.runOrder = runOrder;
1312     }
1313 
1314     protected void addPluginSpecificChecksumItems( ChecksumCalculator checksum )
1315     {
1316     }
1317 
1318 }