/******************************************************************************
 * Copyright (c) 2007, 2010 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.gmf.tests.runtime.diagram.ui.logic;

import java.util.LinkedList;
import java.util.List;

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

import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.PositionConstants;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.gef.EditDomain;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.EditPartViewer;
import org.eclipse.gef.Request;
import org.eclipse.gef.Tool;
import org.eclipse.gef.commands.Command;
import org.eclipse.gef.palette.ToolEntry;
import org.eclipse.gef.requests.ChangeBoundsRequest;
import org.eclipse.gef.requests.GroupRequest;
import org.eclipse.gef.ui.palette.PaletteViewer;
import org.eclipse.gmf.runtime.diagram.ui.actions.ActionIds;
import org.eclipse.gmf.runtime.diagram.ui.actions.internal.ArrangeAction;
import org.eclipse.gmf.runtime.diagram.ui.actions.internal.GroupAction;
import org.eclipse.gmf.runtime.diagram.ui.actions.internal.SelectAllAction;
import org.eclipse.gmf.runtime.diagram.ui.actions.internal.UngroupAction;
import org.eclipse.gmf.runtime.diagram.ui.editparts.ConnectionEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editparts.GroupEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editparts.ShapeEditPart;
import org.eclipse.gmf.runtime.diagram.ui.figures.IExpandableFigure;
import org.eclipse.gmf.runtime.diagram.ui.geoshapes.type.GeoshapeType;
import org.eclipse.gmf.runtime.diagram.ui.requests.RequestConstants;
import org.eclipse.gmf.runtime.diagram.ui.type.DiagramNotationType;
import org.eclipse.gmf.runtime.emf.type.core.ElementTypeRegistry;
import org.eclipse.gmf.runtime.emf.type.core.IElementType;
import org.eclipse.gmf.runtime.notation.View;
import org.eclipse.gmf.tests.runtime.diagram.ui.AbstractTestBase;
import org.eclipse.gmf.tests.runtime.diagram.ui.util.ITestActionCallback;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.widgets.Event;

/**
 * Tests for group and ungroup functionality.
 * 
 * @author crevells
 */
