/** * This returns the label text for the adapted class. * <!-- begin-user-doc * --> * <!-- end-user-doc --> * * @generated NOT * @param object the object to be described * @return the description of the given object */ @Override public String getText(Object object) { if (object instanceof CreateDeleteOperation) { CreateDeleteOperation op = (CreateDeleteOperation) object; EObject modelElement = op.getModelElement(); int childrenCount = ModelUtil.getAllContainedModelElements(modelElement, false).size(); String description; StringBuilder stringBuilder = new StringBuilder(); stringBuilder.append(modelElement.eClass().getName()); stringBuilder.append(getModelElementName(op.getModelElementId())); String elementClassAndName = stringBuilder.toString(); if (op.isDelete()) { description = "Deleted " + elementClassAndName; } else { description = "Created " + elementClassAndName; } if (childrenCount > 0) { description += " including " + childrenCount + " sibling(s)"; } EList<ReferenceOperation> subOperations = op.getSubOperations(); int subOperationCount = subOperations.size(); if (op.isDelete() && subOperationCount > 0) { ReferenceOperation referenceOperation = subOperations.get(subOperationCount - 1); if (referenceOperation.getContainmentType().equals(ContainmentType.CONTAINMENT)) { description += " from its parent " + getModelElementClassAndName(referenceOperation.getModelElementId()); } } return description; } return super.getText(object); }
/** Tests reversibility of 1:n single reference feature. */ @Test public void containmentSingleReferenceReversibilityTest() { final UseCase useCase = RequirementFactory.eINSTANCE.createUseCase(); final Actor actor = RequirementFactory.eINSTANCE.createActor(); final LeafSection section = DocumentFactory.eINSTANCE.createLeafSection(); final LeafSection oldSection = DocumentFactory.eINSTANCE.createLeafSection(); new EMFStoreCommand() { @Override protected void doRun() { getProject().addModelElement(useCase); getProject().addModelElement(actor); getProject().addModelElement(section); getProject().addModelElement(oldSection); useCase.setLeafSection(oldSection); actor.setLeafSection(oldSection); expectedProject = ModelUtil.clone(getProject()); assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); clearOperations(); useCase.setLeafSection(section); } }.run(false); final List<AbstractOperation> operations = getProjectSpace().getOperations(); // composite operation containing a multiref operation and a singleref operation expected assertEquals(operations.size(), 1); new EMFStoreCommand() { @Override protected void doRun() { AbstractOperation reverse = operations.get(0).reverse(); reverse.apply(getProject()); } }.run(false); assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); }
public void showHistory() throws EmfStoreException { if (projectSpace == null) { projectSpace = WorkspaceManager.getInstance() .getCurrentWorkspace() .getProjectSpace(ModelUtil.getProject(modelElement)); } IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); HistoryBrowserView historyBrowserView = null; String viewId = "org.eclipse.emf.emfstore.client.ui.views.historybrowserview.HistoryBrowserView"; try { historyBrowserView = (HistoryBrowserView) page.showView(viewId); } catch (PartInitException e) { EMFStoreMessageDialog.showExceptionDialog(e); } if (historyBrowserView != null) { historyBrowserView.setInput(projectSpace, modelElement); } }
/** * Change a single reference and check the generated operation. * * @throws UnsupportedOperationException on test fail * @throws UnsupportedNotificationException on test fail */ @Test public void changeSingleReference() throws UnsupportedOperationException, UnsupportedNotificationException { final UseCase useCase = RequirementFactory.eINSTANCE.createUseCase(); final Actor actor = RequirementFactory.eINSTANCE.createActor(); new EMFStoreCommand() { @Override protected void doRun() { getProject().addModelElement(useCase); getProject().addModelElement(actor); clearOperations(); useCase.setInitiatingActor(actor); assertEquals(actor, useCase.getInitiatingActor()); EList<UseCase> initiatedUseCases = actor.getInitiatedUseCases(); assertEquals(1, initiatedUseCases.size()); assertEquals(useCase, initiatedUseCases.get(0)); } }.run(false); List<AbstractOperation> operations = getProjectSpace().getOperations(); assertEquals(1, operations.size()); AbstractOperation operation = operations.get(0); assertEquals(true, operation instanceof CompositeOperation); EList<AbstractOperation> subOperations = ((CompositeOperation) operation).getSubOperations(); assertEquals(2, subOperations.size()); operation = subOperations.get(0); assertEquals(true, operation instanceof MultiReferenceOperationImpl); MultiReferenceOperation multiReferenceOperation = (MultiReferenceOperation) operation; assertEquals("initiatedUseCases", multiReferenceOperation.getFeatureName()); assertEquals("initiatingActor", multiReferenceOperation.getOppositeFeatureName()); ModelElementId useCaseId = ModelUtil.getProject(useCase).getModelElementId(useCase); ModelElementId actorId = ModelUtil.getProject(actor).getModelElementId(actor); assertEquals(useCaseId, multiReferenceOperation.getReferencedModelElements().get(0)); assertEquals(actorId, multiReferenceOperation.getModelElementId()); assertTrue(multiReferenceOperation.isBidirectional()); assertTrue(multiReferenceOperation.isAdd()); assertEquals(1, multiReferenceOperation.getOtherInvolvedModelElements().size()); operation = subOperations.get(1); assertEquals(true, operation instanceof SingleReferenceOperation); SingleReferenceOperation singleReferenceOperation = (SingleReferenceOperation) operation; assertEquals(null, singleReferenceOperation.getOldValue()); assertEquals(actorId, singleReferenceOperation.getNewValue()); assertEquals("initiatingActor", singleReferenceOperation.getFeatureName()); assertEquals(useCaseId, singleReferenceOperation.getModelElementId()); assertEquals("initiatedUseCases", singleReferenceOperation.getOppositeFeatureName()); assertEquals(true, singleReferenceOperation.isBidirectional()); Set<ModelElementId> otherInvolvedModelElements = singleReferenceOperation.getOtherInvolvedModelElements(); assertEquals(1, otherInvolvedModelElements.size()); assertEquals(actorId, otherInvolvedModelElements.iterator().next()); }
/** * Test containment removing. * * @throws UnsupportedOperationException on test fail */ @Test public void removeContainment() throws UnsupportedOperationException { final Issue issue = RationaleFactory.eINSTANCE.createIssue(); final Proposal proposal = RationaleFactory.eINSTANCE.createProposal(); new EMFStoreCommand() { @Override protected void doRun() { proposal.setName("proposal"); getProject().addModelElement(issue); getProject().addModelElement(proposal); proposal.setIssue(issue); clearOperations(); assertEquals(1, issue.getProposals().size()); assertEquals(proposal, issue.getProposals().get(0)); assertEquals(issue, proposal.getIssue()); assertEquals(true, getProject().containsInstance(issue)); assertEquals(true, getProject().containsInstance(proposal)); assertEquals(getProject(), ModelUtil.getProject(issue)); assertEquals(getProject(), ModelUtil.getProject(proposal)); assertEquals(issue, proposal.eContainer()); } }.run(false); ModelElementId proposalId = ModelUtil.getProject(proposal).getModelElementId(proposal); new EMFStoreCommand() { @Override protected void doRun() { proposal.setIssue(null); } }.run(false); assertEquals(true, getProject().containsInstance(issue)); assertEquals(false, getProject().containsInstance(proposal)); assertEquals(getProject(), ModelUtil.getProject(issue)); // assertEquals(null, ModelUtil.getProject(proposal)); assertEquals(0, issue.getProposals().size()); assertEquals(null, proposal.getIssue()); // assertEquals(null, proposal.eContainer()); List<AbstractOperation> operations = getProjectSpace().getOperations(); assertEquals(1, operations.size()); ModelElementId issueId = ModelUtil.getProject(issue).getModelElementId(issue); assertEquals(true, operations.get(0) instanceof CreateDeleteOperation); CreateDeleteOperation deleteOperation = (CreateDeleteOperation) operations.get(0); assertEquals(true, deleteOperation.isDelete()); assertEquals(true, deleteOperation.getModelElement() instanceof Proposal); assertEquals("proposal", ((Proposal) deleteOperation.getModelElement()).getName()); assertEquals(proposalId, deleteOperation.getModelElementId()); List<ReferenceOperation> subOperations = ((CreateDeleteOperation) operations.get(0)).getSubOperations(); assertEquals(2, subOperations.size()); AbstractOperation op0 = subOperations.get(0); assertTrue(op0 instanceof MultiReferenceOperation); MultiReferenceOperation multiReferenceOperation = (MultiReferenceOperation) op0; assertEquals(multiReferenceOperation.getModelElementId(), issueId); assertFalse(multiReferenceOperation.isAdd()); assertEquals(multiReferenceOperation.getReferencedModelElements().get(0), proposalId); assertEquals(multiReferenceOperation.getReferencedModelElements().size(), 1); assertEquals(multiReferenceOperation.getIndex(), 0); AbstractOperation operation = subOperations.get(1); assertEquals(true, operation instanceof SingleReferenceOperation); SingleReferenceOperation singleReferenceOperation = (SingleReferenceOperation) operation; assertEquals(issueId, singleReferenceOperation.getOldValue()); assertEquals(null, singleReferenceOperation.getNewValue()); assertEquals( RationalePackage.eINSTANCE.getProposal_Issue().getName(), singleReferenceOperation.getFeatureName()); assertEquals(proposalId, singleReferenceOperation.getModelElementId()); assertEquals( RationalePackage.eINSTANCE.getIssue_Proposals().getName(), singleReferenceOperation.getOppositeFeatureName()); assertEquals(true, singleReferenceOperation.isBidirectional()); Set<ModelElementId> otherInvolvedModelElements = singleReferenceOperation.getOtherInvolvedModelElements(); assertEquals(1, otherInvolvedModelElements.size()); assertEquals(true, otherInvolvedModelElements.contains(issueId)); }
/** * Move a containee to another container. * * @throws UnsupportedOperationException on test fail * @throws UnsupportedNotificationException on test fail */ @Test public void moveContainmentReference() throws UnsupportedOperationException, UnsupportedNotificationException { final Issue oldIssue = RationaleFactory.eINSTANCE.createIssue(); final Issue newIssue = RationaleFactory.eINSTANCE.createIssue(); final Proposal proposal = RationaleFactory.eINSTANCE.createProposal(); new EMFStoreCommand() { @Override protected void doRun() { getProject().addModelElement(oldIssue); getProject().addModelElement(newIssue); getProject().addModelElement(proposal); proposal.setIssue(oldIssue); clearOperations(); assertEquals(0, newIssue.getProposals().size()); assertEquals(1, oldIssue.getProposals().size()); assertEquals(proposal, oldIssue.getProposals().get(0)); assertEquals(oldIssue, proposal.getIssue()); proposal.setIssue(newIssue); assertEquals(0, oldIssue.getProposals().size()); assertEquals(1, newIssue.getProposals().size()); assertEquals(proposal, newIssue.getProposals().get(0)); assertEquals(newIssue, proposal.getIssue()); } }.run(false); List<AbstractOperation> operations = getProjectSpace().getOperations(); assertEquals(1, operations.size()); if (operations.get(0) instanceof CompositeOperation) { operations = ((CompositeOperation) operations.get(0)).getSubOperations(); } else { fail("composite operation expected"); } assertEquals(3, operations.size()); AbstractOperation op0 = operations.get(0); assertTrue(op0 instanceof MultiReferenceOperation); MultiReferenceOperation multiReferenceOperation = (MultiReferenceOperation) op0; ModelElementId oldIssueId = ModelUtil.getProject(oldIssue).getModelElementId(oldIssue); ModelElementId proposalId = ModelUtil.getProject(proposal).getModelElementId(proposal); ModelElementId newIssueId = ModelUtil.getProject(newIssue).getModelElementId(newIssue); assertEquals(multiReferenceOperation.getModelElementId(), oldIssueId); assertFalse(multiReferenceOperation.isAdd()); assertEquals(multiReferenceOperation.getReferencedModelElements().get(0), proposalId); assertEquals(multiReferenceOperation.getReferencedModelElements().size(), 1); assertEquals(multiReferenceOperation.getIndex(), 0); AbstractOperation op1 = operations.get(1); assertTrue(op1 instanceof MultiReferenceOperation); multiReferenceOperation = (MultiReferenceOperation) op1; assertEquals(multiReferenceOperation.getModelElementId(), newIssueId); assertTrue(multiReferenceOperation.isAdd()); assertEquals(multiReferenceOperation.getReferencedModelElements().get(0), proposalId); assertEquals(multiReferenceOperation.getReferencedModelElements().size(), 1); assertEquals(multiReferenceOperation.getIndex(), 0); AbstractOperation operation = operations.get(2); assertEquals(true, operation instanceof SingleReferenceOperation); SingleReferenceOperation singleReferenceOperation = (SingleReferenceOperation) operation; assertEquals(oldIssueId, singleReferenceOperation.getOldValue()); assertEquals(newIssueId, singleReferenceOperation.getNewValue()); assertEquals( RationalePackage.eINSTANCE.getProposal_Issue().getName(), singleReferenceOperation.getFeatureName()); assertEquals(proposalId, singleReferenceOperation.getModelElementId()); assertEquals( RationalePackage.eINSTANCE.getIssue_Proposals().getName(), singleReferenceOperation.getOppositeFeatureName()); assertEquals(true, singleReferenceOperation.isBidirectional()); Set<ModelElementId> otherInvolvedModelElements = singleReferenceOperation.getOtherInvolvedModelElements(); assertEquals(2, otherInvolvedModelElements.size()); assertEquals(true, otherInvolvedModelElements.contains(newIssueId)); assertEquals(true, otherInvolvedModelElements.contains(oldIssueId)); }
/** * Change an single reference and reverse it. * * @throws UnsupportedOperationException on test fail * @throws UnsupportedNotificationException on test fail */ @Test public void reverseSingleReference() throws UnsupportedOperationException, UnsupportedNotificationException { final UseCase useCase = RequirementFactory.eINSTANCE.createUseCase(); final Actor oldActor = RequirementFactory.eINSTANCE.createActor(); final Actor newActor = RequirementFactory.eINSTANCE.createActor(); new EMFStoreCommand() { @Override protected void doRun() { getProject().addModelElement(useCase); getProject().addModelElement(oldActor); getProject().addModelElement(newActor); useCase.setInitiatingActor(oldActor); assertEquals(oldActor, useCase.getInitiatingActor()); EList<UseCase> initiatedUseCases = oldActor.getInitiatedUseCases(); assertEquals(1, initiatedUseCases.size()); assertEquals(useCase, initiatedUseCases.get(0)); clearOperations(); useCase.setInitiatingActor(newActor); assertEquals(newActor, useCase.getInitiatingActor()); initiatedUseCases = newActor.getInitiatedUseCases(); assertEquals(1, initiatedUseCases.size()); assertEquals(useCase, initiatedUseCases.get(0)); } }.run(false); List<AbstractOperation> operations = getProjectSpace().getOperations(); assertEquals(1, operations.size()); assertEquals(1, operations.size()); if (operations.get(0) instanceof CompositeOperation) { operations = ((CompositeOperation) operations.get(0)).getSubOperations(); } else { fail("composite operation expected"); } assertEquals(3, operations.size()); // note: skipping multireferenceop at index 0 in test, as it is not interesting in this context AbstractOperation operation = operations.get(2); assertEquals(true, operation instanceof SingleReferenceOperation); SingleReferenceOperation singleReferenceOperation = (SingleReferenceOperation) operation; ModelElementId useCaseId = ModelUtil.getProject(useCase).getModelElementId(useCase); ModelElementId oldActorId = ModelUtil.getProject(oldActor).getModelElementId(oldActor); ModelElementId newActorId = ModelUtil.getProject(newActor).getModelElementId(newActor); assertEquals(oldActorId, singleReferenceOperation.getOldValue()); assertEquals(newActorId, singleReferenceOperation.getNewValue()); assertEquals("initiatingActor", singleReferenceOperation.getFeatureName()); assertEquals(useCaseId, singleReferenceOperation.getModelElementId()); assertEquals("initiatedUseCases", singleReferenceOperation.getOppositeFeatureName()); assertEquals(true, singleReferenceOperation.isBidirectional()); Set<ModelElementId> otherInvolvedModelElements = singleReferenceOperation.getOtherInvolvedModelElements(); assertEquals(2, otherInvolvedModelElements.size()); assertEquals(true, otherInvolvedModelElements.contains(oldActorId)); assertEquals(true, otherInvolvedModelElements.contains(newActorId)); AbstractOperation reverse = singleReferenceOperation.reverse(); assertEquals(true, reverse instanceof SingleReferenceOperation); final SingleReferenceOperation reversedSingleReferenceOperation = (SingleReferenceOperation) reverse; new EMFStoreCommand() { @Override protected void doRun() { reversedSingleReferenceOperation.apply(getProject()); } }.run(false); assertEquals(oldActor, useCase.getInitiatingActor()); assertEquals(newActorId, reversedSingleReferenceOperation.getOldValue()); assertEquals(oldActorId, reversedSingleReferenceOperation.getNewValue()); assertEquals("initiatingActor", reversedSingleReferenceOperation.getFeatureName()); assertEquals(useCaseId, reversedSingleReferenceOperation.getModelElementId()); assertEquals("initiatedUseCases", reversedSingleReferenceOperation.getOppositeFeatureName()); assertEquals(true, reversedSingleReferenceOperation.isBidirectional()); otherInvolvedModelElements = reversedSingleReferenceOperation.getOtherInvolvedModelElements(); assertEquals(2, otherInvolvedModelElements.size()); assertEquals(true, otherInvolvedModelElements.contains(oldActorId)); assertEquals(true, otherInvolvedModelElements.contains(newActorId)); }