| /******************************************************************************* |
| * Copyright (c) 2010, 2019 THALES GLOBAL SERVICES. |
| * 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: |
| * Obeo - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.sirius.tests.swtbot.clipboard; |
| |
| import java.lang.Thread.UncaughtExceptionHandler; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.stream.Collectors; |
| import java.util.stream.Stream; |
| import java.util.stream.StreamSupport; |
| |
| import org.eclipse.core.runtime.ILogListener; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.emf.ecore.EAttribute; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.transaction.TransactionalEditingDomain; |
| import org.eclipse.gef.EditPart; |
| import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart; |
| import org.eclipse.gmf.runtime.notation.Diagram; |
| import org.eclipse.gmf.runtime.notation.Edge; |
| import org.eclipse.gmf.runtime.notation.Node; |
| import org.eclipse.gmf.runtime.notation.View; |
| import org.eclipse.sirius.business.api.session.Session; |
| import org.eclipse.sirius.common.tools.api.util.StringUtil; |
| import org.eclipse.sirius.diagram.DDiagramElement; |
| import org.eclipse.sirius.diagram.DEdge; |
| import org.eclipse.sirius.diagram.DNodeList; |
| import org.eclipse.sirius.diagram.DSemanticDiagram; |
| import org.eclipse.sirius.diagram.ui.internal.edit.parts.DDiagramEditPart; |
| import org.eclipse.sirius.diagram.ui.tools.internal.clipboard.SiriusClipboardManager; |
| import org.eclipse.sirius.tests.swtbot.support.api.AbstractSiriusSwtBotGefTestCase; |
| import org.eclipse.sirius.tests.swtbot.support.api.business.UILocalSession; |
| import org.eclipse.sirius.tests.swtbot.support.api.business.UIResource; |
| import org.eclipse.sirius.tests.swtbot.support.api.condition.CheckSelectedCondition; |
| import org.eclipse.sirius.tests.swtbot.support.api.editor.SWTBotSiriusDiagramEditor; |
| import org.eclipse.sirius.tests.swtbot.support.api.widget.ContextualMenuItemGetter; |
| import org.eclipse.sirius.viewpoint.DSemanticDecorator; |
| import org.eclipse.sirius.viewpoint.IdentifiedElement; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.MenuItem; |
| import org.eclipse.swtbot.eclipse.gef.finder.widgets.SWTBotGefEditPart; |
| import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException; |
| import org.eclipse.swtbot.swt.finder.finders.UIThreadRunnable; |
| import org.eclipse.swtbot.swt.finder.results.Result; |
| import org.eclipse.swtbot.swt.finder.waits.ICondition; |
| import org.eclipse.swtbot.swt.finder.widgets.SWTBotMenu; |
| |
| import com.google.common.collect.Iterables; |
| import com.google.common.collect.LinkedHashMultimap; |
| |
| /** |
| * |
| * @author jdupont |
| */ |
| public abstract class AbstractClipboardSupportTest extends AbstractSiriusSwtBotGefTestCase { |
| |
| /** |
| * The unchaught exceptions handler. |
| */ |
| private UncaughtExceptionHandler exceptionHandler; |
| |
| /** |
| * The platform error listener. |
| */ |
| private ILogListener logListener; |
| |
| /** |
| * The reported errors. |
| */ |
| private LinkedHashMultimap<String, IStatus> errors; |
| |
| /** |
| * Generic representation instance name. |
| */ |
| protected static final String REPRESENTATION_WITH_GENERIC_PASTE = "GenericClipboard"; |
| |
| /** |
| * Custom representation instance name. |
| */ |
| protected static final String REPRESENTATION_WITH_CUSTOM_PASTE = "CustomClipboard"; |
| |
| /** |
| * Generic representation instance name bis. |
| */ |
| protected static final String REPRESENTATION_WITH_GENERIC_PASTE_BIS = "GenericClipboardBis"; |
| |
| /** |
| * Custom representation instance name bis. |
| */ |
| protected static final String REPRESENTATION_WITH_CUSTOM_PASTE_BIS = "CustomClipboardBis"; |
| |
| /** |
| * Semantic model. |
| */ |
| protected static final String MODEL = "1894.ecore"; |
| |
| /** |
| * Semantic model bis. |
| */ |
| protected static final String MODEL_BIS = "1894Bis.ecore"; |
| |
| /** |
| * Sirius name. |
| */ |
| protected static final String GENERIC_VIEWPOINT_NAME = "Design"; |
| |
| /** |
| * Sirius name. |
| */ |
| protected static final String CUSTOM_VIEWPOINT_NAME = "vp-1894"; |
| |
| /** |
| * Sirius name. |
| */ |
| protected static final String GENERIC_DESCRIPTION = "Entities"; |
| |
| /** |
| * Sirius name. |
| */ |
| protected static final String CUSTOM_DESCRIPTION = "diagramWithCustomClipboard"; |
| |
| /** |
| * Sirius specific model. |
| */ |
| protected static final String VSM_FILE = "vp-1894.odesign"; |
| |
| /** |
| * Session file. |
| */ |
| protected static final String SESSION_FILE = "1894.aird"; |
| |
| /** |
| * Session file. |
| */ |
| protected static final String SESSION_FILE_BIS = "1894Bis.aird"; |
| |
| /** |
| * Repository for data test. |
| */ |
| protected static final String DATA_UNIT_DIR = "data/unit/copyPaste/"; |
| |
| /** |
| * Separator file. |
| */ |
| protected static final String FILE_DIR = "/"; |
| |
| /** |
| * The local session. |
| */ |
| protected UILocalSession localSession; |
| |
| /** |
| * The local session bis. |
| */ |
| protected UILocalSession localSessionBis; |
| |
| /** |
| * The Session Resource wrapper bis. |
| */ |
| protected UIResource sessionAirdResourceBis; |
| |
| /** |
| * Dialect editor. |
| */ |
| protected SWTBotSiriusDiagramEditor editor2; |
| |
| private boolean errorCatchActive; |
| |
| @SuppressWarnings("unused") |
| private String errorMessage; |
| |
| private UncaughtExceptionHandler defaultUncaughtExceptionHandler; |
| |
| private void initErrorLoggers() { |
| errors = LinkedHashMultimap.create(); |
| |
| logListener = new ILogListener() { |
| |
| @Override |
| public void logging(IStatus status, String plugin) { |
| if (status.getSeverity() == IStatus.ERROR) { |
| errorOccurs(status, plugin); |
| } |
| } |
| |
| }; |
| Platform.addLogListener(logListener); |
| |
| exceptionHandler = new UncaughtExceptionHandler() { |
| private String sourcePlugin = "Uncaught exception"; |
| |
| @Override |
| public void uncaughtException(Thread t, Throwable e) { |
| |
| IStatus status = new Status(IStatus.ERROR, sourcePlugin, sourcePlugin, e); |
| errorOccurs(status, sourcePlugin); |
| } |
| }; |
| |
| defaultUncaughtExceptionHandler = Thread.getDefaultUncaughtExceptionHandler(); |
| Thread.setDefaultUncaughtExceptionHandler(exceptionHandler); |
| } |
| |
| private void disposeErrorLoggers() { |
| if (logListener != null) { |
| Platform.removeLogListener(logListener); |
| } |
| |
| if (defaultUncaughtExceptionHandler != null) { |
| Thread.setDefaultUncaughtExceptionHandler(defaultUncaughtExceptionHandler); |
| } |
| |
| clearErrors(); |
| } |
| |
| /** |
| * @param errorCatchActive |
| * error catch active |
| */ |
| @Override |
| protected synchronized void setErrorCatchActive(boolean errorCatchActive) { |
| this.errorCatchActive = errorCatchActive; |
| this.errorMessage = ""; |
| } |
| |
| private synchronized void errorOccurs(IStatus status, String sourcePlugin) { |
| if (errorCatchActive) { |
| errors.put(sourcePlugin, status); |
| } |
| } |
| |
| /** |
| * check if an error occurs. |
| * |
| * @return true if an error occurs. |
| */ |
| @Override |
| protected synchronized boolean doesAnErrorOccurs() { |
| if (errors != null) { |
| return errors.values().size() != 0; |
| } |
| return false; |
| } |
| |
| /** |
| * Clear errors. |
| */ |
| protected void clearErrors() { |
| if (errors != null) { |
| errors.clear(); |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| @Override |
| protected boolean getAutoRefreshMode() { |
| return true; |
| } |
| |
| /** |
| * ! Use with caution ! Will have side effect for cut and paste. |
| * |
| * |
| * Check copy/cut/paste menu status from toolbar edit menu and contextual menu. |
| * |
| * SWTbot cannot just check contextual menu items, it must try to click it. |
| * |
| * Contextual menu is not well updated, and the only action to test is to click. This test is here to test |
| * contextual menu sync with global "Edit" menu. |
| * |
| * Other tests can only check edit menu. |
| * |
| * @param editor |
| * the editor to check. |
| * @param copyState |
| * expected copy menu status. |
| * @param cutState |
| * expected cut menu status. |
| * @param pasteState |
| * expected paste menu status. |
| * |
| */ |
| protected void sideEffectAssertCopyCutPasteActivation(SWTBotSiriusDiagramEditor editor, boolean copyState, boolean cutState, boolean pasteState) { |
| assertCopyCutPasteToolBarActivation(copyState, cutState, pasteState); |
| |
| // now tests context menu |
| |
| /* Init error log and uncauht exception handlers */ |
| initErrorLoggers(); |
| |
| // Check Contextual Menu |
| setErrorCatchActive(true); |
| |
| editor.clickContextMenu("Paste"); |
| assertEquals(pasteState, !doesAnErrorOccurs()); |
| |
| setErrorCatchActive(false); |
| clearErrors(); |
| setErrorCatchActive(true); |
| |
| editor.clickContextMenu("Copy"); |
| assertEquals(copyState, !doesAnErrorOccurs()); |
| |
| setErrorCatchActive(false); |
| clearErrors(); |
| setErrorCatchActive(true); |
| |
| editor.clickContextMenu("Cut"); |
| assertEquals(cutState, !doesAnErrorOccurs()); |
| |
| setErrorCatchActive(false); |
| clearErrors(); |
| setErrorCatchActive(true); |
| |
| // Disable error catching |
| setErrorCatchActive(false); |
| disposeErrorLoggers(); |
| } |
| |
| /** |
| * Check copy/cut menu status from toolbar edit menu and contextual menu. |
| * |
| * @param copyState |
| * expected copy menu enablement |
| * @param cutState |
| * expected cut menu enablement |
| */ |
| protected void assertCopyCutToolBarActivation(boolean copyState, boolean cutState) { |
| SWTBotMenu copyMenu = editor.bot().menu("Edit").menu("Copy"); |
| assertEquals(true, copyMenu.isVisible()); |
| assertEquals("Copy action enabled ?", copyState, copyMenu.isEnabled()); |
| |
| SWTBotMenu cutMenu = editor.bot().menu("Edit").menu("Cut"); |
| assertEquals(true, cutMenu.isVisible()); |
| assertEquals("Cut action enabled ?", cutState, cutMenu.isEnabled()); |
| } |
| |
| /** |
| * Check copy/cut/paste menu status from toolbar edit menu and contextual menu. |
| * |
| * @param copyState |
| * expected copy menu enablement |
| * @param cutState |
| * expected cut menu enablement |
| * @param pasteState |
| * expected delete menu enablement |
| */ |
| protected void assertCopyCutPasteToolBarActivation(boolean copyState, boolean cutState, boolean pasteState) { |
| assertCopyCutToolBarActivation(copyState, cutState); |
| |
| SWTBotMenu pasteMenu = bot.menu("Edit").menu("Paste"); |
| assertEquals(true, pasteMenu.isVisible()); |
| assertEquals("Paste action enabled ?", pasteState, pasteMenu.isEnabled()); |
| } |
| |
| /** |
| * Assert on availability of copy/cut/paste menu item on contextual menu. |
| * |
| * @param expectedCopyState |
| * expected copy menu enablement |
| * @param expectedCutState |
| * expected cut menu enablement |
| * @param expectedPasteState |
| * expected delete menu enablement |
| */ |
| protected void assertCopyCutPasteMenuItemAvailabilityOnContextualMenu(boolean expectedCopyState, boolean expectedCutState, boolean expectedPasteState) { |
| // Copy |
| final Control control = editor.rootEditPart().part().getViewer().getControl(); |
| |
| Result<MenuItem> menuItemGetter = new ContextualMenuItemGetter(control, new String[] { "&Edit", "Copy" }); |
| final MenuItem copyMenuItem = UIThreadRunnable.syncExec(menuItemGetter); |
| |
| boolean currentCopyState = copyMenuItem != null; |
| if (currentCopyState) { |
| currentCopyState = UIThreadRunnable.syncExec(new Result<Boolean>() { |
| |
| @Override |
| public Boolean run() { |
| return copyMenuItem.isEnabled(); |
| } |
| |
| }); |
| } |
| assertEquals("The Copy contextual menuItem was expected " + (expectedCopyState ? "available" : "unavailable") + " but was " + (currentCopyState ? "available" : "unavailable"), |
| expectedCopyState, currentCopyState); |
| |
| // Cut |
| menuItemGetter = new ContextualMenuItemGetter(control, new String[] { "&Edit", "Cut" }); |
| final MenuItem cutMenuItem = UIThreadRunnable.syncExec(menuItemGetter); |
| boolean currentCutState = cutMenuItem != null; |
| if (currentCutState) { |
| currentCutState = UIThreadRunnable.syncExec(new Result<Boolean>() { |
| |
| @Override |
| public Boolean run() { |
| return cutMenuItem.isEnabled(); |
| } |
| |
| }); |
| } |
| assertEquals("The Cut contextual menuItem was expected " + (expectedCutState ? "available" : "unavailable") + " but was " + (currentCutState ? "available" : "unavailable"), expectedCutState, |
| currentCutState); |
| |
| // Paste |
| menuItemGetter = new ContextualMenuItemGetter(control, new String[] { "&Edit", "Paste" }); |
| final MenuItem pasteMenuItem = UIThreadRunnable.syncExec(menuItemGetter); |
| boolean currentPasteState = pasteMenuItem != null; |
| if (currentPasteState) { |
| currentPasteState = UIThreadRunnable.syncExec(new Result<Boolean>() { |
| |
| @Override |
| public Boolean run() { |
| return pasteMenuItem.isEnabled(); |
| } |
| |
| }); |
| } |
| assertEquals("The Paste contextual menuItem was expected " + (expectedPasteState ? "available" : "unavailable") + " but was " + (currentPasteState ? "available" : "unavailable"), |
| expectedPasteState, currentPasteState); |
| } |
| |
| /** |
| * clear viewpoint clipboard. |
| */ |
| protected void clearSiriusClipboard() { |
| // reinit viewpoint clipboard. |
| SiriusClipboardManager.getInstance().dispose(); |
| } |
| |
| /** |
| * Check that copy/paste on edit menu works well. |
| * |
| * Check that element on menu are available or not. |
| * |
| * Test that paste after a copy had paste element in semantic model and on the graphical view. |
| * |
| * @param copyEditor |
| * the editor where copy action is do. |
| * @param pasteEditor |
| * the editor where paste action is do. |
| * @param expectedCanPaste |
| * boolean to know if paste is disabled (a "no paste" tool is defined or generic paste can be executed). |
| * @param elemenToCopyName |
| * the element to copy. If null element to copy is the diagram. |
| * @param pasteTarget |
| * the element to paste. If null element to paste is the diagram. |
| * @param pastedName |
| * expected name of the pasted element. |
| * @param numberElementCopy |
| * number of element corresponding to element paste name. |
| */ |
| protected void checkCopyPaste(SWTBotSiriusDiagramEditor copyEditor, SWTBotGefEditPart elemenToCopyName, SWTBotSiriusDiagramEditor pasteEditor, boolean expectedCanPaste, |
| SWTBotGefEditPart pasteTarget, String pastedName, int numberElementCopy) { |
| |
| // Empty viewpoint clipboard |
| clearSiriusClipboard(); |
| |
| // Init bot to copy |
| copyEditor.show(); |
| copyEditor.setFocus(); |
| SWTBotGefEditPart partToCopyBot = copyEditor.rootEditPart().children().iterator().next(); |
| // if (!StringUtil.isEmpty(elemenToCopyName)) { |
| // partToCopyBot = copyEditor.getEditPart(elemenToCopyName).parent(); |
| // } |
| if (elemenToCopyName != null) { |
| partToCopyBot = elemenToCopyName; |
| } |
| |
| // Init paste target bot |
| pasteEditor.show(); |
| pasteEditor.setFocus(); |
| SWTBotGefEditPart pasteDiagramBot = pasteEditor.rootEditPart().children().iterator().next(); |
| SWTBotGefEditPart pasteTargetBot = pasteDiagramBot; |
| if (pasteTarget != null) { |
| pasteTargetBot = pasteTarget; |
| } |
| // if (!StringUtil.isEmpty(pasteTarget)) { |
| // pasteTargetBot = pasteEditor.getEditPart(pasteTarget).parent(); |
| // } |
| |
| // Select copy source |
| copyEditor.show(); |
| copyEditor.setFocus(); |
| |
| ICondition checkSelected = new CheckSelectedCondition(copyEditor, partToCopyBot.part()); |
| partToCopyBot.select(); |
| bot.waitUntil(checkSelected); |
| |
| // Checks that menu copy is accessible. Paste must be not |
| // accessible |
| assertCopyCutPasteToolBarActivation(true, !(partToCopyBot.part() instanceof DDiagramEditPart), false); |
| |
| copySelection(); |
| |
| // Select paste target |
| if (pasteEditor != copyEditor) { |
| pasteEditor.show(); |
| pasteEditor.setFocus(); |
| pasteDiagramBot.select(); |
| } |
| checkSelected = new CheckSelectedCondition(pasteEditor, pasteTargetBot.part()); |
| pasteTargetBot.select(); |
| bot.waitUntil(checkSelected); |
| |
| assertCopyCutPasteToolBarActivation(true, !(pasteTargetBot.part() instanceof DDiagramEditPart), expectedCanPaste); |
| |
| // "No paste" tool -> do not try to paste |
| if (!expectedCanPaste) { |
| return; |
| } |
| |
| pasteInSelection(); |
| |
| // check IdentifiedElement.uid unicity |
| checkUidUnicity((DDiagramEditPart) copyEditor.mainEditPart().part(), (DDiagramEditPart) pasteDiagramBot.part()); |
| // Check DNode element is paste |
| checkNumberOfDElementWithName(pasteDiagramBot, pastedName, numberElementCopy); |
| // Check DNode element is paste |
| checkGMFCopy(pasteEditor, pastedName, numberElementCopy); |
| |
| // TODO check new edit part : pasted name shoudl be different to use the |
| // following commented code, check expected part type number befiore and |
| // after paste |
| // SWTBotGefEditPart pastedPartBot = |
| // pasteEditor.getEditPart(pastedName).parent(); |
| // assertNotNull(pastedPartBot); |
| |
| // Test undo |
| bot.menu("Edit").menu("Undo Paste").click(); |
| // Check DNode element is paste |
| checkNumberOfDElementWithName(pasteDiagramBot, pastedName, numberElementCopy - 1); |
| // Check DNode element is paste |
| checkGMFCopy(pasteEditor, pastedName, numberElementCopy - 1); |
| |
| // Test Redo |
| bot.menu("Edit").menu("Redo Paste").click(); |
| // check IdentifiedElement.uid unicity |
| checkUidUnicity((DDiagramEditPart) copyEditor.mainEditPart().part(), (DDiagramEditPart) pasteDiagramBot.part()); |
| // Check DNode element is paste |
| checkNumberOfDElementWithName(pasteDiagramBot, pastedName, numberElementCopy); |
| // Check DNode element is paste |
| checkGMFCopy(pasteEditor, pastedName, numberElementCopy); |
| |
| } |
| |
| /** |
| * Check that copy/paste on edit menu works well. |
| * |
| * Check that element on menu are available or not. |
| * |
| * Test that paste after a copy had paste element in semantic model and on the graphical view. |
| * |
| * @param copyEditor |
| * the editor where copy action is do. |
| * @param pasteEditor |
| * the editor where paste action is do. |
| * @param expectedCanPaste |
| * boolean to know if paste is disabled (a "no paste" tool is defined or generic paste can be executed). |
| * @param listElementToCopy |
| * list of elements to copy. |
| * @param pasteTarget |
| * the element to paste. If null element to paste is the diagram. |
| * @param pastedName |
| * expected name of the pasted element. * |
| */ |
| protected void checkCopyPaste(final SWTBotSiriusDiagramEditor copyEditor, final List<SWTBotGefEditPart> listElementToCopy, SWTBotSiriusDiagramEditor pasteEditor, boolean expectedCanPaste, |
| SWTBotGefEditPart pasteTarget, Map<String, Integer> pastedName) { |
| // Empty viewpoint clipboard |
| clearSiriusClipboard(); |
| |
| // Init bot to copy |
| copyEditor.show(); |
| copyEditor.setFocus(); |
| copyEditor.select(listElementToCopy); |
| |
| SWTBotGefEditPart pasteDiagramBot = pasteEditor.rootEditPart().children().iterator().next(); |
| SWTBotGefEditPart pasteTargetBot = pasteDiagramBot; |
| if (pasteTarget != null) { |
| pasteTargetBot = pasteTarget; |
| } |
| |
| // Init paste target bot |
| pasteEditor.show(); |
| pasteEditor.setFocus(); |
| |
| // Checks that menu copy is accessible. Paste must be not |
| // accessible |
| assertCopyCutPasteToolBarActivation(true, true, false); |
| |
| copySelection(); |
| |
| // Select paste target |
| if (pasteEditor != copyEditor) { |
| pasteEditor.show(); |
| pasteEditor.setFocus(); |
| pasteDiagramBot.select(); |
| } |
| ICondition checkSelected = new CheckSelectedCondition(pasteEditor, pasteTargetBot.part()); |
| pasteTargetBot.select(); |
| bot.waitUntil(checkSelected); |
| |
| assertCopyCutPasteToolBarActivation(true, !(pasteTargetBot.part() instanceof DDiagramEditPart), expectedCanPaste); |
| |
| // "No paste" tool -> do not try to paste |
| if (!expectedCanPaste) { |
| return; |
| } |
| |
| pasteInSelection(); |
| |
| // check IdentifiedElement.uid unicity |
| checkUidUnicity((DDiagramEditPart) copyEditor.mainEditPart().part(), (DDiagramEditPart) pasteDiagramBot.part()); |
| |
| // Check DNode element is paste |
| checkNumberOfDChildrenElementWithName(pasteDiagramBot, "attributee1", pastedName.get("attributee1")); |
| // Check DNode element is paste |
| checkGMFChildrenCopy(pasteEditor, "attributee1", pastedName.get("attributee1")); |
| // Check DNode element is paste |
| checkNumberOfDChildrenElementWithName(pasteDiagramBot, "attributee2", pastedName.get("attributee2")); |
| // Check DNode element is paste |
| checkGMFChildrenCopy(pasteEditor, "attributee2", pastedName.get("attributee2")); |
| |
| // Test undo |
| bot.menu("Edit").menu("Undo Paste").click(); |
| |
| // Check DNode element is paste |
| checkNumberOfDChildrenElementWithName(pasteDiagramBot, "attributee1", pastedName.get("attributee1") - 1); |
| // Check DNode element is paste |
| checkGMFChildrenCopy(pasteEditor, "attributee1", pastedName.get("attributee1") - 1); |
| // Check DNode element is paste |
| checkNumberOfDChildrenElementWithName(pasteDiagramBot, "attributee2", pastedName.get("attributee2") - 1); |
| // Check DNode element is paste |
| checkGMFChildrenCopy(pasteEditor, "attributee2", pastedName.get("attributee2") - 1); |
| |
| // Test Redo |
| bot.menu("Edit").menu("Redo Paste").click(); |
| |
| // Check DNode element is paste |
| checkNumberOfDChildrenElementWithName(pasteDiagramBot, "attributee1", pastedName.get("attributee1")); |
| // Check DNode element is paste |
| checkGMFChildrenCopy(pasteEditor, "attributee1", pastedName.get("attributee1")); |
| // Check DNode element is paste |
| checkNumberOfDChildrenElementWithName(pasteDiagramBot, "attributee2", pastedName.get("attributee2")); |
| // Check DNode element is paste |
| checkGMFChildrenCopy(pasteEditor, "attributee2", pastedName.get("attributee2")); |
| } |
| |
| /** |
| * Check that copy/paste on edit menu works well. |
| * |
| * Check that element on menu are available or not. |
| * |
| * Test that paste after a copy had paste element in semantic model and on the graphical view. |
| * |
| * @param copyEditor |
| * the editor where copy action is do. |
| * @param pasteEditor |
| * the editor where paste action is do. |
| * @param expectedCanPaste |
| * boolean to know if paste is disabled (a "no paste" tool is defined or generic paste can be executed). |
| * @param elementToCopy |
| * element to copy. |
| * @param listPasteTarget |
| * list of elements to paste. |
| * @param pastedName |
| * expected name of the pasted element. |
| * @param numberElementCopy |
| * number of element corresponding to element paste name. |
| */ |
| protected void checkCopyPaste(final SWTBotSiriusDiagramEditor copyEditor, final SWTBotGefEditPart elementToCopy, SWTBotSiriusDiagramEditor pasteEditor, boolean expectedCanPaste, |
| List<SWTBotGefEditPart> listPasteTarget, String pastedName, int numberElementCopy) { |
| // Empty viewpoint clipboard |
| clearSiriusClipboard(); |
| |
| // Init bot to copy |
| copyEditor.show(); |
| copyEditor.setFocus(); |
| SWTBotGefEditPart partToCopyBot = copyEditor.rootEditPart().children().iterator().next(); |
| // if (!StringUtil.isEmpty(elemenToCopyName)) { |
| // partToCopyBot = copyEditor.getEditPart(elemenToCopyName).parent(); |
| // } |
| if (elementToCopy != null) { |
| partToCopyBot = elementToCopy; |
| } |
| |
| // Init paste target bot |
| pasteEditor.show(); |
| pasteEditor.setFocus(); |
| |
| // Select copy source |
| copyEditor.show(); |
| copyEditor.setFocus(); |
| |
| ICondition checkSelected = new CheckSelectedCondition(copyEditor, partToCopyBot.part()); |
| partToCopyBot.select(); |
| bot.waitUntil(checkSelected); |
| |
| // Checks that menu copy is accessible. Paste must be not |
| // accessible |
| assertCopyCutPasteToolBarActivation(true, !(partToCopyBot.part() instanceof DDiagramEditPart), false); |
| |
| copySelection(); |
| |
| // "No paste" tool -> do not try to paste |
| if (!expectedCanPaste) { |
| return; |
| } |
| |
| copyEditor.select(listPasteTarget); |
| |
| SWTBotGefEditPart pasteDiagramBot = pasteEditor.rootEditPart().children().iterator().next(); |
| SWTBotGefEditPart pasteTargetBot = pasteDiagramBot; |
| |
| pasteInSelection(); |
| |
| // check IdentifiedElement.uid unicity |
| checkUidUnicity(elementToCopy.part(), (DDiagramEditPart) pasteDiagramBot.part()); |
| |
| // Check DNode element is paste |
| checkNumberOfDChildrenElementWithName(pasteTargetBot, pastedName, numberElementCopy); |
| // Check DNode element is paste |
| checkGMFChildrenCopy(pasteEditor, pastedName, numberElementCopy); |
| |
| // Test undo |
| bot.menu("Edit").menu("Undo Paste").click(); |
| // Check DNode element is paste |
| checkNumberOfDChildrenElementWithName(pasteTargetBot, pastedName, numberElementCopy - 3); |
| // Check DNode element is paste |
| checkGMFChildrenCopy(pasteEditor, pastedName, numberElementCopy - 3); |
| |
| // Test Redo |
| bot.menu("Edit").menu("Redo Paste").click(); |
| // check IdentifiedElement.uid unicity |
| checkUidUnicity(elementToCopy.part(), (DDiagramEditPart) pasteDiagramBot.part()); |
| // Check DNode element is paste |
| checkNumberOfDChildrenElementWithName(pasteTargetBot, pastedName, numberElementCopy); |
| // Check DNode element is paste |
| checkGMFChildrenCopy(pasteEditor, pastedName, numberElementCopy); |
| } |
| |
| /** |
| * Check that the elements have a different uid and check that EObjects contained in targetDiagramEditPart have a |
| * different uid than those in diagram containing sourceEditPart. |
| * |
| * @param sourceEditPart |
| * Source edit part to check (source of the copy/paste action) |
| * @param targetDiagramEditPart |
| * Target diagram edit part to check |
| */ |
| private void checkUidUnicity(final EditPart sourceEditPart, DDiagramEditPart targetDiagramEditPart) { |
| if (sourceEditPart instanceof DDiagramEditPart) { |
| checkUidUnicity((DDiagramEditPart) sourceEditPart, targetDiagramEditPart); |
| } else { |
| checkUidUnicityAmongEObject(sourceEditPart); |
| checkUidUnicity((DDiagramEditPart) sourceEditPart.getRoot().getChildren().iterator().next(), targetDiagramEditPart); |
| } |
| } |
| |
| /** |
| * Check that the elements have a different uid and check that EObjects contained in targetDiagramEditPart have a |
| * different uid than those in sourceDiagramEditPart. |
| * |
| * @param sourceDiagramEditPart |
| * Source diagram edit part to check |
| * @param targetDiagramEditPart |
| * Target diagram edit part to check |
| */ |
| private void checkUidUnicity(final DDiagramEditPart sourceDiagramEditPart, DDiagramEditPart targetDiagramEditPart) { |
| checkUidUnicityAmongEObject(sourceDiagramEditPart); |
| |
| if (sourceDiagramEditPart != targetDiagramEditPart) { |
| EObject diagramSource = ((View) sourceDiagramEditPart.getModel()).getElement(); |
| Iterable<EObject> it = () -> diagramSource.eAllContents(); |
| Stream<String> diagramSourceUids = StreamSupport.stream(it.spliterator(), false).filter(IdentifiedElement.class::isInstance).map(IdentifiedElement.class::cast) |
| .map(IdentifiedElement::getUid); |
| EObject diagramTarget = ((View) targetDiagramEditPart.getModel()).getElement(); |
| Iterable<EObject> it2 = () -> diagramTarget.eAllContents(); |
| List<String> diagramTargetUids = StreamSupport.stream(it2.spliterator(), false).filter(IdentifiedElement.class::isInstance).map(IdentifiedElement.class::cast) |
| .map(IdentifiedElement::getUid).collect(Collectors.toList()); |
| assertFalse("The element in the copied diagram should have different uid than in source diagram", diagramSourceUids.anyMatch(uid -> diagramTargetUids.contains(uid))); |
| |
| checkUidUnicityAmongEObject(targetDiagramEditPart); |
| } |
| } |
| |
| /** |
| * Check that the elements have a different uid. |
| * |
| * @param swtBotEditPart |
| * Edit part to check. |
| */ |
| private void checkUidUnicityAmongEObject(final EditPart editPart) { |
| EObject object = ((View) editPart.getModel()).getElement(); |
| Iterable<EObject> it = () -> object.eAllContents(); |
| long nbIdentifiedElement = StreamSupport.stream(it.spliterator(), false).filter(IdentifiedElement.class::isInstance).count(); |
| long nbDifferentUid = StreamSupport.stream(it.spliterator(), false).filter(IdentifiedElement.class::isInstance).map(IdentifiedElement.class::cast).map(IdentifiedElement::getUid).distinct() |
| .count(); |
| assertEquals("The elements should all have a different uid.", nbIdentifiedElement, nbDifferentUid); |
| } |
| |
| /** |
| * Check that cut from edit menu, delete semantic elements and graphical elements on view. |
| * |
| * @param cutEditor |
| * the editor where cut is do. |
| * @param elementToCutName |
| * name of the element to cut (should be unique) |
| * @param expectedCanDelete |
| * to know if a delete tool is defined. |
| */ |
| protected void checkCutPaste(SWTBotSiriusDiagramEditor cutEditor, String elementToCutName, boolean expectedCanDelete) { |
| // Empty viewpoint clipboard |
| clearSiriusClipboard(); |
| |
| // Init bot to copy |
| cutEditor.show(); |
| cutEditor.setFocus(); |
| SWTBotGefEditPart diagramCutBot = cutEditor.rootEditPart().children().iterator().next(); |
| SWTBotGefEditPart partToCutBot = diagramCutBot; |
| if (!StringUtil.isEmpty(elementToCutName)) { |
| partToCutBot = cutEditor.getEditPart(elementToCutName).parent(); |
| } |
| |
| ICondition checkSelected = new CheckSelectedCondition(cutEditor, partToCutBot.part()); |
| partToCutBot.select(); |
| bot.waitUntil(checkSelected); |
| |
| // Checks that menu copy is accessible. Paste must be not |
| // accessible |
| assertCopyCutPasteToolBarActivation(true, expectedCanDelete, false); |
| |
| checkUidUnicityAmongEObject(diagramCutBot.part()); |
| |
| if (expectedCanDelete) { |
| cutSelection(); |
| |
| // Check DNode element was delete |
| boolean cutDeleteAll; |
| try { |
| cutEditor.getEditPart(elementToCutName); |
| cutDeleteAll = false; |
| } catch (WidgetNotFoundException wnfe) { |
| cutDeleteAll = true; |
| } |
| assertEquals(expectedCanDelete, cutDeleteAll); |
| |
| checkNumberOfDElementWithName(diagramCutBot, elementToCutName, 0); |
| |
| // Select diagram |
| checkSelected = new CheckSelectedCondition(cutEditor, diagramCutBot.part()); |
| diagramCutBot.select(); |
| bot.waitUntil(checkSelected); |
| assertCopyCutPasteToolBarActivation(true, false, true); |
| |
| pasteInSelection(); |
| // check IdentifiedElement.uid unicity |
| checkUidUnicityAmongEObject(diagramCutBot.part()); |
| |
| checkNumberOfDElementWithName(diagramCutBot, elementToCutName, 1); |
| |
| checkGMFCopy(cutEditor, elementToCutName, 1); |
| } |
| } |
| |
| private void checkNumberOfDElementWithName(SWTBotGefEditPart diagramBot, String elementName, int expectedNumber) { |
| // Check semantic element is paste |
| DSemanticDiagram semanticDiagram = (DSemanticDiagram) ((Diagram) diagramBot.part().getModel()).getElement(); |
| List<DDiagramElement> diagramElements = semanticDiagram.getOwnedDiagramElements(); |
| int nbDDE = 0; |
| for (DDiagramElement element : diagramElements) { |
| if (elementName.equals(element.getName())) { |
| nbDDE++; |
| } |
| } |
| assertEquals(expectedNumber, nbDDE); |
| } |
| |
| private void checkNumberOfDChildrenElementWithName(SWTBotGefEditPart diagramBot, String elementName, int expectedNumber) { |
| // Check semantic element is paste |
| DSemanticDiagram semanticDiagram = (DSemanticDiagram) ((Diagram) diagramBot.part().getModel()).getElement(); |
| List<DDiagramElement> diagramElements = semanticDiagram.getOwnedDiagramElements(); |
| int nbDDE = 0; |
| for (DDiagramElement element : diagramElements) { |
| if (element instanceof DNodeList && ((DNodeList) element).getOwnedElements().size() > 0) |
| for (DDiagramElement diagramElement : ((DNodeList) element).getOwnedElements()) { |
| if (elementName.equals(diagramElement.getName())) { |
| nbDDE++; |
| } |
| } |
| } |
| assertEquals(expectedNumber, nbDDE); |
| } |
| |
| /** |
| * Check that graphical elements are copy. |
| * |
| * @param swtBotEditor |
| * the editor where copy is do. |
| * @param pastedName |
| * pasted name. |
| * @param numberElementCopy |
| * number of element parts copy. |
| */ |
| private void checkGMFCopy(SWTBotSiriusDiagramEditor swtBotEditor, String pastedName, int numberElementCopy) { |
| DDiagramEditPart dDiagramEditPart = (DDiagramEditPart) swtBotEditor.rootEditPart().children().iterator().next().part(); |
| // Check gmf node is present |
| Diagram diagramGmf = (Diagram) dDiagramEditPart.getModel(); |
| int nbNodeGmfCopy = 0; |
| for (Node gmfNode : Iterables.filter(diagramGmf.getPersistedChildren(), Node.class)) { |
| if (gmfNode.getElement() instanceof DNodeList) { |
| DNodeList dde = (DNodeList) gmfNode.getElement(); |
| if (pastedName.equals(dde.getName())) { |
| nbNodeGmfCopy++; |
| // Check that sub elements are copy too |
| assertEquals(1, dde.getOwnedElements().size()); |
| assertEquals("attributee2", dde.getOwnedElements().iterator().next().getName()); |
| } |
| } |
| } |
| for (Edge gmfEdge : Iterables.filter(diagramGmf.getEdges(), Edge.class)) { |
| if (gmfEdge.getElement() instanceof DEdge) { |
| DEdge deg = (DEdge) gmfEdge.getElement(); |
| if (pastedName.equals(deg.getName())) { |
| nbNodeGmfCopy++; |
| } |
| } |
| } |
| assertEquals(numberElementCopy, nbNodeGmfCopy); |
| } |
| |
| /** |
| * Check that graphical elements children are copy. |
| * |
| * @param swtBotEditor |
| * the editor where copy is do. |
| * @param pastedName |
| * pasted name. |
| * @param numberElementCopy |
| * number of element parts copy. |
| */ |
| private void checkGMFChildrenCopy(SWTBotSiriusDiagramEditor swtBotEditor, String pastedName, int numberElementCopy) { |
| DDiagramEditPart dDiagramEditPart = (DDiagramEditPart) swtBotEditor.rootEditPart().children().iterator().next().part(); |
| // Check gmf node is present |
| Diagram diagramGmf = (Diagram) dDiagramEditPart.getModel(); |
| int nbNodeGmfCopy = 0; |
| for (Node gmfNode : Iterables.filter(diagramGmf.getPersistedChildren(), Node.class)) { |
| DNodeList dde = (DNodeList) gmfNode.getElement(); |
| for (DDiagramElement element : dde.getOwnedElements()) { |
| if (pastedName.equals(element.getName())) { |
| nbNodeGmfCopy++; |
| } |
| } |
| } |
| assertEquals(numberElementCopy, nbNodeGmfCopy); |
| } |
| |
| /** |
| * Paste actions. |
| */ |
| protected void pasteInSelection() { |
| SWTBotMenu menu = bot.menu("Edit").menu("Paste"); |
| assertEquals("Paste menu should be enable", true, menu.isEnabled()); |
| menu.click(); |
| } |
| |
| /** |
| * Copy action |
| */ |
| protected void copySelection() { |
| SWTBotMenu menu = bot.menu("Edit").menu("Copy"); |
| assertEquals("Copy menu should be enable", true, menu.isEnabled()); |
| menu.click(); |
| } |
| |
| /** |
| * Cut action. |
| */ |
| protected void cutSelection() { |
| SWTBotMenu menu = bot.menu("Edit").menu("Cut"); |
| assertEquals("Cut menu should be enable", true, menu.isEnabled()); |
| menu.click(); |
| } |
| |
| /** |
| * Check viewpoint clipboard : semantic elements and DdiagramElements. Cannot be used to check notes. |
| * |
| * @param selection |
| * selected bots. |
| */ |
| protected void checkSiriusClipboardContent(SWTBotGefEditPart... selection) { |
| assertEquals("Clipboard is not", selection != null && selection.length != 0, SiriusClipboardManager.getInstance().hasPasteData()); |
| |
| Session session = localSession.getOpenedSession(); |
| TransactionalEditingDomain domain = session.getTransactionalEditingDomain(); |
| domain.setClipboard(null); |
| |
| // Get viewpoint clipboard. |
| SiriusClipboardManager.getInstance().setDomainClipboard(domain); |
| |
| assertEquals("Wrong clipboard size", selection == null ? 0 : selection.length, |
| domain.getClipboard() == null ? 0 : Iterables.size(Iterables.filter(domain.getClipboard(), DSemanticDecorator.class))); |
| |
| for (SWTBotGefEditPart selectedBot : selection) { |
| IGraphicalEditPart part = (IGraphicalEditPart) selectedBot.part(); |
| EObject element = ((View) part.getModel()).getElement(); |
| assertTrue("Type not supported by viewpoint clipboard", element instanceof DSemanticDecorator); |
| DSemanticDecorator semDec = (DSemanticDecorator) element; |
| EObject sem = semDec.getTarget(); |
| |
| DSemanticDecorator copySemDec = (DSemanticDecorator) checkCopyInClipboard(domain, semDec); |
| EObject copySem = checkCopyInClipboard(domain, sem); |
| |
| assertEquals("Target link was not copied", copySem, copySemDec.getTarget()); |
| } |
| } |
| |
| private EObject checkCopyInClipboard(TransactionalEditingDomain domain, EObject source) { |
| for (EObject clip : Iterables.filter(Iterables.filter(domain.getClipboard(), source.getClass()), EObject.class)) { |
| assertEquals(source.eClass(), clip.eClass()); |
| boolean copy = false; |
| |
| for (EAttribute attr : source.eClass().getEAllAttributes()) { |
| copy = copy && source.eGet(attr) == clip.eGet(attr); |
| } |
| |
| if (copy = true) { |
| return clip; |
| } |
| } |
| fail("Sirius clipboard do not contain a copy of " + source); |
| return null; |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| @Override |
| protected void tearDown() throws Exception { |
| clearSiriusClipboard(); |
| disposeErrorLoggers(); |
| |
| if (editor != null) { |
| editor.close(); |
| } |
| |
| if (editor2 != null) { |
| editor2.close(); |
| } |
| |
| localSession = null; |
| editor = null; |
| editor2 = null; |
| |
| exceptionHandler = null; |
| logListener = null; |
| |
| if (errors != null) { |
| errors.clear(); |
| } |
| errors = null; |
| |
| super.tearDown(); |
| } |
| |
| } |