public class GroupTests
    extends AbstractTestBase {

    public static Test suite() {
        TestSuite s = new TestSuite(GroupTests.class);
        return s;
    }

    public GroupTests() {
        super("Group Tests");//$NON-NLS-1$
    }

    public class GroupTestFixture
        extends LogicTestFixture {

        protected void createShapesAndConnectors()
            throws Exception {
            // do nothing, each test will create the shapes it wants
        }
    }

    protected void setTestFixture() {
        testFixture = new GroupTestFixture();
    }

    protected LogicTestFixture getFixture() {
        return (LogicTestFixture) testFixture;
    }

    /** the shape in the north-east */
    protected View neView;

    /** the shape in the north-west */
    protected View nwView;

    /** the shape in the south-east */
    protected View seView;

    /** the shape in the south-west */
    protected View swView;

    /**
     * Create the four shapes to be used to test grouping.
     */
    protected void setupShapes() {

        IElementType CIRCUIT_TYPE = ElementTypeRegistry.getInstance().getType(
            "logic.circuit"); //$NON-NLS-1$

        ShapeEditPart nwCircuitEP = getFixture().createShapeUsingTool(
            CIRCUIT_TYPE, new Point(10, 10), new Dimension(50, 50),
            getContainerEP());

        ShapeEditPart neNoteEP = getFixture().createShapeUsingTool(
            DiagramNotationType.NOTE, new Point(100, 10),
            new Dimension(50, 50), getContainerEP());

        ShapeEditPart swGeoshapeEP = getFixture().createShapeUsingTool(
            DiagramNotationType.NOTE, new Point(10, 100),
            new Dimension(50, 50), getContainerEP());

        ShapeEditPart seCircuitEP = getFixture().createShapeUsingTool(
            CIRCUIT_TYPE, new Point(100, 100), new Dimension(50, 50),
            getContainerEP());

        flushEventQueue();

        // Cache the views so we can find the editparts again later.
        nwView = (View) nwCircuitEP.getModel();
        neView = (View) neNoteEP.getModel();
        swView = (View) swGeoshapeEP.getModel();
        seView = (View) seCircuitEP.getModel();

        // Create some connections just to make things more complicated.
        getFixture().createConnectorUsingTool(swGeoshapeEP, nwCircuitEP,
            GeoshapeType.LINE);
        getFixture().createConnectorUsingTool(neNoteEP, seCircuitEP,
            GeoshapeType.LINE);
        getFixture().createConnectorUsingTool(neNoteEP, swGeoshapeEP,
            GeoshapeType.LINE);
        getFixture().createConnectorUsingTool(swGeoshapeEP, seCircuitEP,
            GeoshapeType.LINE);

        flushEventQueue();
    }

    protected IGraphicalEditPart getContainerEP() {
        return getDiagramEditPart();
    }

    protected ShapeEditPart getNWShape() {
        return (ShapeEditPart) findEditPart(nwView);
    }

    protected ShapeEditPart getNEShape() {
        return (ShapeEditPart) findEditPart(neView);
    }

    protected ShapeEditPart getSWShape() {
        return (ShapeEditPart) findEditPart(swView);
    }

    protected ShapeEditPart getSEShape() {
        return (ShapeEditPart) findEditPart(seView);
    }

    protected void setupShapesAndGroups() {
        setupShapes();

        List<ShapeEditPart> shapes = new LinkedList<ShapeEditPart>();
        shapes.add(getNWShape());
        shapes.add(getSWShape());

        GroupEditPart groupEP = groupShapes(shapes);

        shapes.clear();
        shapes.add(groupEP);
        shapes.add(getNEShape());

        groupShapes(shapes);

        assertEquals(2, getContainerEP().getChildren().size());
        assertEquals(2, getOuterGroupEP().getChildren().size());
        assertEquals(2, getInnerGroupEP().getChildren().size());
    }

    protected GroupEditPart getInnerGroupEP() {
        return (GroupEditPart) getNWShape().getParent();
    }

    protected GroupEditPart getOuterGroupEP() {
        return (GroupEditPart) getNEShape().getParent();
    }

    protected GroupEditPart groupShapes(List<ShapeEditPart> editparts) {
        View childView = (View) editparts.get(0).getModel();

        GroupRequest request = new GroupRequest(ActionIds.ACTION_GROUP);
        request.setEditParts(editparts);
        Command cmd = editparts.get(0).getParent().getCommand(request);
        assertTrue(cmd.canExecute());
        getCommandStack().execute(cmd);
        flushEventQueue();

        EditPart groupEP = findEditPart(childView).getParent();
        assertTrue(groupEP instanceof GroupEditPart);
        return (GroupEditPart) groupEP;
    }

    protected Tool getSelectionToolFromPalette() {
        PaletteViewer paletteViewer = getDiagramEditPart().getViewer()
            .getEditDomain().getPaletteViewer();
        ToolEntry selectionTool = paletteViewer.getPaletteRoot()
            .getDefaultEntry();
        paletteViewer.setActiveTool(selectionTool);
        Tool tool = selectionTool.createTool();
        tool.setEditDomain((EditDomain) getDiagramWorkbenchPart()
            .getDiagramEditDomain());
        return tool;
    }

    /**
     * @return
     */
    protected IGraphicalEditPart findEditPart(View view) {
        return (IGraphicalEditPart) getDiagramEditPart().getViewer()
            .getEditPartRegistry().get(view);
    }

    protected MouseEvent createMouseEvent(int x, int y) {
        Event e = new Event();

        e.widget = getDiagramEditPart().getViewer().getControl();
        ;
        e.display = e.widget.getDisplay();
        e.button = 1; // left button
        e.x = x;
        e.y = y;

        return new MouseEvent(e);
    }

    protected MouseEvent createRightMouseEvent(int x, int y) {
        Event e = new Event();

        e.widget = getDiagramEditPart().getViewer().getControl();
        ;
        e.display = e.widget.getDisplay();
        e.button = 3; // right button
        e.x = x;
        e.y = y;

        return new MouseEvent(e);
    }

    protected Rectangle getAbsoluteBounds(IGraphicalEditPart editpart) {
        IFigure figure = editpart.getFigure();
        Rectangle bounds = (figure instanceof IExpandableFigure) ? ((IExpandableFigure) figure)
            .getExtendedBounds().getCopy()
            : figure.getBounds().getCopy();
        editpart.getFigure().translateToAbsolute(bounds);
        return bounds;
    }

    protected void assertNotEquals(Object object1, Object object2) {
        assertFalse(object1.equals(object2));
    }

    public void testGroupCommandAndUndoRedo()
        throws Exception {

        setupShapes();

        // Group the NE shape and the SE shape and test undo/redo of the action.
        List<ShapeEditPart> shapes = new LinkedList<ShapeEditPart>();
        shapes.add(getNWShape());
        shapes.add(getSWShape());

        GroupEditPart group1EP = groupShapes(shapes);

        assertEquals(3, getContainerEP().getChildren().size());
        assertEquals(group1EP, getSWShape().getParent());
        assertEquals(group1EP.getParent(), getContainerEP());
        assertEquals(2, group1EP.getChildren().size());
        assertEquals(getAbsoluteBounds(group1EP), getAbsoluteBounds(
            getNWShape()).union(getAbsoluteBounds(getSWShape())));

        assertTrue(getCommandStack().canUndo());
        getCommandStack().undo();
        flushEventQueue();

        assertEquals(getContainerEP(), getNWShape().getParent());
        assertEquals(getSWShape().getParent(), getContainerEP());
        assertEquals(4, getContainerEP().getChildren().size());

        assertTrue(getCommandStack().canRedo());
        getCommandStack().redo();
        flushEventQueue();

        group1EP = (GroupEditPart) getNWShape().getParent();
        assertEquals(group1EP, getSWShape().getParent());
        assertEquals(group1EP.getParent(), getContainerEP());
        assertEquals(2, group1EP.getChildren().size());
        assertEquals(3, getContainerEP().getChildren().size());
        assertEquals(getAbsoluteBounds(group1EP), getAbsoluteBounds(
            getNWShape()).union(getAbsoluteBounds(getSWShape())));

        // Group group1 and the NE shape and test undo/redo of the action.

        shapes.clear();
        shapes.add(group1EP);
        shapes.add(getNEShape());

        GroupEditPart group2EP = groupShapes(shapes);

        group1EP = (GroupEditPart) getNWShape().getParent();

        assertEquals(group1EP, getSWShape().getParent());
        assertEquals(group2EP, group1EP.getParent());
        assertEquals(group2EP, getNEShape().getParent());
        assertEquals(getContainerEP(), group2EP.getParent());
        assertEquals(2, group1EP.getChildren().size());
        assertEquals(2, group2EP.getChildren().size());
        assertEquals(2, getContainerEP().getChildren().size());
        assertEquals(getAbsoluteBounds(group2EP), getAbsoluteBounds(
            getNEShape()).union(getAbsoluteBounds(group1EP)));

        assertTrue(getCommandStack().canUndo());
        getCommandStack().undo();
        flushEventQueue();

        group1EP = (GroupEditPart) getNWShape().getParent();
        assertEquals(getContainerEP(), group1EP.getParent());
        assertEquals(getContainerEP(), getNEShape().getParent());
        assertEquals(3, getContainerEP().getChildren().size());

        assertTrue(getCommandStack().canRedo());
        getCommandStack().redo();
        flushEventQueue();

        group1EP = (GroupEditPart) getNWShape().getParent();
        group2EP = (GroupEditPart) getNEShape().getParent();
        assertEquals(group2EP, group1EP.getParent());
        assertEquals(getContainerEP(), group2EP.getParent());
        assertEquals(2, group1EP.getChildren().size());
        assertEquals(2, group2EP.getChildren().size());
        assertEquals(2, getContainerEP().getChildren().size());
        assertEquals(getAbsoluteBounds(group2EP), getAbsoluteBounds(
            getNEShape()).union(getAbsoluteBounds(group1EP)));
    }

    public void testUngroupCommandAndUndoRedo()
        throws Exception {

        setupShapesAndGroups();

        // Ungroup the top-level group.
        Request request = new Request(ActionIds.ACTION_UNGROUP);
        Command cmd = getOuterGroupEP().getCommand(request);
        assertTrue(cmd.canExecute());
        getCommandStack().execute(cmd);
        // flushEventQueue();

        assertEquals(3, getContainerEP().getChildren().size());
        assertEquals(getContainerEP(), getInnerGroupEP().getParent());
        assertEquals(getContainerEP(), getNEShape().getParent());

        // Undo the ungroup of the top-level group.
        assertTrue(getCommandStack().canUndo());
        getCommandStack().undo();

        assertEquals(2, getContainerEP().getChildren().size());
        assertEquals(getOuterGroupEP(), getInnerGroupEP().getParent());
        assertEquals(2, getOuterGroupEP().getChildren().size());

        // Redo the ungroup of the top-level group.
        assertTrue(getCommandStack().canRedo());
        getCommandStack().redo();
        // flushEventQueue();

        assertEquals(3, getContainerEP().getChildren().size());
        assertEquals(getContainerEP(), getInnerGroupEP().getParent());
        assertEquals(getContainerEP(), getNEShape().getParent());
    }

    public void testGroupIsSelectedAfterGroupAction()
        throws Exception {

        setupShapes();

        List<ShapeEditPart> shapes = new LinkedList<ShapeEditPart>();
        shapes.add(getNWShape());
        shapes.add(getSWShape());

        GroupAction action = new GroupAction(getWorkbenchPage());
        getWorkbenchPage().activate(getDiagramWorkbenchPart());
        action.init();

        EditPartViewer viewer = getDiagramWorkbenchPart()
            .getDiagramGraphicalViewer();
        viewer.deselectAll();
        viewer.setSelection(new StructuredSelection(shapes));

        action.refresh();
        assertTrue(action.isEnabled());
        action.run();
        action.dispose();

        flushEventQueue();

        assertEquals(1, ((StructuredSelection) viewer.getSelection()).size());
        assertTrue(((StructuredSelection) viewer.getSelection())
            .getFirstElement() instanceof GroupEditPart);
    }

    @SuppressWarnings("unchecked")
	public void testGroupActionEnablement()
        throws Exception {
        setupShapes();

        GroupAction action = new GroupAction(getWorkbenchPage());
        getWorkbenchPage().activate(getDiagramWorkbenchPart());
        action.init();

        EditPartViewer viewer = getDiagramWorkbenchPart()
            .getDiagramGraphicalViewer();
        viewer.deselectAll();

        // should be disabled when there is only one shape and connections are included in the selection
        List<EditPart> selection = new LinkedList<EditPart>(getDiagramEditPart().getConnections());
        selection.add(getNWShape());
        viewer.setSelection(new StructuredSelection(selection));
        action.refresh();
        assertFalse(action.isEnabled());
        
        // should be enabled when connections are included in the selection
        selection = new LinkedList<EditPart>(getDiagramEditPart().getConnections());
        selection.addAll(getContainerEP().getChildren());
        viewer.setSelection(new StructuredSelection(selection));
        action.refresh();
        assertTrue(action.isEnabled());

        // should be disabled when only one shape is selected
        viewer.setSelection(new StructuredSelection(getNWShape()));
        action.refresh();
        assertFalse(action.isEnabled());

        // should be disabled when only connections are selected
        viewer.setSelection(new StructuredSelection(getDiagramEditPart()
            .getConnections()));
        action.refresh();
        assertFalse(action.isEnabled());

        // should be enabled on groups
        List<ShapeEditPart> shapes = new LinkedList<ShapeEditPart>();
        shapes.add(getNWShape());
        shapes.add(getSWShape());
        GroupEditPart groupEP = groupShapes(shapes);
        shapes.clear();
        shapes.add(groupEP);
        shapes.add(getNEShape());
        viewer.setSelection(new StructuredSelection(shapes));
        action.refresh();
        assertTrue(action.isEnabled());

        // should be disabled on uneditable diagrams
        getContainerEP().disableEditMode();
        action.refresh();
        assertFalse(action.isEnabled());
    }

    public void testUngroupActionEnablement()
        throws Exception {
        setupShapes();

        List<ShapeEditPart> shapes = new LinkedList<ShapeEditPart>();
        shapes.add(getNWShape());
        shapes.add(getSWShape());
        GroupEditPart group1EP = groupShapes(shapes);

        shapes.clear();
        shapes.add(getNEShape());
        shapes.add(getSEShape());
        GroupEditPart group2EP = groupShapes(shapes);

        UngroupAction action = new UngroupAction(getWorkbenchPage());
        getWorkbenchPage().activate(getDiagramWorkbenchPart());
        action.init();

        EditPartViewer viewer = getDiagramWorkbenchPart()
            .getDiagramGraphicalViewer();
        viewer.deselectAll();

        // should be enabled when one group is selected
        viewer.setSelection(new StructuredSelection(getInnerGroupEP()));
        action.refresh();
        assertTrue(action.isEnabled());

        // should be enabled when multiple groups are selected
        List<ShapeEditPart> groups = new LinkedList<ShapeEditPart>();
        groups.add(group1EP);
        groups.add(group2EP);
        viewer.setSelection(new StructuredSelection(groups));
        action.refresh();
        assertTrue(action.isEnabled());
    }

    public void testSelectGroupWithClickAndDrag()
        throws Exception {

        setupShapesAndGroups();

        EditPartViewer viewer = getDiagramEditPart().getViewer();
        PaletteViewer paletteViewer = viewer.getEditDomain().getPaletteViewer();

        ToolEntry selectionTool = paletteViewer.getPaletteRoot()
            .getDefaultEntry();
        paletteViewer.setActiveTool(selectionTool);
        Tool tool = selectionTool.createTool();
        tool.setEditDomain((EditDomain) getDiagramWorkbenchPart()
            .getDiagramEditDomain());

        // draw rubber band around all the shapes
        viewer.getSelectionManager().deselectAll();
        tool.activate();
        tool.mouseDown(createMouseEvent(0, 0), viewer);
        tool.mouseDrag(createMouseEvent(200, 200), viewer);
        tool.mouseUp(createMouseEvent(200, 200), viewer);
        tool.deactivate();

        // size should be 6: 1 group, 1 shape, 4 connections
        assertEquals(6, viewer.getSelectedEditParts().size());
        assertTrue(viewer.getSelectedEditParts().contains(getOuterGroupEP()));
    }

    public void testSelectGroupWithRightClick()
        throws Exception {

        setupShapesAndGroups();

        Tool tool = getSelectionToolFromPalette();

        // click on a shape in the outer group and the outer group should be
        // selected
        EditPartViewer viewer = getDiagramEditPart().getViewer();
        viewer.getSelectionManager().deselectAll();
        tool.activate();
        Point point = getAbsoluteBounds(getNEShape()).getCenter();
        tool.mouseDown(createMouseEvent(point.x, point.y), viewer);
        tool.mouseUp(createMouseEvent(point.x, point.y), viewer);

        assertEquals(1, viewer.getSelectedEditParts().size());
        assertTrue(viewer.getSelectedEditParts().contains(getOuterGroupEP()));

        // right-click on the same shape a second time and the group should
        // still be
        // selected
        tool.mouseDown(createRightMouseEvent(point.x, point.y), viewer);
        tool.mouseUp(createRightMouseEvent(point.x, point.y), viewer);

        assertEquals(1, viewer.getSelectedEditParts().size());
        assertTrue(viewer.getSelectedEditParts().contains(getOuterGroupEP()));
    }

    public void testSelectShapesAndGroupsWithClick()
        throws Exception {

        setupShapesAndGroups();

        Tool tool = getSelectionToolFromPalette();

        // click on a shape in the outer group and the outer group should be
        // selected
        EditPartViewer viewer = getDiagramEditPart().getViewer();
        viewer.getSelectionManager().deselectAll();
        tool.activate();
        Point point = getAbsoluteBounds(getNEShape()).getCenter();
        tool.mouseDown(createMouseEvent(point.x, point.y), viewer);
        tool.mouseUp(createMouseEvent(point.x, point.y), viewer);

        assertEquals(1, viewer.getSelectedEditParts().size());
        assertTrue(viewer.getSelectedEditParts().contains(getOuterGroupEP()));

        // click on the same shape a second time and the shape should be
        // selected
        tool.mouseDown(createMouseEvent(point.x, point.y), viewer);
        tool.mouseUp(createMouseEvent(point.x, point.y), viewer);

        assertEquals(1, viewer.getSelectedEditParts().size());
        assertTrue(viewer.getSelectedEditParts().contains(getNEShape()));

        // right-click on the same shape and it should remain selected
        tool.mouseDown(createRightMouseEvent(point.x, point.y), viewer);
        tool.mouseUp(createRightMouseEvent(point.x, point.y), viewer);

        assertEquals(1, viewer.getSelectedEditParts().size());
        assertTrue(viewer.getSelectedEditParts().contains(getNEShape()));

        // click on a shape not in the group and that shape itself should be
        // selected
        viewer.getSelectionManager().deselectAll();
        point = getAbsoluteBounds(getSEShape()).getCenter();
        tool.mouseDown(createMouseEvent(point.x, point.y), viewer);
        tool.mouseUp(createMouseEvent(point.x, point.y), viewer);

        assertEquals(1, viewer.getSelectedEditParts().size());
        assertTrue(viewer.getSelectedEditParts().contains(getSEShape()));

        // click on an area of blank space in a group and nothing should be
        // selected
        viewer.getSelectionManager().deselectAll();
        point = getAbsoluteBounds(getNWShape()).getBottom();
        Point point2 = getAbsoluteBounds(getSWShape()).getTop();
        point.translate(0, (point2.y - point.y) / 2);
        tool.mouseDown(createMouseEvent(point.x, point.y), viewer);
        tool.mouseUp(createMouseEvent(point.x, point.y), viewer);

        assertTrue(
            "should be empty unless we happened to click on one of the lines", //$NON-NLS-1$
            viewer.getSelectedEditParts().isEmpty()
                || viewer.getSelectedEditParts().get(0) instanceof ConnectionEditPart);

        // click on a shape in the inner group and the outer group should be
        // selected
        viewer.getSelectionManager().deselectAll();
        point = getAbsoluteBounds(getNWShape()).getCenter();
        tool.mouseDown(createMouseEvent(point.x, point.y), viewer);
        tool.mouseUp(createMouseEvent(point.x, point.y), viewer);

        assertEquals(1, viewer.getSelectedEditParts().size());
        assertTrue(viewer.getSelectedEditParts().contains(getOuterGroupEP()));

        // click on the same shape a second time and the inner group should be
        // selected
        tool.mouseDown(createMouseEvent(point.x, point.y), viewer);
        tool.mouseUp(createMouseEvent(point.x, point.y), viewer);

        assertEquals(1, viewer.getSelectedEditParts().size());
        assertTrue(viewer.getSelectedEditParts().contains(getInnerGroupEP()));

        // click on the same shape a third time and the shape itself should be
        // selected
        tool.mouseDown(createMouseEvent(point.x, point.y), viewer);
        tool.mouseUp(createMouseEvent(point.x, point.y), viewer);

        assertEquals(1, viewer.getSelectedEditParts().size());
        assertTrue(viewer.getSelectedEditParts().contains(getNWShape()));

        tool.deactivate();
    }

    public void testSelectGroupWithClickOddScenario()
        throws Exception {

        setupShapes();

        List<ShapeEditPart> shapes = new LinkedList<ShapeEditPart>();
        shapes.add(getNWShape());
        shapes.add(getSWShape());

        GroupEditPart group1EP = groupShapes(shapes);

        shapes.clear();
        shapes.add(getNEShape());
        shapes.add(getSEShape());

        GroupEditPart group2EP = groupShapes(shapes);

        shapes.clear();
        shapes.add(group1EP);
        shapes.add(group2EP);

        GroupEditPart outerGroupEP = groupShapes(shapes);

        Tool tool = getSelectionToolFromPalette();

        // click on a shape and the outer group should be
        // selected
        EditPartViewer viewer = getDiagramEditPart().getViewer();
        viewer.getSelectionManager().deselectAll();
        tool.activate();
        Point point = getAbsoluteBounds(getNEShape()).getCenter();
        tool.mouseDown(createMouseEvent(point.x, point.y), viewer);
        tool.mouseUp(createMouseEvent(point.x, point.y), viewer);

        assertEquals(1, viewer.getSelectedEditParts().size());
        assertTrue(viewer.getSelectedEditParts().contains(outerGroupEP));

        tool.deactivate();
    }

    /**
     * This ensure that when a group is created you can select a connection that
     * exists between shapes in the group. The issue was that the connection
     * editpart was not active.
     * 
     * This fails because of GEF Bugzilla 174085.
     * 
     * @throws Exception
     */
    public void testSelectConnectionInGroupWithClick()
        throws Exception {

        setupShapes();

        List<ShapeEditPart> shapes = new LinkedList<ShapeEditPart>();
        shapes.add(getNWShape());
        shapes.add(getSWShape());
        GroupEditPart groupEP = groupShapes(shapes);

        ConnectionEditPart connectionEP = (ConnectionEditPart) getNWShape()
            .getTargetConnections().get(0);

        Tool tool = getSelectionToolFromPalette();
        EditPartViewer viewer = getDiagramEditPart().getViewer();
        viewer.getSelectionManager().deselectAll();
        tool.activate();

        Point point = getAbsoluteBounds(connectionEP).getCenter();
        tool.mouseDown(createMouseEvent(point.x, point.y), viewer);
        tool.mouseUp(createMouseEvent(point.x, point.y), viewer);

        assertEquals(1, viewer.getSelectedEditParts().size());
        assertEquals(connectionEP, viewer.getSelectedEditParts().get(0));
        assertTrue(connectionEP.isActive());
        assertTrue(connectionEP.getSource().isActive());
        assertEquals(groupEP, connectionEP.getSource().getParent());
        assertTrue(connectionEP.getTarget().isActive());
        assertEquals(groupEP, connectionEP.getTarget().getParent());

        tool.deactivate();
    }

    public void disabledM6testMoveGroup()
        throws Exception {

        setupShapesAndGroups();

        Tool tool = getSelectionToolFromPalette();

        Rectangle origGroupBounds = getAbsoluteBounds(getInnerGroupEP());
        Rectangle origNEShapeBounds = getAbsoluteBounds(getNWShape());
        Rectangle origSEShapeBounds = getAbsoluteBounds(getSWShape());

        Point offset = new Point(25, 25);

        // Click and drag the group in one gesture.
        EditPartViewer viewer = getDiagramEditPart().getViewer();
        viewer.getSelectionManager().deselectAll();
        tool.activate();
        Point point = origNEShapeBounds.getCenter();
        tool.mouseDown(createMouseEvent(point.x, point.y), viewer);
        point.translate(offset);
        tool.mouseDrag(createMouseEvent(point.x, point.y), viewer);
        tool.mouseUp(createMouseEvent(point.x, point.y), viewer);
        tool.deactivate();
        flushEventQueue();

        // Cannot test the exact bounds because I can't figure out what the
        // exact bounds should be (maybe there are rounding issues?) so the
        // tests here will have to do.
        Dimension resultingOffset = origGroupBounds.getLocation()
            .getDifference(getAbsoluteBounds(getInnerGroupEP()).getLocation());
        assertTrue(resultingOffset.height != 0 && resultingOffset.width != 0);
        assertEquals(resultingOffset, origNEShapeBounds.getLocation()
            .getDifference(getAbsoluteBounds(getNWShape()).getLocation()));
        assertEquals(resultingOffset, origSEShapeBounds.getLocation()
            .getDifference(getAbsoluteBounds(getSWShape()).getLocation()));

        // Now select the group first and then click over a shape and drag. This
        // should move the group.
        origGroupBounds = getAbsoluteBounds(getInnerGroupEP());
        origNEShapeBounds = getAbsoluteBounds(getNWShape());
        origSEShapeBounds = getAbsoluteBounds(getSWShape());
        point = origNEShapeBounds.getCenter();
        offset = new Point(-25, -25);

        viewer.getSelectionManager().deselectAll();
        viewer.select(getInnerGroupEP());
        tool.activate();

        tool.mouseDown(createMouseEvent(point.x, point.y), viewer);
        point.translate(offset);
        tool.mouseDrag(createMouseEvent(point.x, point.y), viewer);
        tool.mouseUp(createMouseEvent(point.x, point.y), viewer);
        tool.deactivate();

        flushEventQueue();

        // Cannot test the exact bounds because I can't figure out what the
        // exact bounds should be (maybe there are rounding issues?) so the
        // tests here will have to do.
        resultingOffset = origGroupBounds.getLocation().getDifference(
            getAbsoluteBounds(getInnerGroupEP()).getLocation());
        assertTrue(resultingOffset.height != 0 && resultingOffset.width != 0);

        resultingOffset = origNEShapeBounds.getLocation().getDifference(
            getAbsoluteBounds(getNWShape()).getLocation());
        assertTrue(resultingOffset.height != 0 && resultingOffset.width != 0);

        resultingOffset = origSEShapeBounds.getLocation().getDifference(
            getAbsoluteBounds(getSWShape()).getLocation());
        assertTrue(resultingOffset.height != 0 && resultingOffset.width != 0);

        // Confirm sizes are still the same.
        assertEquals(origGroupBounds.getSize(), getAbsoluteBounds(
            getInnerGroupEP()).getSize());
        assertEquals(origNEShapeBounds.getSize(), getAbsoluteBounds(
            getNWShape()).getSize());
        assertEquals(origSEShapeBounds.getSize(), getAbsoluteBounds(
            getSWShape()).getSize());
    }

    public void testMoveShapeInGroup2()
        throws Exception {

        setupShapesAndGroups();

        Rectangle origNEShapeBounds = getAbsoluteBounds(getNWShape());
        Rectangle origSEShapeBounds = getAbsoluteBounds(getSWShape());

        // Move NEShape.
        ChangeBoundsRequest request = new ChangeBoundsRequest(
            RequestConstants.REQ_MOVE);
        request.setMoveDelta(new Point(-20, -20));
        request.setEditParts(getNWShape());
        getNWShape().getCommand(request).execute();
        flushEventQueue();

        assertNotEquals(origNEShapeBounds, getAbsoluteBounds(getNWShape()));
        assertEquals(origSEShapeBounds, getAbsoluteBounds(getSWShape()));
        assertEquals(getAbsoluteBounds(getNWShape()).union(
            getAbsoluteBounds(getSWShape())),
            getAbsoluteBounds(getInnerGroupEP()));
        assertEquals(getAbsoluteBounds(getNEShape()).union(
            getAbsoluteBounds(getInnerGroupEP())),
            getAbsoluteBounds(getOuterGroupEP()));

        // Move the NE shape back to where it was.
        request.setMoveDelta(new Point(20, 20));
        getNWShape().getCommand(request).execute();
        flushEventQueue();

        assertEquals(origNEShapeBounds, getAbsoluteBounds(getNWShape()));
        assertEquals(origSEShapeBounds, getAbsoluteBounds(getSWShape()));
        assertEquals(getAbsoluteBounds(getNWShape()).union(
            getAbsoluteBounds(getSWShape())),
            getAbsoluteBounds(getInnerGroupEP()));
        assertEquals(getAbsoluteBounds(getNEShape()).union(
            getAbsoluteBounds(getInnerGroupEP())),
            getAbsoluteBounds(getOuterGroupEP()));

        // Move the NE shape out beyond the bottom-right of the group.
        request.setMoveDelta(getAbsoluteBounds(getOuterGroupEP())
            .getBottomRight().getTranslated(20, 20));
        getNWShape().getCommand(request).execute();
        flushEventQueue();

        assertNotEquals(origNEShapeBounds.getLocation(), getAbsoluteBounds(
            getNWShape()).getLocation());
        assertEquals(origSEShapeBounds.getLocation(), getAbsoluteBounds(
            getSWShape()).getLocation());
        assertEquals(getAbsoluteBounds(getNWShape()).union(
            getAbsoluteBounds(getSWShape())),
            getAbsoluteBounds(getInnerGroupEP()));
        assertEquals(getAbsoluteBounds(getNEShape()).union(
            getAbsoluteBounds(getInnerGroupEP())),
            getAbsoluteBounds(getOuterGroupEP()));
    }

    public void testUngroupShapesMaintainsShapeLocations()
        throws Exception {

        setupShapesAndGroups();

        // Ungroup the inner group.

        // First cache the bounds in absolute coordinates of one of the figures.
        Rectangle origSEShapeBounds = getAbsoluteBounds(getSWShape());

        // Perform the ungroup.
        Request request = new Request(ActionIds.ACTION_UNGROUP);
        Command cmd = getInnerGroupEP().getCommand(request);
        assertTrue(cmd.canExecute());
        getCommandStack().execute(cmd);
        flushEventQueue();

        // Test that the bounds in absolute have not changed.
        assertEquals(origSEShapeBounds, getAbsoluteBounds(getSWShape()));

        // Ungroup the outer group.

        // First cache the bounds in absolute coordinates of one of the figures.
        Rectangle origNWShapeBounds = getAbsoluteBounds(getNEShape());

        // Perform the ungroup.
        request = new Request(ActionIds.ACTION_UNGROUP);
        cmd = getInnerGroupEP().getCommand(request);
        assertTrue(cmd.canExecute());
        getCommandStack().execute(cmd);
        flushEventQueue();

        // Test that the bounds in absolute have not changed.
        assertEquals(origNWShapeBounds, getAbsoluteBounds(getNEShape()));
    }

    public void testDeleteShapeInGroup()
        throws Exception {

        setupShapes();

        List<ShapeEditPart> shapes = new LinkedList<ShapeEditPart>();
        shapes.add(getNWShape());
        shapes.add(getSWShape());
        shapes.add(getSEShape());

        GroupEditPart groupEP = groupShapes(shapes);

        shapes.clear();
        shapes.add(groupEP);
        shapes.add(getNEShape());

        groupShapes(shapes);

        // Inner group has 3 shapes, outer group has inner group and 1 shape.
        assertEquals(1, getContainerEP().getChildren().size());
        assertEquals(2, getOuterGroupEP().getChildren().size());
        assertEquals(3, getInnerGroupEP().getChildren().size());

        Request request = new GroupRequest(RequestConstants.REQ_DELETE);

        // Delete one shape from the inner group.
        getCommandStack().execute(getSWShape().getCommand(request));

        // Inner group should now have 2 shapes.
        assertEquals(2, getInnerGroupEP().getChildren().size());

        // Delete another shape from the inner group.
        getCommandStack().execute(getNWShape().getCommand(request));

        // Inner group should not exist anymore.
        assertEquals(getOuterGroupEP(), getSEShape().getParent());
        assertEquals(2, getOuterGroupEP().getChildren().size());

        // Now try undo.
        getCommandStack().undo();
        getCommandStack().undo();

        // Inner group has 3 shapes, outer group has inner group and 1 shape.
        assertEquals(1, getContainerEP().getChildren().size());
        assertEquals(2, getOuterGroupEP().getChildren().size());
        assertEquals(3, getInnerGroupEP().getChildren().size());

    }

    /**
     * Resizing a group is not supported yet.
     * 
     * @throws Exception
     */
    public void testCannotResizeGroup()
        throws Exception {

        setupShapesAndGroups();

        ChangeBoundsRequest request = new ChangeBoundsRequest(
            RequestConstants.REQ_RESIZE);
        request.setResizeDirection(PositionConstants.SOUTH);
        request.setEditParts(getOuterGroupEP());
        request.setSizeDelta(new Dimension(0, 100));

        Command cmd = getOuterGroupEP().getCommand(request);
        assertTrue(cmd == null || !cmd.canExecute());
    }

    public void testResizeShapeInGroup()
        throws Exception {

        setupShapesAndGroups();

        Rectangle origNEShapeBounds = getAbsoluteBounds(getNWShape());
        Rectangle origSEShapeBounds = getAbsoluteBounds(getSWShape());

        // Resize the NE shape to the south-west.
        ChangeBoundsRequest request = new ChangeBoundsRequest(
            RequestConstants.REQ_RESIZE);
        request.setResizeDirection(PositionConstants.SOUTH_WEST);
        request.setMoveDelta(new Point(-10, 0));
        request.setEditParts(getNWShape());
        request.setSizeDelta(new Dimension(10, 10));

        getNWShape().getCommand(request).execute();
        flushEventQueue();

        assertNotEquals(origNEShapeBounds.getSize(), getAbsoluteBounds(
            getNWShape()).getSize());
        assertNotEquals(origNEShapeBounds.getLocation(), getAbsoluteBounds(
            getNWShape()).getLocation());
        assertEquals(origSEShapeBounds, getAbsoluteBounds(getSWShape()));
        assertEquals(getAbsoluteBounds(getNWShape()).union(
            getAbsoluteBounds(getSWShape())),
            getAbsoluteBounds(getInnerGroupEP()));

        // Resize the NE shape to the north-east
        origNEShapeBounds = getAbsoluteBounds(getNWShape());
        origSEShapeBounds = getAbsoluteBounds(getSWShape());

        request.setResizeDirection(PositionConstants.NORTH_EAST);
        request.setMoveDelta(new Point(0, -10));
        getNWShape().getCommand(request).execute();
        flushEventQueue();

        assertNotEquals(origNEShapeBounds.getLocation(), getAbsoluteBounds(
            getNWShape()).getLocation());
        assertEquals(origSEShapeBounds, getAbsoluteBounds(getSWShape()));
        assertEquals(getAbsoluteBounds(getNWShape()).union(
            getAbsoluteBounds(getSWShape())),
            getAbsoluteBounds(getInnerGroupEP()));

        // Resize SEShape to the south-east
        origNEShapeBounds = getAbsoluteBounds(getNWShape());
        origSEShapeBounds = getAbsoluteBounds(getSWShape());

        request.setResizeDirection(PositionConstants.SOUTH_EAST);
        request.setMoveDelta(new Point(0, 0));
        request.setEditParts(getSWShape());

        getSWShape().getCommand(request).execute();
        flushEventQueue();

        assertNotEquals(origSEShapeBounds.getSize(), getAbsoluteBounds(
            getSWShape()).getSize());
        assertEquals(origSEShapeBounds.getLocation(), getAbsoluteBounds(
            getSWShape()).getLocation());
        assertEquals(origNEShapeBounds, getAbsoluteBounds(getNWShape()));
        assertEquals(getAbsoluteBounds(getNWShape()).union(
            getAbsoluteBounds(getSWShape())),
            getAbsoluteBounds(getInnerGroupEP()));

        // Resize SEShape to the north-west
        origNEShapeBounds = getAbsoluteBounds(getNWShape());
        origSEShapeBounds = getAbsoluteBounds(getSWShape());

        request.setResizeDirection(PositionConstants.NORTH_WEST);
        request.setMoveDelta(new Point(-10, -10));
        getSWShape().getCommand(request).execute();
        flushEventQueue();

        assertNotEquals(origSEShapeBounds.getSize(), getAbsoluteBounds(
            getSWShape()).getSize());
        assertNotEquals(origSEShapeBounds.getLocation(), getAbsoluteBounds(
            getSWShape()).getLocation());
        assertEquals(origNEShapeBounds, getAbsoluteBounds(getNWShape()));
        assertEquals(getAbsoluteBounds(getNWShape()).union(
            getAbsoluteBounds(getSWShape())),
            getAbsoluteBounds(getInnerGroupEP()));

        // Decrease NEShape's size by 10 on each side.
        origNEShapeBounds = getAbsoluteBounds(getNWShape());
        origSEShapeBounds = getAbsoluteBounds(getSWShape());

        request.setResizeDirection(PositionConstants.NORTH_EAST);
        request.setMoveDelta(new Point(0, 10));
        request.setEditParts(getNWShape());
        request.setSizeDelta(new Dimension(-10, -10));
        getNWShape().getCommand(request).execute();
        flushEventQueue();

        assertNotEquals(origNEShapeBounds, getAbsoluteBounds(getNWShape()));
        assertEquals(origSEShapeBounds, getAbsoluteBounds(getSWShape()));
        assertEquals(getAbsoluteBounds(getNWShape()).union(
            getAbsoluteBounds(getSWShape())),
            getAbsoluteBounds(getInnerGroupEP()));

        request.setResizeDirection(PositionConstants.SOUTH_WEST);
        request.setMoveDelta(new Point(10, 0));
        getNWShape().getCommand(request).execute();
        flushEventQueue();

        assertEquals(origSEShapeBounds, getAbsoluteBounds(getSWShape()));
        assertEquals(getAbsoluteBounds(getNWShape()).union(
            getAbsoluteBounds(getSWShape())),
            getAbsoluteBounds(getInnerGroupEP()));

        // Decrease SEShape's size by 10 on each side.
        origNEShapeBounds = getAbsoluteBounds(getNWShape());
        origSEShapeBounds = getAbsoluteBounds(getNWShape());

        request.setResizeDirection(PositionConstants.SOUTH_EAST);
        request.setMoveDelta(new Point(0, 0));
        request.setEditParts(getSWShape());
        getSWShape().getCommand(request).execute();
        flushEventQueue();

        assertNotEquals(origSEShapeBounds, getSWShape().getFigure().getBounds());
        assertEquals(origNEShapeBounds, getAbsoluteBounds(getNWShape()));
        assertEquals(getAbsoluteBounds(getNWShape()).union(
            getAbsoluteBounds(getSWShape())),
            getAbsoluteBounds(getInnerGroupEP()));

        request.setResizeDirection(PositionConstants.NORTH_WEST);
        request.setMoveDelta(new Point(10, 10));
        getSWShape().getCommand(request).execute();

        assertEquals(origNEShapeBounds, getAbsoluteBounds(getNWShape()));
        assertEquals(getAbsoluteBounds(getNWShape()).union(
            getAbsoluteBounds(getSWShape())),
            getAbsoluteBounds(getInnerGroupEP()));
    }

    public void testDeleteGroup()
        throws Exception {

        setupShapesAndGroups();

        Request request = new GroupRequest(RequestConstants.REQ_DELETE);
        getCommandStack().execute(getOuterGroupEP().getCommand(request));

        assertEquals(1, getContainerEP().getChildren().size());

        getCommandStack().undo();

        assertEquals(2, getContainerEP().getChildren().size());
        assertEquals(2, getOuterGroupEP().getChildren().size());
        assertEquals(2, getInnerGroupEP().getChildren().size());

    }

    public void testSelectActions()
        throws Exception {
        setupShapesAndGroups();

        // test select all
        getContainerEP().getViewer().setSelection(
            new StructuredSelection(getContainerEP()));

        SelectAllAction selectAction = SelectAllAction
            .createSelectAllAction(getWorkbenchPage());

        testAction(selectAction, new ITestActionCallback() {

            public void onRunExecution() {

                List selectedParts = getContainerEP().getViewer()
                    .getSelectedEditParts();

                // 2 shapes and 4 connectors
                assertEquals(6, selectedParts.size());
                assertTrue(selectedParts.contains(getOuterGroupEP()));
                assertTrue(selectedParts.contains(getNEShape()
                    .getSourceConnections().get(0)));
                assertFalse(selectedParts.contains(getNWShape()));

            }
        });

        // test select all shapes
        getContainerEP().getViewer().deselectAll();
        getContainerEP().getViewer().setSelection(
            new StructuredSelection(getContainerEP()));

        selectAction = SelectAllAction
            .createSelectAllShapesAction(getWorkbenchPage());

        testAction(selectAction, new ITestActionCallback() {

            public void onRunExecution() {

                List selectedParts = getContainerEP().getViewer()
                    .getSelectedEditParts();

                // 2 shapes
                assertEquals(2, selectedParts.size());
                assertTrue(selectedParts.contains(getOuterGroupEP()));
                assertTrue(selectedParts.contains(getSEShape()));

            }
        });

        // test select all connections
        getContainerEP().getViewer().deselectAll();
        getContainerEP().getViewer().setSelection(
            new StructuredSelection(getContainerEP()));

        selectAction = SelectAllAction
            .createSelectAllConnectionsAction(getWorkbenchPage());

        testAction(selectAction, new ITestActionCallback() {

            public void onRunExecution() {

                List selectedParts = getContainerEP().getViewer()
                    .getSelectedEditParts();

                // 4 connectors
                assertEquals(4, selectedParts.size());
                assertTrue(selectedParts.contains(getNEShape()
                    .getSourceConnections().get(0)));
            }
        });
    }

    public void disabledM6testArrangeActions()
        throws Exception {
        setupShapesAndGroups();

        // test arrange all
        getContainerEP().getViewer().setSelection(
            new StructuredSelection(getContainerEP()));

        final Rectangle origOuterGroupBounds = getAbsoluteBounds(getOuterGroupEP());
        final Rectangle seShapeBounds = getAbsoluteBounds(getSEShape());

        ArrangeAction arrangeAction = ArrangeAction
            .createArrangeAllAction(getWorkbenchPage());
        testAction(arrangeAction, new ITestActionCallback() {

            public void onRunExecution() {
                assertEquals(origOuterGroupBounds.getSize(), getAbsoluteBounds(
                    getOuterGroupEP()).getSize());
                assertNotEquals(seShapeBounds.getLocation(), getAbsoluteBounds(
                    getSEShape()).getLocation());
            }
        });

        getCommandStack().undo();

        // test arrange selection with a group selected
        getContainerEP().getViewer().deselectAll();
        getContainerEP().getViewer().setSelection(
            new StructuredSelection(getOuterGroupEP()));

        final Rectangle origInnerGroupBounds = getAbsoluteBounds(getInnerGroupEP());
        final Rectangle swShapeBounds = getAbsoluteBounds(getSWShape());

        arrangeAction = ArrangeAction
            .createArrangeSelectionAction(getWorkbenchPage());
        testAction(arrangeAction, new ITestActionCallback() {

            public void onRunExecution() {
                assertAlmostEquals(origInnerGroupBounds.getSize(), getAbsoluteBounds(
                    getInnerGroupEP()).getSize());
                assertNotEquals(swShapeBounds.getLocation(), getAbsoluteBounds(
                    getSWShape()).getLocation());
            }
        });

    }
    
    /**
     * It is possible that two himetric values may be off slightly just because
     * we are mixing doubles and integers in GMF/GEF and there could be slight
     * rounding differences. This method will treat a difference of less than 1
     * as being equal.
     * 
     * @param d1
     * @param d2
     * @return
     */
    private void assertAlmostEquals(Dimension d1, Dimension d2) {
        assertTrue((Math.abs(d1.height - d2.height) <= 1)
            && (Math.abs(d1.width - d2.width) <= 1));
    }

}