| /******************************************************************************* |
| * 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: |
| * chodnick |
| ******************************************************************************/ |
| package org.eclipse.emf.emfstore.client.changetracking.test.canonization; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assert.fail; |
| |
| import java.io.IOException; |
| import java.util.List; |
| |
| import org.eclipse.emf.emfstore.client.test.common.cases.ComparingESTest; |
| import org.eclipse.emf.emfstore.client.test.common.dsl.Create; |
| import org.eclipse.emf.emfstore.internal.client.model.CompositeOperationHandle; |
| import org.eclipse.emf.emfstore.internal.client.model.exceptions.InvalidHandleException; |
| import org.eclipse.emf.emfstore.internal.client.model.util.EMFStoreCommand; |
| 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.AttributeOperation; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.operations.CompositeOperation; |
| 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.util.OperationsCanonizer; |
| import org.eclipse.emf.emfstore.test.model.TestElement; |
| import org.junit.Test; |
| |
| /** |
| * Tests canonization of attribute operations. |
| * |
| * @author chodnick |
| */ |
| public class AttributeTest extends ComparingESTest { |
| |
| private static final String SOME_NAME = "someName"; //$NON-NLS-1$ |
| private static final String SOME_NEW_NAME = "some new Name"; //$NON-NLS-1$ |
| private static final String ORIGINAL_DESCRIPTION2 = "originalDescription2"; //$NON-NLS-1$ |
| private static final String ORIGINAL_NAME2 = "originalName2"; //$NON-NLS-1$ |
| private static final String ORIGINAL_DESCRIPTION1 = "originalDescription1"; //$NON-NLS-1$ |
| private static final String ORIGINAL_NAME1 = "originalName1"; //$NON-NLS-1$ |
| private static final String ORIGINAL_DESCRIPTION = "originalDescription"; //$NON-NLS-1$ |
| private static final String ORIGINAL_NAME = "originalName"; //$NON-NLS-1$ |
| private static final String DESCRIPTION_OF_TEST_ELEMENT2 = "DescriptionOfTestElement2"; //$NON-NLS-1$ |
| private static final String NAME_OF_TEST_ELEMENT2 = "NameOfTestElement2"; //$NON-NLS-1$ |
| private static final String DESCRIPTION_OF_TEST_ELEMENT = "DescriptionOfTestElement"; //$NON-NLS-1$ |
| private static final String NAME_OF_TEST_ELEMENT = "NameOfTestElement"; //$NON-NLS-1$ |
| private static final String DESC_2 = "desc 2"; //$NON-NLS-1$ |
| private static final String DESCRIPTION2 = "description"; //$NON-NLS-1$ |
| private static final String FINAL_DESC = "final desc"; //$NON-NLS-1$ |
| private static final String SOME_OTHER_DESC = "some other desc"; //$NON-NLS-1$ |
| private static final String SOME_DESC = "some desc";//$NON-NLS-1$ |
| private static final String OLD_SECTION = "oldSection";//$NON-NLS-1$ |
| private static final String HOME = "home";//$NON-NLS-1$ |
| private static final String MAGGIE = "maggie";//$NON-NLS-1$ |
| private static final String HOMER = "homer";//$NON-NLS-1$ |
| private static final String SOME_SECTION = "some section";//$NON-NLS-1$ |
| private static final String Y_NAME = "Y";//$NON-NLS-1$ |
| private static final String X_NAME = "X";//$NON-NLS-1$ |
| private static final String SECTION_CREATION = "sectionCreation";//$NON-NLS-1$ |
| private static final String DESC_1 = "desc 1";//$NON-NLS-1$ |
| private static final String NAME = "Name";//$NON-NLS-1$ |
| private static final String NEW_DESCRIPTION = "newDescription";//$NON-NLS-1$ |
| private static final String OLD_DESCRIPTION = "oldDescription";//$NON-NLS-1$ |
| private static final String A_NAME = "A"; //$NON-NLS-1$ |
| private static final String B_NAME = "B"; //$NON-NLS-1$ |
| private static final String C_NAME = "C"; //$NON-NLS-1$ |
| private static final String NEW_NAME = "newName"; //$NON-NLS-1$ |
| private static final String OLD_NAME = "oldName"; //$NON-NLS-1$ |
| |
| /** |
| * Tests canonization for consecutive attribute changes on a single feature. |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void consecutiveAttributeChangeSingleFeature() throws IOException { |
| |
| final TestElement useCase = Create.testElement(); |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(useCase); |
| useCase.setName(OLD_NAME); |
| } |
| }.run(false); |
| |
| final Project expectedProject = ModelUtil.clone(getProject()); |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| clearOperations(); |
| |
| useCase.setName(A_NAME); |
| useCase.setName(B_NAME); |
| useCase.setName(C_NAME); |
| useCase.setName(NEW_NAME); |
| } |
| }.run(false); |
| |
| assertEquals(NEW_NAME, useCase.getName()); |
| assertEquals(4, forceGetOperations().size()); |
| |
| final List<AbstractOperation> operations = forceGetOperations(); |
| |
| new EMFStoreCommand() { |
| |
| @Override |
| protected void doRun() { |
| OperationsCanonizer.canonize(operations); |
| } |
| }.run(false); |
| |
| assertEquals(operations.size(), 1); |
| |
| final AttributeOperation reverse = (AttributeOperation) operations.get(0).reverse(); |
| |
| new EMFStoreCommand() { |
| |
| @Override |
| protected void doRun() { |
| reverse.apply(getProject()); |
| } |
| }.run(false); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| } |
| |
| /** |
| * Tests canonization for consecutive attribute changes on a single feature. |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void consecutiveAttributeChangeSingleFeatureToNull() throws IOException { |
| |
| final TestElement useCase = Create.testElement(); |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(useCase); |
| useCase.setName(OLD_NAME); |
| } |
| }.run(false); |
| |
| final Project expectedProject = ModelUtil.clone(getProject()); |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| |
| new EMFStoreCommand() { |
| |
| @Override |
| protected void doRun() { |
| clearOperations(); |
| |
| useCase.setName(A_NAME); |
| useCase.setName(B_NAME); |
| useCase.setName(C_NAME); |
| useCase.setName(null); |
| } |
| }.run(false); |
| |
| assertEquals(null, useCase.getName()); |
| |
| final List<AbstractOperation> operations = forceGetOperations(); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| OperationsCanonizer.canonize(operations); |
| } |
| }.run(false); |
| |
| assertEquals(operations.size(), 1); |
| |
| final AttributeOperation reverse = (AttributeOperation) operations.get(0).reverse(); |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| reverse.apply(getProject()); |
| } |
| }.run(false); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| |
| } |
| |
| /** |
| * Tests canonization for consecutive attribute changes on a single feature. |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void consecutiveAttributeChangeSingleFeatureNullToValue() throws IOException { |
| |
| final TestElement useCase = Create.testElement(); |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(useCase); |
| useCase.setName(null); |
| } |
| }.run(false); |
| |
| final Project expectedProject = ModelUtil.clone(getProject()); |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| clearOperations(); |
| |
| useCase.setName(A_NAME); |
| useCase.setName(B_NAME); |
| useCase.setName(C_NAME); |
| } |
| }.run(false); |
| |
| assertEquals(C_NAME, useCase.getName()); |
| |
| final List<AbstractOperation> operations = forceGetOperations(); |
| assertEquals(3, operations.size()); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| OperationsCanonizer.canonize(operations); |
| } |
| }.run(false); |
| |
| assertEquals(operations.size(), 1); |
| |
| final AttributeOperation reverse = (AttributeOperation) operations.get(0).reverse(); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| reverse.apply(getProject()); |
| } |
| }.run(false); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| } |
| |
| /** |
| * Tests canonization for consecutive attribute changes, resulting in a noop. |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void attributeChangeNoOp() throws IOException { |
| |
| final TestElement useCase = Create.testElement(); |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(useCase); |
| useCase.setName(OLD_NAME); |
| } |
| }.run(false); |
| |
| final Project expectedProject = ModelUtil.clone(getProject()); |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| clearOperations(); |
| |
| useCase.setName(A_NAME); |
| useCase.setName(B_NAME); |
| useCase.setName(C_NAME); |
| useCase.setName(OLD_NAME); |
| } |
| }.run(false); |
| |
| assertEquals(OLD_NAME, useCase.getName()); |
| final List<AbstractOperation> operations = forceGetOperations(); |
| assertEquals(4, operations.size()); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| |
| canonize(operations); |
| |
| // should not have created any operations, we were just resetting the name to its original value |
| assertEquals(operations.size(), 0); |
| |
| } |
| |
| /** |
| * Tests canonization for consecutive attribute changes, resulting in a noop. |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void attributeChangeNoOpNull() throws IOException { |
| |
| final TestElement useCase = Create.testElement(); |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(useCase); |
| useCase.setName(null); |
| } |
| }.run(false); |
| |
| final Project expectedProject = ModelUtil.clone(getProject()); |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| clearOperations(); |
| |
| useCase.setName(A_NAME); |
| useCase.setName(B_NAME); |
| useCase.setName(C_NAME); |
| useCase.setName(null); |
| } |
| }.run(false); |
| |
| assertEquals(null, useCase.getName()); |
| final List<AbstractOperation> operations = forceGetOperations(); |
| assertEquals(4, operations.size()); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| OperationsCanonizer.canonize(operations); |
| } |
| }.run(false); |
| |
| // should not have created any operations, we were just resetting the name to its original value |
| assertEquals(operations.size(), 0); |
| } |
| |
| /** |
| * Tests canonization for consecutive attribute changes, resulting in a noop. |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void attributeChangeMultiFeatureNoOp() throws IOException { |
| |
| final TestElement useCase = Create.testElement(); |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(useCase); |
| useCase.setName(OLD_NAME); |
| useCase.setDescription(OLD_DESCRIPTION); |
| } |
| }.run(false); |
| |
| final Project expectedProject = ModelUtil.clone(getProject()); |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| clearOperations(); |
| |
| useCase.setName(A_NAME); |
| useCase.setDescription(X_NAME); |
| useCase.setName(B_NAME); |
| useCase.setDescription(Y_NAME); |
| useCase.setName(C_NAME); |
| |
| useCase.setDescription(OLD_DESCRIPTION); |
| useCase.setName(OLD_NAME); |
| } |
| }.run(false); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| final List<AbstractOperation> operations = forceGetOperations(); |
| assertEquals(7, operations.size()); |
| |
| canonize(operations); |
| |
| // should not have created any operations, we were just resetting everything to its original value |
| assertEquals(operations.size(), 0); |
| } |
| |
| /** |
| * Tests canonization for consecutive attribute changes on multiple features. |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void consecutiveAttributeChangeMultiFeature() throws IOException { |
| |
| final TestElement useCase = Create.testElement(); |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(useCase); |
| useCase.setName(OLD_NAME); |
| } |
| }.run(false); |
| |
| final Project expectedProject = ModelUtil.clone(getProject()); |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| clearOperations(); |
| |
| useCase.setName(A_NAME); |
| useCase.setDescription(OLD_DESCRIPTION); |
| useCase.setName(B_NAME); |
| useCase.setName(C_NAME); |
| useCase.setDescription(NEW_DESCRIPTION); |
| useCase.setName(NEW_NAME); |
| } |
| }.run(false); |
| |
| assertEquals(NEW_NAME, useCase.getName()); |
| final List<AbstractOperation> operations = forceGetOperations(); |
| assertEquals(6, operations.size()); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| OperationsCanonizer.canonize(operations); |
| } |
| }.run(false); |
| |
| assertEquals(operations.size(), 2); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| for (int i = operations.size() - 1; i >= 0; i--) { |
| final AbstractOperation reverse = operations.get(i).reverse(); |
| reverse.apply(getProject()); |
| } |
| } |
| }.run(false); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| } |
| |
| /** |
| * Tests canonization for mixed attribute changes on a single feature. |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void mixedAttributeChangeSingleFeature() throws IOException { |
| |
| final TestElement useCase = Create.testElement(); |
| final TestElement actor = Create.testElement(); |
| final TestElement section = Create.testElement(); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(useCase); |
| getProject().addModelElement(actor); |
| getProject().addModelElement(section); |
| |
| useCase.setName(OLD_NAME); |
| section.setName(SOME_SECTION); |
| actor.setName(HOMER); |
| } |
| }.run(false); |
| |
| final Project expectedProject = ModelUtil.clone(getProject()); |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| clearOperations(); |
| |
| useCase.setName(A_NAME); |
| actor.setName(MAGGIE); |
| useCase.setName(B_NAME); |
| useCase.setNonContained_NTo1(actor); |
| useCase.setName(C_NAME); |
| section.setName(HOME); |
| useCase.setName(NEW_NAME); |
| } |
| }.run(false); |
| |
| final List<AbstractOperation> operations = forceGetOperations(); |
| assertEquals(7, operations.size()); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| OperationsCanonizer.canonize(operations); |
| } |
| }.run(false); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| for (int i = operations.size() - 1; i >= 0; i--) { |
| final AbstractOperation reverse = operations.get(i).reverse(); |
| reverse.apply(getProject()); |
| } |
| } |
| }.run(false); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| } |
| |
| /** |
| * Tests canonization for mixed attribute changes on a single feature. |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void mixedAttributeChangeMultiFeature() throws IOException { |
| |
| final TestElement useCase = Create.testElement(); |
| final TestElement actor = Create.testElement(); |
| final TestElement section = Create.testElement(); |
| final TestElement oldSection = Create.testElement(); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(useCase); |
| getProject().addModelElement(actor); |
| getProject().addModelElement(section); |
| getProject().addModelElement(oldSection); |
| |
| useCase.setContainer(oldSection); |
| actor.setContainer(oldSection); |
| |
| useCase.setName(OLD_NAME); |
| oldSection.setName(OLD_SECTION); |
| section.setName(SOME_SECTION); |
| actor.setName(HOMER); |
| } |
| }.run(false); |
| |
| final Project expectedProject = ModelUtil.clone(getProject()); |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| clearOperations(); |
| |
| useCase.setName(A_NAME); |
| actor.setName(MAGGIE); |
| useCase.setName(B_NAME); |
| useCase.setDescription(SOME_DESC); |
| useCase.setNonContained_NTo1(actor); |
| useCase.setName(C_NAME); |
| section.setName(HOME); |
| useCase.setDescription(SOME_OTHER_DESC); |
| useCase.setName(NEW_NAME); |
| useCase.setDescription(FINAL_DESC); |
| } |
| }.run(false); |
| |
| final List<AbstractOperation> operations = forceGetOperations(); |
| assertEquals(NEW_NAME, useCase.getName()); |
| assertEquals(FINAL_DESC, useCase.getDescription()); |
| assertEquals(HOME, section.getName()); |
| assertEquals(MAGGIE, actor.getName()); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| OperationsCanonizer.canonize(operations); |
| } |
| }.run(false); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| for (int i = operations.size() - 1; i >= 0; i--) { |
| final AbstractOperation reverse = operations.get(i).reverse(); |
| reverse.apply(getProject()); |
| } |
| } |
| }.run(false); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| } |
| |
| /** |
| * Test the creation and completion of a composite operation, that contains attribute changes. |
| * |
| * @throws InvalidHandleException if the test fails |
| * @throws IOException |
| */ |
| @Test |
| public void compositeAttributeChangesACA() throws InvalidHandleException, IOException { |
| |
| final TestElement section = Create.testElement(); |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(section); |
| section.setName(NAME); |
| section.setDescription(OLD_DESCRIPTION); |
| } |
| }.run(false); |
| |
| final Project expectedProject = ModelUtil.clone(getProject()); |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| clearOperations(); |
| |
| section.setDescription(DESC_1); |
| |
| final CompositeOperationHandle handle = getProjectSpace().beginCompositeOperation(); |
| section.setDescription(NEW_DESCRIPTION); |
| final TestElement useCase = Create.testElement(); |
| section.getContainedElements().add(useCase); |
| try { |
| handle.end(SECTION_CREATION, DESCRIPTION2, |
| ModelUtil.getProject(section).getModelElementId(section)); |
| } catch (final InvalidHandleException e) { |
| fail(); |
| } |
| section.setDescription(DESC_2); |
| } |
| }.run(false); |
| |
| final List<AbstractOperation> operations = forceGetOperations(); |
| assertEquals(DESC_2, section.getDescription()); |
| assertEquals(3, operations.size()); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| OperationsCanonizer.canonize(operations); |
| } |
| }.run(false); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| for (int i = operations.size() - 1; i >= 0; i--) { |
| final AbstractOperation reverse = operations.get(i).reverse(); |
| reverse.apply(getProject()); |
| } |
| } |
| }.run(false); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| } |
| |
| /** |
| * Test the creation and completion of a composite operation, that contains attribute changes. |
| * |
| * @throws InvalidHandleException if the test fails |
| * @throws IOException |
| */ |
| @Test |
| public void compositeAttributeChangesAC() throws InvalidHandleException, IOException { |
| |
| final TestElement section = Create.testElement(); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(section); |
| section.setName(NAME); |
| section.setDescription(OLD_DESCRIPTION); |
| } |
| }.run(false); |
| |
| final Project expectedProject = ModelUtil.clone(getProject()); |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| clearOperations(); |
| |
| section.setDescription(DESC_1); |
| |
| final CompositeOperationHandle handle = getProjectSpace().beginCompositeOperation(); |
| section.setDescription(NEW_DESCRIPTION); |
| final TestElement useCase = Create.testElement(); |
| section.getContainedElements().add(useCase); |
| try { |
| handle.end(SECTION_CREATION, DESCRIPTION2, |
| ModelUtil.getProject(section).getModelElementId(section)); |
| } catch (final InvalidHandleException e) { |
| fail(); |
| } |
| } |
| }.run(false); |
| |
| final List<AbstractOperation> operations = forceGetOperations(); |
| assertEquals(2, operations.size()); |
| assertEquals(NEW_DESCRIPTION, section.getDescription()); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| OperationsCanonizer.canonize(operations); |
| } |
| }.run(false); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| for (int i = operations.size() - 1; i >= 0; i--) { |
| final AbstractOperation reverse = operations.get(i).reverse(); |
| reverse.apply(getProject()); |
| } |
| } |
| }.run(false); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| } |
| |
| /** |
| * Test the creation and completion of a composite operation, that contains attribute changes. |
| * |
| * @throws InvalidHandleException if the test fails |
| * @throws IOException |
| */ |
| @Test |
| public void compositeAttributeChangesCA() throws InvalidHandleException, IOException { |
| |
| final TestElement section = Create.testElement(); |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(section); |
| section.setName(NAME); |
| section.setDescription(OLD_DESCRIPTION); |
| } |
| }.run(false); |
| |
| final Project expectedProject = ModelUtil.clone(getProject()); |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| clearOperations(); |
| |
| final CompositeOperationHandle handle = getProjectSpace().beginCompositeOperation(); |
| section.setDescription(NEW_DESCRIPTION); |
| final TestElement useCase = Create.testElement(); |
| section.getContainedElements().add(useCase); |
| try { |
| handle.end(SECTION_CREATION, DESCRIPTION2, |
| ModelUtil.getProject(section).getModelElementId(section)); |
| } catch (final InvalidHandleException e) { |
| fail(); |
| } |
| |
| section.setDescription(DESC_2); |
| } |
| }.run(false); |
| |
| final List<AbstractOperation> operations = forceGetOperations(); |
| assertEquals(2, operations.size()); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| OperationsCanonizer.canonize(operations); |
| } |
| }.run(false); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| for (int i = operations.size() - 1; i >= 0; i--) { |
| final AbstractOperation reverse = operations.get(i).reverse(); |
| reverse.apply(getProject()); |
| } |
| } |
| }.run(false); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| } |
| |
| /** |
| * Tests canonization for create and consecutive attribute changes. |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void createAndChangeAttributesSimple() throws IOException { |
| |
| final Project originalProject = ModelUtil.clone(getProject()); |
| |
| final TestElement useCase = Create.testElement(); |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(useCase); |
| useCase.setName(NAME_OF_TEST_ELEMENT); |
| useCase.setDescription(DESCRIPTION_OF_TEST_ELEMENT); |
| } |
| }.run(false); |
| |
| assertEquals(NAME_OF_TEST_ELEMENT, useCase.getName()); |
| |
| final List<AbstractOperation> operations = forceGetOperations(); |
| // expecting a create and two attribute operations |
| assertEquals(3, operations.size()); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| OperationsCanonizer.canonize(operations); |
| } |
| }.run(false); |
| |
| // now expecting only the create with folded in attributes |
| assertEquals(operations.size(), 1); |
| assertTrue(operations.get(0) instanceof CreateDeleteOperation); |
| |
| final CreateDeleteOperation op = (CreateDeleteOperation) operations.get(0); |
| |
| assertEquals(((TestElement) op.getModelElement()).getName(), NAME_OF_TEST_ELEMENT); |
| assertEquals(((TestElement) op.getModelElement()).getDescription(), DESCRIPTION_OF_TEST_ELEMENT); |
| |
| // test if the create is reversible and re-reversible |
| final Project expectedProject = ModelUtil.clone(getProject()); |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| op.reverse().apply(getProject()); |
| } |
| }.run(false); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), originalProject)); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| op.reverse().reverse().apply(getProject()); |
| } |
| }.run(false); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| } |
| |
| /** |
| * Tests canonization for create and consecutive attribute changes. |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void createAndChangeAttributesComplex() throws IOException { |
| |
| final Project originalProject = ModelUtil.clone(getProject()); |
| |
| final TestElement useCase = Create.testElement(); |
| final TestElement useCase2 = Create.testElement(); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(useCase); |
| getProject().addModelElement(useCase2); |
| |
| useCase.setName(NAME_OF_TEST_ELEMENT); |
| useCase.setDescription(DESCRIPTION_OF_TEST_ELEMENT); |
| |
| useCase2.setName(NAME_OF_TEST_ELEMENT2); |
| useCase2.setDescription(DESCRIPTION_OF_TEST_ELEMENT2); |
| } |
| }.run(false); |
| |
| assertEquals(NAME_OF_TEST_ELEMENT, useCase.getName()); |
| assertEquals(NAME_OF_TEST_ELEMENT2, useCase2.getName()); |
| final List<AbstractOperation> operations = forceGetOperations(); |
| // expecting a create and two attribute operations per usecase |
| assertEquals(6, operations.size()); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| OperationsCanonizer.canonize(operations); |
| } |
| }.run(false); |
| |
| // now expecting only the creates with folded in attributes |
| assertEquals(2, operations.size()); |
| assertTrue(operations.get(0) instanceof CreateDeleteOperation); |
| |
| final CreateDeleteOperation op = (CreateDeleteOperation) operations.get(0); |
| |
| assertEquals(((TestElement) op.getModelElement()).getName(), NAME_OF_TEST_ELEMENT); |
| assertEquals(((TestElement) op.getModelElement()).getDescription(), DESCRIPTION_OF_TEST_ELEMENT); |
| |
| assertTrue(operations.get(1) instanceof CreateDeleteOperation); |
| |
| final CreateDeleteOperation op2 = (CreateDeleteOperation) operations.get(1); |
| |
| assertEquals(((TestElement) op2.getModelElement()).getName(), NAME_OF_TEST_ELEMENT2); |
| assertEquals(((TestElement) op2.getModelElement()).getDescription(), DESCRIPTION_OF_TEST_ELEMENT2); |
| |
| // test reversibility, too |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| op2.reverse().apply(getProject()); |
| op.reverse().apply(getProject()); |
| } |
| }.run(false); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), originalProject)); |
| } |
| |
| /** |
| * Test the creation and completion of a composite operation, that contains attribute changes. |
| * |
| * @throws InvalidHandleException if the test fails |
| * @throws IOException |
| */ |
| @Test |
| public void createAndAttributeChangesACA() throws InvalidHandleException, IOException { |
| |
| final Project originalProject = ModelUtil.clone(getProject()); |
| |
| final TestElement section = Create.testElement(); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(section); |
| section.setName(NAME); |
| section.setDescription(OLD_DESCRIPTION); |
| |
| final CompositeOperationHandle handle = getProjectSpace().beginCompositeOperation(); |
| section.setDescription(NEW_DESCRIPTION); |
| final TestElement useCase = Create.testElement(); |
| section.getContainedElements().add(useCase); |
| try { |
| handle.end(SECTION_CREATION, DESCRIPTION2, |
| ModelUtil.getProject(section).getModelElementId(section)); |
| } catch (final InvalidHandleException e) { |
| fail(); |
| } |
| |
| section.setDescription(DESC_2); |
| } |
| }.run(false); |
| |
| final List<AbstractOperation> operations = forceGetOperations(); |
| |
| // expect create, 2 attribute ops, the composite, 1 attribute op |
| assertEquals(5, operations.size()); |
| assertTrue(operations.get(0) instanceof CreateDeleteOperation); |
| assertTrue(operations.get(1) instanceof AttributeOperation); |
| assertTrue(operations.get(2) instanceof AttributeOperation); |
| assertTrue(operations.get(3) instanceof CompositeOperation); |
| assertTrue(operations.get(4) instanceof AttributeOperation); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| OperationsCanonizer.canonize(operations); |
| } |
| }.run(false); |
| |
| // expect create, the composite and 1 attribute op |
| assertEquals(3, operations.size()); |
| assertTrue(operations.get(0) instanceof CreateDeleteOperation); |
| assertTrue(operations.get(1) instanceof CompositeOperation); |
| assertTrue(operations.get(2) instanceof AttributeOperation); |
| |
| final Project expectedProject = ModelUtil.clone(getProject()); |
| |
| // test reversibility |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| for (int i = operations.size() - 1; i >= 0; i--) { |
| final AbstractOperation reverse = operations.get(i).reverse(); |
| reverse.apply(getProject()); |
| } |
| } |
| }.run(false); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), originalProject)); |
| |
| // test redo |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| operations.get(0).apply(getProject()); |
| operations.get(1).apply(getProject()); |
| operations.get(2).apply(getProject()); |
| } |
| }.run(false); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| } |
| |
| /** |
| * Tests canonization for consecutive attribute changes followed by a delete. |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void changeAttributesAndDeleteSimple() throws IOException { |
| |
| final TestElement useCase = Create.testElement(); |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(useCase); |
| useCase.setName(ORIGINAL_NAME); |
| useCase.setDescription(ORIGINAL_DESCRIPTION); |
| } |
| }.run(false); |
| clearOperations(); |
| |
| assertTrue(getProjectSpace().getLocalChangePackage().isEmpty()); |
| assertTrue(forceGetOperations().isEmpty()); |
| final Project originalProject = ModelUtil.clone(getProject()); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| useCase.setName(NAME_OF_TEST_ELEMENT); |
| useCase.setDescription(DESCRIPTION_OF_TEST_ELEMENT); |
| getProject().deleteModelElement(useCase); |
| } |
| }.run(false); |
| |
| final List<AbstractOperation> operations = forceGetOperations(); |
| |
| // expecting two attribute operations and a delete |
| assertEquals(3, operations.size()); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| OperationsCanonizer.canonize(operations); |
| } |
| }.run(false); |
| |
| // now expecting only the delete with folded in attributes |
| assertEquals(1, operations.size()); |
| assertTrue(operations.get(0) instanceof CreateDeleteOperation); |
| |
| final CreateDeleteOperation op = (CreateDeleteOperation) operations.get(0); |
| |
| assertTrue(op.isDelete()); |
| assertEquals(((TestElement) op.getModelElement()).getName(), ORIGINAL_NAME); |
| assertEquals(((TestElement) op.getModelElement()).getDescription(), ORIGINAL_DESCRIPTION); |
| |
| // test if the delete is reversible and re-reversible |
| final Project expectedProject = ModelUtil.clone(getProject()); |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| op.reverse().apply(getProject()); |
| } |
| }.run(false); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), originalProject)); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| op.reverse().reverse().apply(getProject()); |
| } |
| }.run(false); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| } |
| |
| /** |
| * Tests canonization for consecutive attribute changes and delete. |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void changeAttributesAndDeleteComplex() throws IOException { |
| |
| final TestElement useCase = Create.testElement(); |
| final TestElement useCase2 = Create.testElement(); |
| final TestElement section = Create.testElement(); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(section); |
| section.getContainedElements().add(useCase); |
| section.getContainedElements().add(useCase2); |
| |
| useCase.setName(ORIGINAL_NAME1); |
| useCase.setDescription(ORIGINAL_DESCRIPTION1); |
| |
| useCase2.setName(ORIGINAL_NAME2); |
| useCase2.setDescription(ORIGINAL_DESCRIPTION2); |
| } |
| }.run(false); |
| clearOperations(); |
| |
| final Project originalProject = ModelUtil.clone(getProject()); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| |
| useCase.setName(NAME_OF_TEST_ELEMENT); |
| useCase.setDescription(DESCRIPTION_OF_TEST_ELEMENT); |
| |
| useCase2.setName(NAME_OF_TEST_ELEMENT2); |
| useCase2.setDescription(DESCRIPTION_OF_TEST_ELEMENT2); |
| |
| assertEquals(NAME_OF_TEST_ELEMENT, useCase.getName()); |
| assertEquals(NAME_OF_TEST_ELEMENT2, useCase2.getName()); |
| |
| getProject().deleteModelElement(useCase); |
| } |
| }.run(false); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().deleteModelElement(useCase2); |
| } |
| }.run(false); |
| |
| final List<AbstractOperation> operations = forceGetOperations(); |
| |
| // expecting two attribute operations and a delete per usecase |
| assertEquals(6, operations.size()); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| OperationsCanonizer.canonize(operations); |
| } |
| }.run(false); |
| |
| // now expecting only the deletes with folded in attributes |
| assertEquals(2, operations.size()); |
| assertTrue(operations.get(0) instanceof CreateDeleteOperation); |
| |
| final CreateDeleteOperation op = (CreateDeleteOperation) operations.get(0); |
| |
| assertEquals(ORIGINAL_NAME1, ((TestElement) op.getModelElement()).getName()); |
| assertEquals(ORIGINAL_DESCRIPTION1, ((TestElement) op.getModelElement()).getDescription()); |
| |
| assertTrue(operations.get(1) instanceof CreateDeleteOperation); |
| |
| final CreateDeleteOperation op2 = (CreateDeleteOperation) operations.get(1); |
| |
| assertEquals(((TestElement) op2.getModelElement()).getName(), ORIGINAL_NAME2); |
| assertEquals(((TestElement) op2.getModelElement()).getDescription(), ORIGINAL_DESCRIPTION2); |
| |
| // test reversibility, too |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| op2.reverse().apply(getProject()); |
| op.reverse().apply(getProject()); |
| } |
| }.run(false); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), originalProject)); |
| } |
| |
| /** |
| * Tests canonization for consecutive attribute changes and delete on orphans. |
| */ |
| // commented out, orphan behaviour is irrelevant at present. This reversibility test currently fails. |
| // @Test |
| // public void changeAttributesAndDeleteOrphansComplex() { |
| // |
| // TestElement useCase = Create.testElement(); |
| // TestElement useCase2 = Create.testElement(); |
| // |
| // getProject().getModelElements().add(useCase); |
| // getProject().getModelElements().add(useCase2); |
| // |
| // useCase.setName("originalName1"); |
| // useCase.setDescription("originalDescription1"); |
| // |
| // useCase2.setName("originalName2"); |
| // useCase2.setDescription("originalDescription2"); |
| // |
| // Project originalProject = ModelUtil.clone(getProject()); |
| // |
| // clearOperations(); |
| // |
| // useCase.setName("NameOfTestElement"); |
| // useCase.setDescription("DescriptionOfTestElement"); |
| // |
| // useCase2.setName("NameOfTestElement2"); |
| // useCase2.setDescription("DescriptionOfTestElement2"); |
| // |
| // assertEquals("NameOfTestElement", useCase.getName()); |
| // assertEquals("NameOfTestElement2", useCase2.getName()); |
| // |
| // getProject().deleteModelElement(useCase); |
| // getProject().deleteModelElement(useCase2); |
| // |
| // List<AbstractOperation> operations = forceGetOperations(); |
| // |
| // // expecting two attribute operations and a delete per usecase |
| // assertEquals(operations.size(), 6); |
| // OperationsCanonizer.canonize(operations); |
| // |
| // // now expecting only the deletes with folded in attributes |
| // assertEquals(operations.size(), 2); |
| // assertTrue(operations.get(0) instanceof CreateDeleteOperation); |
| // |
| // CreateDeleteOperation op = (CreateDeleteOperation) operations.get(0); |
| // |
| // assertEquals(op.getModelElement().getName(), "originalName1"); |
| // assertEquals(op.getModelElement().getDescription(), "originalDescription1"); |
| // |
| // assertTrue(operations.get(1) instanceof CreateDeleteOperation); |
| // |
| // CreateDeleteOperation op2 = (CreateDeleteOperation) operations.get(1); |
| // |
| // assertEquals(op2.getModelElement().getName(), "originalName2"); |
| // assertEquals(op2.getModelElement().getDescription(), "originalDescription2"); |
| // |
| // // test reversibility, too |
| // |
| // op2.reverse().apply(getProject()); |
| // op.reverse().apply(getProject()); |
| // |
| // assertTrue(ModelUtil.areEqual(getProject(), originalProject)); |
| // |
| // } |
| /** |
| * Test the creation and completion of a composite operation, that contains attribute changes. |
| * |
| * @throws InvalidHandleException if the test fails |
| * @throws IOException |
| */ |
| // BEGIN COMPLEX CODE |
| @Test |
| public void attributeChangesACAAndDelete() throws InvalidHandleException, IOException { |
| |
| final TestElement section = Create.testElement(); |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(section); |
| section.setName(ORIGINAL_NAME); |
| section.setDescription(ORIGINAL_DESCRIPTION); |
| } |
| }.run(false); |
| |
| final Project originalProject = ModelUtil.clone(getProject()); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| clearOperations(); |
| section.setName(SOME_NEW_NAME); |
| |
| final CompositeOperationHandle handle = getProjectSpace().beginCompositeOperation(); |
| section.setDescription(NEW_DESCRIPTION); |
| final TestElement useCase = Create.testElement(); |
| section.getContainedElements().add(useCase); |
| try { |
| handle.end(SECTION_CREATION, DESCRIPTION2, |
| ModelUtil.getProject(section).getModelElementId(section)); |
| } catch (final InvalidHandleException e) { |
| fail(); |
| } |
| |
| section.setDescription(DESC_2); |
| |
| getProject().deleteModelElement(section); |
| } |
| }.run(false); |
| |
| final List<AbstractOperation> operations = forceGetOperations(); |
| |
| // expect 1 attribute op, the composite, 1 attribute op, the delete |
| assertEquals(4, operations.size()); |
| assertTrue(operations.get(0) instanceof AttributeOperation); |
| assertTrue(operations.get(1) instanceof CompositeOperation); |
| assertTrue(operations.get(2) instanceof AttributeOperation); |
| assertTrue(operations.get(3) instanceof CreateDeleteOperation); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| OperationsCanonizer.canonize(operations); |
| } |
| }.run(false); |
| |
| // expect 1 attribute op, the composite and the delete with folded in attribute |
| assertEquals(3, operations.size()); |
| assertTrue(operations.get(0) instanceof AttributeOperation); |
| assertTrue(operations.get(1) instanceof CompositeOperation); |
| assertTrue(operations.get(2) instanceof CreateDeleteOperation); |
| |
| final CreateDeleteOperation delOp = (CreateDeleteOperation) operations.get(2); |
| assertTrue(delOp.isDelete()); |
| // not folded, interfering composite was inbeetween |
| assertEquals(SOME_NEW_NAME, ((TestElement) delOp.getModelElement()).getName()); |
| // folded, value is oldValue from "newDescription"-> "desc 2" |
| assertEquals(NEW_DESCRIPTION, ((TestElement) delOp.getModelElement()).getDescription()); |
| |
| final Project expectedProject = ModelUtil.clone(getProject()); |
| |
| // test reversibility |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| for (int i = operations.size() - 1; i >= 0; i--) { |
| final AbstractOperation reverse = operations.get(i).reverse(); |
| reverse.apply(getProject()); |
| } |
| } |
| }.run(false); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), originalProject)); |
| |
| // test redo |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| operations.get(0).apply(getProject()); |
| operations.get(1).apply(getProject()); |
| operations.get(2).apply(getProject()); |
| } |
| }.run(false); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), expectedProject)); |
| } |
| |
| // END COMPLEX CODE |
| |
| /** |
| * Tests canonization for create, attribute changes and delete. |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void createChangeAttributeAndDelete() throws IOException { |
| |
| final Project originalProject = ModelUtil.clone(getProject()); |
| |
| final TestElement useCase = Create.testElement(); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(useCase); |
| useCase.setName(SOME_NAME); |
| useCase.setName(NEW_NAME); |
| getProject().deleteModelElement(useCase); |
| } |
| }.run(false); |
| |
| final List<AbstractOperation> operations = forceGetOperations(); |
| // expect create, 2 attribute ops, delete |
| assertEquals(4, operations.size()); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| OperationsCanonizer.canonize(operations); |
| } |
| }.run(false); |
| |
| // expect attributes folding into create, and create and delete removed, |
| // as they would be directly adjacent to each other |
| assertEquals(operations.size(), 0); |
| assertTrue(ModelUtil.areEqual(getProject(), originalProject)); |
| } |
| |
| /** |
| * Tests canonization for create, attribute changes and delete. |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void createChangeReferencesAndDelete() throws IOException { |
| |
| final TestElement useCase2 = Create.testElement(); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| getProject().addModelElement(useCase2); |
| } |
| }.run(false); |
| |
| final Project originalProject = ModelUtil.clone(getProject()); |
| |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| clearOperations(); |
| |
| final TestElement useCase = Create.testElement(); |
| getProject().addModelElement(useCase); |
| useCase.setName(SOME_NAME); |
| useCase.getReferences().add(useCase2); |
| getProject().deleteModelElement(useCase); |
| } |
| }.run(false); |
| |
| final List<AbstractOperation> operations = forceGetOperations(); |
| // expect create, 1 attribute ops, 1 multiref op, the delete |
| assertEquals(4, operations.size()); |
| |
| canonize(operations); |
| |
| // expect attributes folding into create, the multiref and delete remain |
| assertEquals(operations.size(), 3); |
| assertTrue(operations.get(0) instanceof CreateDeleteOperation); |
| assertTrue(operations.get(1) instanceof MultiReferenceOperation); |
| assertTrue(operations.get(2) instanceof CreateDeleteOperation); |
| |
| // check the folding of the attribute |
| final CreateDeleteOperation createOp = (CreateDeleteOperation) operations.get(0); |
| assertEquals(SOME_NAME, ((TestElement) createOp.getModelElement()).getName()); |
| |
| // check reversibility |
| new EMFStoreCommand() { |
| @Override |
| protected void doRun() { |
| operations.get(2).reverse().apply(getProject()); |
| operations.get(1).reverse().apply(getProject()); |
| operations.get(0).reverse().apply(getProject()); |
| } |
| }.run(false); |
| |
| assertTrue(ModelUtil.areEqual(getProject(), originalProject)); |
| } |
| |
| } |
