org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/launching/LaunchModeTests.java - jdt/eclipse.jdt.debug - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2012 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.jdt.debug.tests.launching;

 import java.util.Arrays;
 import java.util.HashSet;

 import junit.framework.AssertionFailedError;

 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.debug.core.ILaunch;
 import org.eclipse.debug.core.ILaunchConfiguration;
 import org.eclipse.debug.core.ILaunchConfigurationType;
 import org.eclipse.debug.core.ILaunchDelegate;
 import org.eclipse.debug.core.ILaunchManager;
 import org.eclipse.debug.core.ILaunchMode;
 import org.eclipse.debug.internal.core.LaunchManager;
 import org.eclipse.debug.internal.ui.DebugUIPlugin;
 import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationPresentationManager;
 import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationsDialog;
 import org.eclipse.debug.ui.CommonTab;
 import org.eclipse.debug.ui.DebugUITools;
 import org.eclipse.debug.ui.EnvironmentTab;
 import org.eclipse.debug.ui.IDebugUIConstants;
 import org.eclipse.debug.ui.ILaunchConfigurationDialog;
 import org.eclipse.debug.ui.ILaunchConfigurationTab;
 import org.eclipse.debug.ui.ILaunchConfigurationTabGroup;
 import org.eclipse.debug.ui.sourcelookup.SourceLookupTab;
 import org.eclipse.jdt.debug.testplugin.launching.TestModeLaunchDelegate;
 import org.eclipse.jdt.debug.tests.AbstractDebugTest;
 import org.eclipse.jdt.debug.ui.launchConfigurations.JavaArgumentsTab;
 import org.eclipse.jdt.debug.ui.launchConfigurations.JavaClasspathTab;
 import org.eclipse.jdt.debug.ui.launchConfigurations.JavaJRETab;
 import org.eclipse.jdt.debug.ui.launchConfigurations.JavaMainTab;
 import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
 import org.eclipse.jdt.ui.JavaUI;

 /**
  * LaunchModeTests
  */
 public class LaunchModeTests extends AbstractDebugTest {

 	private ILaunchConfiguration fConfiguration;
 	private String fMode;

 	/**
 	 * @param name
 	 */
 	public LaunchModeTests(String name) {
 		super(name);
 	}

 	/**
 	 * Called by launch "TestModeLaunchDelegate" delegate when launch method invoked.
 	 *
 	 * @param configuration
 	 * @param mode
 	 */
 	public synchronized void launch(ILaunchConfiguration configuration, String mode) {
 		fConfiguration = configuration;
 		fMode = mode;
 		notifyAll();
 	}

 	/**
 	 * Tests that launch delegate for "TEST_MODE" and Java applications is invoked when
 	 * "TEST_MODE" is used.
 	 *
 	 * @throws CoreException
 	 * @see TestModeLaunchDelegate
 	 */
 	public void testContributedLaunchMode() throws CoreException {
 		ILaunch launch = null;
 		try {
 			fConfiguration = null;
 			fMode = null;
 			TestModeLaunchDelegate.setTestCase(this);
 			ILaunchConfiguration configuration = getLaunchConfiguration("Breakpoints"); //$NON-NLS-1$
 			assertNotNull(configuration);
 			launch = configuration.launch("TEST_MODE", null); //$NON-NLS-1$
 			assertEquals("Launch delegate not invoked", configuration, getLaunchConfigurationSetByDelegate()); //$NON-NLS-1$
 			assertEquals("Launch delegate not invoked in correct mode", "TEST_MODE", fMode); //$NON-NLS-1$ //$NON-NLS-2$
 		} finally {
 			TestModeLaunchDelegate.setTestCase(null);
 			fConfiguration = null;
 			fMode = null;
 			if (launch != null) {
 				getLaunchManager().removeLaunch(launch);
 			}
 		}
 	}

 	/**
 	 * Returns the launch configuration set by the TestModeLaunchDelegate, or <code>null</code>
 	 * if no launch configuration was set (the correct delegate was not called).
 	 * A wait must occur due to the use of Jobs for launching.
 	 */
 	private synchronized Object getLaunchConfigurationSetByDelegate() {
 		if (fConfiguration == null) {
 			try {
 				wait(10000);
 			} catch (InterruptedException ie) {
 				System.err.println("Interrupted waiting for launch configuration"); //$NON-NLS-1$
 			}
 		}

 		return fConfiguration;
 	}

 	/**
 	 * Ensure our contributed launch mode exists.
 	 */
 	public void testLaunchModes() {
 		ILaunchMode[] modes = getLaunchManager().getLaunchModes();
 		String[] ids = new String[modes.length];
 		for (int i = 0; i < modes.length; i++) {
 			ILaunchMode mode = modes[i];
 			ids[i] = mode.getIdentifier();
 		}
 		assertContains("Missing TEST_MODE", ids, "TEST_MODE"); //$NON-NLS-1$ //$NON-NLS-2$
 		assertContains("Missing debug mode", ids, ILaunchManager.DEBUG_MODE); //$NON-NLS-1$
 		assertContains("Missing run mode", ids, ILaunchManager.RUN_MODE); //$NON-NLS-1$
 		assertContains("Missing TEST_MODE", ids, "alternate"); //$NON-NLS-1$ //$NON-NLS-2$
 	}

 	/**
 	 * Asserts that the array contains the given object
 	 * @param message
 	 * @param array
 	 * @param object
 	 */
 	static public void assertContains(String message, Object[] array, Object object) {
 		for (int i = 0; i < array.length; i++) {
 			if (array[i].equals(object)) {
 				return;
 			}
 		}
 		throw new AssertionFailedError(message);
 	}

 	/**
 	 * Ensure our contributed mode is supported.
 	 * @throws CoreException
 	 */
 	public void testSupportsMode() throws CoreException {
 		ILaunchConfiguration configuration = getLaunchConfiguration("Breakpoints"); //$NON-NLS-1$
 		assertNotNull(configuration);
 		assertTrue("Java application configuration should support TEST_MODE", configuration.supportsMode("TEST_MODE")); //$NON-NLS-1$ //$NON-NLS-2$
 		assertTrue("Java application type should support TEST_MODE", configuration.getType().supportsMode("TEST_MODE")); //$NON-NLS-1$ //$NON-NLS-2$

 		assertTrue("Java application configuration should support debug mode", configuration.supportsMode(ILaunchManager.DEBUG_MODE)); //$NON-NLS-1$
 		assertTrue("Java application type should support debug mode", configuration.getType().supportsMode(ILaunchManager.DEBUG_MODE)); //$NON-NLS-1$

 		assertTrue("Java application configuration should support run mode", configuration.supportsMode(ILaunchManager.RUN_MODE)); //$NON-NLS-1$
 		assertTrue("Java application type should support run mode", configuration.getType().supportsMode(ILaunchManager.RUN_MODE));		 //$NON-NLS-1$
 	}

 	/**
 	 * Tests that mode specific tab group contributions work.
 	 * @throws CoreException
 	 */
 	public void testModeSpecificTabGroups() throws CoreException {
 		ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
 		ILaunchConfigurationTabGroup standardGroup = LaunchConfigurationPresentationManager.getDefault().getTabGroup(javaType, ILaunchManager.DEBUG_MODE);
 		ILaunchConfigurationTabGroup testGroup = LaunchConfigurationPresentationManager.getDefault().getTabGroup(javaType, "TEST_MODE"); //$NON-NLS-1$
 		ILaunchConfigurationDialog dialog = new LaunchConfigurationsDialog(null, DebugUIPlugin.getDefault().getLaunchConfigurationManager().getLaunchGroup(IDebugUIConstants.ID_DEBUG_LAUNCH_GROUP));
 		standardGroup.createTabs(dialog, ILaunchManager.DEBUG_MODE);
 		testGroup.createTabs(dialog, "TEST_MODE"); //$NON-NLS-1$

 		ILaunchConfigurationTab[] tabs = standardGroup.getTabs();
 		HashSet<Class<? extends ILaunchConfigurationTab>> tabset = new HashSet<>();
 		for(int i = 0; i< tabs.length; i++) {
 			tabset.add(tabs[i].getClass());
 		}
 		Class<?>[] classes = new Class<?>[] {
 				JavaMainTab.class,
 				JavaArgumentsTab.class,
 				JavaJRETab.class,
 				JavaClasspathTab.class,
 				SourceLookupTab.class,
 				EnvironmentTab.class,
 				CommonTab.class};
 		assertTrue("Tab set does not contain all default java tabs", tabset.containsAll(new HashSet<>(Arrays.asList(classes)))); //$NON-NLS-1$

 		tabs = testGroup.getTabs();
 		assertEquals("Wrong number of tabs in the test group", 4, tabs.length); //$NON-NLS-1$
 		tabset = new HashSet<>();
 		for(int i = 0; i< tabs.length; i++) {
 			tabset.add(tabs[i].getClass());
 		}
 		classes = new Class<?>[] {
 				JavaMainTab.class,
 				JavaArgumentsTab.class,
 				JavaJRETab.class,
 				JavaClasspathTab.class};
 		assertTrue("Test tab set does not contain all default tabs", tabset.containsAll(new HashSet<>(Arrays.asList(classes)))); //$NON-NLS-1$
 		standardGroup.dispose();
 		testGroup.dispose();
 	}

 	/**
 	 * Tests that the default debug perspective for java applications is debug.
 	 */
 	public void testDefaultDebugLaunchPerspective() {
 		ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
 		assertEquals("Java debug perspective should be debug", IDebugUIConstants.ID_DEBUG_PERSPECTIVE, DebugUITools.getLaunchPerspective(javaType, ILaunchManager.DEBUG_MODE)); //$NON-NLS-1$
 	}

 	/**
 	 * Test that the default debug perspective for Java Application types is debug.
 	 * Same notion as <code>testDefaultDebugLaunchPerspective()</code>, but using the new API
 	 * for getting perspectives
 	 *
 	 * @since 3.3
 	 */
 	public void testDefaultDebugLaunchPerspective2() {
 		ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
 		HashSet<String> modes =  new HashSet<>();
 		modes.add(ILaunchManager.DEBUG_MODE);
 		assertEquals("Java debug perspective should be debug", IDebugUIConstants.ID_DEBUG_PERSPECTIVE, DebugUITools.getLaunchPerspective(javaType, null, modes)); //$NON-NLS-1$
 	}

 	/**
 	 * Tests that the default run perspective for java applications is none (<code>null</code>).
 	 */
 	public void testDefaultRunLaunchPerspective() {
 		ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
 		assertNull("Java run perspective should be null", DebugUITools.getLaunchPerspective(javaType, ILaunchManager.RUN_MODE)); //$NON-NLS-1$
 	}

 	/**
 	 * Tests that the default run perspective for java applications is none (<code>null</code>).
 	 * Same notion as <code>testDefaultRunLaunchPerspective()</code>, but using the new API for getting
 	 * launch perspectives
 	 *
 	 * @since 3.3
 	 */
 	public void testDefaultRunLaunchPerspective2() {
 		ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
 		HashSet<String> modes = new HashSet<>();
 		modes.add(ILaunchManager.RUN_MODE);
 		assertNull("Java run perspective should be null", DebugUITools.getLaunchPerspective(javaType, null, modes)); //$NON-NLS-1$
 	}

 	/**
 	 * Tests that the default debug perspective can be over-ridden and reset
 	 */
 	public void testResetDebugLaunchPerspective() {
 		ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
 		assertEquals("Java debug perspective should be debug", IDebugUIConstants.ID_DEBUG_PERSPECTIVE, //$NON-NLS-1$
 			DebugUITools.getLaunchPerspective(javaType, ILaunchManager.DEBUG_MODE));
 		// set to NONE
 		DebugUITools.setLaunchPerspective(javaType, ILaunchManager.DEBUG_MODE, IDebugUIConstants.PERSPECTIVE_NONE);
 		assertNull("Java debug perspective should now be null",  //$NON-NLS-1$
 			DebugUITools.getLaunchPerspective(javaType, ILaunchManager.DEBUG_MODE));
 		// re-set to default
 		DebugUITools.setLaunchPerspective(javaType, ILaunchManager.DEBUG_MODE, IDebugUIConstants.PERSPECTIVE_DEFAULT);
 		assertEquals("Java debug perspective should now be debug", IDebugUIConstants.ID_DEBUG_PERSPECTIVE, //$NON-NLS-1$
 			DebugUITools.getLaunchPerspective(javaType, ILaunchManager.DEBUG_MODE));

 	}

 	/**
 	 * Tests that the default debug perspective can be over-ridden and reset.
 	 * Same notion as <code>testResetDebugLaunchPerspective()</code>, but using the new API
 	 * for setting an resetting perspectives.
 	 *
 	 * @since 3.3
 	 */
 	public void testResetDebugLaunchPerspective2() {
 		ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
 		HashSet<String> modes = new HashSet<>();
 		modes.add(ILaunchManager.DEBUG_MODE);
 		assertEquals("Java debug perspective should be debug", IDebugUIConstants.ID_DEBUG_PERSPECTIVE, DebugUITools.getLaunchPerspective(javaType, null, modes)); //$NON-NLS-1$
 		// set to NONE
 		DebugUITools.setLaunchPerspective(javaType, null, modes, IDebugUIConstants.PERSPECTIVE_NONE);
 		assertNull("Java debug perspective should now be null", DebugUITools.getLaunchPerspective(javaType, null, modes)); //$NON-NLS-1$
 		// re-set to default
 		DebugUITools.setLaunchPerspective(javaType, null, modes, IDebugUIConstants.PERSPECTIVE_DEFAULT);
 		assertEquals("Java debug perspective should now be debug", IDebugUIConstants.ID_DEBUG_PERSPECTIVE, DebugUITools.getLaunchPerspective(javaType, null, modes)); //$NON-NLS-1$

 	}

 	/**
 	 * Tests that the default debug perspective can be over-ridden and reset
 	 * Same notion as <code>testResetDebugLaunchPerspective2()</code>, but using the
 	 * JDT Java launch delegate instead of <code>null</code>
 	 *
 	 * @since 3.3
 	 */
 	public void testResetDebugPerspectiveJavaLaunchDelegate() {
 		ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
 		HashSet<String> modes = new HashSet<>();
 		modes.add(ILaunchManager.DEBUG_MODE);
 		ILaunchDelegate delegate = ((LaunchManager)getLaunchManager()).getLaunchDelegate("org.eclipse.jdt.launching.localJavaApplication"); //$NON-NLS-1$
 		assertNotNull("Java launch delegate should not be null", delegate); //$NON-NLS-1$
 		assertEquals("Java debug perspective should be debug", IDebugUIConstants.ID_DEBUG_PERSPECTIVE, DebugUITools.getLaunchPerspective(javaType, delegate, modes)); //$NON-NLS-1$
 		// set to NONE
 		DebugUITools.setLaunchPerspective(javaType, null, modes, IDebugUIConstants.PERSPECTIVE_NONE);
 		assertNull("Java debug perspective should now be null", DebugUITools.getLaunchPerspective(javaType, delegate, modes)); //$NON-NLS-1$
 		// re-set to default
 		DebugUITools.setLaunchPerspective(javaType, null, modes, IDebugUIConstants.PERSPECTIVE_DEFAULT);
 		assertEquals("Java debug perspective should now be debug", IDebugUIConstants.ID_DEBUG_PERSPECTIVE, DebugUITools.getLaunchPerspective(javaType, delegate, modes)); //$NON-NLS-1$
 	}

 	/**
 	 * Tests that the default run perspective can be over-ridden and reset
 	 */
 	public void testResetRunLaunchPerspective() {
 		ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
 		assertNull("Java run perspective should be null",  //$NON-NLS-1$
 			DebugUITools.getLaunchPerspective(javaType, ILaunchManager.RUN_MODE));
 		// set to Java perspective
 		DebugUITools.setLaunchPerspective(javaType, ILaunchManager.RUN_MODE, JavaUI.ID_PERSPECTIVE);
 		assertEquals("Java run perspective should now be java", JavaUI.ID_PERSPECTIVE, //$NON-NLS-1$
 					DebugUITools.getLaunchPerspective(javaType, ILaunchManager.RUN_MODE));
 		// re-set to default
 		DebugUITools.setLaunchPerspective(javaType, ILaunchManager.RUN_MODE, IDebugUIConstants.PERSPECTIVE_DEFAULT);
 		assertNull("Java run perspective should now be null",  //$NON-NLS-1$
 			DebugUITools.getLaunchPerspective(javaType, ILaunchManager.RUN_MODE));
 	}

 	/**
 	 * Tests that the default run perspective can be over-ridden and reset.
 	 * Same notion as <code>testResetRunLaunchPerspective()</code>, but using the new API
 	 * for getting/setting/re-setting perspective settings.
 	 *
 	 * @since 3.3
 	 */
 	public void testResetRunLaunchPerspective2() {
 		ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
 		HashSet<String> modes = new HashSet<>();
 		modes.add(ILaunchManager.RUN_MODE);
 		assertNull("Java run perspective should be null", DebugUITools.getLaunchPerspective(javaType, null, modes)); //$NON-NLS-1$
 		// set to Java perspective
 		DebugUITools.setLaunchPerspective(javaType, null, modes, JavaUI.ID_PERSPECTIVE);
 		assertEquals("Java run perspective should now be java", JavaUI.ID_PERSPECTIVE, DebugUITools.getLaunchPerspective(javaType, null, modes)); //$NON-NLS-1$
 		// re-set to default
 		DebugUITools.setLaunchPerspective(javaType, ILaunchManager.RUN_MODE, IDebugUIConstants.PERSPECTIVE_DEFAULT);
 		assertNull("Java run perspective should now be null", DebugUITools.getLaunchPerspective(javaType, null, modes));		 //$NON-NLS-1$
 	}

 	/**
 	 * Tests that the default debug perspective can be over-ridden and reset
 	 * Same notion as <code>testResetRunLaunchPerspective2()</code>, but using the
 	 * JDT Java launch delegate instead of <code>null</code>
 	 *
 	 * @since 3.3
 	 */
 	public void testResetRunPerspectiveJavaLaunchDelegate() {
 		ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
 		HashSet<String> modes = new HashSet<>();
 		modes.add(ILaunchManager.RUN_MODE);
 		ILaunchDelegate delegate = ((LaunchManager)getLaunchManager()).getLaunchDelegate("org.eclipse.jdt.launching.localJavaApplication"); //$NON-NLS-1$
 		assertNotNull("Java launch delegate should not be null", delegate); //$NON-NLS-1$
 		assertNull("Java run perspective should be null", DebugUITools.getLaunchPerspective(javaType, delegate, modes)); //$NON-NLS-1$
 		// set to NONE
 		DebugUITools.setLaunchPerspective(javaType, null, modes, IDebugUIConstants.PERSPECTIVE_NONE);
 		assertNull("Java run perspective should now be null", DebugUITools.getLaunchPerspective(javaType, delegate, modes)); //$NON-NLS-1$
 		// re-set to default
 		DebugUITools.setLaunchPerspective(javaType, null, modes, IDebugUIConstants.PERSPECTIVE_DEFAULT);
 		assertNull("Java run perspective should now be null", DebugUITools.getLaunchPerspective(javaType, delegate, modes)); //$NON-NLS-1$
 	}

 	/**
 	 * Tests that the default launch perspective for the 'debug' modeset and java launch delegate is
 	 * <code>ILaunchManager.DEBUG_MODE</code> using the new API.
 	 *
 	 * @since 3.3
 	 */
 	public void testDefaultDebugPerspectiveJavaLaunchDelegate() {
 		ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
 		HashSet<String> modes = new HashSet<>();
 		modes.add(ILaunchManager.DEBUG_MODE);
 		ILaunchDelegate delegate = ((LaunchManager)getLaunchManager()).getLaunchDelegate("org.eclipse.jdt.launching.localJavaApplication"); //$NON-NLS-1$
 		assertNotNull("Java launch delegate should not be null", delegate); //$NON-NLS-1$
 		String p = DebugUITools.getLaunchPerspective(javaType, delegate, modes);
 		assertEquals("Java debug perspective should be debug", IDebugUIConstants.ID_DEBUG_PERSPECTIVE, p); //$NON-NLS-1$
 	}

 	/**
 	 * Tests that the default launch perspective for the 'run' modeset and java launch delegate
 	 * is <code>null/code> using the new API
 	 *
 	 * @since 3.3
 	 */
 	public void testDefaultRunPerspectiveJavaLaunchDelegate() {
 		ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
 		HashSet<String> modes = new HashSet<>();
 		modes.add(ILaunchManager.RUN_MODE);
 		ILaunchDelegate delegate = ((LaunchManager)getLaunchManager()).getLaunchDelegate("org.eclipse.jdt.launching.localJavaApplication"); //$NON-NLS-1$
 		assertNotNull("Java launch delegate should not be null", delegate); //$NON-NLS-1$
 		String p = DebugUITools.getLaunchPerspective(javaType, delegate, modes);
 		assertNull("Java run perspective should be null", p); //$NON-NLS-1$
 	}

 	/**
 	 * Tests a perspective contributed with a launch tab group.
 	 */
 	public void testContributedLaunchPerspective() {
 		ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
 		assertEquals("perspective for TEST_MODE should be 'java'", JavaUI.ID_PERSPECTIVE, //$NON-NLS-1$
 			DebugUITools.getLaunchPerspective(javaType, "TEST_MODE")); //$NON-NLS-1$
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2012 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.jdt.debug.tests.launching;

	import java.util.Arrays;
	import java.util.HashSet;

	import junit.framework.AssertionFailedError;

	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.debug.core.ILaunch;
	import org.eclipse.debug.core.ILaunchConfiguration;
	import org.eclipse.debug.core.ILaunchConfigurationType;
	import org.eclipse.debug.core.ILaunchDelegate;
	import org.eclipse.debug.core.ILaunchManager;
	import org.eclipse.debug.core.ILaunchMode;
	import org.eclipse.debug.internal.core.LaunchManager;
	import org.eclipse.debug.internal.ui.DebugUIPlugin;
	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationPresentationManager;
	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationsDialog;
	import org.eclipse.debug.ui.CommonTab;
	import org.eclipse.debug.ui.DebugUITools;
	import org.eclipse.debug.ui.EnvironmentTab;
	import org.eclipse.debug.ui.IDebugUIConstants;
	import org.eclipse.debug.ui.ILaunchConfigurationDialog;
	import org.eclipse.debug.ui.ILaunchConfigurationTab;
	import org.eclipse.debug.ui.ILaunchConfigurationTabGroup;
	import org.eclipse.debug.ui.sourcelookup.SourceLookupTab;
	import org.eclipse.jdt.debug.testplugin.launching.TestModeLaunchDelegate;
	import org.eclipse.jdt.debug.tests.AbstractDebugTest;
	import org.eclipse.jdt.debug.ui.launchConfigurations.JavaArgumentsTab;
	import org.eclipse.jdt.debug.ui.launchConfigurations.JavaClasspathTab;
	import org.eclipse.jdt.debug.ui.launchConfigurations.JavaJRETab;
	import org.eclipse.jdt.debug.ui.launchConfigurations.JavaMainTab;
	import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
	import org.eclipse.jdt.ui.JavaUI;

	/**
	* LaunchModeTests
	*/
	public class LaunchModeTests extends AbstractDebugTest {

	private ILaunchConfiguration fConfiguration;
	private String fMode;

	/**
	* @param name
	*/
	public LaunchModeTests(String name) {
	super(name);
	}

	/**
	* Called by launch "TestModeLaunchDelegate" delegate when launch method invoked.
	*
	* @param configuration
	* @param mode
	*/
	public synchronized void launch(ILaunchConfiguration configuration, String mode) {
	fConfiguration = configuration;
	fMode = mode;
	notifyAll();
	}

	/**
	* Tests that launch delegate for "TEST_MODE" and Java applications is invoked when
	* "TEST_MODE" is used.
	*
	* @throws CoreException
	* @see TestModeLaunchDelegate
	*/
	public void testContributedLaunchMode() throws CoreException {
	ILaunch launch = null;
	try {
	fConfiguration = null;
	fMode = null;
	TestModeLaunchDelegate.setTestCase(this);
	ILaunchConfiguration configuration = getLaunchConfiguration("Breakpoints"); //$NON-NLS-1$
	assertNotNull(configuration);
	launch = configuration.launch("TEST_MODE", null); //$NON-NLS-1$
	assertEquals("Launch delegate not invoked", configuration, getLaunchConfigurationSetByDelegate()); //$NON-NLS-1$
	assertEquals("Launch delegate not invoked in correct mode", "TEST_MODE", fMode); //$NON-NLS-1$ //$NON-NLS-2$
	} finally {
	TestModeLaunchDelegate.setTestCase(null);
	fConfiguration = null;
	fMode = null;
	if (launch != null) {
	getLaunchManager().removeLaunch(launch);
	}
	}
	}

	/**
	* Returns the launch configuration set by the TestModeLaunchDelegate, or <code>null</code>
	* if no launch configuration was set (the correct delegate was not called).
	* A wait must occur due to the use of Jobs for launching.
	*/
	private synchronized Object getLaunchConfigurationSetByDelegate() {
	if (fConfiguration == null) {
	try {
	wait(10000);
	} catch (InterruptedException ie) {
	System.err.println("Interrupted waiting for launch configuration"); //$NON-NLS-1$
	}
	}

	return fConfiguration;
	}

	/**
	* Ensure our contributed launch mode exists.
	*/
	public void testLaunchModes() {
	ILaunchMode[] modes = getLaunchManager().getLaunchModes();
	String[] ids = new String[modes.length];
	for (int i = 0; i < modes.length; i++) {
	ILaunchMode mode = modes[i];
	ids[i] = mode.getIdentifier();
	}
	assertContains("Missing TEST_MODE", ids, "TEST_MODE"); //$NON-NLS-1$ //$NON-NLS-2$
	assertContains("Missing debug mode", ids, ILaunchManager.DEBUG_MODE); //$NON-NLS-1$
	assertContains("Missing run mode", ids, ILaunchManager.RUN_MODE); //$NON-NLS-1$
	assertContains("Missing TEST_MODE", ids, "alternate"); //$NON-NLS-1$ //$NON-NLS-2$
	}

	/**
	* Asserts that the array contains the given object
	* @param message
	* @param array
	* @param object
	*/
	static public void assertContains(String message, Object[] array, Object object) {
	for (int i = 0; i < array.length; i++) {
	if (array[i].equals(object)) {
	return;
	}
	}
	throw new AssertionFailedError(message);
	}

	/**
	* Ensure our contributed mode is supported.
	* @throws CoreException
	*/
	public void testSupportsMode() throws CoreException {
	ILaunchConfiguration configuration = getLaunchConfiguration("Breakpoints"); //$NON-NLS-1$
	assertNotNull(configuration);
	assertTrue("Java application configuration should support TEST_MODE", configuration.supportsMode("TEST_MODE")); //$NON-NLS-1$ //$NON-NLS-2$
	assertTrue("Java application type should support TEST_MODE", configuration.getType().supportsMode("TEST_MODE")); //$NON-NLS-1$ //$NON-NLS-2$

	assertTrue("Java application configuration should support debug mode", configuration.supportsMode(ILaunchManager.DEBUG_MODE)); //$NON-NLS-1$
	assertTrue("Java application type should support debug mode", configuration.getType().supportsMode(ILaunchManager.DEBUG_MODE)); //$NON-NLS-1$

	assertTrue("Java application configuration should support run mode", configuration.supportsMode(ILaunchManager.RUN_MODE)); //$NON-NLS-1$
	assertTrue("Java application type should support run mode", configuration.getType().supportsMode(ILaunchManager.RUN_MODE)); //$NON-NLS-1$
	}

	/**
	* Tests that mode specific tab group contributions work.
	* @throws CoreException
	*/
	public void testModeSpecificTabGroups() throws CoreException {
	ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
	ILaunchConfigurationTabGroup standardGroup = LaunchConfigurationPresentationManager.getDefault().getTabGroup(javaType, ILaunchManager.DEBUG_MODE);
	ILaunchConfigurationTabGroup testGroup = LaunchConfigurationPresentationManager.getDefault().getTabGroup(javaType, "TEST_MODE"); //$NON-NLS-1$
	ILaunchConfigurationDialog dialog = new LaunchConfigurationsDialog(null, DebugUIPlugin.getDefault().getLaunchConfigurationManager().getLaunchGroup(IDebugUIConstants.ID_DEBUG_LAUNCH_GROUP));
	standardGroup.createTabs(dialog, ILaunchManager.DEBUG_MODE);
	testGroup.createTabs(dialog, "TEST_MODE"); //$NON-NLS-1$

	ILaunchConfigurationTab[] tabs = standardGroup.getTabs();
	HashSet<Class<? extends ILaunchConfigurationTab>> tabset = new HashSet<>();
	for(int i = 0; i< tabs.length; i++) {
	tabset.add(tabs[i].getClass());
	}
	Class<?>[] classes = new Class<?>[] {
	JavaMainTab.class,
	JavaArgumentsTab.class,
	JavaJRETab.class,
	JavaClasspathTab.class,
	SourceLookupTab.class,
	EnvironmentTab.class,
	CommonTab.class};
	assertTrue("Tab set does not contain all default java tabs", tabset.containsAll(new HashSet<>(Arrays.asList(classes)))); //$NON-NLS-1$

	tabs = testGroup.getTabs();
	assertEquals("Wrong number of tabs in the test group", 4, tabs.length); //$NON-NLS-1$
	tabset = new HashSet<>();
	for(int i = 0; i< tabs.length; i++) {
	tabset.add(tabs[i].getClass());
	}
	classes = new Class<?>[] {
	JavaMainTab.class,
	JavaArgumentsTab.class,
	JavaJRETab.class,
	JavaClasspathTab.class};
	assertTrue("Test tab set does not contain all default tabs", tabset.containsAll(new HashSet<>(Arrays.asList(classes)))); //$NON-NLS-1$
	standardGroup.dispose();
	testGroup.dispose();
	}

	/**
	* Tests that the default debug perspective for java applications is debug.
	*/
	public void testDefaultDebugLaunchPerspective() {
	ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
	assertEquals("Java debug perspective should be debug", IDebugUIConstants.ID_DEBUG_PERSPECTIVE, DebugUITools.getLaunchPerspective(javaType, ILaunchManager.DEBUG_MODE)); //$NON-NLS-1$
	}

	/**
	* Test that the default debug perspective for Java Application types is debug.
	* Same notion as <code>testDefaultDebugLaunchPerspective()</code>, but using the new API
	* for getting perspectives
	*
	* @since 3.3
	*/
	public void testDefaultDebugLaunchPerspective2() {
	ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
	HashSet<String> modes = new HashSet<>();
	modes.add(ILaunchManager.DEBUG_MODE);
	assertEquals("Java debug perspective should be debug", IDebugUIConstants.ID_DEBUG_PERSPECTIVE, DebugUITools.getLaunchPerspective(javaType, null, modes)); //$NON-NLS-1$
	}

	/**
	* Tests that the default run perspective for java applications is none (<code>null</code>).
	*/
	public void testDefaultRunLaunchPerspective() {
	ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
	assertNull("Java run perspective should be null", DebugUITools.getLaunchPerspective(javaType, ILaunchManager.RUN_MODE)); //$NON-NLS-1$
	}

	/**
	* Tests that the default run perspective for java applications is none (<code>null</code>).
	* Same notion as <code>testDefaultRunLaunchPerspective()</code>, but using the new API for getting
	* launch perspectives
	*
	* @since 3.3
	*/
	public void testDefaultRunLaunchPerspective2() {
	ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
	HashSet<String> modes = new HashSet<>();
	modes.add(ILaunchManager.RUN_MODE);
	assertNull("Java run perspective should be null", DebugUITools.getLaunchPerspective(javaType, null, modes)); //$NON-NLS-1$
	}

	/**
	* Tests that the default debug perspective can be over-ridden and reset
	*/
	public void testResetDebugLaunchPerspective() {
	ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
	assertEquals("Java debug perspective should be debug", IDebugUIConstants.ID_DEBUG_PERSPECTIVE, //$NON-NLS-1$
	DebugUITools.getLaunchPerspective(javaType, ILaunchManager.DEBUG_MODE));
	// set to NONE
	DebugUITools.setLaunchPerspective(javaType, ILaunchManager.DEBUG_MODE, IDebugUIConstants.PERSPECTIVE_NONE);
	assertNull("Java debug perspective should now be null", //$NON-NLS-1$
	DebugUITools.getLaunchPerspective(javaType, ILaunchManager.DEBUG_MODE));
	// re-set to default
	DebugUITools.setLaunchPerspective(javaType, ILaunchManager.DEBUG_MODE, IDebugUIConstants.PERSPECTIVE_DEFAULT);
	assertEquals("Java debug perspective should now be debug", IDebugUIConstants.ID_DEBUG_PERSPECTIVE, //$NON-NLS-1$
	DebugUITools.getLaunchPerspective(javaType, ILaunchManager.DEBUG_MODE));

	}

	/**
	* Tests that the default debug perspective can be over-ridden and reset.
	* Same notion as <code>testResetDebugLaunchPerspective()</code>, but using the new API
	* for setting an resetting perspectives.
	*
	* @since 3.3
	*/
	public void testResetDebugLaunchPerspective2() {
	ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
	HashSet<String> modes = new HashSet<>();
	modes.add(ILaunchManager.DEBUG_MODE);
	assertEquals("Java debug perspective should be debug", IDebugUIConstants.ID_DEBUG_PERSPECTIVE, DebugUITools.getLaunchPerspective(javaType, null, modes)); //$NON-NLS-1$
	// set to NONE
	DebugUITools.setLaunchPerspective(javaType, null, modes, IDebugUIConstants.PERSPECTIVE_NONE);
	assertNull("Java debug perspective should now be null", DebugUITools.getLaunchPerspective(javaType, null, modes)); //$NON-NLS-1$
	// re-set to default
	DebugUITools.setLaunchPerspective(javaType, null, modes, IDebugUIConstants.PERSPECTIVE_DEFAULT);
	assertEquals("Java debug perspective should now be debug", IDebugUIConstants.ID_DEBUG_PERSPECTIVE, DebugUITools.getLaunchPerspective(javaType, null, modes)); //$NON-NLS-1$

	}

	/**
	* Tests that the default debug perspective can be over-ridden and reset
	* Same notion as <code>testResetDebugLaunchPerspective2()</code>, but using the
	* JDT Java launch delegate instead of <code>null</code>
	*
	* @since 3.3
	*/
	public void testResetDebugPerspectiveJavaLaunchDelegate() {
	ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
	HashSet<String> modes = new HashSet<>();
	modes.add(ILaunchManager.DEBUG_MODE);
	ILaunchDelegate delegate = ((LaunchManager)getLaunchManager()).getLaunchDelegate("org.eclipse.jdt.launching.localJavaApplication"); //$NON-NLS-1$
	assertNotNull("Java launch delegate should not be null", delegate); //$NON-NLS-1$
	assertEquals("Java debug perspective should be debug", IDebugUIConstants.ID_DEBUG_PERSPECTIVE, DebugUITools.getLaunchPerspective(javaType, delegate, modes)); //$NON-NLS-1$
	// set to NONE
	DebugUITools.setLaunchPerspective(javaType, null, modes, IDebugUIConstants.PERSPECTIVE_NONE);
	assertNull("Java debug perspective should now be null", DebugUITools.getLaunchPerspective(javaType, delegate, modes)); //$NON-NLS-1$
	// re-set to default
	DebugUITools.setLaunchPerspective(javaType, null, modes, IDebugUIConstants.PERSPECTIVE_DEFAULT);
	assertEquals("Java debug perspective should now be debug", IDebugUIConstants.ID_DEBUG_PERSPECTIVE, DebugUITools.getLaunchPerspective(javaType, delegate, modes)); //$NON-NLS-1$
	}

	/**
	* Tests that the default run perspective can be over-ridden and reset
	*/
	public void testResetRunLaunchPerspective() {
	ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
	assertNull("Java run perspective should be null", //$NON-NLS-1$
	DebugUITools.getLaunchPerspective(javaType, ILaunchManager.RUN_MODE));
	// set to Java perspective
	DebugUITools.setLaunchPerspective(javaType, ILaunchManager.RUN_MODE, JavaUI.ID_PERSPECTIVE);
	assertEquals("Java run perspective should now be java", JavaUI.ID_PERSPECTIVE, //$NON-NLS-1$
	DebugUITools.getLaunchPerspective(javaType, ILaunchManager.RUN_MODE));
	// re-set to default
	DebugUITools.setLaunchPerspective(javaType, ILaunchManager.RUN_MODE, IDebugUIConstants.PERSPECTIVE_DEFAULT);
	assertNull("Java run perspective should now be null", //$NON-NLS-1$
	DebugUITools.getLaunchPerspective(javaType, ILaunchManager.RUN_MODE));
	}

	/**
	* Tests that the default run perspective can be over-ridden and reset.
	* Same notion as <code>testResetRunLaunchPerspective()</code>, but using the new API
	* for getting/setting/re-setting perspective settings.
	*
	* @since 3.3
	*/
	public void testResetRunLaunchPerspective2() {
	ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
	HashSet<String> modes = new HashSet<>();
	modes.add(ILaunchManager.RUN_MODE);
	assertNull("Java run perspective should be null", DebugUITools.getLaunchPerspective(javaType, null, modes)); //$NON-NLS-1$
	// set to Java perspective
	DebugUITools.setLaunchPerspective(javaType, null, modes, JavaUI.ID_PERSPECTIVE);
	assertEquals("Java run perspective should now be java", JavaUI.ID_PERSPECTIVE, DebugUITools.getLaunchPerspective(javaType, null, modes)); //$NON-NLS-1$
	// re-set to default
	DebugUITools.setLaunchPerspective(javaType, ILaunchManager.RUN_MODE, IDebugUIConstants.PERSPECTIVE_DEFAULT);
	assertNull("Java run perspective should now be null", DebugUITools.getLaunchPerspective(javaType, null, modes)); //$NON-NLS-1$
	}

	/**
	* Tests that the default debug perspective can be over-ridden and reset
	* Same notion as <code>testResetRunLaunchPerspective2()</code>, but using the
	* JDT Java launch delegate instead of <code>null</code>
	*
	* @since 3.3
	*/
	public void testResetRunPerspectiveJavaLaunchDelegate() {
	ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
	HashSet<String> modes = new HashSet<>();
	modes.add(ILaunchManager.RUN_MODE);
	ILaunchDelegate delegate = ((LaunchManager)getLaunchManager()).getLaunchDelegate("org.eclipse.jdt.launching.localJavaApplication"); //$NON-NLS-1$
	assertNotNull("Java launch delegate should not be null", delegate); //$NON-NLS-1$
	assertNull("Java run perspective should be null", DebugUITools.getLaunchPerspective(javaType, delegate, modes)); //$NON-NLS-1$
	// set to NONE
	DebugUITools.setLaunchPerspective(javaType, null, modes, IDebugUIConstants.PERSPECTIVE_NONE);
	assertNull("Java run perspective should now be null", DebugUITools.getLaunchPerspective(javaType, delegate, modes)); //$NON-NLS-1$
	// re-set to default
	DebugUITools.setLaunchPerspective(javaType, null, modes, IDebugUIConstants.PERSPECTIVE_DEFAULT);
	assertNull("Java run perspective should now be null", DebugUITools.getLaunchPerspective(javaType, delegate, modes)); //$NON-NLS-1$
	}

	/**
	* Tests that the default launch perspective for the 'debug' modeset and java launch delegate is
	* <code>ILaunchManager.DEBUG_MODE</code> using the new API.
	*
	* @since 3.3
	*/
	public void testDefaultDebugPerspectiveJavaLaunchDelegate() {
	ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
	HashSet<String> modes = new HashSet<>();
	modes.add(ILaunchManager.DEBUG_MODE);
	ILaunchDelegate delegate = ((LaunchManager)getLaunchManager()).getLaunchDelegate("org.eclipse.jdt.launching.localJavaApplication"); //$NON-NLS-1$
	assertNotNull("Java launch delegate should not be null", delegate); //$NON-NLS-1$
	String p = DebugUITools.getLaunchPerspective(javaType, delegate, modes);
	assertEquals("Java debug perspective should be debug", IDebugUIConstants.ID_DEBUG_PERSPECTIVE, p); //$NON-NLS-1$
	}

	/**
	* Tests that the default launch perspective for the 'run' modeset and java launch delegate
	* is <code>null/code> using the new API
	*
	* @since 3.3
	*/
	public void testDefaultRunPerspectiveJavaLaunchDelegate() {
	ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
	HashSet<String> modes = new HashSet<>();
	modes.add(ILaunchManager.RUN_MODE);
	ILaunchDelegate delegate = ((LaunchManager)getLaunchManager()).getLaunchDelegate("org.eclipse.jdt.launching.localJavaApplication"); //$NON-NLS-1$
	assertNotNull("Java launch delegate should not be null", delegate); //$NON-NLS-1$
	String p = DebugUITools.getLaunchPerspective(javaType, delegate, modes);
	assertNull("Java run perspective should be null", p); //$NON-NLS-1$
	}

	/**
	* Tests a perspective contributed with a launch tab group.
	*/
	public void testContributedLaunchPerspective() {
	ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
	assertEquals("perspective for TEST_MODE should be 'java'", JavaUI.ID_PERSPECTIVE, //$NON-NLS-1$
	DebugUITools.getLaunchPerspective(javaType, "TEST_MODE")); //$NON-NLS-1$
	}
	}