Coverage Report

Coverage Report - org.apache.maven.plugin.TestCompilerMojo

Classes in this File

Line Coverage

Branch Coverage

Complexity

TestCompilerMojo

89%

26/29

59%

13/22

2.1

 package org.apache.maven.plugin;
 
 /*
  * 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 org.codehaus.plexus.compiler.util.scan.SimpleSourceInclusionScanner;
 import org.codehaus.plexus.compiler.util.scan.SourceInclusionScanner;
 import org.codehaus.plexus.compiler.util.scan.StaleSourceScanner;
 
 import java.io.File;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 /**
  * Compiles application test sources.
  *
  * @author <a href="mailto:jason@maven.org">Jason van Zyl</a>
  * @version $Id: org.apache.maven.plugin.TestCompilerMojo.html 816611 2012-05-08 13:04:26Z hboutemy $
  * @since 2.0
  * @goal testCompile
  * @phase test-compile
  * @requiresDependencyResolution test
  */
 public class TestCompilerMojo
     extends AbstractCompilerMojo
 {
     /**
      * Set this to 'true' to bypass unit tests entirely.
      * Its use is NOT RECOMMENDED, but quite convenient on occasion.
      *
      * @parameter expression="${maven.test.skip}"
      */
     private boolean skip;
 
     /**
      * The source directories containing the test-source to be compiled.
      *
      * @parameter default-value="${project.testCompileSourceRoots}"
      * @required
      * @readonly
      */
     private List compileSourceRoots;
 
     /**
      * Project test classpath.
      *
      * @parameter default-value="${project.testClasspathElements}"
      * @required
      * @readonly
      */
     private List classpathElements;
 
     /**
      * The directory where compiled test classes go.
      *
      * @parameter default-value="${project.build.testOutputDirectory}"
      * @required
      * @readonly
      */
     private File outputDirectory;
 
     /**
      * A list of inclusion filters for the compiler.
      *
      * @parameter
      */
     private Set testIncludes = new HashSet();
 
     /**
      * A list of exclusion filters for the compiler.
      *
      * @parameter
      */
     private Set testExcludes = new HashSet();
 
     /**
      * The -source argument for the test Java compiler.
      *
      * @parameter expression="${maven.compiler.testSource}"
      */
     private String testSource;
 
     /**
      * The -target argument for the test Java compiler.
      *
      * @parameter expression="${maven.compiler.testTarget}"
      */
     private String testTarget;
 
 
     /**
      * <p>
      * Sets the arguments to be passed to test compiler (prepending a dash) if fork is set to true.
      * </p>
      * <p>
      * This is because the list of valid arguments passed to a Java compiler
      * varies based on the compiler version.
      * </p>
      *
      * @parameter
      * @since 2.0.1
      */
     private Map testCompilerArguments;
 
     /**
      * <p>
      * Sets the unformatted argument string to be passed to test compiler if fork is set to true.
      * </p>
      * <p>
      * This is because the list of valid arguments passed to a Java compiler
      * varies based on the compiler version.
      * </p>
      *
      * @parameter
      */
     private String testCompilerArgument;
 
     public void execute()
         throws MojoExecutionException, CompilationFailureException
     {
         if ( skip )
         {
             getLog().info( "Not compiling test sources" );
         }
         else
         {
             super.execute();
         }
     }
 
     protected List getCompileSourceRoots()
     {
         return compileSourceRoots;
     }
 
     protected List getClasspathElements()
     {
         return classpathElements;
     }
 
     protected File getOutputDirectory()
     {
         return outputDirectory;
     }
 
     protected SourceInclusionScanner getSourceInclusionScanner( int staleMillis )
     {
         SourceInclusionScanner scanner = null;
 
         if ( testIncludes.isEmpty() && testExcludes.isEmpty() )
         {
             scanner = new StaleSourceScanner( staleMillis );
         }
         else
         {
             if ( testIncludes.isEmpty() )
             {
                 testIncludes.add( "**/*.java" );
             }
             scanner = new StaleSourceScanner( staleMillis, testIncludes, testExcludes );
         }
 
         return scanner;
     }
 
     protected SourceInclusionScanner getSourceInclusionScanner( String inputFileEnding )
     {
         SourceInclusionScanner scanner = null;
 
         if ( testIncludes.isEmpty() && testExcludes.isEmpty() )
         {
             testIncludes = Collections.singleton( "**/*." + inputFileEnding );
             scanner = new SimpleSourceInclusionScanner( testIncludes, Collections.EMPTY_SET );
         }
         else
         {
             if ( testIncludes.isEmpty() )
             {
                 testIncludes.add( "**/*." + inputFileEnding );
             }
             scanner = new SimpleSourceInclusionScanner( testIncludes, testExcludes );
         }
 
         return scanner;
     }
 
     protected String getSource()
     {
       return testSource == null ? source : testSource;
     }
 
     protected String getTarget()
     {
       return testTarget == null ? target : testTarget;
     }
 
     protected String getCompilerArgument()
     {
       return testCompilerArgument == null ? compilerArgument : testCompilerArgument;
     }
 
     protected Map getCompilerArguments()
     {
       return testCompilerArguments == null ? compilerArguments : testCompilerArguments;
     }
 
 }

