// Copied from Maven maven-surefire-plugin 2.3, 2006-2007
package org.freehep.maven.nar;
/*
* 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.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
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.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.versioning.InvalidVersionSpecificationException;
import org.apache.maven.artifact.versioning.VersionRange;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.project.MavenProject;
import org.apache.maven.surefire.booter.ForkConfiguration;
import org.apache.maven.surefire.booter.SurefireBooter;
import org.apache.maven.surefire.booter.SurefireBooterForkException;
import org.apache.maven.surefire.booter.SurefireExecutionException;
import org.apache.maven.surefire.report.BriefConsoleReporter;
import org.apache.maven.surefire.report.BriefFileReporter;
import org.apache.maven.surefire.report.ConsoleReporter;
import org.apache.maven.surefire.report.DetailedConsoleReporter;
import org.apache.maven.surefire.report.FileReporter;
import org.apache.maven.surefire.report.ForkingConsoleReporter;
import org.apache.maven.surefire.report.XMLReporter;
import org.codehaus.plexus.util.StringUtils;
/**
* Run integration tests using Surefire.
*
* This goal was copied from Maven's surefire plugin to accomodate a few things
* for the NAR plugin: 1. To test a jar file with its native module we can only
* run after the package phase, so we use the integration-test phase. 2. We need
* to set java.library.path to an AOL (architecture-os-linker) specific value,
* but AOL is only known in the NAR plugin and thus cannot be set from the pom.
* 3. To have the java.library.path definition picked up by java we need the
* "pertest" forkmode.
*
* To use this goal you need to put the test sources in the regular test
* directories but disable the running of the tests by the
* maven-surefire-plugin.
*
* @author Jason van Zyl (modified by Mark Donszelmann, noted by FREEHEP)
* @version $Id: NarIntegrationTestMojo.java 13111 2007-07-24 04:02:00Z duns $,
* 2.3 maven repository maven-surefire-plugin
* @requiresDependencyResolution test
* @goal nar-integration-test
* @phase integration-test
*/
// FREEHEP, changed class name, inheritence, goal and phase
public class NarIntegrationTestMojo extends AbstractCompileMojo {
// FREEHEP added test for JNI module
private boolean testJNIModule() {
for (Iterator i = getLibraries().iterator(); i.hasNext();) {
Library lib = (Library) i.next();
if (lib.getType().equals(Library.JNI))
return true;
}
return false;
}
// FREEHEP added to get names
/**
* @parameter expression="${project}"
* @readonly
* @required
*/
private MavenProject project;
// FREEHEP added because of naming conflict
/**
* Skip running of NAR plugins (any) altogether.
*
* @parameter expression="${nar.skip}" default-value="false"
*/
private boolean skipNAR;
/**
* 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;
/**
* Set this to 'true' to bypass unit tests execution, but still compile
* them. Its use is NOT RECOMMENDED, but quite convenient on occasion.
*
* @parameter expression="${maven.test.skip.exec}"
*/
private boolean skipExec;
/**
* Set this to true to ignore a failure during testing. Its use is NOT
* RECOMMENDED, but quite convenient on occasion.
*
* @parameter expression="${maven.test.failure.ignore}"
*/
private boolean testFailureIgnore;
/**
* The base directory of the project being tested. This can be obtained in
* your unit test by System.getProperty("basedir").
*
* @parameter expression="${basedir}"
* @required
*/
private File basedir;
// FIXME this field is not used
/**
* The directory containing generated classes of the project being tested.
*
* @parameter expression="${project.build.outputDirectory}"
* @required
*/
// FREEHEP
// private File classesDirectory;
/**
* The directory containing generated test classes of the project being
* tested.
*
* @parameter expression="${project.build.testOutputDirectory}"
* @required
*/
private File testClassesDirectory;
/**
* The classpath elements of the project being tested.
*
* @parameter expression="${project.testClasspathElements}"
* @required
* @readonly
*/
private List classpathElements;
/**
* Base directory where all reports are written to.
*
* @parameter expression="${project.build.directory}/surefire-reports"
*/
private File reportsDirectory;
/**
* The test source directory containing test class sources.
*
* @parameter expression="${project.build.testSourceDirectory}"
* @required
*/
private File testSourceDirectory;
/**
* Specify this parameter(can be a comma separated list) if you want to use
* the test pattern matching notation, Ant pattern matching, to select tests
* to run. The Ant pattern will be used to create an include pattern
* formatted like <code>**/${test}.java</code> When used, the
* <code>includes</code> and <code>excludes</code> patterns parameters
* are ignored.
*
* @parameter expression="${test}"
*/
private String test;
/**
* List of patterns (separated by commas) used to specify the tests that
* should be included in testing. When not specified and when the
* <code>test</code> parameter is not specified, the default includes will
* be
* <code>**/Test*.java **/*Test.java **/*TestCase.java</code>
*
* @parameter
*/
private List includes;
/**
* List of patterns (separated by commas) used to specify the tests 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>**/Abstract*Test.java **/Abstract*TestCase.java **/*$*</code>
*
* @parameter
*/
private List excludes;
/**
* ArtifactRepository of the localRepository. To obtain the directory of
* localRepository in unit tests use System.setProperty( "localRepository").
*
* @parameter expression="${localRepository}"
* @required
* @readonly
*/
// FREEHEP removed, already in superclass
// private ArtifactRepository localRepository;
/**
* List of System properties to pass to the JUnit tests.
*
* @parameter
*/
private Properties systemProperties;
/**
* Map of of plugin artifacts.
*
* @parameter expression="${plugin.artifactMap}"
* @required
* @readonly
*/
private Map pluginArtifactMap;
/**
* Map of of project artifacts.
*
* @parameter expression="${project.artifactMap}"
* @required
* @readonly
*/
private Map projectArtifactMap;
/**
* Option to print summary of test suites or just print the test cases that
* has errors.
*
* @parameter expression="${surefire.printSummary}" default-value="true"
*/
private boolean printSummary;
/**
* Selects the formatting for the test report to be generated. Can be set as
* brief or plain.
*
* @parameter expression="${surefire.reportFormat}" default-value="brief"
*/
private String reportFormat;
/**
* Option to generate a file test report or just output the test report to
* the console.
*
* @parameter expression="${surefire.useFile}" default-value="true"
*/
private boolean useFile;
/**
* When forking, set this to true to redirect the unit test standard output
* to a file (found in reportsDirectory/testName-output.txt).
*
* @parameter expression="${maven.test.redirectTestOutputToFile}"
* default-value="false"
*/
private boolean redirectTestOutputToFile;
/**
* Option to specify the forking mode. Can be "never", "once" or "always".
* "none" and "pertest" are also accepted for backwards compatibility.
*
* @parameter expression="${forkMode}" default-value="once"
*/
private 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 the same as the one
* used to run Maven.
*
* @parameter expression="${jvm}"
*/
private String jvm;
/**
* Arbitrary options to set on the command line.
*
* @parameter expression="${argLine}"
*/
private String argLine;
/**
* Additional environments to set on the command line.
*
* @parameter
*/
private Map environmentVariables = new HashMap();
/**
* Command line working directory.
*
* @parameter
*/
private 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.
*
* @parameter expression="${childDelegation}" default-value="false"
*/
private boolean childDelegation;
/**
* Groups for this test. Only classes/methods/etc decorated with one of the
* groups specified here will be included in test run, if specified.
*
* @parameter expression="${groups}"
*/
private String groups;
/**
* Excluded groups. Any methods/classes/etc with one of the groups specified
* in this list will specifically not be run.
*
* @parameter expression="${excludedGroups}"
*/
private String excludedGroups;
/**
* List of TestNG suite xml file locations, seperated by commas. It should
* be noted that if suiteXmlFiles is specified, <b>no</b> other tests will
* be run, ignoring other parameters, like includes and excludes.
*
* @parameter
*/
private File[] suiteXmlFiles;
/**
* 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 parallel.
*
* @parameter expression="${threadCount}" default-value="5"
*/
private int threadCount;
/**
* When you use the parallel 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.
*
* @parameter expression="${parallel}" default-value="false"
* @todo test how this works with forking, and console/file output
* parallelism
*/
private boolean parallel;
/**
* Whether to trim the stack trace in the reports to just the lines within
* the test, or show the full trace.
*
* @parameter expression="${trimStackTrace}" default-value="true"
*/
private boolean trimStackTrace;
/**
* Resolves the artifacts needed.
*
* @component
*/
private ArtifactResolver artifactResolver;
/**
* Creates the artifact
*
* @component
*/
private ArtifactFactory artifactFactory;
/**
* The plugin remote repositories declared in the pom.
*
* @parameter expression="${project.pluginArtifactRepositories}"
*/
private List remoteRepositories;
/**
* For retrieval of artifact's metadata.
*
* @component
*/
private ArtifactMetadataSource metadataSource;
private static final String BRIEF_REPORT_FORMAT = "brief";
private static final String PLAIN_REPORT_FORMAT = "plain";
private Properties originalSystemProperties;
/**
* Flag to disable the generation of report files in xml format.
*
* @parameter expression="${disableXmlReport}" default-value="false"
*/
private boolean disableXmlReport;
/**
* Option to pass dependencies to the system's classloader instead of using
* an isolated class loader when forking. Prevents problems with JDKs which
* implement the service provider lookup mechanism by using the system's
* classloader.
*
* @parameter expression="${surefire.useSystemClassLoader}"
* default-value="false"
*/
private boolean useSystemClassLoader;
public void execute() throws MojoExecutionException, MojoFailureException {
if (verifyParameters()) {
SurefireBooter surefireBooter = constructSurefireBooter();
getLog().info("Surefire report directory: " + reportsDirectory);
boolean success;
try {
success = surefireBooter.run();
} catch (SurefireBooterForkException e) {
throw new MojoExecutionException(e.getMessage(), e);
} catch (SurefireExecutionException e) {
throw new MojoExecutionException(e.getMessage(), e);
}
if (originalSystemProperties != null) {
// restore system properties
System.setProperties(originalSystemProperties);
}
if (!success) {
String msg = "There are test failures.";
if (testFailureIgnore) {
getLog().error(msg);
} else {
throw new MojoFailureException(msg);
}
}
}
}
private boolean verifyParameters() throws MojoFailureException {
// FREEHEP, shouldSkip() does not work...
if (skipNAR) {
getLog()
.info(
"***********************************************************************");
getLog()
.info(
"NAR Integration Tests are SKIPPED since no NAR libraries were built.");
getLog()
.info(
"***********************************************************************");
return false;
}
if (skip || skipExec) {
getLog().info("Tests are skipped.");
return false;
} else if (!testClassesDirectory.exists()) {
getLog().info("No tests to run.");
return false;
}
if (parallel) {
if (threadCount < 1) {
throw new MojoFailureException(
"Must have at least one thread in parallel mode");
}
}
if (useSystemClassLoader
&& ForkConfiguration.FORK_NEVER.equals(forkMode)) {
getLog()
.warn(
"useSystemClassloader=true setting has no effect when not forking");
}
return true;
}
private SurefireBooter constructSurefireBooter()
throws MojoExecutionException, MojoFailureException {
SurefireBooter surefireBooter = new SurefireBooter();
Artifact surefireArtifact = (Artifact) pluginArtifactMap
.get("org.apache.maven.surefire:surefire-booter");
if (surefireArtifact == null) {
throw new MojoExecutionException(
"Unable to locate surefire-booter in the list of plugin artifacts");
}
surefireArtifact.isSnapshot(); // TODO: this is ridiculous, but it
// fixes getBaseVersion to be -SNAPSHOT
// if needed
Artifact junitArtifact;
Artifact testNgArtifact;
try {
addArtifact(surefireBooter, surefireArtifact);
junitArtifact = (Artifact) projectArtifactMap.get("junit:junit");
// TODO: this is pretty manual, but I'd rather not require the
// plugin > dependencies section right now
testNgArtifact = (Artifact) projectArtifactMap
.get("org.testng:testng");
if (testNgArtifact != null) {
addArtifact(surefireBooter, testNgArtifact);
VersionRange range = VersionRange
.createFromVersionSpec("[4.7,)");
if (!range.containsVersion(testNgArtifact.getSelectedVersion())) {
throw new MojoFailureException(
"TestNG support requires version 4.7 or above. You have declared version "
+ testNgArtifact.getVersion());
}
// The plugin uses a JDK based profile to select the right
// testng. We might be explicity using a
// different one since its based on the source level, not the
// JVM. Prune using the filter.
addProvider(surefireBooter, "surefire-testng", surefireArtifact
.getBaseVersion(), testNgArtifact);
} else if (junitArtifact != null
&& junitArtifact.getBaseVersion().startsWith("4")) {
addProvider(surefireBooter, "surefire-junit4", surefireArtifact
.getBaseVersion(), null);
} else {
// add the JUnit provider as default - it doesn't require JUnit
// to be present,
// since it supports POJO tests.
addProvider(surefireBooter, "surefire-junit", surefireArtifact
.getBaseVersion(), null);
}
} catch (ArtifactNotFoundException e) {
throw new MojoExecutionException(
"Unable to locate required surefire provider dependency: "
+ e.getMessage(), e);
} catch (InvalidVersionSpecificationException e) {
throw new MojoExecutionException(
"Error determining the TestNG version requested: "
+ e.getMessage(), e);
} catch (ArtifactResolutionException e) {
throw new MojoExecutionException(
"Error to resolving surefire provider dependency: "
+ e.getMessage(), e);
}
if (suiteXmlFiles != null && suiteXmlFiles.length > 0) {
if (testNgArtifact == null) {
throw new MojoExecutionException(
"suiteXmlFiles is configured, but there is no TestNG dependency");
}
for (int i = 0; i < suiteXmlFiles.length; i++) {
File file = suiteXmlFiles[i];
if (file.exists()) {
surefireBooter
.addTestSuite(
"org.apache.maven.surefire.testng.TestNGXmlTestSuite",
new Object[] {
file,
testSourceDirectory
.getAbsolutePath() });
}
}
} else {
List includes;
List excludes;
if (test != null) {
// 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
includes = new ArrayList();
excludes = new ArrayList();
String[] testRegexes = StringUtils.split(test, ",");
for (int i = 0; i < testRegexes.length; i++) {
includes.add("**/" + testRegexes[i] + ".java");
}
} else {
includes = this.includes;
excludes = this.excludes;
// 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 = new ArrayList(Arrays.asList(new String[] {
"**/Test*.java", "**/*Test.java",
"**/*TestCase.java" }));
}
if (excludes == null || excludes.size() == 0) {
excludes = new ArrayList(Arrays.asList(new String[] {
"**/Abstract*Test.java",
"**/Abstract*TestCase.java", "**/*$*" }));
}
}
if (testNgArtifact != null) {
surefireBooter
.addTestSuite(
"org.apache.maven.surefire.testng.TestNGDirectoryTestSuite",
new Object[] { testClassesDirectory, includes,
excludes, groups, excludedGroups,
Boolean.valueOf(parallel),
new Integer(threadCount),
testSourceDirectory.getAbsolutePath() });
} else {
String junitDirectoryTestSuite;
// FREEHEP NP check
if (junitArtifact != null
&& junitArtifact.getBaseVersion().startsWith("4")) {
junitDirectoryTestSuite = "org.apache.maven.surefire.junit4.JUnit4DirectoryTestSuite";
} else {
junitDirectoryTestSuite = "org.apache.maven.surefire.junit.JUnitDirectoryTestSuite";
}
// fall back to JUnit, which also contains POJO support. Also it
// can run
// classes compiled against JUnit since it has a dependency on
// JUnit itself.
surefireBooter
.addTestSuite(junitDirectoryTestSuite, new Object[] {
testClassesDirectory, includes, excludes });
}
}
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
getLog().debug("Test Classpath :");
// no need to add classes/test classes directory here - they are in the
// classpath elements already
for (Iterator i = classpathElements.iterator(); i.hasNext();) {
String classpathElement = (String) i.next();
getLog().debug(" " + classpathElement);
surefireBooter.addClassPathUrl(classpathElement);
}
// ----------------------------------------------------------------------
// Forking
// ----------------------------------------------------------------------
ForkConfiguration fork = new ForkConfiguration();
// FREEHEP
if (project.getPackaging().equals("nar")
|| (getNarManager().getNarDependencies("test").size() > 0))
forkMode = "pertest";
fork.setForkMode(forkMode);
processSystemProperties(!fork.isForking());
if (getLog().isDebugEnabled()) {
showMap(systemProperties, "system property");
}
if (fork.isForking()) {
fork.setSystemProperties(systemProperties);
if (jvm == null || "".equals(jvm)) {
// use the same JVM as the one used to run Maven (the
// "java.home" one)
jvm = System.getProperty("java.home") + File.separator + "bin"
+ File.separator + "java";
getLog().debug("Using JVM: " + jvm);
}
fork.setJvmExecutable(jvm);
if (workingDirectory != null) {
fork.setWorkingDirectory(workingDirectory);
} else {
fork.setWorkingDirectory(basedir);
}
// BEGINFREEHEP
if (argLine == null)
argLine = "";
StringBuffer javaLibraryPath = new StringBuffer();
if (testJNIModule()) {
// Add libraries to java.library.path for testing
File jniLibraryPathEntry = new File(project.getBasedir(),
"target/nar/lib/" + getAOL() + "/jni");
if (jniLibraryPathEntry.exists()) {
getLog().debug(
"Adding library directory to java.library.path: "
+ jniLibraryPathEntry);
if (javaLibraryPath.length() > 0)
javaLibraryPath.append(File.pathSeparator);
javaLibraryPath.append(jniLibraryPathEntry);
}
File sharedLibraryPathEntry = new File(project.getBasedir(),
"target/nar/lib/" + getAOL() + "/shared");
if (sharedLibraryPathEntry.exists()) {
getLog().debug(
"Adding library directory to java.library.path: "
+ sharedLibraryPathEntry);
if (javaLibraryPath.length() > 0)
javaLibraryPath.append(File.pathSeparator);
javaLibraryPath.append(sharedLibraryPathEntry);
}
// add jar file to classpath, as one may want to read a
// properties file for artifactId and version
String jarFile = "target/" + project.getArtifactId() + "-"
+ project.getVersion() + ".jar";
getLog().debug("Adding to surefire test classpath: " + jarFile);
surefireBooter.addClassPathUrl(jarFile);
}
List dependencies = getNarManager().getNarDependencies("test");
for (Iterator i = dependencies.iterator(); i.hasNext();) {
NarArtifact dependency = (NarArtifact) i.next();
// FIXME this should be overridable
// NarInfo info = dependency.getNarInfo();
// String binding = info.getBinding(getAOL(), Library.STATIC);
// NOTE: fixed to shared, jni
String[] bindings = { Library.SHARED, Library.JNI };
for (int j = 0; j < bindings.length; j++) {
String binding = bindings[j];
if (!binding.equals(Library.STATIC)) {
File depLibPathEntry = new File(getNarManager()
.getNarFile(dependency).getParent(), "nar/lib/"
+ getAOL() + "/" + binding);
if (depLibPathEntry.exists()) {
getLog().debug(
"Adding dependency directory to java.library.path: "
+ depLibPathEntry);
if (javaLibraryPath.length() > 0)
javaLibraryPath.append(File.pathSeparator);
javaLibraryPath.append(depLibPathEntry);
}
}
}
}
// add final javalibrary path
if (javaLibraryPath.length() > 0) {
// NOTE java.library.path only works for the jni lib itself, and
// not for its dependent shareables.
// NOTE: java.library.path does not work with arguments with
// spaces as
// SureFireBooter splits the line in parts and then quotes
// it wrongly
NarUtil.addLibraryPathToEnv(javaLibraryPath.toString(), environmentVariables, getOS());
}
// necessary to find WinSxS
if (getOS().equals(OS.WINDOWS)) {
environmentVariables.put("SystemRoot", NarUtil.getEnv("SystemRoot", "SystemRoot", "C:\\Windows"));
}
// ENDFREEHEP
fork.setArgLine(argLine);
fork.setEnvironmentVariables(environmentVariables);
if (getLog().isDebugEnabled()) {
showMap(environmentVariables, "environment variable");
fork.setDebug(true);
}
}
surefireBooter.setRedirectTestOutputToFile(redirectTestOutputToFile);
surefireBooter.setForkConfiguration(fork);
surefireBooter.setChildDelegation(childDelegation);
surefireBooter.setReportsDirectory(reportsDirectory);
surefireBooter.setUseSystemClassLoader(useSystemClassLoader);
addReporters(surefireBooter, fork.isForking());
return surefireBooter;
}
private void showMap(Map map, String setting) {
for (Iterator i = map.keySet().iterator(); i.hasNext();) {
String key = (String) i.next();
String value = (String) map.get(key);
getLog().debug(
"Setting " + setting + " [" + key + "]=[" + value + "]");
}
}
private void addProvider(SurefireBooter surefireBooter, String provider,
String version, Artifact filteredArtifact)
throws ArtifactNotFoundException, ArtifactResolutionException {
Artifact providerArtifact = artifactFactory.createDependencyArtifact(
"org.apache.maven.surefire", provider, VersionRange
.createFromVersion(version), "jar", null,
Artifact.SCOPE_TEST);
ArtifactResolutionResult result = resolveArtifact(filteredArtifact,
providerArtifact);
for (Iterator i = result.getArtifacts().iterator(); i.hasNext();) {
Artifact artifact = (Artifact) i.next();
getLog().debug(
"Adding to surefire test classpath: "
+ artifact.getFile().getAbsolutePath());
surefireBooter.addSurefireClassPathUrl(artifact.getFile()
.getAbsolutePath());
}
}
private ArtifactResolutionResult resolveArtifact(Artifact filteredArtifact,
Artifact providerArtifact) throws ArtifactResolutionException,
ArtifactNotFoundException {
ArtifactFilter filter = null;
if (filteredArtifact != null) {
filter = new ExcludesArtifactFilter(Collections
.singletonList(filteredArtifact.getGroupId() + ":"
+ filteredArtifact.getArtifactId()));
}
Artifact originatingArtifact = artifactFactory.createBuildArtifact(
"dummy", "dummy", "1.0", "jar");
// FREEHEP, use access method rather than "localRepository" field.
return artifactResolver.resolveTransitively(Collections
.singleton(providerArtifact), originatingArtifact,
getLocalRepository(), remoteRepositories, metadataSource,
filter);
}
private void addArtifact(SurefireBooter surefireBooter,
Artifact surefireArtifact) throws ArtifactNotFoundException,
ArtifactResolutionException {
ArtifactResolutionResult result = resolveArtifact(null,
surefireArtifact);
for (Iterator i = result.getArtifacts().iterator(); i.hasNext();) {
Artifact artifact = (Artifact) i.next();
getLog().debug(
"Adding to surefire booter test classpath: "
+ artifact.getFile().getAbsolutePath());
surefireBooter.addSurefireBootClassPathUrl(artifact.getFile()
.getAbsolutePath());
}
}
protected void processSystemProperties(boolean setInSystem) {
if (systemProperties == null) {
systemProperties = new Properties();
}
originalSystemProperties = (Properties) System.getProperties().clone();
systemProperties.setProperty("basedir", basedir.getAbsolutePath());
// FREEHEP, use access method rather than "localRepository" field.
systemProperties.setProperty("localRepository", getLocalRepository()
.getBasedir());
if (setInSystem) {
// Add all system properties configured by the user
Iterator iter = systemProperties.keySet().iterator();
while (iter.hasNext()) {
String key = (String) iter.next();
String value = systemProperties.getProperty(key);
System.setProperty(key, value);
}
}
}
/**
* <p>
* Adds Reporters that will generate reports with different formatting.
* <p>
* The Reporter that will be added will be based on the value of the
* parameter useFile, reportFormat, and printSummary.
*
* @param surefireBooter
* The surefire booter that will run tests.
* @param forking
*/
private void addReporters(SurefireBooter surefireBooter, boolean forking) {
Boolean trimStackTrace = Boolean.valueOf(this.trimStackTrace);
if (useFile) {
if (printSummary) {
if (forking) {
surefireBooter.addReport(ForkingConsoleReporter.class
.getName(), new Object[] { trimStackTrace });
} else {
surefireBooter.addReport(ConsoleReporter.class.getName(),
new Object[] { trimStackTrace });
}
}
if (BRIEF_REPORT_FORMAT.equals(reportFormat)) {
surefireBooter.addReport(BriefFileReporter.class.getName(),
new Object[] { reportsDirectory, trimStackTrace });
} else if (PLAIN_REPORT_FORMAT.equals(reportFormat)) {
surefireBooter.addReport(FileReporter.class.getName(),
new Object[] { reportsDirectory, trimStackTrace });
}
} else {
if (BRIEF_REPORT_FORMAT.equals(reportFormat)) {
surefireBooter.addReport(BriefConsoleReporter.class.getName(),
new Object[] { trimStackTrace });
} else if (PLAIN_REPORT_FORMAT.equals(reportFormat)) {
surefireBooter.addReport(DetailedConsoleReporter.class
.getName(), new Object[] { trimStackTrace });
}
}
if (!disableXmlReport) {
surefireBooter.addReport(XMLReporter.class.getName(), new Object[] {
reportsDirectory, trimStackTrace });
}
}
/**
* @return SurefirePlugin Returns the skipExec.
*/
public boolean isSkipExec() {
return this.skipExec;
}
/**
* @param skipExec
* the skipExec to set
*/
public void setSkipExec(boolean skipExec) {
this.skipExec = skipExec;
}
}