bundles/org.eclipse.test/src/org/eclipse/test/EclipseTestRunner.java

/*******************************************************************************
 * Copyright (c) 2000, 2018 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Anthony Dahanne  <anthony.dahanne@compuware.com> - enhance ETF to be able to launch several tests in several bundles - https://bugs.eclipse.org/330613
 *******************************************************************************/
package org.eclipse.test;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.URISyntaxException;
import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.Dictionary;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Locale;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Timer;
import java.util.TimerTask;
import java.util.Vector;

import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.taskdefs.optional.junit.JUnitResultFormatter;
import org.apache.tools.ant.taskdefs.optional.junit.JUnitTest;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.osgi.util.ManifestElement;
import org.eclipse.swt.SWT;
import org.eclipse.swt.SWTException;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.ImageLoader;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleException;
import org.osgi.framework.Constants;

import junit.framework.AssertionFailedError;
import junit.framework.Test;
import junit.framework.TestListener;
import junit.framework.TestResult;

/**
 * A TestRunner for JUnit that supports Ant JUnitResultFormatters and running
 * tests inside Eclipse. Example call: EclipseTestRunner -classname
 * junit.samples.SimpleTest
 * formatter=org.apache.tools.ant.taskdefs.optional.junit
 * .XMLJUnitResultFormatter
 */
public class EclipseTestRunner implements TestListener {
	class TestFailedException extends Exception {

		private static final long serialVersionUID = 6009335074727417445L;

		TestFailedException(String message) {
			super(message);
		}

		TestFailedException(Throwable e) {
			super(e);
		}
	}

	static class ThreadDump extends Exception {

		private static final long serialVersionUID = 1L;

		ThreadDump(String message) {
			super(message);
		}
	}

	static class StreamForwarder extends Thread {
		private InputStream fProcessOutput;

		private PrintStream fStream;

		public StreamForwarder(InputStream processOutput, PrintStream stream) {
			fProcessOutput = processOutput;
			fStream = stream;
		}

