diff options
Diffstat (limited to 'maven-plugins/tags/maven-osgi-junit-plugin-1.0/src/main/java/org/apache/tuscany/maven/plugin/surefire/ForkConfiguration.java')
-rw-r--r-- | maven-plugins/tags/maven-osgi-junit-plugin-1.0/src/main/java/org/apache/tuscany/maven/plugin/surefire/ForkConfiguration.java | 239 |
1 files changed, 239 insertions, 0 deletions
diff --git a/maven-plugins/tags/maven-osgi-junit-plugin-1.0/src/main/java/org/apache/tuscany/maven/plugin/surefire/ForkConfiguration.java b/maven-plugins/tags/maven-osgi-junit-plugin-1.0/src/main/java/org/apache/tuscany/maven/plugin/surefire/ForkConfiguration.java new file mode 100644 index 0000000000..eb391970ca --- /dev/null +++ b/maven-plugins/tags/maven-osgi-junit-plugin-1.0/src/main/java/org/apache/tuscany/maven/plugin/surefire/ForkConfiguration.java @@ -0,0 +1,239 @@ +package org.apache.tuscany.maven.plugin.surefire; + +/* + * 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.io.FileOutputStream; +import java.io.IOException; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Properties; +import java.util.jar.JarEntry; +import java.util.jar.JarOutputStream; +import java.util.jar.Manifest; + +import org.apache.maven.surefire.booter.SurefireBooterForkException; +import org.apache.maven.surefire.booter.shade.org.codehaus.plexus.util.cli.Commandline; +import org.apache.maven.surefire.util.UrlUtils; +import org.codehaus.plexus.util.StringUtils; + +/** + * Derived from surefire-booter 2.4.3 + * Configuration for forking tests. + * + */ +@SuppressWarnings("unchecked") +public class ForkConfiguration { + public static final String FORK_ONCE = "once"; + + public static final String FORK_ALWAYS = "always"; + + public static final String FORK_NEVER = "never"; + + private String forkMode; + + private boolean useSystemClassLoader; + private boolean useManifestOnlyJar; + + private Properties systemProperties; + + private String jvmExecutable; + + private String argLine; + + private Map environmentVariables; + + private File workingDirectory; + + private boolean debug; + + private String debugLine; + + public void setForkMode(String forkMode) { + if ("pertest".equalsIgnoreCase(forkMode)) { + this.forkMode = FORK_ALWAYS; + } else if ("none".equalsIgnoreCase(forkMode)) { + this.forkMode = FORK_NEVER; + } else if (forkMode.equals(FORK_NEVER) || forkMode.equals(FORK_ONCE) || forkMode.equals(FORK_ALWAYS)) { + this.forkMode = forkMode; + } else { + throw new IllegalArgumentException("Fork mode " + forkMode + " is not a legal value"); + } + } + + public boolean isForking() { + return !FORK_NEVER.equals(forkMode); + } + + public void setUseSystemClassLoader(boolean useSystemClassLoader) { + this.useSystemClassLoader = useSystemClassLoader; + } + + public boolean isUseSystemClassLoader() { + return useSystemClassLoader; + } + + public void setSystemProperties(Properties systemProperties) { + this.systemProperties = (Properties)systemProperties.clone(); + } + + public void setJvmExecutable(String jvmExecutable) { + this.jvmExecutable = jvmExecutable; + } + + public void setArgLine(String argLine) { + this.argLine = argLine; + } + + public void setDebugLine(String debugLine) { + this.debugLine = debugLine; + } + + public void setEnvironmentVariables(Map environmentVariables) { + this.environmentVariables = new HashMap(environmentVariables); + } + + public void setWorkingDirectory(File workingDirectory) { + this.workingDirectory = workingDirectory; + } + + public String getForkMode() { + return forkMode; + } + + public Properties getSystemProperties() { + return systemProperties; + } + + /** + * @throws SurefireBooterForkException + * @deprecated use the 2-arg alternative. + */ + public Commandline createCommandLine(List classPath) throws SurefireBooterForkException { + return createCommandLine(classPath, false); + } + + public Commandline createCommandLine(List classPath, boolean useJar) throws SurefireBooterForkException { + Commandline cli = new Commandline(); + + cli.setExecutable(jvmExecutable); + + if (argLine != null) { + cli.createArg().setLine(argLine); + } + + if (environmentVariables != null) { + Iterator iter = environmentVariables.keySet().iterator(); + + while (iter.hasNext()) { + String key = (String)iter.next(); + + String value = (String)environmentVariables.get(key); + + cli.addEnvironment(key, value); + } + } + + if (debugLine != null && !"".equals(debugLine)) { + cli.createArg().setLine(debugLine); + } + + if (useJar) { + File jarFile; + try { + jarFile = createJar(classPath); + } catch (IOException e) { + throw new SurefireBooterForkException("Error creating archive file", e); + } + + cli.createArg().setValue("-jar"); + + cli.createArg().setValue(jarFile.getAbsolutePath()); + } else { + cli.createArg().setValue("-classpath"); + + cli.createArg().setValue(StringUtils.join(classPath.iterator(), File.pathSeparator)); + + cli.createArg().setValue(OSGiSurefireBooter.class.getName()); + } + + cli.setWorkingDirectory(workingDirectory.getAbsolutePath()); + + return cli; + } + + /** + * Create a jar with just a manifest containing a Main-Class entry for SurefireBooter and a Class-Path entry + * for all classpath elements. + * + * @param classPath List<String> of all classpath elements. + * @return + * @throws IOException + */ + private File createJar(List classPath) throws IOException { + File file = File.createTempFile("surefirebooter", ".jar"); + if (!debug) { + file.deleteOnExit(); + } + FileOutputStream fos = new FileOutputStream(file); + JarOutputStream jos = new JarOutputStream(fos); + jos.setLevel(JarOutputStream.STORED); + JarEntry je = new JarEntry("META-INF/MANIFEST.MF"); + jos.putNextEntry(je); + + Manifest man = new Manifest(); + + // we can't use StringUtils.join here since we need to add a '/' to + // the end of directory entries - otherwise the jvm will ignore them. + String cp = ""; + for (Iterator it = classPath.iterator(); it.hasNext();) { + String el = (String)it.next(); + // NOTE: if File points to a directory, this entry MUST end in '/'. + cp += UrlUtils.getURL(new File(el)).toExternalForm() + " "; + } + + man.getMainAttributes().putValue("Manifest-Version", "1.0"); + man.getMainAttributes().putValue("Class-Path", cp.trim()); + man.getMainAttributes().putValue("Main-Class", OSGiSurefireBooter.class.getName()); + + man.write(jos); + jos.close(); + + return file; + } + + public void setDebug(boolean debug) { + this.debug = debug; + } + + public boolean isDebug() { + return debug; + } + + public void setUseManifestOnlyJar(boolean useManifestOnlyJar) { + this.useManifestOnlyJar = useManifestOnlyJar; + } + + public boolean isUseManifestOnlyJar() { + return useManifestOnlyJar; + } +} |