org.codehaus.mojo.cobertura.configuration.ConfigInstrumentation Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of cobertura-maven-plugin Show documentation
Show all versions of cobertura-maven-plugin Show documentation
This is the Mojo's Maven plugin for Cobertura. Cobertura is a free Java tool that calculates the percentage of code accessed by
tests. It can be used to identify which parts of your Java program are lacking test coverage.
package org.codehaus.mojo.cobertura.configuration;
/*
* Copyright 2011
*
* Licensed 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.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* The Configuration for the Instrumentation.
*
* @author Joakim Erdfelt
*/
public class ConfigInstrumentation
{
private File basedir;
private List excludes;
private List ignores;
private List includes;
private String maxmem;
private boolean ignoreTrivial;
private List ignoreMethodAnnotations;
/**
* Construct a new ConfigInstrumentation object.
*/
public ConfigInstrumentation()
{
this.includes = new ArrayList();
this.excludes = new ArrayList();
this.ignores = new ArrayList();
this.ignoreTrivial = false;
this.ignoreMethodAnnotations = new ArrayList();
this.basedir = new File( System.getProperty( "user.dir" ) );
if ( MaxHeapSizeUtil.getInstance().envHasMavenMaxMemSetting() )
{
maxmem = MaxHeapSizeUtil.getInstance().getMavenMaxMemSetting();
}
else
{
this.maxmem = "64m";
}
}
/**
* Add an Exclude to the underlying list.
*
* @param exclude the exlude string.
*/
public void addExclude( String exclude )
{
this.excludes.add( exclude );
}
/**
* Add an Ignore to the underlying list.
*
* @param ignore the ignore string.
*/
public void addIgnore( String ignore )
{
this.ignores.add( ignore );
}
/**
* Add an IgnoreMethodAnnotation to the underlying list.
*
* @param ignoreMethodAnnotation the ignore string.
*/
public void addIgnoreMethodAnnotation( String ignoreMethodAnnotation )
{
this.ignoreMethodAnnotations.add( ignoreMethodAnnotation );
}
/**
* Add an Include ot the underlying list.
*
* @param include the include string.
*/
public void addInclude( String include )
{
this.includes.add( include );
}
/**
* @return Returns the basedir.
*/
public File getBasedir()
{
return basedir;
}
/**
* Get the Exclude List.
*
* @return the exlude list.
*/
public List getExcludes()
{
return excludes;
}
/**
* Get the Ignore List.
*
* @return the ignore list.
*/
public List getIgnores()
{
return ignores;
}
/**
* Get the Include List.
*
* @return the include list.
*/
public List getIncludes()
{
return includes;
}
/**
* @param basedir The basedir to set.
*/
public void setBasedir( File basedir )
{
this.basedir = basedir;
}
/**
* Get the maxmem setting.
*
* @return the maxmem setting.
*/
public String getMaxmem()
{
return maxmem;
}
/** Sets the max memory for the JVM used to run the InstrumentationTask task.
* The format is "". Ex: "64m" where 64 is the value, and "m" denotes megabytes.
* @param maxmem the value to which maxmem will be set
*/
public void setMaxmem( String maxmem )
{
this.maxmem = maxmem;
}
/**
* Get the ignoreTrivial setting.
*
* @return the ignoreTrivial setting.
*/
public boolean getIgnoreTrivial()
{
return ignoreTrivial;
}
/**
* IgnoreTrivial switch that tells Cobertura to ignore the following in the coverage report:
* Getter methods that simply read a class field; Setter methods that set a class field;
* Constructors that only set class fields and call a super class constructor.
*
* @param ignoreTrivial enable ignoreTrivial
*/
public void setIgnoreTrivial(boolean ignoreTrivial) {
this.ignoreTrivial = ignoreTrivial;
}
/**
* Get the ignoreMethodAnnotations setting.
*
* @return the ignoreMethodAnnotations setting.
*/
public List getIgnoreMethodAnnotations() {
return ignoreMethodAnnotations;
}
/**
* IgnoreMethodAnnotation switch used to specify an annotation that, when present on a method,
* will cause Cobertura to ignore the method in the coverage report.
*
* @param ignoreMethodAnnotations
*/
public void setIgnoreMethodAnnotations(List ignoreMethodAnnotations) {
this.ignoreMethodAnnotations = ignoreMethodAnnotations;
}
/**
* {@inheritDoc}
*/
public String toString()
{
StringBuffer sb = new StringBuffer();
sb.append( " it = this.includes.iterator();
while ( it.hasNext() )
{
String include = (String) it.next();
sb.append( include );
if ( it.hasNext() )
{
sb.append( " " );
}
}
sb.append( "\"" );
}
if ( !this.excludes.isEmpty() )
{
sb.append( " excludes=\"" );
Iterator it = this.excludes.iterator();
while ( it.hasNext() )
{
String exclude = (String) it.next();
sb.append( exclude );
if ( it.hasNext() )
{
sb.append( " " );
}
}
sb.append( "\"" );
}
if ( !this.ignores.isEmpty() )
{
sb.append( " ignores=\"" );
Iterator it = this.ignores.iterator();
while ( it.hasNext() )
{
String ignore = (String) it.next();
sb.append( ignore );
if ( it.hasNext() )
{
sb.append( " " );
}
}
sb.append( "\"" );
}
if ( 0 != getMaxmem().length() )
{
sb.append( " maxmem=\"" );
sb.append( getMaxmem() );
sb.append( "\"" );
}
sb.append("ignoreTrivial=\"");
sb.append(getIgnoreTrivial());
sb.append( "\"" );
if ( !this.ignoreMethodAnnotations.isEmpty() )
{
sb.append( " ignoreMethodAnnotations=\"" );
Iterator it = this.ignoreMethodAnnotations.iterator();
while ( it.hasNext() )
{
String ignore = (String) it.next();
sb.append( ignore );
if ( it.hasNext() )
{
sb.append( " " );
}
}
sb.append( "\"" );
}
return sb.append( " />" ).toString();
}
}