/*******************************************************************************
 * Copyright (c) 2000, 2013 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.ant.tests.ui.debug;

import org.eclipse.ant.internal.launching.debug.model.AntDebugTarget;
import org.eclipse.ant.internal.launching.debug.model.AntLineBreakpoint;
import org.eclipse.ant.internal.launching.debug.model.AntStackFrame;
import org.eclipse.ant.internal.launching.debug.model.AntThread;
import org.eclipse.ant.tests.ui.AbstractAntUIBuildTest;
import org.eclipse.ant.tests.ui.testplugin.DebugElementKindEventWaiter;
import org.eclipse.ant.tests.ui.testplugin.DebugEventWaiter;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.Path;
import org.eclipse.debug.core.DebugEvent;
import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.IBreakpointManager;
import org.eclipse.debug.core.ILaunch;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.debug.core.model.IBreakpoint;
import org.eclipse.debug.core.model.ILineBreakpoint;
import org.eclipse.debug.core.model.IProcess;
import org.eclipse.debug.core.model.IThread;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
import org.eclipse.debug.internal.ui.preferences.IDebugPreferenceConstants;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.debug.ui.IDebugUIConstants;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.text.BadPositionCategoryException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.util.SafeRunnable;
import org.eclipse.ui.IPerspectiveDescriptor;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.console.IHyperlink;
import org.eclipse.ui.internal.console.ConsoleHyperlinkPosition;

/**
 * Tests for launch configurations
 */
public abstract class AbstractAntDebugTest extends AbstractAntUIBuildTest {

	public static final int DEFAULT_TIMEOUT = 20000;

	/**
	 * The last relevant event set - for example, that caused a thread to suspend
	 */
	protected DebugEvent[] fEventSet;

	public AbstractAntDebugTest(String name) {
		super(name);
		// set error dialog to non-blocking to avoid hanging the UI during test
		ErrorDialog.AUTOMATED_MODE = true;
		SafeRunnable.setIgnoreErrors(true);
	}

	/**
	 * Sets the last relevant event set
	 * 
	 * @param set
	 *            event set
	 */
	protected void setEventSet(DebugEvent[] set) {
		fEventSet = set;
	}

	/**
	 * Returns the last relevant event set
	 * 
	 * @return event set
	 */
	protected DebugEvent[] getEventSet() {
		return fEventSet;
	}

	/**
	 * Returns the breakpoint manager
	 * 
	 * @return breakpoint manager
	 */
	protected IBreakpointManager getBreakpointManager() {
		return DebugPlugin.getDefault().getBreakpointManager();
	}

	/**
	 * Returns the source folder with the given name in the given project.
	 * 
	 * @param project
	 * @param name
	 *            source folder name
	 * @return package fragment root
	 */
	protected IPackageFragmentRoot getPackageFragmentRoot(IJavaProject project, String name) {
		IProject p = project.getProject();
		return project.getPackageFragmentRoot(p.getFolder(name));
	}

	@Override
	protected IHyperlink getHyperlink(int offset, IDocument doc) {
		if (offset >= 0 && doc != null) {
			Position[] positions = null;
			try {
				positions = doc.getPositions(ConsoleHyperlinkPosition.HYPER_LINK_CATEGORY);
			}
			catch (BadPositionCategoryException ex) {
				// no links have been added
				return null;
			}
			for (int i = 0; i < positions.length; i++) {
				Position position = positions[i];
				if (offset >= position.getOffset() && offset <= (position.getOffset() + position.getLength())) {
					return ((ConsoleHyperlinkPosition) position).getHyperLink();
				}
			}
		}
		return null;
	}

	/**
	 * Launches the given configuration and waits for an event. Returns the source of the event. If the event is not received, the launch is
	 * terminated and an exception is thrown.
	 * 
	 * @param configuration
	 *            the configuration to launch
	 * @param waiter
	 *            the event waiter to use
	 * @return Object the source of the event
	 * @exception Exception
	 *                if the event is never received.
	 */
	@Override
	protected Object launchAndWait(ILaunchConfiguration configuration, DebugEventWaiter waiter) throws CoreException {
		return launchAndWait(configuration, waiter, true);
	}

