| /******************************************************************************* |
| * Copyright (c) 2008-2011 Chair for Applied Software Engineering, |
| * Technische Universitaet Muenchen. |
| * 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: |
| * koegel |
| ******************************************************************************/ |
| package org.eclipse.emf.emfstore.client.changetracking.test.command; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertSame; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assert.fail; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.eclipse.emf.common.command.Command; |
| import org.eclipse.emf.common.command.CommandStack; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.edit.command.AddCommand; |
| import org.eclipse.emf.edit.command.CommandParameter; |
| import org.eclipse.emf.edit.command.CopyCommand; |
| import org.eclipse.emf.edit.command.CopyToClipboardCommand; |
| import org.eclipse.emf.edit.command.CutToClipboardCommand; |
| import org.eclipse.emf.edit.command.DeleteCommand; |
| import org.eclipse.emf.edit.command.PasteFromClipboardCommand; |
| import org.eclipse.emf.edit.command.RemoveCommand; |
| import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain; |
| import org.eclipse.emf.edit.domain.EditingDomain; |
| import org.eclipse.emf.emfstore.client.test.common.cases.ESTest; |
| import org.eclipse.emf.emfstore.client.test.common.dsl.Add; |
| import org.eclipse.emf.emfstore.client.test.common.dsl.Create; |
| import org.eclipse.emf.emfstore.client.test.common.util.ProjectUtil; |
| import org.eclipse.emf.emfstore.internal.client.model.ESWorkspaceProviderImpl; |
| import org.eclipse.emf.emfstore.internal.client.model.exceptions.UnsupportedNotificationException; |
| import org.eclipse.emf.emfstore.internal.client.model.util.EMFStoreCommand; |
| import org.eclipse.emf.emfstore.internal.common.model.IdEObjectCollection; |
| import org.eclipse.emf.emfstore.internal.common.model.ModelElementId; |
| import org.eclipse.emf.emfstore.internal.common.model.Project; |
| import org.eclipse.emf.emfstore.internal.common.model.util.ModelUtil; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.operations.AbstractOperation; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.operations.CreateDeleteOperation; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.operations.MultiReferenceOperation; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.operations.ReferenceOperation; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.operations.SingleReferenceOperation; |
| import org.eclipse.emf.emfstore.test.model.TestElement; |
| import org.eclipse.emf.emfstore.test.model.TestmodelPackage; |
| import org.junit.Test; |
| |
| /** |
| * Tests for the command recording to detect deletes, cuts and copies. |
| * |
| * @author koegel |
| */ |
| public class CommandTest extends ESTest { |
| |
| private static final String AI22 = "AI2"; //$NON-NLS-1$ |
| private static final String AI12 = "AI1"; //$NON-NLS-1$ |
| private static final String SPRINT1 = "Sprint1"; //$NON-NLS-1$ |
| private static final String COMMAND_NOT_EXECUTABLE = "Command not executable"; //$NON-NLS-1$ |
| private static final String NON_CONTAINED_M_TO_N = "nonContained_MToN"; //$NON-NLS-1$ |
| private static final String NON_CONTAINED_N_TO_M = "nonContained_NToM"; //$NON-NLS-1$ |
| private static final String NON_CONTAINED_1_TO_N = "nonContained_1ToN"; //$NON-NLS-1$ |
| private static final String NON_CONTAINED_N_TO1 = "nonContained_NTo1"; //$NON-NLS-1$ |
| private static final String CONTAINED_ELEMENTS = "containedElements"; //$NON-NLS-1$ |
| private static final String CONTAINER = "container"; //$NON-NLS-1$ |
| private static final String OTHER_TEST_ELEMENT = "other TestElement"; //$NON-NLS-1$ |
| private static final String NEW_TEST_ELEMENT = "new TestElement"; //$NON-NLS-1$ |
| private static final String OLD_TEST_ELEMENT = "old TestElement"; //$NON-NLS-1$ |
| |
| /** |
| * Tests the copy to clipboard and paste from clipboard command. |
| */ |
| @Test |
| public void copyAndPasteFromClipboardCommand() { |
| |
| final TestElement leafSection = Create.testElement(); |
| final TestElement actor = Create.testElement(); |
| leafSection.getContainedElements().add(actor); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(leafSection); |
| } |
| }.run(false); |
| |
| final EditingDomain editingDomain = ESWorkspaceProviderImpl.getInstance().getEditingDomain(); |
| |
| // copy to clipboard |
| final Collection<EObject> toCopy = new ArrayList<EObject>(); |
| toCopy.add(actor); |
| final Command copyCommand = editingDomain.createCommand(CopyToClipboardCommand.class, new CommandParameter( |
| null, |
| null, toCopy)); |
| editingDomain.getCommandStack().execute(copyCommand); |
| |
| // paste from clipboard |
| final Command pasteCommand = editingDomain.createCommand(PasteFromClipboardCommand.class, new CommandParameter( |
| leafSection, TestmodelPackage.Literals.TEST_ELEMENT__CONTAINED_ELEMENTS, Collections.emptyList(), |
| CommandParameter.NO_INDEX)); |
| |
| editingDomain.getCommandStack().execute(pasteCommand); |
| |
| final EObject copyOfTestElement = leafSection.getContainedElements().get(1); |
| final ModelElementId actorId = ModelUtil.getProject(actor).getModelElementId(actor); |
| final ModelElementId copyOfTestElementId = ModelUtil.getProject(copyOfTestElement).getModelElementId( |
| copyOfTestElement); |
| |
| assertTrue(actorId.equals(actorId)); |
| assertTrue(!copyOfTestElementId.equals(actorId)); |
| } |
| |
| /** |
| * Tests to delete a workpackage with a containec command with a recipient. This test also the removal o |
| * unicdirectional cross references |
| */ |
| @Test |
| public void testDeleteWithUnidirectionalCrossReference() { |
| final TestElement createCompositeSection = Create.testElement(); |
| final TestElement createTestElement = Create.testElement(); |
| final TestElement workPackage = Create.testElement(); |
| final TestElement createActionItem = Create.testElement(); |
| final TestElement createComment = Create.testElement(); |
| final TestElement createUser = Create.testElement(); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(createCompositeSection); |
| createCompositeSection.getContainedElements().add(createTestElement); |
| createTestElement.getContainedElements().add(workPackage); |
| createTestElement.getContainedElements().add(createUser); |
| workPackage.getContainedElements2().add(createActionItem); |
| createActionItem.getContainedElements().add(createComment); |
| createComment.getReferences().add(createUser); |
| clearOperations(); |
| } |
| }.run(false); |
| |
| final Command delete = DeleteCommand.create( |
| ESWorkspaceProviderImpl.getInstance().getEditingDomain(), workPackage); |
| ESWorkspaceProviderImpl.getInstance().getEditingDomain().getCommandStack().execute(delete); |
| |
| assertEquals(0, createComment.getContainedElements().size()); |
| assertEquals(1, forceGetOperations().size()); |
| assertTrue(forceGetOperations().get(0) instanceof CreateDeleteOperation); |
| } |
| |
| /** |
| * Tests the copy and paste commands. |
| */ |
| @Test |
| public void copyAndPasteCommand() { |
| |
| final TestElement leafSection = Create.testElement(); |
| final TestElement actor = Create.testElement(); |
| leafSection.getContainedElements().add(actor); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(leafSection); |
| } |
| }.run(false); |
| |
| final EditingDomain editingDomain = ESWorkspaceProviderImpl.getInstance().getEditingDomain(); |
| |
| // copy |
| final CopyCommand.Helper helper = new CopyCommand.Helper(); |
| final Command command = editingDomain.createCommand(CopyCommand.class, new CommandParameter( |
| actor, null, helper)); |
| editingDomain.getCommandStack().execute(command); |
| |
| // paste |
| final TestElement copyOfTestElement = (TestElement) helper.get(actor); |
| |
| final Collection<TestElement> toPaste = new ArrayList<TestElement>(); |
| toPaste.add(copyOfTestElement); |
| |
| final Command pasteCommand = editingDomain.createCommand(AddCommand.class, new CommandParameter(leafSection, |
| TestmodelPackage.Literals.TEST_ELEMENT__CONTAINED_ELEMENTS, toPaste, CommandParameter.NO_INDEX)); |
| |
| editingDomain.getCommandStack().execute(pasteCommand); |
| |
| final EObject copyOfTestElementRead = leafSection.getContainedElements().get(1); |
| |
| final ModelElementId actorId = ModelUtil.getProject(actor).getModelElementId(actor); |
| final ModelElementId copyOfTestElementReadId = ModelUtil.getProject(copyOfTestElementRead).getModelElementId( |
| copyOfTestElementRead); |
| assertFalse(actorId.equals(copyOfTestElementReadId)); |
| |
| } |
| |
| /** |
| * Tests the copy to clipboard and paste from clipboard command. |
| */ |
| @Test |
| public void copyAndPasteFromClipboardCommandDirectCreation() { |
| |
| final TestElement leafSection = Create.testElement(); |
| final TestElement actor = Create.testElement(); |
| leafSection.getContainedElements().add(actor); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(leafSection); |
| } |
| }.run(false); |
| |
| final EditingDomain editingDomain = ESWorkspaceProviderImpl.getInstance().getEditingDomain(); |
| |
| // copy |
| final Command command = CopyToClipboardCommand.create(editingDomain, actor); |
| editingDomain.getCommandStack().execute(command); |
| |
| // paste |
| final Command pasteCommand = PasteFromClipboardCommand.create(editingDomain, leafSection, |
| TestmodelPackage.Literals.TEST_ELEMENT__CONTAINED_ELEMENTS, CommandParameter.NO_INDEX); |
| editingDomain.getCommandStack().execute(pasteCommand); |
| |
| final EObject copyOfTestElementRead = leafSection.getContainedElements().get(1); |
| |
| final ModelElementId actorId = ModelUtil.getProject(actor).getModelElementId(actor); |
| final ModelElementId copyOfTestElementReadId = ModelUtil.getProject(copyOfTestElementRead).getModelElementId( |
| copyOfTestElementRead); |
| assertFalse(actorId.equals(copyOfTestElementReadId)); |
| } |
| |
| /** |
| * Tests the copy and paste commands. |
| */ |
| @Test |
| public void copyAndPasteCommandDirectCreation() { |
| |
| final TestElement leafSection = Create.testElement(); |
| final TestElement actor = Create.testElement(); |
| leafSection.getContainedElements().add(actor); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(leafSection); |
| } |
| }.run(false); |
| |
| final EditingDomain editingDomain = ESWorkspaceProviderImpl.getInstance().getEditingDomain(); |
| |
| // copy |
| final Command command = CopyCommand.create(editingDomain, actor); |
| editingDomain.getCommandStack().execute(command); |
| |
| // paste |
| final TestElement copyOfTestElement = (TestElement) command.getResult().toArray()[0]; |
| |
| final Collection<TestElement> toPaste = new ArrayList<TestElement>(); |
| toPaste.add(copyOfTestElement); |
| |
| final Command pasteCommand = AddCommand.create(editingDomain, leafSection, |
| TestmodelPackage.Literals.TEST_ELEMENT__CONTAINED_ELEMENTS, toPaste, CommandParameter.NO_INDEX); |
| |
| editingDomain.getCommandStack().execute(pasteCommand); |
| |
| final EObject copyOfTestElementRead = leafSection.getContainedElements().get(1); |
| |
| final ModelElementId actorId = ModelUtil.getProject(actor).getModelElementId(actor); |
| final ModelElementId copyOfTestElementReadId = ModelUtil.getProject(copyOfTestElementRead).getModelElementId( |
| copyOfTestElementRead); |
| assertFalse(actorId.equals(copyOfTestElementReadId)); |
| } |
| |
| /** |
| * check element deletion tracking. |
| * |
| * @throws UnsupportedOperationException on test fail |
| * @throws UnsupportedNotificationException on test fail |
| */ |
| @Test |
| public void deleteCommandTest() throws UnsupportedOperationException, UnsupportedNotificationException { |
| |
| final TestElement useCase = Create.testElement(); |
| Add.toProject(getLocalProject(), useCase); |
| clearOperations(); |
| final ModelElementId useCaseId = getProject().getModelElementId(useCase); |
| |
| final Command deleteCommand = DeleteCommand.create( |
| ESWorkspaceProviderImpl.getInstance().getEditingDomain(), |
| useCase); |
| final CommandStack commandStack = ESWorkspaceProviderImpl.getInstance().getEditingDomain().getCommandStack(); |
| if (deleteCommand.canExecute()) { |
| commandStack.execute(deleteCommand); |
| } else { |
| fail(COMMAND_NOT_EXECUTABLE); |
| } |
| |
| final List<AbstractOperation> operations = forceGetOperations(); |
| |
| assertEquals(1, operations.size()); |
| final AbstractOperation operation = operations.get(0); |
| assertTrue(operation instanceof CreateDeleteOperation); |
| final CreateDeleteOperation createDeleteOperation = (CreateDeleteOperation) operation; |
| |
| assertEquals(useCaseId, createDeleteOperation.getModelElementId()); |
| assertEquals(0, createDeleteOperation.getSubOperations().size()); |
| assertTrue(createDeleteOperation.isDelete()); |
| } |
| |
| /** |
| * check complex element deletion tracking. |
| * |
| * @throws UnsupportedOperationException on test fail |
| * @throws UnsupportedNotificationException on test fail |
| */ |
| // BEGIN COMPLEX CODE |
| @Test |
| public void complexDeleteCommandTest() throws UnsupportedOperationException, UnsupportedNotificationException { |
| |
| final TestElement section = Create.testElement(); |
| final TestElement useCase = Create.testElement(); |
| final TestElement oldTestElement = Create.testElement(); |
| final TestElement newTestElement = Create.testElement(); |
| final TestElement otherTestElement = Create.testElement(); |
| |
| oldTestElement.setName(OLD_TEST_ELEMENT); |
| newTestElement.setName(NEW_TEST_ELEMENT); |
| otherTestElement.setName(OTHER_TEST_ELEMENT); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(section); |
| section.getContainedElements().add(useCase); |
| section.getContainedElements().add(oldTestElement); |
| getProject().addModelElement(newTestElement); |
| getProject().addModelElement(otherTestElement); |
| useCase.setNonContained_NTo1(oldTestElement); |
| useCase.getNonContained_NToM().add(newTestElement); |
| useCase.getNonContained_NToM().add(otherTestElement); |
| assertTrue(getProject().contains(useCase)); |
| assertEquals(getProject(), ModelUtil.getProject(useCase)); |
| clearOperations(); |
| } |
| }.run(false); |
| |
| final Project project = ModelUtil.getProject(useCase); |
| final ModelElementId useCaseId = project.getModelElementId(useCase); |
| |
| final Command deleteCommand = DeleteCommand.create( |
| ESWorkspaceProviderImpl.getInstance().getEditingDomain(), |
| useCase); |
| ESWorkspaceProviderImpl.getInstance().getEditingDomain().getCommandStack().execute(deleteCommand); |
| |
| assertFalse(getProject().contains(useCase)); |
| |
| final List<AbstractOperation> operations = forceGetOperations(); |
| |
| assertEquals(1, operations.size()); |
| final AbstractOperation operation = operations.get(0); |
| assertTrue(operation instanceof CreateDeleteOperation); |
| final CreateDeleteOperation createDeleteOperation = (CreateDeleteOperation) operation; |
| assertTrue(createDeleteOperation.isDelete()); |
| |
| assertEquals(useCaseId, createDeleteOperation.getModelElementId()); |
| final EList<ReferenceOperation> subOperations = createDeleteOperation.getSubOperations(); |
| |
| assertEquals(8, subOperations.size()); |
| final AbstractOperation suboperation0 = subOperations.get(0); |
| final AbstractOperation suboperation1 = subOperations.get(1); |
| final AbstractOperation suboperation2 = subOperations.get(2); |
| final AbstractOperation suboperation3 = subOperations.get(3); |
| final AbstractOperation suboperation4 = subOperations.get(4); |
| final AbstractOperation suboperation5 = subOperations.get(5); |
| final AbstractOperation suboperation6 = subOperations.get(6); |
| final AbstractOperation suboperation7 = subOperations.get(7); |
| |
| assertTrue(suboperation0 instanceof SingleReferenceOperation); |
| assertTrue(suboperation1 instanceof MultiReferenceOperation); |
| assertTrue(suboperation2 instanceof SingleReferenceOperation); |
| assertTrue(suboperation3 instanceof MultiReferenceOperation); |
| assertTrue(suboperation4 instanceof MultiReferenceOperation); |
| assertTrue(suboperation5 instanceof MultiReferenceOperation); |
| assertTrue(suboperation6 instanceof MultiReferenceOperation); |
| assertTrue(suboperation7 instanceof MultiReferenceOperation); |
| |
| final SingleReferenceOperation mrSuboperation0 = (SingleReferenceOperation) suboperation0; |
| final MultiReferenceOperation mrSuboperation1 = (MultiReferenceOperation) suboperation1; |
| final SingleReferenceOperation mrSuboperation2 = (SingleReferenceOperation) suboperation2; |
| final MultiReferenceOperation mrSuboperation3 = (MultiReferenceOperation) suboperation3; |
| final MultiReferenceOperation mrSuboperation4 = (MultiReferenceOperation) suboperation4; |
| final MultiReferenceOperation mrSuboperation5 = (MultiReferenceOperation) suboperation5; |
| final MultiReferenceOperation mrSuboperation6 = (MultiReferenceOperation) suboperation6; |
| final MultiReferenceOperation mrSuboperation7 = (MultiReferenceOperation) suboperation7; |
| |
| final ModelElementId sectionId = ModelUtil.getProject(section).getModelElementId(section); |
| |
| assertEquals(useCaseId, mrSuboperation0.getModelElementId()); |
| assertEquals(CONTAINER, mrSuboperation0.getFeatureName()); |
| assertEquals(sectionId, mrSuboperation0.getOldValue()); |
| assertEquals(null, mrSuboperation0.getNewValue()); |
| |
| assertEquals(CONTAINED_ELEMENTS, mrSuboperation1.getFeatureName()); |
| assertEquals(0, mrSuboperation1.getIndex()); |
| assertEquals(sectionId, mrSuboperation1.getModelElementId()); |
| assertEquals(CONTAINER, mrSuboperation1.getOppositeFeatureName()); |
| assertFalse(mrSuboperation1.isAdd()); |
| assertTrue(mrSuboperation1.isBidirectional()); |
| final Set<ModelElementId> otherInvolvedModelElements3 = mrSuboperation1.getOtherInvolvedModelElements(); |
| assertEquals(1, otherInvolvedModelElements3.size()); |
| final EList<ModelElementId> referencedModelElements3 = mrSuboperation1.getReferencedModelElements(); |
| assertEquals(1, referencedModelElements3.size()); |
| assertEquals(useCaseId, referencedModelElements3.get(0)); |
| |
| final ModelElementId oldTestElementId = ModelUtil.getProject(oldTestElement).getModelElementId(oldTestElement); |
| |
| assertEquals(oldTestElementId, mrSuboperation2.getOldValue()); |
| assertEquals(null, mrSuboperation2.getNewValue()); |
| assertEquals(NON_CONTAINED_N_TO1, mrSuboperation2.getFeatureName()); |
| assertEquals(useCaseId, mrSuboperation2.getModelElementId()); |
| assertEquals(NON_CONTAINED_1_TO_N, mrSuboperation2.getOppositeFeatureName()); |
| assertTrue(mrSuboperation2.isBidirectional()); |
| final Set<ModelElementId> otherInvolvedModelElements = mrSuboperation2.getOtherInvolvedModelElements(); |
| assertEquals(1, otherInvolvedModelElements.size()); |
| assertEquals(oldTestElementId, otherInvolvedModelElements.iterator().next()); |
| |
| assertEquals(NON_CONTAINED_1_TO_N, mrSuboperation3.getFeatureName()); |
| assertEquals(0, mrSuboperation3.getIndex()); |
| assertEquals(oldTestElementId, mrSuboperation3.getModelElementId()); |
| assertEquals(NON_CONTAINED_N_TO1, mrSuboperation3.getOppositeFeatureName()); |
| assertFalse(mrSuboperation3.isAdd()); |
| assertTrue(mrSuboperation3.isBidirectional()); |
| final Set<ModelElementId> otherInvolvedModelElements0 = mrSuboperation3.getOtherInvolvedModelElements(); |
| assertEquals(1, otherInvolvedModelElements0.size()); |
| final EList<ModelElementId> referencedModelElements0 = mrSuboperation3.getReferencedModelElements(); |
| assertEquals(1, referencedModelElements0.size()); |
| assertEquals(useCaseId, referencedModelElements0.get(0)); |
| |
| final ModelElementId newTestElementId = ModelUtil.getProject(newTestElement).getModelElementId(newTestElement); |
| |
| assertEquals(NON_CONTAINED_N_TO_M, mrSuboperation4.getFeatureName()); |
| assertEquals(0, mrSuboperation4.getIndex()); |
| assertEquals(useCaseId, mrSuboperation4.getModelElementId()); |
| assertEquals(NON_CONTAINED_M_TO_N, mrSuboperation4.getOppositeFeatureName()); |
| assertFalse(mrSuboperation4.isAdd()); |
| assertTrue(mrSuboperation4.isBidirectional()); |
| final Set<ModelElementId> otherInvolvedModelElements2 = mrSuboperation4.getOtherInvolvedModelElements(); |
| assertEquals(1, otherInvolvedModelElements2.size()); |
| final EList<ModelElementId> referencedModelElements = mrSuboperation4.getReferencedModelElements(); |
| assertEquals(1, referencedModelElements.size()); |
| assertEquals(newTestElementId, referencedModelElements.get(0)); |
| |
| assertEquals(newTestElementId, mrSuboperation5.getModelElementId()); |
| assertEquals(NON_CONTAINED_M_TO_N, mrSuboperation5.getFeatureName()); |
| assertEquals(false, mrSuboperation5.isAdd()); |
| assertEquals(1, mrSuboperation5.getReferencedModelElements().size()); |
| assertEquals(useCaseId, mrSuboperation5.getReferencedModelElements().get(0)); |
| |
| assertEquals(NON_CONTAINED_N_TO_M, mrSuboperation6.getFeatureName()); |
| assertEquals(0, mrSuboperation6.getIndex()); |
| assertEquals(useCaseId, mrSuboperation6.getModelElementId()); |
| assertEquals(NON_CONTAINED_M_TO_N, mrSuboperation6.getOppositeFeatureName()); |
| assertEquals(false, mrSuboperation6.isAdd()); |
| assertEquals(true, mrSuboperation6.isBidirectional()); |
| final Set<ModelElementId> otherInvolvedModelElements6 = mrSuboperation6.getOtherInvolvedModelElements(); |
| assertEquals(1, otherInvolvedModelElements6.size()); |
| final EList<ModelElementId> referencedModelElements6 = mrSuboperation6.getReferencedModelElements(); |
| assertEquals(1, referencedModelElements6.size()); |
| final ModelElementId otherTestElementId = ModelUtil.getProject(otherTestElement).getModelElementId( |
| otherTestElement); |
| assertEquals(otherTestElementId, referencedModelElements6.get(0)); |
| |
| assertEquals(otherTestElementId, mrSuboperation7.getModelElementId()); |
| assertEquals(NON_CONTAINED_M_TO_N, mrSuboperation7.getFeatureName()); |
| assertEquals(false, mrSuboperation7.isAdd()); |
| assertEquals(1, mrSuboperation7.getReferencedModelElements().size()); |
| assertEquals(useCaseId, mrSuboperation7.getReferencedModelElements().get(0)); |
| } |
| |
| // END COMPLEX CODE |
| |
| /** |
| * Tests the copy to clipboard and paste from clipboard command. |
| */ |
| @Test |
| public void cutAndPasteFromClipboardCommand() { |
| |
| final TestElement leafSection = Create.testElement(); |
| final TestElement actor = Create.testElement(); |
| leafSection.getContainedElements().add(actor); |
| |
| ProjectUtil.addElement(getProjectSpace().toAPI(), leafSection); |
| |
| final EditingDomain editingDomain = ESWorkspaceProviderImpl.getInstance().getEditingDomain(); |
| |
| // cut to clipboard |
| final Collection<TestElement> toCut = new ArrayList<TestElement>(); |
| toCut.add(actor); |
| final Command copyCommand = editingDomain.createCommand(CutToClipboardCommand.class, new CommandParameter( |
| leafSection, TestmodelPackage.Literals.TEST_ELEMENT__CONTAINED_ELEMENTS, toCut)); |
| |
| editingDomain.getCommandStack().execute(copyCommand); |
| |
| assertEquals(0, leafSection.getContainedElements().size()); |
| assertTrue(editingDomain.getCommandStack().canUndo()); |
| |
| // undo the cut command |
| editingDomain.getCommandStack().undo(); |
| |
| assertEquals(1, leafSection.getContainedElements().size()); |
| assertTrue(editingDomain.getCommandStack().canRedo()); |
| |
| // redo the cut command |
| editingDomain.getCommandStack().redo(); |
| |
| assertEquals(0, leafSection.getContainedElements().size()); |
| |
| // paste from clipboard |
| final Command pasteCommand = editingDomain.createCommand(PasteFromClipboardCommand.class, new CommandParameter( |
| leafSection, |
| TestmodelPackage.Literals.TEST_ELEMENT__CONTAINED_ELEMENTS, Collections.emptyList(), |
| CommandParameter.NO_INDEX)); |
| |
| editingDomain.getCommandStack().execute(pasteCommand); |
| |
| // assert that the ids are not equal |
| assertEquals(1, leafSection.getContainedElements().size()); |
| |
| // undo the paste command |
| editingDomain.getCommandStack().undo(); |
| |
| assertEquals(0, leafSection.getContainedElements().size()); |
| |
| // redo the paste command |
| editingDomain.getCommandStack().redo(); |
| |
| assertEquals(1, leafSection.getContainedElements().size()); |
| } |
| |
| /** |
| * Tests the cut to clipboard and paste from clipboard command. |
| */ |
| // BEGIN COMPLEX CODE |
| @Test |
| public void cutAndPasteFromClipboardCommand_DirectCreation() { |
| |
| final TestElement leafSection = Create.testElement(); |
| final TestElement actor = Create.testElement(); |
| leafSection.getContainedElements().add(actor); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(leafSection); |
| } |
| }.run(false); |
| |
| final EditingDomain editingDomain = ESWorkspaceProviderImpl.getInstance().getEditingDomain(); |
| |
| // copy to clipboard |
| final Command cutCommand = CutToClipboardCommand.create(editingDomain, leafSection, |
| TestmodelPackage.Literals.TEST_ELEMENT__CONTAINED_ELEMENTS, actor); |
| |
| if (cutCommand.canExecute()) { |
| editingDomain.getCommandStack().execute(cutCommand); |
| } else { |
| fail(COMMAND_NOT_EXECUTABLE); |
| } |
| assertEquals(0, leafSection.getContainedElements().size()); |
| assertTrue(editingDomain.getCommandStack().canUndo()); |
| |
| // undo the cut command |
| editingDomain.getCommandStack().undo(); |
| assertEquals(1, leafSection.getContainedElements().size()); |
| assertTrue(editingDomain.getCommandStack().canRedo()); |
| |
| // redo the cut command |
| editingDomain.getCommandStack().redo(); |
| assertEquals(0, leafSection.getContainedElements().size()); |
| |
| // paste from clipboard |
| final Command pasteCommand = PasteFromClipboardCommand.create(editingDomain, leafSection, |
| TestmodelPackage.Literals.TEST_ELEMENT__CONTAINED_ELEMENTS, |
| CommandParameter.NO_INDEX); |
| |
| if (pasteCommand.canExecute()) { |
| editingDomain.getCommandStack().execute(pasteCommand); |
| assertEquals(1, leafSection.getContainedElements().size()); |
| } else { |
| fail(COMMAND_NOT_EXECUTABLE); |
| } |
| |
| // undo the paste command |
| editingDomain.getCommandStack().undo(); |
| assertEquals(0, leafSection.getContainedElements().size()); |
| |
| // redo the paste command |
| editingDomain.getCommandStack().redo(); |
| assertEquals(1, leafSection.getContainedElements().size()); |
| } |
| |
| // END COMPLEX CODE |
| |
| /** |
| * Might be no problem in runtime??!! Please have a look at it. |
| */ |
| @Test |
| public void testFunnyIssue() { |
| |
| final TestElement leafSection = Create.testElement(); |
| final TestElement actor = Create.testElement(); |
| leafSection.getContainedElements().add(actor); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(leafSection); |
| } |
| }.run(false); |
| |
| final EditingDomain editingDomain = ESWorkspaceProviderImpl.getInstance().getEditingDomain(); |
| |
| // cut to clipboard |
| final Command cutCommand = CutToClipboardCommand.create(editingDomain, leafSection, |
| TestmodelPackage.Literals.TEST_ELEMENT__CONTAINED_ELEMENTS, actor); |
| |
| if (cutCommand.canExecute()) { |
| editingDomain.getCommandStack().execute(cutCommand); |
| } else { |
| fail(COMMAND_NOT_EXECUTABLE); |
| } |
| assertEquals(0, leafSection.getContainedElements().size()); |
| assertTrue(editingDomain.getCommandStack().canUndo()); |
| |
| // undo the command |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| editingDomain.getCommandStack().undo(); |
| } |
| }.run(false); |
| // does not work but is strange anyway |
| // assertTrue(editingDomain.getCommandStack().canRedo()); |
| assertEquals(1, leafSection.getContainedElements().size()); |
| |
| } |
| |
| /** |
| * Tests remove command. |
| */ |
| // BEGIN COMPLEX CODE |
| @Test |
| public void removeCommand_DirectCreation() { |
| |
| final TestElement leafSection = Create.testElement(); |
| final TestElement actor = Create.testElement(); |
| leafSection.getContainedElements().add(actor); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(leafSection); |
| } |
| }.run(false); |
| |
| final EditingDomain editingDomain = ESWorkspaceProviderImpl.getInstance().getEditingDomain(); |
| |
| // remove |
| final Command removeCommand = RemoveCommand.create(editingDomain, leafSection, |
| TestmodelPackage.Literals.TEST_ELEMENT__CONTAINED_ELEMENTS, actor); |
| if (removeCommand.canExecute()) { |
| editingDomain.getCommandStack().execute(removeCommand); |
| } else { |
| fail(COMMAND_NOT_EXECUTABLE); |
| } |
| assertEquals(0, leafSection.getContainedElements().size()); |
| assertTrue(editingDomain.getCommandStack().canUndo()); |
| |
| // undo the command |
| editingDomain.getCommandStack().undo(); |
| assertEquals(1, leafSection.getContainedElements().size()); |
| assertTrue(editingDomain.getCommandStack().canRedo()); |
| |
| // redo the command |
| editingDomain.getCommandStack().redo(); |
| assertEquals(0, leafSection.getContainedElements().size()); |
| } |
| |
| // END COMPLEX CODE |
| |
| /** |
| * Tests the remove command. |
| */ |
| @Test |
| public void removeCommand() { |
| final TestElement leafSection = Create.testElement(); |
| final TestElement actor = Create.testElement(); |
| leafSection.getContainedElements().add(actor); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(leafSection); |
| } |
| }.run(false); |
| |
| final EditingDomain editingDomain = ESWorkspaceProviderImpl.getInstance().getEditingDomain(); |
| |
| // remove |
| final Collection<TestElement> toRemove = new ArrayList<TestElement>(); |
| toRemove.add(actor); |
| final Command copyCommand = editingDomain.createCommand(RemoveCommand.class, new CommandParameter(leafSection, |
| TestmodelPackage.Literals.TEST_ELEMENT__CONTAINED_ELEMENTS, toRemove)); |
| if (copyCommand.canExecute()) { |
| editingDomain.getCommandStack().execute(copyCommand); |
| } else { |
| fail(COMMAND_NOT_EXECUTABLE); |
| } |
| |
| assertEquals(0, leafSection.getContainedElements().size()); |
| assertTrue(editingDomain.getCommandStack().canUndo()); |
| |
| // undo the command |
| editingDomain.getCommandStack().undo(); |
| assertEquals(1, leafSection.getContainedElements().size()); |
| assertTrue(editingDomain.getCommandStack().canRedo()); |
| |
| // redo the command |
| editingDomain.getCommandStack().redo(); |
| assertEquals(0, leafSection.getContainedElements().size()); |
| } |
| |
| /** |
| * Tests delete command. |
| */ |
| @Test |
| public void deleteCommandDirectCreation() { |
| |
| final TestElement leafSection = Create.testElement(); |
| final TestElement actor = Create.testElement(); |
| leafSection.getContainedElements().add(actor); |
| |
| Add.toProject(getLocalProject(), leafSection); |
| |
| final EditingDomain editingDomain = ESWorkspaceProviderImpl.getInstance().getEditingDomain(); |
| |
| // delete |
| final Collection<TestElement> toDelete = new ArrayList<TestElement>(); |
| toDelete.add(actor); |
| final Command command = DeleteCommand.create(editingDomain, toDelete); |
| if (command.canExecute()) { |
| editingDomain.getCommandStack().execute(command); |
| } else { |
| fail(COMMAND_NOT_EXECUTABLE); |
| } |
| assertEquals(0, leafSection.getContainedElements().size()); |
| assertTrue(editingDomain.getCommandStack().canUndo()); |
| |
| // undo the command |
| editingDomain.getCommandStack().undo(); |
| assertEquals(1, leafSection.getContainedElements().size()); |
| assertTrue(editingDomain.getCommandStack().canRedo()); |
| |
| // redo the command |
| editingDomain.getCommandStack().redo(); |
| assertEquals(0, leafSection.getContainedElements().size()); |
| } |
| |
| /** |
| * Tests the delete command. |
| */ |
| @Test |
| public void deleteCommand() { |
| final TestElement leafSection = Create.testElement(); |
| final TestElement actor = Create.testElement(); |
| leafSection.getContainedElements().add(actor); |
| |
| Add.toProject(getLocalProject(), leafSection); |
| |
| clearOperations(); |
| |
| assertEquals(0, forceGetOperations().size()); |
| final EditingDomain editingDomain = ESWorkspaceProviderImpl.getInstance().getEditingDomain(); |
| |
| // delete |
| final Collection<TestElement> toDelete = new ArrayList<TestElement>(); |
| toDelete.add(actor); |
| |
| // delete actor from model elements feature |
| final Command command = editingDomain.createCommand(DeleteCommand.class, new CommandParameter(leafSection, |
| TestmodelPackage.Literals.TEST_ELEMENT__CONTAINED_ELEMENTS, toDelete)); |
| if (command.canExecute()) { |
| editingDomain.getCommandStack().execute(command); |
| } else { |
| fail(COMMAND_NOT_EXECUTABLE); |
| } |
| |
| assertEquals(0, leafSection.getContainedElements().size()); |
| // undo delete |
| assertTrue(editingDomain.getCommandStack().canUndo()); |
| assertEquals(1, forceGetOperations().size()); |
| |
| // undo the command - add actor to model elements feature |
| |
| editingDomain.getCommandStack().undo(); |
| |
| assertEquals(1, leafSection.getContainedElements().size()); |
| // // assertEquals(0,forceGetOperations().size()); |
| assertTrue(editingDomain.getCommandStack().canRedo()); |
| |
| // redo the command - delete again |
| editingDomain.getCommandStack().redo(); |
| |
| assertEquals(0, leafSection.getContainedElements().size()); |
| } |
| |
| // @Test: disabled for Bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=357464 |
| public void cutAndPasteFromClipboardCommandComplex() { |
| |
| final TestElement leafSection = Create.testElement(); |
| final TestElement workPackage = Create.testElement(); |
| final TestElement user = Create.testElement(); |
| |
| workPackage.setName(SPRINT1); |
| workPackage.setNonContained_NTo1(user); |
| |
| final TestElement ai1 = Create.testElement(); |
| ai1.setName(AI12); |
| ai1.setContainer2(workPackage); |
| final TestElement ai2 = Create.testElement(); |
| ai2.setName(AI22); |
| ai2.setContainer2(workPackage); |
| leafSection.getContainedElements().add(workPackage); |
| leafSection.getContainedElements().add(user); |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(leafSection); |
| clearOperations(); |
| } |
| }.run(false); |
| final ModelElementId workPackageId = getProject().getModelElementId(workPackage); |
| |
| final EditingDomain editingDomain = ESWorkspaceProviderImpl.getInstance().getEditingDomain(); |
| |
| // cut the element |
| final Command command = CutToClipboardCommand.create(editingDomain, workPackage); |
| editingDomain.getCommandStack().execute(command); |
| |
| assertTrue(ESWorkspaceProviderImpl.getInstance().getEditingDomain().getClipboard().contains(workPackage)); |
| assertEquals(1, ModelUtil.getAllContainedModelElements(leafSection, false).size()); |
| |
| assertTrue(getProject().contains(workPackageId)); |
| |
| final Command pasteCommand = PasteFromClipboardCommand.create(editingDomain, leafSection, |
| TestmodelPackage.Literals.TEST_ELEMENT__CONTAINED_ELEMENTS, CommandParameter.NO_INDEX); |
| editingDomain.getCommandStack().execute(pasteCommand); |
| |
| assertEquals(4, ModelUtil.getAllContainedModelElements(leafSection, false).size()); |
| assertTrue(getProject().contains(workPackageId)); |
| |
| assertEquals(2, forceGetOperations().size()); |
| |
| } |
| |
| @Test |
| public void testGetEditingDomain() { |
| final TestElement leafSection = Create.testElement(); |
| final TestElement actor = Create.testElement(); |
| leafSection.getContainedElements().add(actor); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(leafSection); |
| clearOperations(); |
| } |
| }.run(false); |
| |
| assertEquals(0, forceGetOperations().size()); |
| |
| final EditingDomain editingDomain = ESWorkspaceProviderImpl.getInstance().getEditingDomain(); |
| |
| final EditingDomain domain1 = AdapterFactoryEditingDomain.getEditingDomainFor(actor); |
| assertSame(editingDomain, domain1); |
| assertNotNull(domain1); |
| assertNotNull(editingDomain); |
| } |
| |
| /** |
| * Tests the delete from unicase delete command. |
| */ |
| @Test |
| public void deleteByUnicaseDeleteCommand() { |
| final TestElement leafSection = Create.testElement(); |
| final TestElement actor = Create.testElement(); |
| leafSection.getContainedElements().add(actor); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(leafSection); |
| clearOperations(); |
| } |
| }.run(false); |
| |
| assertEquals(0, forceGetOperations().size()); |
| final EditingDomain editingDomain = ESWorkspaceProviderImpl.getInstance().getEditingDomain(); |
| |
| // delete |
| editingDomain.getCommandStack().execute(DeleteCommand.create(editingDomain, actor)); |
| |
| assertEquals(0, leafSection.getContainedElements().size()); |
| assertTrue(editingDomain.getCommandStack().canUndo()); |
| assertEquals(1, forceGetOperations().size()); |
| |
| // undo the command |
| // command.undo(); |
| editingDomain.getCommandStack().undo(); |
| |
| assertEquals(1, leafSection.getContainedElements().size()); |
| // assertEquals(0,forceGetOperations().size()); |
| assertTrue(editingDomain.getCommandStack().canRedo()); |
| |
| // redo the command |
| editingDomain.getCommandStack().redo(); |
| assertEquals(0, leafSection.getContainedElements().size()); |
| // assertEquals(1,forceGetOperations().size()); |
| } |
| |
| @Test |
| public void supressCommandStackException() { |
| new EMFStoreCommand() { |
| @SuppressWarnings("null") |
| @Override |
| protected void doRun() { |
| final IdEObjectCollection col = null; |
| // provoke NPE |
| col.getModelElements(); |
| } |
| }.run(true); |
| } |
| |
| @Test(expected = NullPointerException.class) |
| public void rethrowCommandStackException() { |
| new EMFStoreCommand() { |
| @SuppressWarnings("null") |
| @Override |
| protected void doRun() { |
| final IdEObjectCollection col = null; |
| // provoke NPE |
| col.getModelElements(); |
| } |
| }.run(false); |
| } |
| } |
