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
 
 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$
 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  
 }