Java tutorial
/* Copyright 2013 Jonatan Jnsson * * 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. */ package se.softhouse.common.testlib; import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Preconditions.checkNotNull; import static java.lang.reflect.Modifier.isPublic; import static java.lang.reflect.Modifier.isStatic; import java.io.File; import java.io.IOException; import java.lang.management.ManagementFactory; import java.lang.management.RuntimeMXBean; import java.util.Arrays; import java.util.List; import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; import javax.annotation.concurrent.Immutable; import com.google.common.base.Charsets; import com.google.common.collect.Lists; /** * Can launch java programs for a {@link Class} with a main method. Output is captured in the * returned {@link LaunchedProgram}. */ @Immutable public final class Launcher { /** * Result from a {@link Launcher#launch(Class, String...) launched program} */ @Immutable public static final class LaunchedProgram { private final String errors; private final String output; private final String debugInformation; private LaunchedProgram(String errors, String output, String debugInformation) { this.errors = errors; this.output = output; this.debugInformation = debugInformation; } /** * The {@link System#out} in {@link Charsets#UTF_8 UTF-8} from the launched program */ public String output() { return output; } /** * The {@link System#err} in {@link Charsets#UTF_8 UTF-8} from the launched program */ public String errors() { return errors; } /** * Returns information suitable to print in case of errors on a debug level */ public String debugInformation() { return debugInformation; } @Override public String toString() { return "Output: " + output() + "\nErrors: " + errors(); } } private Launcher() { } /** * Runs {@code classWithMainMethod} in a separate process using the system property * {@code java.home} to find java and {@code java.class.path} for the class path. This method * will wait until program execution has finished. * * @param classWithMainMethod a class with a static "main" method * @param programArguments optional arguments to pass to the program * @return output/errors from the executed program * @throws IOException if an I/O error occurs while starting {@code classWithMainMethod} as a * process * @throws InterruptedException if the thread starting the program is * {@link Thread#interrupted()} while waiting for the program to finish * @throws IllegalArgumentException if {@code classWithMainMethod} doesn't have a public static * main method * @throws SecurityException if it's not possible to validate the existence of a main method in * {@code classWithMainMethod} (or if {@link SecurityManager#checkExec checkExec} * fails) */ public static LaunchedProgram launch(Class<?> classWithMainMethod, String... programArguments) throws IOException, InterruptedException { checkNotNull(programArguments); try { int modifiers = classWithMainMethod.getDeclaredMethod("main", String[].class).getModifiers(); boolean validModifiers = isStatic(modifiers) && isPublic(modifiers); checkArgument(validModifiers, "%s's main method needs to be static and public for it to be launchable", classWithMainMethod.getName()); } catch (NoSuchMethodException e) { throw new IllegalArgumentException("No main method found on: " + classWithMainMethod.getName(), e); } RuntimeMXBean runtimeInformation = ManagementFactory.getRuntimeMXBean(); String jvm = new File(new File(System.getProperty("java.home"), "bin"), "java").getAbsolutePath(); String classPath = runtimeInformation.getClassPath(); List<String> vmArgs = runtimeInformation.getInputArguments(); List<String> args = Lists.newArrayList(jvm, "-cp", classPath); args.addAll(vmArgs); args.add(classWithMainMethod.getName()); args.addAll(Arrays.asList(programArguments)); String debugInformation = "\njvm: " + jvm + "\nvm args: " + vmArgs + "\nclasspath: " + classPath; return execute(args, debugInformation); } /** * Runs {@code program} with {@code programArguments} as arguments. This method * will wait until program execution has finished. * * @param program the executable to run * @param programArguments optional arguments to pass to the program * @return output/errors from the executed program * @throws IOException if an I/O error occurs while starting {@code program} * @throws InterruptedException if the thread starting the program is * {@link Thread#interrupted()} while waiting for the program to finish * @throws SecurityException if {@link SecurityManager#checkExec checkExec} fails */ public static LaunchedProgram launch(String program, String... programArguments) throws IOException, InterruptedException { return execute(Lists.asList(program, programArguments), "Failed to launch " + program); } private static LaunchedProgram execute(List<String> args, String debugInformation) throws IOException, InterruptedException { Process program = new ProcessBuilder().command(args).start(); Future<String> stdout = Streams.readAsynchronously(program.getInputStream()); Future<String> stderr = Streams.readAsynchronously(program.getErrorStream()); program.waitFor(); try { String output = stdout.get(); String errors = stderr.get(); return new LaunchedProgram(errors, output, debugInformation); } catch (ExecutionException e) { if (e.getCause() instanceof IOException) throw (IOException) e.getCause(); throw new RuntimeException("Failed to read stdout/stderr", e); } } }