1		package org.apache.maven.plugin;
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 org.codehaus.plexus.compiler.util.scan.SimpleSourceInclusionScanner;
23		import org.codehaus.plexus.compiler.util.scan.SourceInclusionScanner;
24		import org.codehaus.plexus.compiler.util.scan.StaleSourceScanner;
25
26		import java.io.File;
27		import java.util.Collections;
28		import java.util.HashSet;
29		import java.util.List;
30		import java.util.Map;
31		import java.util.Set;
32
33		/**
34		* Compiles application test sources.
35		*
36		* @author <a href="mailto:jason@maven.org">Jason van Zyl</a>
37		* @version $Id: org.apache.maven.plugin.TestCompilerMojo.html 816611 2012-05-08 13:04:26Z hboutemy $
38		* @since 2.0
39		* @goal testCompile
40		* @phase test-compile
41		* @requiresDependencyResolution test
42		*/
43	6	public class TestCompilerMojo
44		extends AbstractCompilerMojo
45		{
46		/**
47		* Set this to 'true' to bypass unit tests entirely.
48		* Its use is NOT RECOMMENDED, but quite convenient on occasion.
49		*
50		* @parameter expression="${maven.test.skip}"
51		*/
52		private boolean skip;
53
54		/**
55		* The source directories containing the test-source to be compiled.
56		*
57		* @parameter default-value="${project.testCompileSourceRoots}"
58		* @required
59		* @readonly
60		*/
61		private List compileSourceRoots;
62
63		/**
64		* Project test classpath.
65		*
66		* @parameter default-value="${project.testClasspathElements}"
67		* @required
68		* @readonly
69		*/
70		private List classpathElements;
71
72		/**
73		* The directory where compiled test classes go.
74		*
75		* @parameter default-value="${project.build.testOutputDirectory}"
76		* @required
77		* @readonly
78		*/
79		private File outputDirectory;
80
81		/**
82		* A list of inclusion filters for the compiler.
83		*
84		* @parameter
85		*/
86	6	private Set testIncludes = new HashSet();
87
88		/**
89		* A list of exclusion filters for the compiler.
90		*
91		* @parameter
92		*/
93	6	private Set testExcludes = new HashSet();
94
95		/**
96		* The -source argument for the test Java compiler.
97		*
98		* @parameter expression="${maven.compiler.testSource}"
99		*/
100		private String testSource;
101
102		/**
103		* The -target argument for the test Java compiler.
104		*
105		* @parameter expression="${maven.compiler.testTarget}"
106		*/
107		private String testTarget;
108
109
110		/**
111		* <p>
112		* Sets the arguments to be passed to test compiler (prepending a dash) if fork is set to true.
113		* </p>
114		* <p>
115		* This is because the list of valid arguments passed to a Java compiler
116		* varies based on the compiler version.
117		* </p>
118		*
119		* @parameter
120		* @since 2.0.1
121		*/
122		private Map testCompilerArguments;
123
124		/**
125		* <p>
126		* Sets the unformatted argument string to be passed to test compiler if fork is set to true.
127		* </p>
128		* <p>
129		* This is because the list of valid arguments passed to a Java compiler
130		* varies based on the compiler version.
131		* </p>
132		*
133		* @parameter
134		*/
135		private String testCompilerArgument;
136
137		public void execute()
138		throws MojoExecutionException, CompilationFailureException
139		{
140	6	if ( skip )
141		{
142	0	getLog().info( "Not compiling test sources" );
143		}
144		else
145		{
146	6	super.execute();
147		}
148	6	}
149
150		protected List getCompileSourceRoots()
151		{
152	15	return compileSourceRoots;
153		}
154
155		protected List getClasspathElements()
156		{
157	12	return classpathElements;
158		}
159
160		protected File getOutputDirectory()
161		{
162	21	return outputDirectory;
163		}
164
165		protected SourceInclusionScanner getSourceInclusionScanner( int staleMillis )
166		{
167	5	SourceInclusionScanner scanner = null;
168
169	5	if ( testIncludes.isEmpty() && testExcludes.isEmpty() )
170		{
171	3	scanner = new StaleSourceScanner( staleMillis );
172		}
173		else
174		{
175	2	if ( testIncludes.isEmpty() )
176		{
177	0	testIncludes.add( "*/.java" );
178		}
179	2	scanner = new StaleSourceScanner( staleMillis, testIncludes, testExcludes );
180		}
181
182	5	return scanner;
183		}
184
185		protected SourceInclusionScanner getSourceInclusionScanner( String inputFileEnding )
186		{
187	2	SourceInclusionScanner scanner = null;
188
189	2	if ( testIncludes.isEmpty() && testExcludes.isEmpty() )
190		{
191	1	testIncludes = Collections.singleton( "*/." + inputFileEnding );
192	1	scanner = new SimpleSourceInclusionScanner( testIncludes, Collections.EMPTY_SET );
193		}
194		else
195		{
196	1	if ( testIncludes.isEmpty() )
197		{
198	0	testIncludes.add( "*/." + inputFileEnding );
199		}
200	1	scanner = new SimpleSourceInclusionScanner( testIncludes, testExcludes );
201		}
202
203	2	return scanner;
204		}
205
206		protected String getSource()
207		{
208	5	return testSource == null ? source : testSource;
209		}
210
211		protected String getTarget()
212		{
213	5	return testTarget == null ? target : testTarget;
214		}
215
216		protected String getCompilerArgument()
217		{
218	5	return testCompilerArgument == null ? compilerArgument : testCompilerArgument;
219		}
220
221		protected Map getCompilerArguments()
222		{
223	5	return testCompilerArguments == null ? compilerArguments : testCompilerArguments;
224		}
225
226		}