		@Override
		public void run() {
			try (BufferedReader reader = new BufferedReader(new InputStreamReader(fProcessOutput))) {
				String line = null;
				while ((line = reader.readLine()) != null) {
					fStream.println(line);
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * No problems with this test.
	 */
	public static final int SUCCESS = 0;
	/**
	 * Some tests failed.
	 */
	public static final int FAILURES = 1;
	/**
	 * An error occured.
	 */
	public static final int ERRORS = 2;

	private static final String SUITE_METHODNAME = "suite";
	/**
	 * SECONDS_BEFORE_TIMEOUT_BUFFER is the time we allow ourselves to take stack
	 * traces, get a screen shot, delay "SECONDS_BETWEEN_DUMPS", then do it again.
	 * On current build machine, it takes about 30 seconds to do all that, so 2
	 * minutes should be suffiencient time allowed for most machines. Though, should
	 * increase, say, if we increase the "time beteen dumps" to a minute or more.
	 */
	private static final int SECONDS_BEFORE_TIMEOUT_BUFFER = 120;

	/**
	 * SECONDS_BETWEEN_DUMPS is the time we wait from first to second dump of stack
	 * trace and screenshots. In most cases, this should suffice to determine if
	 * still busy doing something, or, hung, or waiting for user input.
	 */
	private static final int SECONDS_BETWEEN_DUMPS = 5;

	/**
	 * The current test result
	 */
	private TestResult fTestResult;
	/**
	 * The name of the plugin containing the test
	 */
	private String fTestPluginName;
	/**
	 * The corresponding testsuite.
	 */
	private Test fSuite;
	/**
	 * Formatters from the command line.
	 */
	private static Vector<JUnitResultFormatter> fgFromCmdLine = new Vector<>();
	/**
	 * Holds the registered formatters.
	 */
	private Vector<JUnitResultFormatter> formatters = new Vector<>();
	/**
	 * Do we stop on errors.
	 */
	private boolean fHaltOnError = false;
	/**
	 * Do we stop on test failures.
	 */
	private boolean fHaltOnFailure = false;
	/**
	 * The TestSuite we are currently running.
	 */
	private JUnitTest fJunitTest;
	/**
	 * output written during the test
	 */
	private PrintStream fSystemError;
	/**
	 * Error output during the test
	 */
	private PrintStream fSystemOut;
	/**
	 * Exception caught in constructor.
	 */
	private Exception fException;
	/**
	 * Returncode
	 */
	private int fRetCode = SUCCESS;

	/**
	 * The main entry point (the parameters are not yet consistent with the Ant
	 * JUnitTestRunner, but eventually they should be). Parameters
	 *
	 * <pre>
	 * -className: the name of the testSuite
	 * -testPluginName: the name of the containing plugin
	 * haltOnError: halt test on errors?
	 * haltOnFailure: halt test on failures?
	 * -testlistener listenerClass: deprecated
	 * 		print a warning that this option is deprecated
	 * formatter: a JUnitResultFormatter given as classname,filename.
	 *  	If filename is ommitted, System.out is assumed.
	 * </pre>
	 */
	public static void main(String[] args) throws IOException {
		System.exit(run(args));
	}

	public static int run(String[] args) throws IOException {
		String className = null;
		String classesNames = null;
		String testPluginName = null;
		String testPluginsNames = null;
		String formatterString = null;
		String timeoutString = null;
		String junitReportOutput = null;

		boolean haltError = false;
		boolean haltFail = false;

		Properties props = new Properties();

		int startArgs = 0;
		if (args.length > 0) {
			// support the JUnit task commandline syntax where
			// the first argument is the name of the test class
			if (!args[0].startsWith("-")) {
				className = args[0];
				startArgs++;
			}
		}
		for (int i = startArgs; i < args.length; i++) {
			if (args[i].toLowerCase().equals("-classname")) {
				if (i < args.length - 1)
					className = args[i + 1];
				i++;
			} else if (args[i].toLowerCase().equals("-classesnames")) {
				if (i < args.length - 1)
					classesNames = args[i + 1];
				i++;
			} else if (args[i].toLowerCase().equals("-testpluginname")) {
				if (i < args.length - 1)
					testPluginName = args[i + 1];
				i++;
			} else if (args[i].toLowerCase().equals("-testpluginsnames")) {
				if (i < args.length - 1)
					testPluginsNames = args[i + 1];
				i++;
			} else if (args[i].equals("-junitReportOutput")) {
				if (i < args.length - 1)
					junitReportOutput = args[i + 1];
				i++;
			} else if (args[i].startsWith("haltOnError=")) {
				haltError = Project.toBoolean(args[i].substring(12));
			} else if (args[i].startsWith("haltOnFailure=")) {
				haltFail = Project.toBoolean(args[i].substring(14));
			} else if (args[i].startsWith("formatter=")) {
				formatterString = args[i].substring(10);
			} else if (args[i].startsWith("propsfile=")) {
				try (FileInputStream in = new FileInputStream(args[i].substring(10))) {
					props.load(in);
				}
			} else if (args[i].equals("-testlistener")) {
				System.err
						.println("The -testlistener option is no longer supported\nuse the formatter= option instead");
				return ERRORS;
			} else if (args[i].equals("-timeout")) {
				if (i < args.length - 1)
					timeoutString = args[i + 1];
				i++;
			}
		}
		// Add/overlay system properties on the properties from the Ant project
		Hashtable<Object, Object> p = System.getProperties();
		for (Enumeration<Object> _enum = p.keys(); _enum.hasMoreElements();) {
			Object key = _enum.nextElement();
			props.put(key, p.get(key));
		}

		if (timeoutString == null || timeoutString.isEmpty()) {
			System.err.println("INFO: optional timeout was not specified.");
		} else {
			String timeoutScreenOutputDir = null;
			if (junitReportOutput == null || junitReportOutput.isEmpty()) {
				timeoutScreenOutputDir = "timeoutScreens";
			} else {
				timeoutScreenOutputDir = junitReportOutput + "/timeoutScreens";
			}
			System.err.println("INFO: timeoutScreenOutputDir: " + timeoutScreenOutputDir);
			System.err.println("INFO: timeout: " + timeoutString);
			startStackDumpTimeoutTimer(timeoutString, new File(timeoutScreenOutputDir), className);
		}

		if (testPluginsNames != null && classesNames != null) {
			// we have several plugins to look tests for, let's parse their
			// names
			String[] testPlugins = testPluginsNames.split(",");
			String[] suiteClasses = classesNames.split(",");
			try {
				createAndStoreFormatter(formatterString, suiteClasses);
			} catch (BuildException be) {
				System.err.println(be.getMessage());
				return ERRORS;
			}
			int returnCode = 0;
			int j = 0;
			for (String oneClassName : suiteClasses) {
				JUnitTest t = new JUnitTest(oneClassName);
				t.setProperties(props);
				EclipseTestRunner runner = new EclipseTestRunner(t, testPlugins[j], haltError, haltFail);
				transferFormatters(runner, j);
				runner.run();
				j++;
				if (runner.getRetCode() != 0) {
					returnCode = runner.getRetCode();
				}
			}
			return returnCode;
		}
		try {
			createAndStoreFormatter(formatterString);
		} catch (BuildException be) {
			System.err.println(be.getMessage());
			return ERRORS;
		}
		if (className == null)
			throw new IllegalArgumentException("Test class name not specified");

		JUnitTest t = new JUnitTest(className);

		t.setProperties(props);

		EclipseTestRunner runner = new EclipseTestRunner(t, testPluginName, haltError, haltFail);
		transferFormatters(runner);
		runner.run();
		return runner.getRetCode();
	}

	/**
	 * Starts a timer that dumps interesting debugging information shortly before
	 * the given timeout expires.
	 *
	 * @param timeoutArg      the -timeout argument from the command line
	 * @param outputDirectory where the test results end up
	 * @param classname       the class that is running the tests suite
	 */
	private static void startStackDumpTimeoutTimer(final String timeoutArg, final File outputDirectory,
			final String classname) {
		try {
			/*
			 * The delay (in ms) is the sum of - the expected time it took for launching the
			 * current VM and reaching this method - the time it will take to run the
			 * garbage collection and dump all the infos (twice)
			 */
			int delay = SECONDS_BEFORE_TIMEOUT_BUFFER * 1000;

			int timeout = Integer.parseInt(timeoutArg) - delay;
			String time0 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss Z", Locale.US).format(new Date());
			System.err.println("starting EclipseTestRunner Timer with timeout=" + timeout + " at " + time0);
			if (timeout > 0) {
				new Timer("EclipseTestRunner Timer", true).schedule(new TimerTask() {

					volatile boolean assumeUiThreadIsResponsive;

					@Override
					public void run() {
						assumeUiThreadIsResponsive = true;
						dump(0);
						try {
							Thread.sleep(SECONDS_BETWEEN_DUMPS * 1000);
						} catch (InterruptedException e) {
							// continue
						}
						dump(SECONDS_BETWEEN_DUMPS);
					}

					/**
					 *
					 * @param num num is purely a lable used in naming the screen capture files. By
					 *            convention, we pass in 0 or "SECONDS_BETWEEN_DUMPS" just as a
					 *            subtle reminder of how much time as elapsed. Thus, files end up
					 *            with names similar to <classname>_screen0.png,
					 *            <classname>_screem5.png in a directory named "timeoutScreens"
					 *            under "results", such as
					 *            .../results/linux.gtk.x86_64/timeoutScreens/
					 */
					private void dump(final int num) {
						// Time elapsed time to do each dump, so we'll
						// know if/when we get too close to the 2
						// minutes we allow
						long start = System.currentTimeMillis();

						// Dump all stacks:
						dumpStackTraces(num, System.err);
						dumpStackTraces(num, System.out); // System.err could be blocked, see
															// https://bugs.eclipse.org/506304
						logStackTraces(num);              // make this available in the log, see bug 533367

						if (!dumpSwtDisplay(num)) {
							String screenshotFile = getScreenshotFile(num);
							dumpAwtScreenshot(screenshotFile);
						}

						// Elapsed time in milliseconds
						long elapsedTimeMillis = System.currentTimeMillis() - start;

						// Print in seconds
						float elapsedTimeSec = elapsedTimeMillis / 1000F;
						System.err.println("INFO: Seconds to do dump " + num + ": " + elapsedTimeSec);
					}

					private void logStackTraces(int num) {
						ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
						dumpStackTraces(num, new PrintStream(outputStream));
						String symbolicName = "org.eclipse.test";
						IStatus warningStatus = new Status(IStatus.WARNING, symbolicName, outputStream.toString());
						Platform.getLog(Platform.getBundle(symbolicName)).log(warningStatus);
					}

					private void dumpStackTraces(int num, PrintStream out) {
						out.println("EclipseTestRunner almost reached timeout '" + timeoutArg + "'.");
						out.println("totalMemory:            " + Runtime.getRuntime().totalMemory());
						out.println("freeMemory (before GC): " + Runtime.getRuntime().freeMemory());
						out.flush(); // bug 420258: flush aggressively, we could be low on memory
						System.gc();
						out.println("freeMemory (after GC):  " + Runtime.getRuntime().freeMemory());
						String time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss Z", Locale.US).format(new Date());
						out.println("Thread dump " + num + " at " + time + ":");
						out.flush();
						Map<Thread, StackTraceElement[]> stackTraces = Thread.getAllStackTraces();
						for (Entry<Thread, StackTraceElement[]> entry : stackTraces.entrySet()) {
							String name = entry.getKey().getName();
							StackTraceElement[] stack = entry.getValue();
							ThreadDump exception = new ThreadDump("for thread \"" + name + "\"");
							exception.setStackTrace(stack);
							exception.printStackTrace(out);
						}
						out.flush();
					}

					String getScreenshotFile(final int num) {
						if (!outputDirectory.exists()) {
							outputDirectory.mkdirs();
						}
						String filename = outputDirectory.getAbsolutePath() + "/" + classname + "_screen" + num
								+ ".png";
						return filename;
					}

					@SuppressWarnings("deprecation")
					private boolean dumpSwtDisplay(final int num) {
						try {
							final Display display = Display.getDefault();

							if (!assumeUiThreadIsResponsive) {
								String message = "trying to make UI thread respond";
								IllegalStateException toThrow = new IllegalStateException(message);
								Thread t = display.getThread();
								// Initialize the cause. Its stack trace will be that of the current thread.
								toThrow.initCause(new RuntimeException(message));
								// Set the stack trace to that of the target thread.
								toThrow.setStackTrace(t.getStackTrace());
								// Stop the thread using the specified throwable.
								try {
									t.stop(toThrow);
								} catch (UnsupportedOperationException e) {
									// Thread#stop(Throwable) doesn't work any more in JDK 8. Try stop0:
									try {
										Method stop0 = Thread.class.getDeclaredMethod("stop0", Object.class);
										stop0.setAccessible(true);
										stop0.invoke(t, toThrow);
									} catch (Exception e1) {
										e1.printStackTrace();
									}
								}
							}

							assumeUiThreadIsResponsive = false;

							display.asyncExec(new Runnable() {
								@Override
								public void run() {
									assumeUiThreadIsResponsive = true;

									dumpDisplayState(System.err);
									dumpDisplayState(System.out); // System.err could be blocked, see
																	// https://bugs.eclipse.org/506304

									// Take a screenshot:
									GC gc = new GC(display);
									final Image image = new Image(display, display.getBounds());
									gc.copyArea(image, 0, 0);
									gc.dispose();

									ImageLoader loader = new ImageLoader();
									loader.data = new ImageData[] { image.getImageData() };
									String filename = getScreenshotFile(num);
									loader.save(filename, SWT.IMAGE_PNG);
									System.err.println("Screenshot saved to: " + filename);
									System.out.println("Screenshot saved to: " + filename);
									image.dispose();
								}

								private void dumpDisplayState(PrintStream out) {
									// Dump focus control, parents, and
									// shells:
									Control focusControl = display.getFocusControl();
									if (focusControl != null) {
										out.println("FocusControl: ");
										StringBuilder indent = new StringBuilder("  ");
										do {
											out.println(indent.toString() + focusControl);
											focusControl = focusControl.getParent();
											indent.append("  ");
										} while (focusControl != null);
									}
									Shell[] shells = display.getShells();
									if (shells.length > 0) {
										out.println("Shells: ");
										for (Shell shell : shells) {
											out.println((shell.isVisible() ? "  visible: " : "  invisible: ") + shell);
										}
									}
									out.flush(); // for bug 420258
								}
							});
							return true;
						} catch (SWTException e) {
							e.printStackTrace();
							return false;
						}
					}

				}, timeout);
			} else {
				System.err.println("EclipseTestRunner argument error: '-timeout " + timeoutArg
						+ "' was too short to accommodate time delay required (" + delay + ").");
			}
		} catch (NumberFormatException e) {
			e.printStackTrace();
		}
	}

	public EclipseTestRunner(JUnitTest test, String testPluginName, boolean haltOnError, boolean haltOnFailure) {
		fJunitTest = test;
		fTestPluginName = testPluginName;
		fHaltOnError = haltOnError;
		fHaltOnFailure = haltOnFailure;

		try {
			fSuite = getTest(test.getName());
		} catch (Exception e) {
			fRetCode = ERRORS;
			fException = e;
		}
	}

	protected Test getTest(String suiteClassName) throws TestFailedException {
		if (suiteClassName.isEmpty()) {
			clearStatus();
			return null;
		}
		Class<?> testClass = null;
		try {
			testClass = loadSuiteClass(suiteClassName);
		} catch (ClassNotFoundException e) {
			if (e.getCause() != null) {
				runFailed(e.getCause());
			}
			String clazz = e.getMessage();
			if (clazz == null)
				clazz = suiteClassName;
			runFailed("Class not found \"" + clazz + "\"");
			return null;
		} catch (Exception e) {
			runFailed(e);
			return null;
		}
		Method suiteMethod = null;
		try {
			suiteMethod = testClass.getMethod(SUITE_METHODNAME);
		} catch (Exception e) {
			// try to extract a test suite automatically
			clearStatus();
			return new junit.framework.JUnit4TestAdapter(testClass);
		}
		if (!Modifier.isStatic(suiteMethod.getModifiers())) {
			runFailed("suite() method must be static");
			return null;
		}
		Test test = null;
		try {
			test = (Test) suiteMethod.invoke(null); // static method
			if (test == null)
				return test;
		} catch (InvocationTargetException e) {
			runFailed("Failed to invoke suite():" + e.getTargetException().toString());
			return null;
		} catch (IllegalAccessException e) {
			runFailed("Failed to invoke suite():" + e.toString());
			return null;
		}
		clearStatus();
		return test;
	}

	protected void runFailed(String message) throws TestFailedException {
		System.err.println(message);
		throw new TestFailedException(message);
	}

	protected void runFailed(Throwable e) throws TestFailedException {
		e.printStackTrace();
		throw new TestFailedException(e);
	}

	protected void clearStatus() {
	}

	/**
	 * Loads the class either with the system class loader or a plugin class loader
	 * if a plugin name was specified
	 */
	protected Class<?> loadSuiteClass(String suiteClassName) throws ClassNotFoundException {
		if (fTestPluginName == null)
			return Class.forName(suiteClassName);
		Bundle bundle = Platform.getBundle(fTestPluginName);
		if (bundle == null) {
			throw new ClassNotFoundException(suiteClassName,
					new Exception("Could not find plugin \"" + fTestPluginName + "\""));
		}

		// is the plugin a fragment?
		Dictionary<String, String> headers = bundle.getHeaders();
		String hostHeader = headers.get(Constants.FRAGMENT_HOST);
		if (hostHeader != null) {
			// we are a fragment for sure
			// we need to find which is our host
			ManifestElement[] hostElement = null;
			try {
				hostElement = ManifestElement.parseHeader(Constants.FRAGMENT_HOST, hostHeader);
			} catch (BundleException e) {
				throw new RuntimeException("Could not find host for fragment:" + fTestPluginName, e);
			}
			Bundle host = Platform.getBundle(hostElement[0].getValue());
			// we really want to get the host not the fragment
			bundle = host;
		}

		return bundle.loadClass(suiteClassName);
	}

	public void run() {
		fTestResult = new TestResult();
		fTestResult.addListener(this);
		for (int i = 0; i < formatters.size(); i++) {
			fTestResult.addListener(formatters.elementAt(i));
		}

		long start = System.currentTimeMillis();
		fireStartTestSuite();

		if (fException != null) { // had an exception in the constructor
			for (int i = 0; i < formatters.size(); i++) {
				formatters.elementAt(i).addError(null, fException);
			}
			fJunitTest.setCounts(1, 0, 1);
			fJunitTest.setRunTime(0);
		} else {
			ByteArrayOutputStream errStrm = new ByteArrayOutputStream();
			fSystemError = new PrintStream(errStrm);

			ByteArrayOutputStream outStrm = new ByteArrayOutputStream();
			fSystemOut = new PrintStream(outStrm);

			try {
				// pm.snapshot(1); // before
				fSuite.run(fTestResult);
			} finally {
				// pm.snapshot(2); // after
				fSystemError.close();
				fSystemError = null;
				fSystemOut.close();
				fSystemOut = null;
				sendOutAndErr(new String(outStrm.toByteArray()), new String(errStrm.toByteArray()));
				fJunitTest.setCounts(fTestResult.runCount(), fTestResult.failureCount(), fTestResult.errorCount());
				fJunitTest.setRunTime(System.currentTimeMillis() - start);
			}
		}
		fireEndTestSuite();

		if (fRetCode != SUCCESS || fTestResult.errorCount() != 0) {
			fRetCode = ERRORS;
		} else if (fTestResult.failureCount() != 0) {
			fRetCode = FAILURES;
		}

		// pm.upload(getClass().getName());
	}

	/**
	 * Returns what System.exit() would return in the standalone version.
	 *
	 * @return 2 if errors occurred, 1 if tests failed else 0.
	 */
	public int getRetCode() {
		return fRetCode;
	}

	@Override
	public void startTest(Test t) {
	}

	@Override
	public void endTest(Test test) {
	}

	@Override
	public void addFailure(Test test, AssertionFailedError t) {
		if (fHaltOnFailure) {
			fTestResult.stop();
		}
	}

	@Override
	public void addError(Test test, Throwable t) {
		if (fHaltOnError) {
			fTestResult.stop();
		}
	}

	private void fireStartTestSuite() {
		for (int i = 0; i < formatters.size(); i++) {
			formatters.elementAt(i).startTestSuite(fJunitTest);
		}
	}

	private void fireEndTestSuite() {
		for (int i = 0; i < formatters.size(); i++) {
			formatters.elementAt(i).endTestSuite(fJunitTest);
		}
	}

	public void addFormatter(JUnitResultFormatter f) {
		formatters.addElement(f);
	}

	/**
	 * Line format is: formatter=<classname>(,<pathname>)?
	 */
	private static void createAndStoreFormatter(String line) throws BuildException {
		String formatterClassName = null;
		File formatterFile = null;

		int pos = line.indexOf(',');
		if (pos == -1) {
			formatterClassName = line;
		} else {
			formatterClassName = line.substring(0, pos);
			formatterFile = new File(line.substring(pos + 1)); // the method is
																// package
																// visible
		}
		fgFromCmdLine.addElement(createFormatter(formatterClassName, formatterFile));
	}

	/**
	 * Line format is: formatter=<pathname>
	 */
	private static void createAndStoreFormatter(String line, String... suiteClassesNames) throws BuildException {
		String formatterClassName = null;
		File formatterFile = null;

		int pos = line.indexOf(',');
		if (pos == -1) {
			formatterClassName = line;
		} else {
			formatterClassName = line.substring(0, pos);
		}
		File outputDirectory = new File(line.substring(pos + 1));
		outputDirectory.mkdir();
		for (String suiteClassName : suiteClassesNames) {

			String pathname = "TEST-" + suiteClassName + ".xml";
			if (outputDirectory.exists()) {
				pathname = outputDirectory.getAbsolutePath() + "/" + pathname;
			}
			formatterFile = new File(pathname);
			fgFromCmdLine.addElement(createFormatter(formatterClassName, formatterFile));
		}

	}

	private static void transferFormatters(EclipseTestRunner runner, int j) {
		runner.addFormatter(fgFromCmdLine.elementAt(j));
	}

	private static void transferFormatters(EclipseTestRunner runner) {
		for (int i = 0; i < fgFromCmdLine.size(); i++) {
			runner.addFormatter(fgFromCmdLine.elementAt(i));
		}
	}

	/*
	 * DUPLICATED from FormatterElement, since it is package visible only
	 */
	private static JUnitResultFormatter createFormatter(String classname, File outfile) throws BuildException {
		OutputStream out = System.out;

		if (classname == null) {
			throw new BuildException("you must specify type or classname");
		}
		Class<?> f = null;
		try {
			f = EclipseTestRunner.class.getClassLoader().loadClass(classname);
		} catch (ClassNotFoundException e) {
			throw new BuildException(e);
		}

		Object o = null;
		try {
			o = f.getDeclaredConstructor().newInstance();
		} catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException
				| NoSuchMethodException | SecurityException e) {
			throw new BuildException(e);
		}

		if (!(o instanceof JUnitResultFormatter)) {
			throw new BuildException(classname + " is not a JUnitResultFormatter");
		}

		JUnitResultFormatter r = (JUnitResultFormatter) o;

		if (outfile != null) {
			try {
				out = new FileOutputStream(outfile);
			} catch (java.io.IOException e) {
				throw new BuildException(e);
			}
		}
		r.setOutput(out);
		return r;
	}

	public static void dumpAwtScreenshot(String screenshotFile) {
		try {
			URL location = AwtScreenshot.class.getProtectionDomain().getCodeSource().getLocation();
			String cp = location.toURI().getPath();
			String javaHome = System.getProperty("java.home");
			String javaExe = javaHome + File.separatorChar + "bin" + File.separatorChar + "java";
			if (File.separatorChar == '\\') {
				javaExe += ".exe"; // assume it's Windows
			}
			String[] args = new String[] { javaExe, "-cp", cp, AwtScreenshot.class.getName(), screenshotFile };
			System.err.println("Start process: " + Arrays.asList(args));
			ProcessBuilder processBuilder = new ProcessBuilder(args);
			if ("Mac OS X".equals(System.getProperty("os.name"))) {
				processBuilder.environment().put("AWT_TOOLKIT", "CToolkit");
			}
			Process process = processBuilder.start();
			new StreamForwarder(process.getErrorStream(), System.err).start();
			new StreamForwarder(process.getInputStream(), System.err).start();
			int screenshotTimeout = 15;
			long end = System.currentTimeMillis() + screenshotTimeout * 1000;
			boolean done = false;
			do {
				try {
					process.exitValue();
					done = true;
				} catch (IllegalThreadStateException e) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e1) {
					}
				}
			} while (!done && System.currentTimeMillis() < end);

			if (done) {
				System.err.println("AwtScreenshot VM finished with exit code " + process.exitValue() + ".");
			} else {
				process.destroy();
				System.err.println("Killed AwtScreenshot VM after " + screenshotTimeout + " seconds.");
			}
		} catch (URISyntaxException | IOException e) {
			e.printStackTrace();
		}
	}

	private void sendOutAndErr(String out, String err) {
		for (JUnitResultFormatter formatter : formatters) {
			formatter.setSystemOutput(out);
			formatter.setSystemError(err);
		}
	}

	protected void handleOutput(String line) {
		if (fSystemOut != null) {
			fSystemOut.println(line);
		}
	}

	protected void handleErrorOutput(String line) {
		if (fSystemError != null) {
			fSystemError.println(line);
		}
	}
}