	/**
	 * Launches the given configuration and waits for an event. Returns the source of the event. If the event is not received, the launch is
	 * terminated and an exception is thrown.
	 * 
	 * @param configuration
	 *            the configuration to launch
	 * @param waiter
	 *            the event waiter to use
	 * @param register
	 *            whether to register the launch
	 * @return Object the source of the event
	 * @exception Exception
	 *                if the event is never received.
	 */
	protected Object launchAndWait(ILaunchConfiguration configuration, DebugEventWaiter waiter, boolean register) throws CoreException {
		ILaunch launch = configuration.launch(ILaunchManager.DEBUG_MODE, null, false, register);
		Object suspendee = waiter.waitForEvent();
		if (suspendee == null) {
			try {
				launch.terminate();
			}
			catch (CoreException e) {
				e.printStackTrace();
				fail("Program did not suspend, and unable to terminate launch."); //$NON-NLS-1$
			}
		}
		setEventSet(waiter.getEventSet());
		if (suspendee == null) {
			throw new TestAgainException("Retest - Program did not suspend, launch terminated"); //$NON-NLS-1$
		}
		return suspendee;
	}

	/**
	 * Launches the build file with the given name, and waits for a suspend event in that program. Returns the thread in which the suspend event
	 * occurred.
	 * 
	 * @param buildFileName
	 *            the build file to launch
	 * @return thread in which the first suspend event occurred
	 */
	protected AntThread launchAndSuspend(String buildFileName) throws Exception {
		ILaunchConfiguration config = getLaunchConfiguration(buildFileName);
		assertNotNull("Could not locate launch configuration for " + buildFileName, config); //$NON-NLS-1$
		return launchAndSuspend(config);
	}

	/**
	 * Launches the given configuration in debug mode, and waits for a suspend event in that program. Returns the thread in which the suspend event
	 * occurred.
	 * 
	 * @param config
	 *            the configuration to launch
	 * @return thread in which the first suspend event occurred
	 */
	protected AntThread launchAndSuspend(ILaunchConfiguration config) throws Exception {
		DebugEventWaiter waiter = new DebugElementKindEventWaiter(DebugEvent.SUSPEND, AntThread.class);
		waiter.setTimeout(DEFAULT_TIMEOUT);
		Object suspendee = launchAndWait(config, waiter);
		return (AntThread) suspendee;
	}

	/**
	 * Launches the build file with the given name, and waits for a breakpoint-caused suspend event in that program. Returns the thread in which the
	 * suspend event occurred.
	 * 
	 * @param buildFileName
	 *            the build file to launch
	 * @return thread in which the first suspend event occurred
	 */
	protected AntThread launchToBreakpoint(String buildFileName) throws Exception {
		return launchToBreakpoint(buildFileName, true, false);
	}

	/**
	 * Launches the build file with the given name in a separate VM, and waits for a breakpoint-caused suspend event in that program. Returns the
	 * thread in which the suspend event occurred.
	 * 
	 * @param buildFileName
	 *            the build file to launch
	 * @return thread in which the first suspend event occurred
	 */
	protected AntThread launchToBreakpointSepVM(String buildFileName) throws Exception {
		return launchToBreakpoint(buildFileName, true, true);
	}

	/**
	 * Launches the build file with the given name, and waits for a breakpoint-caused suspend event in that program. Returns the thread in which the
	 * suspend event occurred.
	 * 
	 * @param buildFileName
	 *            the build file to launch
	 * @param register
	 *            whether to register the launch
	 * @return thread in which the first suspend event occurred
	 */
	protected AntThread launchToBreakpoint(String buildFileName, boolean register, boolean sepVM) throws Exception {
		if (sepVM) {
			buildFileName += "SepVM"; //$NON-NLS-1$
		}
		ILaunchConfiguration config = getLaunchConfiguration(buildFileName);
		assertNotNull("Could not locate launch configuration for " + buildFileName, config); //$NON-NLS-1$
		return launchToBreakpoint(config, register);
	}

	/**
	 * Launches the given configuration in debug mode, and waits for a breakpoint-caused suspend event in that program. Returns the thread in which
	 * the suspend event occurred.
	 * 
	 * @param config
	 *            the configuration to launch
	 * @return thread in which the first suspend event occurred
	 */
	protected AntThread launchToBreakpoint(ILaunchConfiguration config) throws CoreException {
		return launchToBreakpoint(config, true);
	}

