tests/org.eclipse.ui.tests/Eclipse UI Tests/org/eclipse/ui/tests/dnd/DragTestSuite.java - platform/eclipse.platform.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2004, 2005 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
  *******************************************************************************/
 package org.eclipse.ui.tests.dnd;

 import junit.framework.Test;
 import junit.framework.TestSuite;

 import org.eclipse.core.runtime.Path;
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.swt.widgets.Shell;
 import org.eclipse.ui.IPageLayout;
 import org.eclipse.ui.internal.dnd.TestDropLocation;
 import org.eclipse.ui.tests.TestPlugin;
 import org.eclipse.ui.tests.autotests.AutoTestSuite;

 /**
  * @since 3.0
  */
 public class DragTestSuite extends AutoTestSuite {

     /**
      * Returns the suite. This is required to use the JUnit Launcher.
      */
     public static Test suite() {
         return new DragTestSuite();
     }

     /**
      * Whether the platform we're running on supports the detaching of views.
      * This is initialized in the following static block.
      *
      * @since 3.2
      */
 	private static final boolean isDetachingSupported;

 	static {
 		Shell shell = new Shell();
 		Composite c = new Composite(shell, SWT.NONE);
 		isDetachingSupported  = c.isReparentable();
 		shell.dispose();
 	}

     public DragTestSuite() {
         super(Platform.find(TestPlugin.getDefault().getBundle(), new Path("data/dragtests.xml")));

         String resNav = IPageLayout.ID_RES_NAV;
         String probView = IPageLayout.ID_PROBLEM_VIEW;

         // Drag sources for views
         TestDragSource[] viewDragSources = new TestDragSource[] {
                 new ViewDragSource(resNav, false),
                 new ViewDragSource(resNav, true),
                 new ViewDragSource(probView, false),
                 new ViewDragSource(probView, true) };

         // Drag sources for editors
         TestDragSource[] editorDragSources = new TestDragSource[] {
                 new EditorDragSource(0, false), new EditorDragSource(0, true),
                 new EditorDragSource(2, false), new EditorDragSource(2, true) };

         // Drop targets that will only be tested for views

         // Drag sources for maximized views
         TestDragSource[] maximizedViewDragSources = new TestDragSource[] {
                 new ViewDragSource(resNav, false, true),
                 new ViewDragSource(resNav, true, true),
                 new ViewDragSource(probView, false, true),
                 new ViewDragSource(probView, true, true) };

         // Now generate all test cases
         for (int i = 0; i < maximizedViewDragSources.length; i++) {
             TestDragSource source = maximizedViewDragSources[i];

             addAllCombinations(source, getMaximizedViewDropTargets(source));
         }

         for (int i = 0; i < viewDragSources.length; i++) {
             TestDragSource source = viewDragSources[i];

             addAllCombinations(source, getViewDropTargets(source));
             addAllCombinations(source, getCommonDropTargets(source));

             // Test dragging onto a detached window
             addAllCombinationsDetached(source, getDetachedWindowDropTargets(source));
         }

         for (int i = 0; i < editorDragSources.length; i++) {
             TestDragSource source = editorDragSources[i];

             addAllCombinations(source, getEditorDropTargets(source));
             addAllCombinations(source, getCommonDropTargets(source));

             // Test dragging onto a detached window
             addAllCombinationsDetached(source, getDetachedWindowDropTargets(source));
         }
         addTest(new TestSuite(Bug87211Test.class));
     }

     /**
      * Returns drop targets that will only be tested for maximized views. (we only need to ensure
      * that the view will become un-maximized -- the regular view test cases will excercise
      * the remainder of the view dragging code). We need to drag each kind of maximized view
      * to something that couldn't be seen while the view is maximized -- like the editor area).
      *
      * @param dragSource
      * @return
      * @since 3.1
      */
     private TestDropLocation[] getMaximizedViewDropTargets(IWorkbenchWindowProvider originatingWindow) {
         return new TestDropLocation[] {
                 new EditorAreaDropTarget(originatingWindow, SWT.RIGHT) };
     }

     private TestDropLocation[] getCommonDropTargets(IWorkbenchWindowProvider dragSource) {
         TestDropLocation[] targets = {
             // Test dragging to the edges of the workbench window
             new WindowDropTarget(dragSource, SWT.TOP),
             new WindowDropTarget(dragSource, SWT.BOTTOM),
             new WindowDropTarget(dragSource, SWT.LEFT),
             new WindowDropTarget(dragSource, SWT.RIGHT) };

 		return targets;
     }

     /**
      * Return all drop targets that only apply to views, given the window being dragged from.
      *
      * @param provider
      * @return
      * @since 3.1
      */
     private TestDropLocation[] getViewDropTargets(IWorkbenchWindowProvider dragSource) {

         String resNav = IPageLayout.ID_RES_NAV;
         String probView = IPageLayout.ID_PROBLEM_VIEW;

         TestDropLocation[] targets = new TestDropLocation[] {
             // Editor area
             new EditorAreaDropTarget(dragSource, SWT.LEFT),
             new EditorAreaDropTarget(dragSource, SWT.RIGHT),
             new EditorAreaDropTarget(dragSource, SWT.TOP),
             new EditorAreaDropTarget(dragSource, SWT.BOTTOM),

             // Resource navigator (a view that isn't in a stack)
             new ViewDropTarget(dragSource, resNav, SWT.LEFT),
             new ViewDropTarget(dragSource, resNav, SWT.RIGHT),
             new ViewDropTarget(dragSource, resNav, SWT.BOTTOM),
             new ViewDropTarget(dragSource, resNav, SWT.CENTER),
             new ViewDropTarget(dragSource, resNav, SWT.TOP),

             // Problems view (a view that is in a stack)
             // Omit the top from this test, since the meaning of dropping on the top border of
             // a stack may change in the near future
             new ViewDropTarget(dragSource, probView, SWT.LEFT),
             new ViewDropTarget(dragSource, probView, SWT.RIGHT),
             new ViewDropTarget(dragSource, probView, SWT.BOTTOM),
             new ViewDropTarget(dragSource, probView, SWT.CENTER),
             new ViewDropTarget(dragSource, probView, SWT.TOP),

             // Fast view bar
             new FastViewBarDropTarget(dragSource),

             // View tabs
             new ViewTabDropTarget(dragSource, resNav),
             new ViewTabDropTarget(dragSource, probView),
             new ViewTitleDropTarget(dragSource, probView),
             };

 		return targets;
     }

     /**
      * Return all drop targets that apply to detached windows, given the window being dragged from.
      *
      * @param provider
      * @return
      * @since 3.1
      */
     private TestDropLocation[] getDetachedWindowDropTargets(IWorkbenchWindowProvider dragSource) {
         TestDropLocation[] targets = new TestDropLocation[] {
             // Editor area
             new ViewDropTarget(dragSource, DragDropPerspectiveFactory.dropViewId1, SWT.CENTER),
             new ViewDropTarget(dragSource, DragDropPerspectiveFactory.dropViewId3, SWT.CENTER),
             new ViewTabDropTarget(dragSource, DragDropPerspectiveFactory.dropViewId1),
             new DetachedDropTarget()
         };

 		return targets;
     }

     private TestDropLocation[] getEditorDropTargets(IWorkbenchWindowProvider originatingWindow) {
         String resNav = IPageLayout.ID_RES_NAV;
         // Drop targets that will only be tested for editors
         return new TestDropLocation[] {
         // A view
                 new ViewDropTarget(originatingWindow, resNav, SWT.CENTER),

                 // A stand-alone editor
                 new EditorDropTarget(originatingWindow, 2, SWT.LEFT),
                 new EditorDropTarget(originatingWindow, 2, SWT.RIGHT),
                 new EditorDropTarget(originatingWindow, 2, SWT.TOP),
                 new EditorDropTarget(originatingWindow, 2, SWT.BOTTOM),
                 new EditorDropTarget(originatingWindow, 2, SWT.CENTER),

                 // Editors (a stack of editors)
                 new EditorDropTarget(originatingWindow, 0, SWT.LEFT),
                 new EditorDropTarget(originatingWindow, 0, SWT.RIGHT),
                 new EditorDropTarget(originatingWindow, 0, SWT.BOTTOM),
                 new EditorDropTarget(originatingWindow, 0, SWT.CENTER),
                 new EditorTabDropTarget(originatingWindow, 0),
                 new EditorTitleDropTarget(originatingWindow, 0),
                 };
     }

     private void addAllCombinations(TestDragSource dragSource,
             TestDropLocation[] dropTargets) {

         for (int destId = 0; destId < dropTargets.length; destId++) {
             DragTest newTest = new DragTest(dragSource, dropTargets[destId], getLog());
             addTest(newTest);
         }
     }

     private void addAllCombinationsDetached(TestDragSource dragSource,
             TestDropLocation[] dropTargets) {

     	if (isDetachingSupported) {
 	        for (int destId = 0; destId < dropTargets.length; destId++) {
 	            DragTest newTest = new DetachedWindowDragTest(dragSource, dropTargets[destId], getLog());
 	            addTest(newTest);
 	        }
     	}
     }

 }
	/*******************************************************************************
	* Copyright (c) 2004, 2005 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
	*******************************************************************************/
	package org.eclipse.ui.tests.dnd;

	import junit.framework.Test;
	import junit.framework.TestSuite;

	import org.eclipse.core.runtime.Path;
	import org.eclipse.core.runtime.Platform;
	import org.eclipse.swt.SWT;
	import org.eclipse.swt.widgets.Composite;
	import org.eclipse.swt.widgets.Shell;
	import org.eclipse.ui.IPageLayout;
	import org.eclipse.ui.internal.dnd.TestDropLocation;
	import org.eclipse.ui.tests.TestPlugin;
	import org.eclipse.ui.tests.autotests.AutoTestSuite;

	/**
	* @since 3.0
	*/
	public class DragTestSuite extends AutoTestSuite {

	/**
	* Returns the suite. This is required to use the JUnit Launcher.
	*/
	public static Test suite() {
	return new DragTestSuite();
	}

	/**
	* Whether the platform we're running on supports the detaching of views.
	* This is initialized in the following static block.
	*
	* @since 3.2
	*/
	private static final boolean isDetachingSupported;

	static {
	Shell shell = new Shell();
	Composite c = new Composite(shell, SWT.NONE);
	isDetachingSupported = c.isReparentable();
	shell.dispose();
	}

	public DragTestSuite() {
	super(Platform.find(TestPlugin.getDefault().getBundle(), new Path("data/dragtests.xml")));

	String resNav = IPageLayout.ID_RES_NAV;
	String probView = IPageLayout.ID_PROBLEM_VIEW;

	// Drag sources for views
	TestDragSource[] viewDragSources = new TestDragSource[] {
	new ViewDragSource(resNav, false),
	new ViewDragSource(resNav, true),
	new ViewDragSource(probView, false),
	new ViewDragSource(probView, true) };

	// Drag sources for editors
	TestDragSource[] editorDragSources = new TestDragSource[] {
	new EditorDragSource(0, false), new EditorDragSource(0, true),
	new EditorDragSource(2, false), new EditorDragSource(2, true) };

	// Drop targets that will only be tested for views

	// Drag sources for maximized views
	TestDragSource[] maximizedViewDragSources = new TestDragSource[] {
	new ViewDragSource(resNav, false, true),
	new ViewDragSource(resNav, true, true),
	new ViewDragSource(probView, false, true),
	new ViewDragSource(probView, true, true) };

	// Now generate all test cases
	for (int i = 0; i < maximizedViewDragSources.length; i++) {
	TestDragSource source = maximizedViewDragSources[i];

	addAllCombinations(source, getMaximizedViewDropTargets(source));
	}

	for (int i = 0; i < viewDragSources.length; i++) {
	TestDragSource source = viewDragSources[i];

	addAllCombinations(source, getViewDropTargets(source));
	addAllCombinations(source, getCommonDropTargets(source));

	// Test dragging onto a detached window
	addAllCombinationsDetached(source, getDetachedWindowDropTargets(source));
	}

	for (int i = 0; i < editorDragSources.length; i++) {
	TestDragSource source = editorDragSources[i];

	addAllCombinations(source, getEditorDropTargets(source));
	addAllCombinations(source, getCommonDropTargets(source));

	// Test dragging onto a detached window
	addAllCombinationsDetached(source, getDetachedWindowDropTargets(source));
	}
	addTest(new TestSuite(Bug87211Test.class));
	}

	/**
	* Returns drop targets that will only be tested for maximized views. (we only need to ensure
	* that the view will become un-maximized -- the regular view test cases will excercise
	* the remainder of the view dragging code). We need to drag each kind of maximized view
	* to something that couldn't be seen while the view is maximized -- like the editor area).
	*
	* @param dragSource
	* @return
	* @since 3.1
	*/
	private TestDropLocation[] getMaximizedViewDropTargets(IWorkbenchWindowProvider originatingWindow) {
	return new TestDropLocation[] {
	new EditorAreaDropTarget(originatingWindow, SWT.RIGHT) };
	}

	private TestDropLocation[] getCommonDropTargets(IWorkbenchWindowProvider dragSource) {
	TestDropLocation[] targets = {
	// Test dragging to the edges of the workbench window
	new WindowDropTarget(dragSource, SWT.TOP),
	new WindowDropTarget(dragSource, SWT.BOTTOM),
	new WindowDropTarget(dragSource, SWT.LEFT),
	new WindowDropTarget(dragSource, SWT.RIGHT) };

	return targets;
	}

	/**
	* Return all drop targets that only apply to views, given the window being dragged from.
	*
	* @param provider
	* @return
	* @since 3.1
	*/
	private TestDropLocation[] getViewDropTargets(IWorkbenchWindowProvider dragSource) {

	String resNav = IPageLayout.ID_RES_NAV;
	String probView = IPageLayout.ID_PROBLEM_VIEW;

	TestDropLocation[] targets = new TestDropLocation[] {
	// Editor area
	new EditorAreaDropTarget(dragSource, SWT.LEFT),
	new EditorAreaDropTarget(dragSource, SWT.RIGHT),
	new EditorAreaDropTarget(dragSource, SWT.TOP),
	new EditorAreaDropTarget(dragSource, SWT.BOTTOM),

	// Resource navigator (a view that isn't in a stack)
	new ViewDropTarget(dragSource, resNav, SWT.LEFT),
	new ViewDropTarget(dragSource, resNav, SWT.RIGHT),
	new ViewDropTarget(dragSource, resNav, SWT.BOTTOM),
	new ViewDropTarget(dragSource, resNav, SWT.CENTER),
	new ViewDropTarget(dragSource, resNav, SWT.TOP),

	// Problems view (a view that is in a stack)
	// Omit the top from this test, since the meaning of dropping on the top border of
	// a stack may change in the near future
	new ViewDropTarget(dragSource, probView, SWT.LEFT),
	new ViewDropTarget(dragSource, probView, SWT.RIGHT),
	new ViewDropTarget(dragSource, probView, SWT.BOTTOM),
	new ViewDropTarget(dragSource, probView, SWT.CENTER),
	new ViewDropTarget(dragSource, probView, SWT.TOP),

	// Fast view bar
	new FastViewBarDropTarget(dragSource),

	// View tabs
	new ViewTabDropTarget(dragSource, resNav),
	new ViewTabDropTarget(dragSource, probView),
	new ViewTitleDropTarget(dragSource, probView),
	};

	return targets;
	}

	/**
	* Return all drop targets that apply to detached windows, given the window being dragged from.
	*
	* @param provider
	* @return
	* @since 3.1
	*/
	private TestDropLocation[] getDetachedWindowDropTargets(IWorkbenchWindowProvider dragSource) {
	TestDropLocation[] targets = new TestDropLocation[] {
	// Editor area
	new ViewDropTarget(dragSource, DragDropPerspectiveFactory.dropViewId1, SWT.CENTER),
	new ViewDropTarget(dragSource, DragDropPerspectiveFactory.dropViewId3, SWT.CENTER),
	new ViewTabDropTarget(dragSource, DragDropPerspectiveFactory.dropViewId1),
	new DetachedDropTarget()
	};

	return targets;
	}

	private TestDropLocation[] getEditorDropTargets(IWorkbenchWindowProvider originatingWindow) {
	String resNav = IPageLayout.ID_RES_NAV;
	// Drop targets that will only be tested for editors
	return new TestDropLocation[] {
	// A view
	new ViewDropTarget(originatingWindow, resNav, SWT.CENTER),

	// A stand-alone editor
	new EditorDropTarget(originatingWindow, 2, SWT.LEFT),
	new EditorDropTarget(originatingWindow, 2, SWT.RIGHT),
	new EditorDropTarget(originatingWindow, 2, SWT.TOP),
	new EditorDropTarget(originatingWindow, 2, SWT.BOTTOM),
	new EditorDropTarget(originatingWindow, 2, SWT.CENTER),

	// Editors (a stack of editors)
	new EditorDropTarget(originatingWindow, 0, SWT.LEFT),
	new EditorDropTarget(originatingWindow, 0, SWT.RIGHT),
	new EditorDropTarget(originatingWindow, 0, SWT.BOTTOM),
	new EditorDropTarget(originatingWindow, 0, SWT.CENTER),
	new EditorTabDropTarget(originatingWindow, 0),
	new EditorTitleDropTarget(originatingWindow, 0),
	};
	}

	private void addAllCombinations(TestDragSource dragSource,
	TestDropLocation[] dropTargets) {

	for (int destId = 0; destId < dropTargets.length; destId++) {
	DragTest newTest = new DragTest(dragSource, dropTargets[destId], getLog());
	addTest(newTest);
	}
	}

	private void addAllCombinationsDetached(TestDragSource dragSource,
	TestDropLocation[] dropTargets) {

	if (isDetachingSupported) {
	for (int destId = 0; destId < dropTargets.length; destId++) {
	DragTest newTest = new DetachedWindowDragTest(dragSource, dropTargets[destId], getLog());
	addTest(newTest);
	}
	}
	}

	}