| /******************************************************************************* |
| * Copyright (c) 2014, 2016 Obeo and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Obeo - initial API and implementation |
| * Philip Langer - bug 501864 |
| *******************************************************************************/ |
| package org.eclipse.emf.compare.uml2.tests.stereotypes; |
| |
| import static com.google.common.base.Predicates.and; |
| import static com.google.common.base.Predicates.instanceOf; |
| import static org.eclipse.emf.compare.merge.AbstractMerger.isInTerminalState; |
| import static org.eclipse.emf.compare.utils.EMFComparePredicates.added; |
| import static org.eclipse.emf.compare.utils.EMFComparePredicates.ofKind; |
| import static org.eclipse.emf.compare.utils.EMFComparePredicates.removed; |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertNull; |
| import static org.junit.Assert.assertSame; |
| import static org.junit.Assert.assertTrue; |
| |
| import com.google.common.base.Function; |
| import com.google.common.base.Predicate; |
| import com.google.common.collect.ImmutableSet; |
| import com.google.common.collect.ImmutableSet.Builder; |
| import com.google.common.collect.Iterables; |
| |
| import java.io.IOException; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.Set; |
| import java.util.regex.Pattern; |
| |
| import org.eclipse.emf.common.util.BasicMonitor; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.compare.AttributeChange; |
| import org.eclipse.emf.compare.Comparison; |
| import org.eclipse.emf.compare.Conflict; |
| import org.eclipse.emf.compare.Diff; |
| import org.eclipse.emf.compare.DifferenceKind; |
| import org.eclipse.emf.compare.DifferenceState; |
| import org.eclipse.emf.compare.ReferenceChange; |
| import org.eclipse.emf.compare.merge.BatchMerger; |
| import org.eclipse.emf.compare.tests.postprocess.data.TestPostProcessor; |
| import org.eclipse.emf.compare.uml2.internal.StereotypedElementChange; |
| import org.eclipse.emf.compare.uml2.internal.postprocessor.StereotypedElementChangePostProcessor; |
| import org.eclipse.emf.compare.uml2.tests.AbstractUMLProfileTest; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.uml2.uml.Class; |
| import org.eclipse.uml2.uml.Model; |
| import org.eclipse.uml2.uml.util.UMLUtil; |
| |
| /** |
| * Abstract class used to test the merge of {@link StereotypedElementChange}. |
| * |
| * @author <a href="mailto:arthur.daussy@obeo.fr">Arthur Daussy</a> |
| */ |
| public abstract class AbstractStereotypedElementChangeTests extends AbstractUMLProfileTest { |
| |
| /** |
| * Each sublass of AbstractUMLTest have to call this method in a @BeforeClass annotated method. This allow |
| * each test to customize its context. |
| */ |
| public static void beforeClass() { |
| addProfilePathmap(); |
| } |
| |
| /** |
| * Each sublass of AbstractUMLTest have to call this method in a @BeforeClass annotated method. This allow |
| * each test to safely delete its context. |
| */ |
| public static void afterClass() { |
| resetProfilePathmap(); |
| } |
| |
| @Override |
| protected void registerPostProcessors( |
| org.eclipse.emf.compare.postprocessor.IPostProcessor.Descriptor.Registry<String> postProcessorRegistry) { |
| super.registerPostProcessors(postProcessorRegistry); |
| postProcessorRegistry.put(StereotypedElementChangePostProcessor.class.getName(), |
| new TestPostProcessor.TestPostProcessorDescriptor( |
| Pattern.compile("http://www.eclipse.org/uml2/\\d\\.0\\.0/UML"), null, //$NON-NLS-1$ |
| new StereotypedElementChangePostProcessor(), 25)); |
| } |
| |
| /** |
| * Tests that no {@link StereotypedElementChange} is created when applying a stereotype on an existing |
| * element. |
| * <p> |
| * <h3>Inputs</h4> |
| * </p> |
| * <h3>Left model</h3> |
| * |
| * <pre> |
| * <Model> aModel |
| * `-- <<ACliche>> <Class> Test |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * <b>ACliche [base <<ACliche>> <Class> Test]</b> |
| * </pre> |
| * |
| * <h3>Right model</h3> |
| * |
| * <pre> |
| * <Model> aModel |
| * `-- <Class> Test |
| * </pre> |
| * |
| * @throws IOException |
| */ |
| protected void testApplyStereotypeOnExistingElement(Resource left, Resource right) throws IOException { |
| |
| final Comparison comparison = compare(left, right); |
| |
| EList<Diff> differences = comparison.getDifferences(); |
| Iterable<StereotypedElementChange> stereotypesChanges = getStereotypedElementChanges(differences, |
| DifferenceKind.ADD); |
| assertEquals(0, Iterables.size(stereotypesChanges)); |
| |
| } |
| |
| /** |
| * Tests that no {@link StereotypedElementChange} is created when unapplying a stereotype. |
| * <p> |
| * <h3>Inputs</h4> |
| * </p> |
| * <h3>Left model</h3> |
| * |
| * <pre> |
| * <Model> aModel |
| * `-- <Class> Test |
| * </pre> |
| * |
| * <h3>Right model</h3> |
| * |
| * <pre> |
| * <Model> aModel |
| * `-- <<ACliche>> <Class> Test |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * <b>ACliche [base <<ACliche>> <Class> Test]</b> |
| * </pre> |
| * |
| * @throws IOException |
| */ |
| protected void testRemoveStereotypeOnExistingElement(Resource left, Resource right) throws IOException { |
| |
| final Comparison comparison = compare(left, right); |
| |
| EList<Diff> differences = comparison.getDifferences(); |
| Iterable<StereotypedElementChange> stereotypesChanges = getStereotypedElementChanges(differences, |
| DifferenceKind.DELETE); |
| assertEquals(0, Iterables.size(stereotypesChanges)); |
| |
| } |
| |
| /** |
| * Tests basic use case: |
| * <ol> |
| * <li>Creates a {@link StereotypedElementChange} of kind {@link DifferenceKind#ADD}</li> |
| * <li>Merges it from left to right</li> |
| * </ol> |
| * <p> |
| * <h3>Inputs</h3> |
| * <h4>Left model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <b><<ACliche>> <Class> Class0</b> |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * <b>ACliche [base <<ACliche>> <Class> Class0]</b> |
| * </pre> |
| * |
| * <h4>Right model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * </pre> |
| * |
| * <h4>Expected right model after merging</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <<ACliche>> <Class> Class0 |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * ACliche [base <<ACliche>> <Class> Class0] |
| * </pre> |
| * </p> |
| * |
| * @throws IOException |
| */ |
| protected void testAddStereotypedElementMergeLToR(Resource left, Resource right) throws IOException { |
| |
| final Comparison comparison = compare(left, right); |
| |
| // Checks comparison model |
| final EList<Diff> differences = comparison.getDifferences(); |
| final StereotypedElementChange stereotypedElementChange = getStereotypedElementChange(differences, |
| DifferenceKind.ADD, 2); |
| |
| assertAddedBaseElementDiff(differences, "model.Class0", stereotypedElementChange); //$NON-NLS-1$ |
| |
| // Merges |
| mergeLeftToRight(stereotypedElementChange); |
| |
| // Checks comparison model state |
| for (Diff diff : differences) { |
| assertSame(DifferenceState.MERGED, diff.getState()); |
| } |
| |
| // Checks right model content after merging |
| assertEqualsM1(right); |
| |
| // Checks left model content after merging |
| assertEqualsM1(left); |
| |
| } |
| |
| /** |
| * Tests basic use case: |
| * <ol> |
| * <li>Creates a {@link StereotypedElementChange} of kind {@link DifferenceKind#DELETE}</li> |
| * <li>Merges it from left to right</li> |
| * </ol> |
| * <p> |
| * <h3>Inputs</h3> |
| * <h4>Left model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * </pre> |
| * |
| * <h4>Right model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `--<b> <<ACliche>> <Class> Class0</b> |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * <b>ACliche [base <<ACliche>> <Class> Class0]</b> |
| * </pre> |
| * |
| * <h4>Expected right model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * </pre> |
| * </p> |
| * |
| * @throws IOException |
| */ |
| protected void testDelStereotypedElementMergeLToR(Resource left, Resource right) throws IOException { |
| |
| final Comparison comparison = compare(left, right); |
| |
| // Checks comparison model |
| final EList<Diff> differences = comparison.getDifferences(); |
| final StereotypedElementChange stereotypedElementChange = getStereotypedElementChange(differences, |
| DifferenceKind.DELETE, 2); |
| |
| assertDeletedBaseElementDiff(differences, "model.Class0", stereotypedElementChange); //$NON-NLS-1$ |
| |
| // Merges |
| mergeLeftToRight(stereotypedElementChange); |
| |
| // Checks comparison model |
| for (Diff diff : differences) { |
| assertSame(DifferenceState.MERGED, diff.getState()); |
| } |
| |
| // Checks right model content after merging |
| assertEqualsM2(right); |
| |
| // Checks left model content after merging |
| assertEqualsM2(left); |
| } |
| |
| /** |
| * Tests basic use case: |
| * <ol> |
| * <li>Creates a {@link StereotypedElementChange} of kind {@link DifferenceKind#ADD}</li> |
| * <li>Merges it from right to left</li> |
| * </ol> |
| * <p> |
| * <h3>Inputs</h3> |
| * <h4>Left model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <b><<ACliche>> <Class> Class0</b> |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * <b>ACliche [base <<ACliche>> <Class> Class0]</b> |
| * </pre> |
| * |
| * <h4>Right model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * </pre> |
| * |
| * <h4>Expected left model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * </pre> |
| * </p> |
| * |
| * @throws IOException |
| */ |
| protected void testAddStereotypedElementMergeRToL(Resource left, Resource right) throws IOException { |
| |
| final Comparison comparison = compare(left, right); |
| |
| // Checks comparison model |
| EList<Diff> differences = comparison.getDifferences(); |
| final StereotypedElementChange stereotypedElementChange = getStereotypedElementChange(differences, |
| DifferenceKind.ADD, 2); |
| assertAddedBaseElementDiff(differences, "model.Class0", stereotypedElementChange); //$NON-NLS-1$ |
| |
| // Merges |
| mergeRightToLeft(stereotypedElementChange); |
| |
| // Checks comparison model after merging |
| for (Diff diff : differences) { |
| assertTrue(isInTerminalState(diff)); |
| } |
| |
| // Checks right model content after merging |
| assertEqualsM2(right); |
| |
| // Checks left model content after merging |
| assertEqualsM2(left); |
| } |
| |
| /** |
| * Tests basic use case: |
| * <ol> |
| * <li>Creates a {@link StereotypedElementChange} of kind {@link DifferenceKind#DELETE}</li> |
| * <li>Merges it from right to left</li> |
| * </ol> |
| * <p> |
| * <h3>Inputs</h3> |
| * <h4>Left model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * </pre> |
| * |
| * <h4>Right model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <b><<ACliche>> <Class> Class0</b> |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * <b>ACliche [base <<ACliche>> <Class> Class0]</b> |
| * </pre> |
| * |
| * <h4>Expected left model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <<ACliche>> <Class> Class0 |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * ACliche [base <<ACliche>> <Class> Class0] |
| * </pre> |
| * </p> |
| * |
| * @throws IOException |
| */ |
| protected void testDelStereotypedElementMergeRToL(Resource left, Resource right) throws IOException { |
| |
| final Comparison comparison = compare(left, right); |
| |
| // Checks model structure |
| final EList<Diff> differences = comparison.getDifferences(); |
| final StereotypedElementChange stereotypedElementChange = getStereotypedElementChange(differences, |
| DifferenceKind.DELETE, 2); |
| |
| assertDeletedBaseElementDiff(differences, "model.Class0", stereotypedElementChange); //$NON-NLS-1$ |
| |
| // Merges |
| mergeRightToLeft(stereotypedElementChange); |
| for (Diff diff : differences) { |
| assertTrue(isInTerminalState(diff)); |
| } |
| |
| // Checks right model content after merging |
| assertEqualsM1(right); |
| |
| // Checks left model content after merging |
| assertEqualsM1(left); |
| } |
| |
| /** |
| * Tests advanced use case: |
| * <ol> |
| * <li>Creates a {@link StereotypedElementChange} of kind {@link DifferenceKind#ADD} with dependencies |
| * (requires creation of parent + profile application)</li> |
| * <li>Merges it from left to right</li> |
| * </ol> |
| * <p> |
| * <h3>Inputs</h3> |
| * <h4>Left model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <b><Model> MyNiceModel |
| * `-- <<ACliche>> <Class> Class1 |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * ACliche [base <<ACliche>> <Class> Class1]</b> |
| * </pre> |
| * |
| * <h4>Right model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * </pre> |
| * |
| * <h4>Expected right model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <Model> MyNiceModel |
| * `-- <<ACliche>> <Class> Class1 |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * ACliche [base <<ACliche>> <Class> Class1] |
| * </pre> |
| * </p> |
| * |
| * @throws IOException |
| */ |
| protected void testAddStereotypedElementLToR2(Resource left, Resource right) throws IOException { |
| |
| final Comparison comparison = compare(left, right); |
| |
| // Checks model structure |
| final EList<Diff> differences = comparison.getDifferences(); |
| final StereotypedElementChange stereotypedElementChange = getStereotypedElementChange(differences, |
| DifferenceKind.ADD, 2); |
| |
| assertAddedBaseElementDiff(differences, "model.MyNiceModel.Class1", stereotypedElementChange); //$NON-NLS-1$ |
| |
| // Merge |
| mergeLeftToRight(stereotypedElementChange); |
| |
| // Checks comparison model |
| for (Diff diff : differences) { |
| assertSame(DifferenceState.MERGED, diff.getState()); |
| } |
| |
| // Checks right model content after merging |
| assertEqualsM3(right); |
| |
| // Checks left model content after merging |
| assertEqualsM3(left); |
| |
| } |
| |
| /** |
| * Tests advanced use case: |
| * <ol> |
| * <li>Creates a {@link StereotypedElementChange} of kind {@link DifferenceKind#DELETE} with dependencies |
| * (requires creation of parent + profile application)</li> |
| * <li>Merges it from left to right</li> |
| * </ol> |
| * <p> |
| * <h3>Inputs</h3> |
| * <h4>Left model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * </pre> |
| * |
| * <h4>Right model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <Model> MyNiceModel |
| * `-- <<ACliche>> <Class> Class1 |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * ACliche [base <<ACliche>> <Class> Class1] |
| * </pre> |
| * |
| * <h4>Expected right model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <Model> MyNiceModel |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * </pre> |
| * </p> |
| * |
| * @throws IOException |
| */ |
| protected void testDelStereotypedElementLToR2(Resource left, Resource right) throws IOException { |
| |
| final Comparison comparison = compare(left, right); |
| |
| // Checks differences |
| final EList<Diff> differences = comparison.getDifferences(); |
| final StereotypedElementChange stereotypedElementChange = getStereotypedElementChange(differences, |
| DifferenceKind.DELETE, 2); |
| |
| assertDeletedBaseElementDiff(differences, "model.MyNiceModel.Class1", stereotypedElementChange); //$NON-NLS-1$ |
| |
| // Merges |
| mergeLeftToRight(stereotypedElementChange); |
| |
| // Checks comparison model |
| Set<Diff> expectedMergeDifferences = getRefinedByClosure(stereotypedElementChange); |
| for (Diff diff : differences) { |
| final DifferenceState expectedDiffState; |
| if (expectedMergeDifferences.contains(diff) || stereotypedElementChange.equals(diff)) { |
| expectedDiffState = DifferenceState.MERGED; |
| } else { |
| expectedDiffState = DifferenceState.UNRESOLVED; |
| } |
| assertSame(expectedDiffState, diff.getState()); |
| } |
| |
| // Checks the content of the right model after merging |
| // @formatter:off |
| EList<EObject> contents = right.getContents(); |
| assertEquals(1, contents.size()); |
| Model model = (Model)contents.get(0); |
| assertEquals(1, model.getPackagedElements().size()); |
| Model subModel = (Model)model.getPackagedElements().get(0); |
| assertEquals(0, subModel.getPackagedElements().size()); |
| assertEquals(1, subModel.getAppliedProfiles().size()); |
| // @formatter:on |
| |
| // Checks the content of the left model after merging |
| assertEqualsM6(left); |
| } |
| |
| /** |
| * Tests advanced use case: |
| * <ol> |
| * <li>Creates a {@link StereotypedElementChange} of kind {@link DifferenceKind#ADD} with dependencies |
| * (requires creation of parent + profile application)</li> |
| * <li>Merges it from right to left</li> |
| * </ol> |
| * <p> |
| * <p> |
| * <h3>Inputs</h3> |
| * <h4>Left model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `--<b> <Model> MyNiceModel |
| * `-- <<ACliche>> <Class> Class1 |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * ACliche [base <<ACliche>> <Class> Class1]</b> |
| * </pre> |
| * |
| * <h4>Right model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * </pre> |
| * |
| * <h4>Expected left model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `--<b> <Model> MyNiceModel |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * </pre> |
| * </p> |
| * |
| * @throws IOException |
| */ |
| protected void testAddStereotypedElementRToL2(Resource left, Resource right) throws IOException { |
| |
| final Comparison comparison = compare(left, right); |
| |
| // Checks differences |
| final EList<Diff> differences = comparison.getDifferences(); |
| final StereotypedElementChange stereotypedElementChange = getStereotypedElementChange(differences, |
| DifferenceKind.ADD, 2); |
| |
| assertAddedBaseElementDiff(differences, "model.MyNiceModel.Class1", stereotypedElementChange); //$NON-NLS-1$ |
| |
| // Merges |
| mergeRightToLeft(stereotypedElementChange); |
| |
| // Checks comparison model after merging |
| Set<Diff> expectedMergeDifferences = getRefinedByClosure(stereotypedElementChange); |
| for (Diff diff : differences) { |
| final DifferenceState expectedDiffState; |
| if (expectedMergeDifferences.contains(diff) || stereotypedElementChange.equals(diff)) { |
| expectedDiffState = DifferenceState.DISCARDED; |
| } else { |
| expectedDiffState = DifferenceState.UNRESOLVED; |
| } |
| assertSame(expectedDiffState, diff.getState()); |
| } |
| |
| // Checks left model content after merging |
| // @formatter:off |
| EList<EObject> contents = left.getContents(); |
| assertEquals(1, contents.size()); |
| Model model = (Model)contents.get(0); |
| assertEquals(1, model.getPackagedElements().size()); |
| Model subModel = (Model)model.getPackagedElements().get(0); |
| assertEquals(0, subModel.getPackagedElements().size()); |
| assertEquals(1, subModel.getAppliedProfiles().size()); |
| // @formatter:on |
| |
| // Checks right model content after merging |
| assertEqualsM6(right); |
| } |
| |
| /** |
| * Tests advanced use case: |
| * <ol> |
| * <li>Creates a {@link StereotypedElementChange} of kind {@link DifferenceKind#DELL} with dependencies |
| * </li> |
| * <li>Merges it from right to left</li> |
| * </ol> |
| * <p> |
| * <h3>Inputs</h3> |
| * <h4>Left model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * </pre> |
| * |
| * <h4>Right model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `--<b> <Model> MyNiceModel |
| * `-- <<ACliche>> <Class> Class1 |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * ACliche [base <<ACliche>> <Class> Class1]</b> |
| * </pre> |
| * |
| * <h4>Expected left model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <Model> MyNiceModel |
| * `-- <<ACliche>> <Class> Class1 |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * ACliche [base <<ACliche>> <Class> Class1] |
| * </pre> |
| * </p> |
| * |
| * @throws IOException |
| */ |
| protected void testDelStereotypedElementRToL2(Resource left, Resource right) throws IOException { |
| |
| final Comparison comparison = compare(left, right); |
| |
| // Checks model structure |
| final EList<Diff> differences = comparison.getDifferences(); |
| final StereotypedElementChange stereotypedElementChange = getStereotypedElementChange(differences, |
| DifferenceKind.DELETE, 2); |
| |
| assertDeletedBaseElementDiff(differences, "model.MyNiceModel.Class1", stereotypedElementChange); //$NON-NLS-1$ |
| // Merges |
| mergeRightToLeft(stereotypedElementChange); |
| |
| // Check comparison model |
| // Everything should be merged |
| for (Diff diff : differences) { |
| assertTrue(isInTerminalState(diff)); |
| } |
| |
| // Checks left model content after merging |
| assertEqualsM3(left); |
| |
| // Checks right model content after merging |
| assertEqualsM3(right); |
| |
| } |
| |
| /** |
| * Tests to merge a {@link StereotypedElementChange} of kind ADD with 2 stereotypes being applied from |
| * left to right. |
| * <p> |
| * <h3>Inputs</h3> |
| * <h4>Left model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `--<b> <<ACliche, ACliche3>> <Class> Class0</b> |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * <b>ACliche [base <<ACliche, ACliche3>> <Class> Class0]</b> |
| * <b>ACliche3 [base <<ACliche, ACliche3>> <Class> Class0]</b> |
| * </pre> |
| * |
| * <h4>Right model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * </pre> |
| * |
| * <h4>Expected right model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <<ACliche, ACliche3>> <Class> Class0 |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * ACliche [base <<ACliche, ACliche3>> <Class> Class0] |
| * ACliche3 [base <<ACliche, ACliche3>> <Class> Class0] |
| * </pre> |
| * </p> |
| * |
| * @param left |
| * @param right |
| */ |
| protected void testAddMultipleStereotypesLToR(Resource left, Resource right) { |
| final Comparison comparison = compare(left, right); |
| |
| // Checks differences |
| final EList<Diff> differences = comparison.getDifferences(); |
| final StereotypedElementChange stereotypedElementChange = getStereotypedElementChange(differences, |
| DifferenceKind.ADD, 3); |
| |
| assertAddedBaseElementDiff(differences, "model.Class0", stereotypedElementChange); //$NON-NLS-1$ |
| |
| // Merges |
| mergeLeftToRight(stereotypedElementChange); |
| |
| // Checks comparison model after merging |
| for (Diff diff : differences) { |
| assertSame(DifferenceState.MERGED, diff.getState()); |
| } |
| |
| // Checks right model content after merging |
| assertEqualsM7(right); |
| |
| // Checks left model content after merging |
| assertEqualsM7(left); |
| |
| } |
| |
| /** |
| * Tests to merge of a {@link StereotypedElementChange} of kind ADD with 2 stereotypes being applied from |
| * right to left. |
| * <p> |
| * <h3>Inputs</h3> |
| * <h4>Left model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <b><<ACliche, ACliche3>> <Class> Class0</b> |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * <b>ACliche [base <<ACliche, ACliche3>> <Class> Class0]</b> |
| * <b>ACliche3 [base <<ACliche, ACliche3>> <Class> Class0]</b> |
| * </pre> |
| * |
| * <h4>Right model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * </pre> |
| * |
| * <h4>Expected left model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * </pre> |
| * |
| * @param left |
| * @param right |
| */ |
| protected void testAddMultipleStereotypesRToL(Resource left, Resource right) { |
| final Comparison comparison = compare(left, right); |
| |
| // Checks differences |
| final EList<Diff> differences = comparison.getDifferences(); |
| final StereotypedElementChange stereotypedElementChange = getStereotypedElementChange(differences, |
| DifferenceKind.ADD, 3); |
| |
| assertAddedBaseElementDiff(differences, "model.Class0", stereotypedElementChange); //$NON-NLS-1$ |
| |
| // Merges |
| mergeRightToLeft(stereotypedElementChange); |
| |
| // Check comparison model |
| for (Diff diff : differences) { |
| assertTrue(isInTerminalState(diff)); |
| } |
| |
| // Checks left model content after merging |
| assertEqualsM2(left); |
| |
| // Checks right model content after merging |
| assertEqualsM2(right); |
| |
| } |
| |
| /** |
| * Tests to merge a {@link StereotypedElementChange} of kind DELETE in conflict with another diff from |
| * right to left. |
| * <p> |
| * <h3>Inputs</h3> |
| * <h4>Left model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <b><<ACliche, ACliche3>> <Class> Class0_newName</b> |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * <b>ACliche [base <<ACliche, ACliche3>> <Class> Class0_newName]</b> |
| * <b>ACliche3 [base <<ACliche, ACliche3>> <Class> Class0_newName]</b> |
| * </pre> |
| * |
| * <h4>Right model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * </pre> |
| * |
| * <h4>Ancestor model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <<ACliche, ACliche3>> <Class> Class0 |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * ACliche [base <<ACliche, ACliche3>> <Class> Class0] |
| * ACliche3 [base <<ACliche, ACliche3>> <Class> Class0] |
| * </pre> |
| * |
| * <h4>Expected left model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * </pre> |
| * </p> |
| * |
| * @param left |
| * @param right |
| * @param origin |
| */ |
| protected void testDelConflictRToL(Resource left, Resource right, Resource origin) { |
| final Comparison comparison = compare(left, right, origin); |
| |
| // Checks differences |
| final EList<Diff> differences = comparison.getDifferences(); |
| final StereotypedElementChange stereotypedElementChange = getStereotypedElementChange(differences, |
| DifferenceKind.DELETE, 3); |
| |
| final ReferenceChange baseDiff = assertDeletedBaseElementDiff(differences, "model.Class0", //$NON-NLS-1$ |
| stereotypedElementChange); |
| |
| // the stereotype change itself is not in a conflict |
| assertNull(stereotypedElementChange.getConflict()); |
| |
| // but one of its refining diffs is in exactly one conflict |
| final Set<Conflict> conflicts = getConflictsOfRefiningDiffs(stereotypedElementChange); |
| final Conflict conflict = Iterables.getOnlyElement(conflicts); |
| |
| assertNotNull(conflict); |
| assertEquals(2, conflict.getDifferences().size()); |
| |
| final EList<Diff> leftDifferences = conflict.getLeftDifferences(); |
| assertEquals(1, leftDifferences.size()); |
| |
| final Diff leftDiff = leftDifferences.get(0); |
| assertTrue(leftDiff instanceof AttributeChange); |
| assertEquals(1, conflict.getRightDifferences().size()); |
| assertTrue(conflict.getRightDifferences().contains(baseDiff)); |
| |
| // Merges |
| mergeRightToLeft(stereotypedElementChange); |
| |
| for (Diff diff : differences) { |
| assertTrue(isInTerminalState(diff)); |
| } |
| // Checks left model content after merging |
| assertEqualsM2(left); |
| |
| // Checks right model content after merging |
| assertEqualsM2(right); |
| |
| } |
| |
| /** |
| * Tests to merge a {@link StereotypedElementChange} of kind DELETE in conflict with another diff from |
| * left to right. |
| * <p> |
| * <h3>Inputs</h3> |
| * <h4>Left model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <b><<ACliche, ACliche3>> <Class> Class0_newName</b> |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * <b>ACliche [base <<ACliche, ACliche3>> <Class> Class0_newName]</b> |
| * <b>ACliche3 [base <<ACliche, ACliche3>> <Class> Class0_newName]</b> |
| * </pre> |
| * |
| * <h4>Right model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * </pre> |
| * |
| * <h4>Ancestor model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <<ACliche, ACliche3>> <Class> Class0 |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * ACliche [base <<ACliche, ACliche3>> <Class> Class0] |
| * ACliche3 [base <<ACliche, ACliche3>> <Class> Class0] |
| * </pre> |
| * |
| * <h4>Expected right model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <<ACliche, ACliche3>> <Class> Class0_newName |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * ACliche [base <<ACliche, ACliche3>> <Class> Class0_newName] |
| * ACliche3 [base <<ACliche, ACliche3>> <Class> Class0_newName] |
| * </pre> |
| * </p> |
| * |
| * @param left |
| * @param right |
| * @param origin |
| */ |
| protected void testAbstractDelConflictLToR(Resource left, Resource right, Resource origin) { |
| final Comparison comparison = compare(left, right, origin); |
| |
| // Checks model structure |
| final EList<Diff> differences = comparison.getDifferences(); |
| final StereotypedElementChange stereotypedElementChange = getStereotypedElementChange(differences, |
| DifferenceKind.DELETE, 3); |
| |
| final ReferenceChange baseDiff = assertDeletedBaseElementDiff(differences, "model.Class0", //$NON-NLS-1$ |
| stereotypedElementChange); |
| |
| // the stereotype change itself is not in a conflict |
| assertNull(stereotypedElementChange.getConflict()); |
| |
| // but one of its refining diffs is in exactly one conflict |
| final Set<Conflict> conflicts = getConflictsOfRefiningDiffs(stereotypedElementChange); |
| final Conflict conflict = Iterables.getOnlyElement(conflicts); |
| assertEquals(2, conflict.getDifferences().size()); |
| |
| final EList<Diff> leftDifferences = conflict.getLeftDifferences(); |
| assertEquals(1, leftDifferences.size()); |
| |
| final Diff leftConflictDiff = leftDifferences.get(0); |
| |
| assertTrue(leftConflictDiff instanceof AttributeChange); |
| assertEquals(1, conflict.getRightDifferences().size()); |
| assertTrue(conflict.getRightDifferences().contains(baseDiff)); |
| // Merges |
| mergeLeftToRight(stereotypedElementChange); |
| |
| for (Diff diff : differences) { |
| if (leftConflictDiff.equals(diff)) { |
| assertSame(DifferenceState.UNRESOLVED, diff.getState()); |
| } else { |
| assertSame(DifferenceState.DISCARDED, diff.getState()); |
| } |
| } |
| |
| // Checks right model content after merging |
| assertEqualsM4(right); |
| |
| // Checks left model content after merging |
| assertEqualsM5(left); |
| |
| } |
| |
| /** |
| * Returns the conflicts of the refining diffs of the given {@code refinedDiff}. |
| * |
| * @param refinedDiff |
| * The refined diff to get the conflicts from. |
| * @return the list of conflicts. |
| */ |
| private Set<Conflict> getConflictsOfRefiningDiffs(Diff refinedDiff) { |
| Builder<Conflict> builder = ImmutableSet.builder(); |
| for (Diff refiningDiff : refinedDiff.getRefinedBy()) { |
| if (refiningDiff.getConflict() != null) { |
| builder.add(refiningDiff.getConflict()); |
| } |
| } |
| return builder.build(); |
| } |
| |
| /** |
| * Checks that the input has the same structure than described bellow: |
| * <p> |
| * <h4>Expected model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <<ACliche>> <Class> Class0 |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * ACliche [base <<ACliche>> <Class> Class0] |
| * </pre> |
| * </p> |
| * |
| * @param input |
| */ |
| private void assertEqualsM1(final Resource input) { |
| // @formatter:off |
| EList<EObject> contents = input.getContents(); |
| assertEquals(2, contents.size()); |
| Model model = (Model)contents.get(0); |
| assertEquals(1, model.getPackagedElements().size()); |
| Class clazz = (Class)model.getPackagedElements().get(0); |
| assertEquals(1, clazz.getAppliedStereotypes().size()); |
| assertEquals(1, model.getAppliedProfiles().size()); |
| EObject stereotypeApplication = contents.get(1); |
| assertSame(clazz, UMLUtil.getBaseElement(stereotypeApplication)); |
| // @formatter:on |
| } |
| |
| /** |
| * Checks that the input has the same structure than described bellow: |
| * <p> |
| * <h4>Expected model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * </pre> |
| * </p> |
| * |
| * @param input |
| */ |
| private void assertEqualsM2(final Resource input) { |
| // @formatter:off |
| EList<EObject> contents = input.getContents(); |
| assertEquals(1, contents.size()); |
| Model model = (Model)contents.get(0); |
| assertEquals(0, model.getPackagedElements().size()); |
| assertEquals(1, model.getAppliedProfiles().size()); |
| // @formatter:on |
| } |
| |
| /** |
| * Checks that the input has the same structure than described bellow: |
| * <p> |
| * <h4>Expected model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <Model> MyNiceModel |
| * `-- <<ACliche>> <Class> Class1 |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * ACliche [base <<ACliche>> <Class> Class1] |
| * </pre> |
| * </p> |
| * |
| * @param input |
| */ |
| private void assertEqualsM3(Resource input) { |
| // @formatter:off |
| EList<EObject> contents = input.getContents(); |
| assertEquals(2, contents.size()); |
| Model model = (Model)contents.get(0); |
| assertEquals(1, model.getPackagedElements().size()); |
| Model subModel = (Model)model.getPackagedElements().get(0); |
| assertEquals(1, subModel.getPackagedElements().size()); |
| Class clazz = (Class)subModel.getPackagedElements().get(0); |
| assertEquals(1, clazz.getAppliedStereotypes().size()); |
| assertEquals(1, subModel.getAppliedProfiles().size()); |
| EObject stereotypeApplication = contents.get(1); |
| assertSame(clazz, UMLUtil.getBaseElement(stereotypeApplication)); |
| // @formatter:on |
| } |
| |
| /** |
| * Checks that the input has the same structure than described bellow: |
| * <p> |
| * <h4>Expected model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <<ACliche, ACliche3>> <Class> Class0_newName |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * ACliche [base <<ACliche, ACliche3>> <Class> Class0_newName] |
| * ACliche3 [base <<ACliche, ACliche3>> <Class> Class0_newName] |
| * </pre> |
| * </p> |
| * |
| * @param input |
| */ |
| private void assertEqualsM4(Resource right) { |
| // @formatter:off |
| EList<EObject> contents = right.getContents(); |
| assertEquals(3, contents.size()); |
| Model model = (Model)contents.get(0); |
| assertEquals(1, model.getPackagedElements().size()); |
| Class clazz = (Class)model.getPackagedElements().get(0); |
| assertEquals(2, clazz.getAppliedStereotypes().size()); |
| assertEquals("Class0", clazz.getName()); //$NON-NLS-1$ |
| assertEquals(1, model.getAppliedProfiles().size()); |
| EObject stereotypeApplication = contents.get(1); |
| assertSame(clazz, UMLUtil.getBaseElement(stereotypeApplication)); |
| EObject stereotypeApplication2 = contents.get(2); |
| assertSame(clazz, UMLUtil.getBaseElement(stereotypeApplication2)); |
| // @formatter:on |
| } |
| |
| /** |
| * Checks that the input has the same structure than described bellow: |
| * <p> |
| * <h4>Expected model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <<ACliche, ACliche3>> <Class> Class0_newName |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * ACliche [base <<ACliche, ACliche3>> <Class> Class0_newName] |
| * ACliche3 [base <<ACliche, ACliche3>> <Class> Class0_newName] |
| * </pre> |
| * </p> |
| * |
| * @param input |
| */ |
| private void assertEqualsM5(Resource right) { |
| // @formatter:off |
| EList<EObject> contents = right.getContents(); |
| assertEquals(3, contents.size()); |
| Model model = (Model)contents.get(0); |
| assertEquals(1, model.getPackagedElements().size()); |
| Class clazz = (Class)model.getPackagedElements().get(0); |
| assertEquals(2, clazz.getAppliedStereotypes().size()); |
| assertEquals("Class0_newName", clazz.getName()); //$NON-NLS-1$ |
| assertEquals(1, model.getAppliedProfiles().size()); |
| EObject stereotypeApplication = contents.get(1); |
| assertSame(clazz, UMLUtil.getBaseElement(stereotypeApplication)); |
| EObject stereotypeApplication2 = contents.get(2); |
| assertSame(clazz, UMLUtil.getBaseElement(stereotypeApplication2)); |
| // @formatter:on |
| } |
| |
| /** |
| * Checks that the input has the same structure than described bellow: |
| * <p> |
| * <h4>Expected model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * </pre> |
| * </p> |
| * |
| * @param input |
| */ |
| private void assertEqualsM6(Resource input) { |
| // @formatter:off |
| EList<EObject> leftContent = input.getContents(); |
| assertEquals(1, leftContent.size()); |
| Model leftModel = (Model)leftContent.get(0); |
| assertEquals(0, leftModel.getPackagedElements().size()); |
| assertEquals(0, leftModel.getAppliedProfiles().size()); |
| // @formatter:on |
| } |
| |
| /** |
| * Checks that the input has the same structure than described bellow: |
| * <p> |
| * <h4>Expected model</h4> |
| * |
| * <pre> |
| * <Model> model |
| * `-- <<ACliche, ACliche3>> <Class> Class0 |
| * `-- <Profile Application> UML2CompareTestProfile |
| * `-- UML |
| * ACliche [base <<ACliche, ACliche3>> <Class> Class0] |
| * ACliche3 [base <<ACliche, ACliche3>> <Class> Class0] |
| * </pre> |
| * </p> |
| * |
| * @param input |
| */ |
| private void assertEqualsM7(Resource inputs) { |
| // @formatter:off |
| EList<EObject> contents = inputs.getContents(); |
| assertEquals(3, contents.size()); |
| Model model = (Model)contents.get(0); |
| assertEquals(1, model.getPackagedElements().size()); |
| Class clazz = (Class)model.getPackagedElements().get(0); |
| assertEquals(2, clazz.getAppliedStereotypes().size()); |
| assertEquals(1, model.getAppliedProfiles().size()); |
| EObject stereotypeApplication = contents.get(1); |
| assertSame(clazz, UMLUtil.getBaseElement(stereotypeApplication)); |
| EObject stereotypeApplication2 = contents.get(2); |
| assertSame(clazz, UMLUtil.getBaseElement(stereotypeApplication2)); |
| // @formatter:on |
| } |
| |
| private StereotypedElementChange getStereotypedElementChange(final EList<Diff> differences, |
| DifferenceKind diffKind, int expectedRefine) { |
| Iterable<StereotypedElementChange> stereotypesChanges = getStereotypedElementChanges(differences, |
| diffKind); |
| assertEquals(1, Iterables.size(stereotypesChanges)); |
| final StereotypedElementChange stereotypedElementChange = stereotypesChanges.iterator().next(); |
| assertSame(diffKind, stereotypedElementChange.getKind()); |
| assertEquals(expectedRefine, stereotypedElementChange.getRefinedBy().size()); |
| return stereotypedElementChange; |
| } |
| |
| /** |
| * Gets the closure of the refined by elements from a starting diff. |
| * |
| * @param startingDiff |
| * @return |
| */ |
| private Set<Diff> getRefinedByClosure(Diff startingDiff) { |
| Set<Diff> result = new HashSet<Diff>(); |
| for (Diff refinedByDiff : startingDiff.getRefinedBy()) { |
| if (!result.contains(refinedByDiff)) { |
| getRefinedByClosure(refinedByDiff, result); |
| } |
| } |
| return result; |
| } |
| |
| private void getRefinedByClosure(Diff d, Set<Diff> result) { |
| result.add(d); |
| for (Diff refinedByDiff : d.getRefinedBy()) { |
| if (!result.contains(refinedByDiff)) { |
| getRefinedByClosure(refinedByDiff, result); |
| } |
| } |
| } |
| |
| protected void mergeLeftToRight(Diff difference) { |
| BatchMerger merger = new BatchMerger(getMergerRegistry()); |
| merger.copyAllLeftToRight(Collections.singleton(difference), new BasicMonitor()); |
| } |
| |
| protected void mergeRightToLeft(Diff difference) { |
| BatchMerger merger = new BatchMerger(getMergerRegistry()); |
| merger.copyAllRightToLeft(Collections.singleton(difference), new BasicMonitor()); |
| } |
| |
| private ReferenceChange assertAddedBaseElementDiff(Iterable<Diff> differences, String qualifiedName, |
| StereotypedElementChange stereotypedElementChange) { |
| ReferenceChange referenceChange = (ReferenceChange)Iterables.find(differences, added(qualifiedName)); |
| assertTrue(stereotypedElementChange.getRefinedBy().contains(referenceChange)); |
| assertSame(referenceChange.getValue(), stereotypedElementChange.getDiscriminant()); |
| return referenceChange; |
| } |
| |
| private ReferenceChange assertDeletedBaseElementDiff(Iterable<Diff> differences, String qualifiedName, |
| StereotypedElementChange stereotypedElementChange) { |
| ReferenceChange referenceChange = (ReferenceChange)Iterables.find(differences, |
| removed(qualifiedName)); |
| assertTrue(stereotypedElementChange.getRefinedBy().contains(referenceChange)); |
| assertSame(referenceChange.getValue(), stereotypedElementChange.getDiscriminant()); |
| return referenceChange; |
| } |
| |
| /** |
| * Gets the {@link StereotypedElementChange}s contained in the input differences. |
| * |
| * @param differences |
| * Input differences. |
| * @param diffKind |
| * Kind of difference you are looking for. |
| * @return |
| */ |
| private Iterable<StereotypedElementChange> getStereotypedElementChanges(Iterable<Diff> differences, |
| DifferenceKind diffKind) { |
| final Predicate<Diff> selectingPredicate = and(instanceOf(StereotypedElementChange.class), |
| ofKind(diffKind)); |
| return Iterables.transform(Iterables.filter(differences, selectingPredicate), |
| new Function<Diff, StereotypedElementChange>() { |
| |
| public StereotypedElementChange apply(Diff input) { |
| return (StereotypedElementChange)input; |
| } |
| }); |
| } |
| |
| } |
