| /******************************************************************************* |
| * Copyright (c) 2012, 2014 Obeo. |
| * 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 |
| *******************************************************************************/ |
| package org.eclipse.emf.compare.uml2.tests.generalizationSet; |
| |
| import static com.google.common.base.Predicates.and; |
| import static com.google.common.base.Predicates.instanceOf; |
| 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.onEObject; |
| import static org.eclipse.emf.compare.utils.EMFComparePredicates.referenceValueMatch; |
| 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.assertTrue; |
| |
| import com.google.common.base.Predicate; |
| import com.google.common.collect.Iterators; |
| |
| import java.io.IOException; |
| import java.util.List; |
| |
| import org.eclipse.emf.compare.Comparison; |
| import org.eclipse.emf.compare.Diff; |
| import org.eclipse.emf.compare.DifferenceKind; |
| import org.eclipse.emf.compare.uml2.internal.GeneralizationSetChange; |
| import org.eclipse.emf.compare.uml2.tests.AbstractUMLInputData; |
| import org.eclipse.emf.compare.uml2.tests.AbstractUMLTest; |
| import org.eclipse.emf.compare.uml2.tests.generalizationSet.data.GeneralizationSetInputData; |
| import org.eclipse.emf.ecore.EStructuralFeature; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.uml2.uml.UMLPackage; |
| import org.junit.AfterClass; |
| import org.junit.BeforeClass; |
| import org.junit.Test; |
| |
| @SuppressWarnings("nls") |
| public class AddGeneralizationSetTest extends AbstractUMLTest { |
| |
| private GeneralizationSetInputData input = new GeneralizationSetInputData(); |
| |
| @BeforeClass |
| public static void setupClass() { |
| fillRegistries(); |
| } |
| |
| @AfterClass |
| public static void teardownClass() { |
| resetRegistries(); |
| } |
| |
| @Test |
| public void testA10UseCase() throws IOException { |
| final Resource left = input.getA1Left(); |
| final Resource right = input.getA1Right(); |
| |
| final Comparison comparison = compare(left, right); |
| testAB1(TestKind.ADD, comparison); |
| |
| testMergeLeftToRight(left, right, null); |
| testMergeRightToLeft(left, right, null); |
| } |
| |
| @Test |
| public void testA11UseCase() throws IOException { |
| final Resource left = input.getA1Left(); |
| final Resource right = input.getA1Right(); |
| |
| final Comparison comparison = compare(right, left); |
| testAB1(TestKind.DELETE, comparison); |
| |
| testMergeLeftToRight(right, left, null); |
| testMergeRightToLeft(right, left, null); |
| } |
| |
| @Test |
| public void testA10UseCase3way() throws IOException { |
| final Resource left = input.getA1Left(); |
| final Resource right = input.getA1Right(); |
| |
| final Comparison comparison = compare(left, right, right); |
| testAB1(TestKind.ADD, comparison); |
| |
| testMergeLeftToRight(left, right, right); |
| testMergeRightToLeft(left, right, right); |
| } |
| |
| @Test |
| public void testA11UseCase3way() throws IOException { |
| final Resource left = input.getA1Left(); |
| final Resource right = input.getA1Right(); |
| |
| final Comparison comparison = compare(left, right, left); |
| testAB1(TestKind.DELETE, comparison); |
| |
| testMergeLeftToRight(left, right, left); |
| testMergeRightToLeft(left, right, left); |
| } |
| |
| private void testAB1(TestKind kind, final Comparison comparison) { |
| final List<Diff> differences = comparison.getDifferences(); |
| |
| // We should have no less and no more than 6 differences |
| assertEquals(6, differences.size()); |
| |
| Predicate<? super Diff> addGeneralizationSetDescription = null; |
| Predicate<? super Diff> addRefGeneralizationSetInClass2Description = null; |
| Predicate<? super Diff> addRefGeneralizationSetInClass0Description = null; |
| Predicate<? super Diff> addRefGeneralizationInGeneralizationSetDescription1 = null; |
| Predicate<? super Diff> addRefGeneralizationInGeneralizationSetDescription2 = null; |
| |
| if (kind.equals(TestKind.DELETE)) { |
| addGeneralizationSetDescription = removed("model.GeneralizationSet_Class2_Class0"); //$NON-NLS-1$ |
| addRefGeneralizationSetInClass2Description = removedFromReference1("model.Class2.Class1", |
| "generalizationSet", "model.GeneralizationSet_Class2_Class0", |
| UMLPackage.Literals.GENERALIZATION__GENERAL); |
| addRefGeneralizationSetInClass0Description = removedFromReference1("model.Class0.Class1", |
| "generalizationSet", "model.GeneralizationSet_Class2_Class0", |
| UMLPackage.Literals.GENERALIZATION__GENERAL); |
| addRefGeneralizationInGeneralizationSetDescription1 = removedFromReference2( |
| "model.GeneralizationSet_Class2_Class0", "generalization", "model.Class0.Class1", |
| UMLPackage.Literals.GENERALIZATION__GENERAL); |
| addRefGeneralizationInGeneralizationSetDescription2 = removedFromReference2( |
| "model.GeneralizationSet_Class2_Class0", "generalization", "model.Class2.Class1", |
| UMLPackage.Literals.GENERALIZATION__GENERAL); |
| } else { |
| addGeneralizationSetDescription = added("model.GeneralizationSet_Class2_Class0"); //$NON-NLS-1$ |
| addRefGeneralizationSetInClass2Description = addedToReference1("model.Class2.Class1", |
| "generalizationSet", "model.GeneralizationSet_Class2_Class0", |
| UMLPackage.Literals.GENERALIZATION__GENERAL); |
| addRefGeneralizationSetInClass0Description = addedToReference1("model.Class0.Class1", |
| "generalizationSet", "model.GeneralizationSet_Class2_Class0", |
| UMLPackage.Literals.GENERALIZATION__GENERAL); |
| addRefGeneralizationInGeneralizationSetDescription1 = addedToReference2( |
| "model.GeneralizationSet_Class2_Class0", "generalization", "model.Class0.Class1", |
| UMLPackage.Literals.GENERALIZATION__GENERAL); |
| addRefGeneralizationInGeneralizationSetDescription2 = addedToReference2( |
| "model.GeneralizationSet_Class2_Class0", "generalization", "model.Class2.Class1", |
| UMLPackage.Literals.GENERALIZATION__GENERAL); |
| } |
| |
| final Diff addGeneralizationSet = Iterators.find(differences.iterator(), |
| addGeneralizationSetDescription); |
| final Diff addRefGeneralizationSetInClass0 = Iterators.find(differences.iterator(), |
| addRefGeneralizationSetInClass0Description); |
| final Diff addRefGeneralizationSetInClass2 = Iterators.find(differences.iterator(), |
| addRefGeneralizationSetInClass2Description); |
| final Diff addRefGeneralizationInGeneralizationSet1 = Iterators.find(differences.iterator(), |
| addRefGeneralizationInGeneralizationSetDescription1); |
| final Diff addRefGeneralizationInGeneralizationSet2 = Iterators.find(differences.iterator(), |
| addRefGeneralizationInGeneralizationSetDescription2); |
| |
| assertNotNull(addGeneralizationSet); |
| assertNotNull(addRefGeneralizationSetInClass0); |
| assertNotNull(addRefGeneralizationSetInClass2); |
| assertNotNull(addRefGeneralizationInGeneralizationSet1); |
| assertNotNull(addRefGeneralizationInGeneralizationSet2); |
| |
| // CHECK EXTENSION |
| assertEquals(1, count(differences, instanceOf(GeneralizationSetChange.class))); |
| Diff addUMLGeneralizationSet = null; |
| if (kind.equals(TestKind.ADD)) { |
| addUMLGeneralizationSet = Iterators.find(differences.iterator(), |
| and(instanceOf(GeneralizationSetChange.class), ofKind(DifferenceKind.ADD))); |
| } else { |
| addUMLGeneralizationSet = Iterators.find(differences.iterator(), |
| and(instanceOf(GeneralizationSetChange.class), ofKind(DifferenceKind.DELETE))); |
| } |
| assertNotNull(addUMLGeneralizationSet); |
| assertEquals(5, addUMLGeneralizationSet.getRefinedBy().size()); |
| assertTrue(addUMLGeneralizationSet.getRefinedBy().contains(addRefGeneralizationInGeneralizationSet1)); |
| assertTrue(addUMLGeneralizationSet.getRefinedBy().contains(addRefGeneralizationInGeneralizationSet2)); |
| assertTrue(addUMLGeneralizationSet.getRefinedBy().contains(addGeneralizationSet)); |
| assertTrue(addUMLGeneralizationSet.getRefinedBy().contains(addRefGeneralizationSetInClass0)); |
| assertTrue(addUMLGeneralizationSet.getRefinedBy().contains(addRefGeneralizationSetInClass2)); |
| |
| // CHECK REQUIREMENT |
| if (kind.equals(TestKind.ADD)) { |
| assertEquals(1, addRefGeneralizationInGeneralizationSet1.getRequires().size()); |
| assertTrue(addRefGeneralizationInGeneralizationSet1.getRequires().contains(addGeneralizationSet)); |
| |
| assertEquals(1, addRefGeneralizationInGeneralizationSet2.getRequires().size()); |
| assertTrue(addRefGeneralizationInGeneralizationSet2.getRequires().contains(addGeneralizationSet)); |
| |
| assertEquals(1, addRefGeneralizationSetInClass0.getRequires().size()); |
| assertTrue(addRefGeneralizationSetInClass0.getRequires().contains(addGeneralizationSet)); |
| |
| assertEquals(1, addRefGeneralizationSetInClass2.getRequires().size()); |
| assertTrue(addRefGeneralizationSetInClass2.getRequires().contains(addGeneralizationSet)); |
| |
| assertEquals(0, addGeneralizationSet.getRequires().size()); |
| assertEquals(0, addUMLGeneralizationSet.getRequires().size()); |
| } else { |
| assertEquals(0, addRefGeneralizationInGeneralizationSet1.getRequires().size()); |
| |
| assertEquals(0, addRefGeneralizationInGeneralizationSet2.getRequires().size()); |
| |
| assertEquals(0, addRefGeneralizationSetInClass0.getRequires().size()); |
| |
| assertEquals(0, addRefGeneralizationSetInClass2.getRequires().size()); |
| |
| assertEquals(4, addGeneralizationSet.getRequires().size()); |
| assertTrue(addGeneralizationSet.getRequires().contains(addRefGeneralizationInGeneralizationSet1)); |
| assertTrue(addGeneralizationSet.getRequires().contains(addRefGeneralizationInGeneralizationSet2)); |
| assertTrue(addGeneralizationSet.getRequires().contains(addRefGeneralizationSetInClass0)); |
| assertTrue(addGeneralizationSet.getRequires().contains(addRefGeneralizationSetInClass2)); |
| |
| assertEquals(0, addUMLGeneralizationSet.getRequires().size()); |
| } |
| |
| // CHECK EQUIVALENCE |
| assertEquals(2, comparison.getEquivalences().size()); |
| |
| assertNotNull(addRefGeneralizationInGeneralizationSet1.getEquivalence()); |
| assertEquals(2, addRefGeneralizationInGeneralizationSet1.getEquivalence().getDifferences().size()); |
| assertTrue(addRefGeneralizationInGeneralizationSet1.getEquivalence().getDifferences() |
| .contains(addRefGeneralizationSetInClass0)); |
| |
| assertNotNull(addRefGeneralizationInGeneralizationSet2.getEquivalence()); |
| assertEquals(2, addRefGeneralizationInGeneralizationSet2.getEquivalence().getDifferences().size()); |
| assertTrue(addRefGeneralizationInGeneralizationSet2.getEquivalence().getDifferences() |
| .contains(addRefGeneralizationSetInClass2)); |
| |
| testIntersections(comparison); |
| |
| } |
| |
| public static Predicate<? super Diff> removedFromReference1(final String qualifiedName, |
| final String referenceName, final String removedQualifiedName, |
| final EStructuralFeature featureDelegate) { |
| // This is only meant for multi-valued references |
| return and(ofKind(DifferenceKind.DELETE), onEObject(qualifiedName, featureDelegate), |
| referenceValueMatch(referenceName, removedQualifiedName, true)); |
| } |
| |
| public static Predicate<? super Diff> removedFromReference2(final String qualifiedName, |
| final String referenceName, final String removedQualifiedName, |
| final EStructuralFeature featureDelegate) { |
| // This is only meant for multi-valued references |
| return and(ofKind(DifferenceKind.DELETE), onEObject(qualifiedName), |
| referenceValueMatch(referenceName, removedQualifiedName, true, featureDelegate)); |
| } |
| |
| public static Predicate<? super Diff> addedToReference1(final String qualifiedName, |
| final String referenceName, final String removedQualifiedName, |
| final EStructuralFeature featureDelegate) { |
| // This is only meant for multi-valued references |
| return and(ofKind(DifferenceKind.ADD), onEObject(qualifiedName, featureDelegate), |
| referenceValueMatch(referenceName, removedQualifiedName, true)); |
| } |
| |
| public static Predicate<? super Diff> addedToReference2(final String qualifiedName, |
| final String referenceName, final String removedQualifiedName, |
| final EStructuralFeature featureDelegate) { |
| // This is only meant for multi-valued references |
| return and(ofKind(DifferenceKind.ADD), onEObject(qualifiedName), |
| referenceValueMatch(referenceName, removedQualifiedName, true, featureDelegate)); |
| } |
| |
| @Override |
| protected AbstractUMLInputData getInput() { |
| return input; |
| } |
| |
| } |