	/**
	 * Launches the given configuration in debug mode, and waits for a breakpoint-caused suspend event in that program. Returns the thread in which
	 * the suspend event occurred.
	 * 
	 * @param config
	 *            the configuration to launch
	 * @param whether
	 *            to register the launch
	 * @return thread in which the first suspend event occurred
	 */
	protected AntThread launchToBreakpoint(ILaunchConfiguration config, boolean register) throws CoreException {
		DebugEventWaiter waiter = new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, AntThread.class, DebugEvent.BREAKPOINT);
		waiter.setTimeout(DEFAULT_TIMEOUT);

		Object suspendee = launchAndWait(config, waiter, register);
		assertTrue("suspendee was not an AntThread", suspendee instanceof AntThread); //$NON-NLS-1$
		return (AntThread) suspendee;
	}

	/**
	 * Launches the build file with the given name, and waits for a terminate event in that program. Returns the debug target in which the suspend
	 * event occurred.
	 * 
	 * @param buildFileName
	 *            the build file to execute
	 * @return debug target in which the terminate event occurred
	 */
	protected AntDebugTarget launchAndTerminate(String buildFileName) throws Exception {
		return launchAndTerminate(buildFileName, false);
	}

	protected AntDebugTarget launchAndTerminate(String buildFileName, boolean sepVM) throws Exception {
		if (sepVM) {
			buildFileName += "SepVM"; //$NON-NLS-1$
		}
		ILaunchConfiguration config = getLaunchConfiguration(buildFileName);
		assertNotNull("Could not locate launch configuration for " + buildFileName, config); //$NON-NLS-1$
		return debugLaunchAndTerminate(config, DEFAULT_TIMEOUT);
	}

	/**
	 * Launches the given configuration in debug mode, and waits for a terminate event in that program. Returns the debug target in which the
	 * terminate event occurred.
	 * 
	 * @param config
	 *            the configuration to launch
	 * @param timeout
	 *            the number of milliseconds to wait for a terminate event
	 * @return thread in which the first suspend event occurred
	 */
	protected AntDebugTarget debugLaunchAndTerminate(ILaunchConfiguration config, int timeout) throws Exception {
		DebugEventWaiter waiter = new DebugElementKindEventWaiter(DebugEvent.TERMINATE, AntDebugTarget.class);
		waiter.setTimeout(timeout);

		Object terminatee = launchAndWait(config, waiter);
		assertNotNull("Program did not terminate.", terminatee); //$NON-NLS-1$
		assertTrue("terminatee is not an AntDebugTarget", terminatee instanceof AntDebugTarget); //$NON-NLS-1$
		AntDebugTarget debugTarget = (AntDebugTarget) terminatee;
		assertTrue("debug target is not terminated", debugTarget.isTerminated() || debugTarget.isDisconnected()); //$NON-NLS-1$
		return debugTarget;
	}

	/**
	 * Launches the build file with the given name, and waits for a line breakpoint suspend event in that program. Returns the thread in which the
	 * suspend event occurred.
	 * 
	 * @param buildFileName
	 *            the build file to execute
	 * @param bp
	 *            the breakpoint that should cause a suspend event
	 * @return thread in which the first suspend event occurred
	 * @throws CoreException
	 */
	protected AntThread launchToLineBreakpoint(String buildFileName, ILineBreakpoint bp) throws CoreException {
		ILaunchConfiguration config = getLaunchConfiguration(buildFileName);
		assertNotNull("Could not locate launch configuration for " + buildFileName, config); //$NON-NLS-1$
		return launchToLineBreakpoint(config, bp);
	}

	/**
	 * Launches the given configuration in debug mode, and waits for a line breakpoint suspend event in that program. Returns the thread in which the
	 * suspend event occurred.
	 * 
	 * @param config
	 *            the configuration to launch
	 * @param bp
	 *            the breakpoint that should cause a suspend event
	 * @return thread in which the first suspend event occurred
	 * @throws CoreException
	 */
	protected AntThread launchToLineBreakpoint(ILaunchConfiguration config, ILineBreakpoint bp) throws CoreException {
		DebugEventWaiter waiter = new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, AntThread.class, DebugEvent.BREAKPOINT);
		waiter.setTimeout(DEFAULT_TIMEOUT);

		Object suspendee = launchAndWait(config, waiter);
		assertTrue("suspendee was not an AntThread", suspendee instanceof AntThread); //$NON-NLS-1$
		AntThread thread = (AntThread) suspendee;
		IBreakpoint hit = getBreakpoint(thread);
		assertNotNull("suspended, but not by breakpoint", hit); //$NON-NLS-1$
		assertTrue("hit un-registered breakpoint", bp.equals(hit)); //$NON-NLS-1$
		assertTrue("suspended, but not by line breakpoint", hit instanceof ILineBreakpoint); //$NON-NLS-1$
		ILineBreakpoint breakpoint = (ILineBreakpoint) hit;
		int lineNumber = breakpoint.getLineNumber();
		int stackLine = thread.getTopStackFrame().getLineNumber();
		assertTrue("line numbers of breakpoint and stack frame do not match", lineNumber == stackLine); //$NON-NLS-1$

		return thread;
	}

	/**
	 * Resumes the given thread, and waits for another breakpoint-caused suspend event. Returns the thread in which the suspend event occurs.
	 * 
	 * @param thread
	 *            thread to resume
	 * @return thread in which the first suspend event occurs
	 */
	protected AntThread resume(AntThread thread) throws Exception {
		return resume(thread, DEFAULT_TIMEOUT);
	}

	/**
	 * Resumes the given thread, and waits for another breakpoint-caused suspend event. Returns the thread in which the suspend event occurs.
	 * 
	 * @param thread
	 *            thread to resume
	 * @param timeout
	 *            timeout in ms
	 * @return thread in which the first suspend event occurs
	 */
	protected AntThread resume(AntThread thread, int timeout) throws Exception {
		DebugEventWaiter waiter = new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, AntThread.class, DebugEvent.BREAKPOINT);
		waiter.setTimeout(timeout);

		thread.resume();

		Object suspendee = waiter.waitForEvent();
		setEventSet(waiter.getEventSet());
		if (suspendee == null) {
			throw new TestAgainException("Retest - Program did not suspend"); //$NON-NLS-1$
		}
		return (AntThread) suspendee;
	}

	/**
	 * Resumes the given thread, and waits for a suspend event caused by the specified line breakpoint. Returns the thread in which the suspend event
	 * occurs.
	 * 
	 * @param thread
	 *            thread to resume
	 * @return thread in which the first suspend event occurs
	 * @throws CoreException
	 */
	protected AntThread resumeToLineBreakpoint(AntThread resumeThread, ILineBreakpoint bp) throws CoreException {
		DebugEventWaiter waiter = new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, AntThread.class, DebugEvent.BREAKPOINT);
		waiter.setTimeout(DEFAULT_TIMEOUT);

		resumeThread.resume();

		Object suspendee = waiter.waitForEvent();
		setEventSet(waiter.getEventSet());
		if (suspendee == null) {
			throw new TestAgainException("Retest - Program did not suspend"); //$NON-NLS-1$
		}
		assertTrue("suspendee was not an AntThread", suspendee instanceof AntThread); //$NON-NLS-1$
		AntThread thread = (AntThread) suspendee;
		IBreakpoint hit = getBreakpoint(thread);
		assertNotNull("suspended, but not by breakpoint", hit); //$NON-NLS-1$
		assertTrue("hit un-registered breakpoint", bp.equals(hit)); //$NON-NLS-1$
		assertTrue("suspended, but not by line breakpoint", hit instanceof ILineBreakpoint); //$NON-NLS-1$
		ILineBreakpoint breakpoint = (ILineBreakpoint) hit;
		int lineNumber = breakpoint.getLineNumber();
		int stackLine = thread.getTopStackFrame().getLineNumber();
		assertTrue("line numbers of breakpoint and stack frame do not match", lineNumber == stackLine); //$NON-NLS-1$

		return (AntThread) suspendee;
	}

	/**
	 * Resumes the given thread, and waits for the debug target to terminate (i.e. finish/exit the program).
	 * 
	 * @param thread
	 *            thread to resume
	 */
	protected void exit(AntThread thread) throws Exception {
		DebugEventWaiter waiter = new DebugElementKindEventWaiter(DebugEvent.TERMINATE, IProcess.class);
		waiter.setTimeout(DEFAULT_TIMEOUT);

		thread.resume();

		Object suspendee = waiter.waitForEvent();
		setEventSet(waiter.getEventSet());
		assertNotNull("Program did not terminate.", suspendee); //$NON-NLS-1$
	}

	/**
	 * Resumes the given thread, and waits for the associated debug target to terminate.
	 * 
	 * @param thread
	 *            thread to resume
	 * @return the terminated debug target
	 */
	protected AntDebugTarget resumeAndExit(AntThread thread) throws Exception {
		DebugEventWaiter waiter = new DebugElementEventWaiter(DebugEvent.TERMINATE, thread.getDebugTarget());
		waiter.setTimeout(DEFAULT_TIMEOUT);

		thread.resume();

		Object suspendee = waiter.waitForEvent();
		setEventSet(waiter.getEventSet());
		if (suspendee == null) {
			throw new TestAgainException("Retest - The program did not terminate"); //$NON-NLS-1$
		}
		AntDebugTarget target = (AntDebugTarget) suspendee;
		assertTrue("program should have exited", target.isTerminated() || target.isDisconnected()); //$NON-NLS-1$
		return target;
	}

	protected IResource getBreakpointResource(String typeName) throws Exception {
		IJavaElement element = getJavaProject().findElement(new Path(typeName + ".java")); //$NON-NLS-1$
		IResource resource = element.getCorrespondingResource();
		if (resource == null) {
			resource = getJavaProject().getProject();
		}
		return resource;
	}

	/**
	 * Creates and returns a line breakpoint at the given line number in the given build file
	 * 
	 * @param lineNumber
	 *            line number
	 * @param file
	 *            the build file
	 * @throws CoreException
	 */
	protected AntLineBreakpoint createLineBreakpoint(int lineNumber, IFile file) throws CoreException {
		return new AntLineBreakpoint(file, lineNumber);
	}

	/**
	 * Creates and returns a line breakpoint at the given line number in the given build file.
	 * 
	 * @param lineNumber
	 *            line number
	 * @param file
	 *            the build file
	 */
	protected AntLineBreakpoint createLineBreakpoint(int lineNumber, String buildFileName) throws CoreException {
		return new AntLineBreakpoint(getIFile(buildFileName), lineNumber);
	}

	/**
	 * Terminates the given thread and removes its launch
	 */
	protected void terminateAndRemove(AntThread thread) throws CoreException {
		if (thread != null) {
			terminateAndRemove((AntDebugTarget) thread.getDebugTarget());
		}
	}

	/**
	 * Terminates the given debug target and removes its launch.
	 * 
	 * NOTE: all breakpoints are removed, all threads are resumed, and then the target is terminated. This avoids defunct processes on linux.
	 */
	protected void terminateAndRemove(AntDebugTarget debugTarget) throws CoreException {
		if (debugTarget != null && !(debugTarget.isTerminated() || debugTarget.isDisconnected())) {
			DebugEventWaiter waiter = new DebugElementEventWaiter(DebugEvent.TERMINATE, debugTarget);
			removeAllBreakpoints();
			IThread[] threads = debugTarget.getThreads();
			for (int i = 0; i < threads.length; i++) {
				IThread thread = threads[i];
				try {
					if (thread.isSuspended()) {
						thread.resume();
					}
				}
				catch (CoreException e) {
					// do nothing
				}
			}
			debugTarget.terminate();
			Object event = waiter.waitForEvent();
			if (event == null) {
				throw new TestAgainException("Retest - Program did not terminate"); //$NON-NLS-1$
			}
			getLaunchManager().removeLaunch(debugTarget.getLaunch());
		}

		// ensure event queue is flushed
		DebugEventWaiter waiter = new DebugElementEventWaiter(DebugEvent.MODEL_SPECIFIC, this);
		DebugPlugin.getDefault().fireDebugEventSet(new DebugEvent[] { new DebugEvent(this, DebugEvent.MODEL_SPECIFIC) });
		Object event = waiter.waitForEvent();
		if (event == null) {
			throw new TestAgainException("Retest - The model specific event was never recieved"); //$NON-NLS-1$
		}
	}

	/**
	 * Deletes all existing breakpoints
	 */
	protected void removeAllBreakpoints() throws CoreException {
		IBreakpoint[] bps = getBreakpointManager().getBreakpoints();
		getBreakpointManager().removeBreakpoints(bps, true);
	}

	/**
	 * Returns the first breakpoint the given thread is suspended at, or <code>null</code> if none.
	 * 
	 * @return the first breakpoint the given thread is suspended at, or <code>null</code> if none
	 */
	protected IBreakpoint getBreakpoint(IThread thread) {
		IBreakpoint[] bps = thread.getBreakpoints();
		if (bps.length > 0) {
			return bps[0];
		}
		return null;
	}

	/**
	 * Performs a step over in the given stack frame and returns when complete.
	 * 
	 * @param frame
	 *            stack frame to step in
	 * @throws DebugException
	 */
	protected AntThread stepOver(AntStackFrame frame) throws DebugException {
		org.eclipse.ant.tests.ui.testplugin.DebugEventWaiter waiter = new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, AntThread.class, DebugEvent.STEP_END);
		waiter.setTimeout(DEFAULT_TIMEOUT);

		frame.stepOver();

		Object suspendee = waiter.waitForEvent();
		setEventSet(waiter.getEventSet());
		if (suspendee == null) {
			throw new TestAgainException("Retest - Program did not suspend"); //$NON-NLS-1$
		}
		return (AntThread) suspendee;
	}

	/**
	 * Performs a step over in the given stack frame and expects to hit a breakpoint as part of the step over
	 * 
	 * @param frame
	 *            stack frame to step in
	 * @throws DebugException
	 */
	protected AntThread stepOverToHitBreakpoint(AntStackFrame frame) throws DebugException {
		org.eclipse.ant.tests.ui.testplugin.DebugEventWaiter waiter = new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, AntThread.class, DebugEvent.BREAKPOINT);
		waiter.setTimeout(DEFAULT_TIMEOUT);

		frame.stepOver();

		Object suspendee = waiter.waitForEvent();
		setEventSet(waiter.getEventSet());
		if (suspendee == null) {
			throw new TestAgainException("Retest - Program did not suspend"); //$NON-NLS-1$
		}
		return (AntThread) suspendee;
	}

	/**
	 * Performs a step into in the given stack frame and returns when complete.
	 * 
	 * @param frame
	 *            stack frame to step in
	 */
	protected AntThread stepInto(AntStackFrame frame) throws DebugException {
		DebugEventWaiter waiter = new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, AntThread.class, DebugEvent.STEP_END);
		waiter.setTimeout(DEFAULT_TIMEOUT);

		frame.stepInto();

		Object suspendee = waiter.waitForEvent();
		setEventSet(waiter.getEventSet());
		if (suspendee == null) {
			throw new TestAgainException("Retest - Program did not suspend"); //$NON-NLS-1$
		}
		return (AntThread) suspendee;
	}

	/**
	 * Performs a step return in the given stack frame and returns when complete.
	 * 
	 * @param frame
	 *            stack frame to step return from
	 */
	protected AntThread stepReturn(AntStackFrame frame) throws DebugException {
		DebugEventWaiter waiter = new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, AntThread.class, DebugEvent.STEP_END);
		waiter.setTimeout(DEFAULT_TIMEOUT);

		frame.stepReturn();

		Object suspendee = waiter.waitForEvent();
		setEventSet(waiter.getEventSet());
		if (suspendee == null) {
			throw new TestAgainException("Retest - Program did not suspend"); //$NON-NLS-1$
		}
		return (AntThread) suspendee;
	}

	/**
	 * Performs a step into with filters in the given stack frame and returns when complete.
	 * 
	 * @param frame
	 *            stack frame to step in
	 */
	protected AntThread stepIntoWithFilters(AntStackFrame frame) throws DebugException {
		DebugEventWaiter waiter = new DebugElementKindEventWaiter(DebugEvent.SUSPEND, AntThread.class);
		waiter.setTimeout(DEFAULT_TIMEOUT);

		// turn filters on
		try {
			DebugUITools.setUseStepFilters(true);
			frame.stepInto();
		}
		finally {
			// turn filters off
			DebugUITools.setUseStepFilters(false);
		}

		Object suspendee = waiter.waitForEvent();
		setEventSet(waiter.getEventSet());
		if (suspendee == null) {
			throw new TestAgainException("Retest - Program did not suspend"); //$NON-NLS-1$
		}
		return (AntThread) suspendee;
	}

	/**
	 * Performs a step return with filters in the given stack frame and returns when complete.
	 * 
	 * @param frame
	 *            stack frame to step in
	 */
	protected AntThread stepReturnWithFilters(AntStackFrame frame) throws DebugException {
		DebugEventWaiter waiter = new DebugElementKindEventWaiter(DebugEvent.SUSPEND, AntThread.class);
		waiter.setTimeout(DEFAULT_TIMEOUT);

		// turn filters on
		try {
			DebugUITools.setUseStepFilters(true);
			frame.stepReturn();
		}
		finally {
			// turn filters off
			DebugUITools.setUseStepFilters(false);
		}

		Object suspendee = waiter.waitForEvent();
		setEventSet(waiter.getEventSet());
		if (suspendee == null) {
			throw new TestAgainException("Retest - Program did not suspend"); //$NON-NLS-1$
		}
		return (AntThread) suspendee;
	}

	/**
	 * Performs a step over with filters in the given stack frame and returns when complete.
	 * 
	 * @param frame
	 *            stack frame to step in
	 */
	protected AntThread stepOverWithFilters(AntStackFrame frame) throws DebugException {
		DebugEventWaiter waiter = new DebugElementKindEventWaiter(DebugEvent.SUSPEND, AntThread.class);
		waiter.setTimeout(DEFAULT_TIMEOUT);

		// turn filters on
		try {
			DebugUITools.setUseStepFilters(true);
			frame.stepOver();
		}
		finally {
			// turn filters off
			DebugUITools.setUseStepFilters(false);
		}

		Object suspendee = waiter.waitForEvent();
		setEventSet(waiter.getEventSet());
		if (suspendee == null) {
			throw new TestAgainException("Retest - Program did not suspend"); //$NON-NLS-1$
		}
		return (AntThread) suspendee;
	}

	/**
	 * Returns the compilation unit with the given name.
	 * 
	 * @param project
	 *            the project containing the CU
	 * @param root
	 *            the name of the source folder in the project
	 * @param pkg
	 *            the name of the package (empty string for default package)
	 * @param name
	 *            the name of the CU (ex. Something.java)
	 * @return compilation unit
	 */
	protected ICompilationUnit getCompilationUnit(IJavaProject project, String root, String pkg, String name) {
		IProject p = project.getProject();
		IResource r = p.getFolder(root);
		return project.getPackageFragmentRoot(r).getPackageFragment(pkg).getCompilationUnit(name);
	}

	/**
	 * Sets the current set of Debug / Other preferences to use during each test
	 * 
	 * @since 3.5
	 */
	protected void setPreferences() {
		IPreferenceStore debugUIPreferences = DebugUIPlugin.getDefault().getPreferenceStore();
		String property = System.getProperty("debug.workbenchActivation"); //$NON-NLS-1$
		boolean activate = property != null && property.equals("on"); //$NON-NLS-1$
		debugUIPreferences.setValue(IDebugPreferenceConstants.CONSOLE_OPEN_ON_ERR, activate);
		debugUIPreferences.setValue(IDebugPreferenceConstants.CONSOLE_OPEN_ON_OUT, activate);
		debugUIPreferences.setValue(IInternalDebugUIConstants.PREF_ACTIVATE_DEBUG_VIEW, activate);
		debugUIPreferences.setValue(IDebugUIConstants.PREF_ACTIVATE_WORKBENCH, activate);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see junit.framework.TestCase#tearDown()
	 */
	@Override
	protected void tearDown() throws Exception {
		if (fEventSet != null) {
			fEventSet = null;
		}
		// reset the options
		IPreferenceStore debugUIPreferences = DebugUIPlugin.getDefault().getPreferenceStore();
		debugUIPreferences.setToDefault(IDebugPreferenceConstants.CONSOLE_OPEN_ON_ERR);
		debugUIPreferences.setToDefault(IDebugPreferenceConstants.CONSOLE_OPEN_ON_OUT);
		debugUIPreferences.setToDefault(IInternalDebugUIConstants.PREF_ACTIVATE_DEBUG_VIEW);
		debugUIPreferences.setToDefault(IDebugUIConstants.PREF_ACTIVATE_WORKBENCH);
		super.tearDown();
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see junit.framework.TestCase#setUp()
	 */
	@Override
	protected void setUp() throws Exception {
		super.setUp();
		setPreferences();
		DebugUIPlugin.getStandardDisplay().syncExec(() -> {
			IWorkbench workbench = PlatformUI.getWorkbench();
			IPerspectiveDescriptor descriptor = workbench.getPerspectiveRegistry().findPerspectiveWithId(IDebugUIConstants.ID_DEBUG_PERSPECTIVE);
			workbench.getActiveWorkbenchWindow().getActivePage().setPerspective(descriptor);
		});
	}
}