| /******************************************************************************* |
| * Copyright (c) 2013 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.stereotypes; |
| |
| 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.onFeature; |
| import static org.eclipse.emf.compare.utils.EMFComparePredicates.removed; |
| import static org.eclipse.emf.compare.utils.EMFComparePredicates.valueIs; |
| import static org.eclipse.emf.compare.utils.EMFComparePredicates.valueNameMatches; |
| 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 com.google.common.collect.UnmodifiableIterator; |
| |
| import java.io.IOException; |
| import java.util.List; |
| |
| import org.eclipse.emf.compare.AttributeChange; |
| import org.eclipse.emf.compare.Comparison; |
| import org.eclipse.emf.compare.Diff; |
| import org.eclipse.emf.compare.DifferenceKind; |
| import org.eclipse.emf.compare.ReferenceChange; |
| import org.eclipse.emf.compare.ResourceAttachmentChange; |
| import org.eclipse.emf.compare.uml2.internal.ProfileApplicationChange; |
| import org.eclipse.emf.compare.uml2.internal.StereotypeApplicationChange; |
| import org.eclipse.emf.compare.uml2.internal.StereotypeAttributeChange; |
| import org.eclipse.emf.compare.uml2.internal.StereotypeReferenceChange; |
| import org.eclipse.emf.compare.uml2.tests.AbstractDynamicProfileTest; |
| import org.eclipse.emf.compare.uml2.tests.AbstractUMLInputData; |
| import org.eclipse.emf.compare.uml2.tests.stereotypes.data.dynamic.DynamicStereotypeInputData; |
| import org.eclipse.emf.ecore.EcorePackage; |
| 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 DynamicStereotypeTest extends AbstractDynamicProfileTest { |
| |
| private DynamicStereotypeInputData input = new DynamicStereotypeInputData(); |
| |
| @BeforeClass |
| public static void setupClass() { |
| initEPackageNsURIToProfileLocationMap(); |
| } |
| |
| @AfterClass |
| public static void teardownClass() { |
| resetEPackageNsURIToProfileLocationMap(); |
| } |
| |
| @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); |
| |
| testMergeRightToLeft(left, right, null); |
| testMergeLeftToRight(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); |
| |
| testMergeRightToLeft(right, left, null); |
| testMergeLeftToRight(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); |
| |
| testMergeRightToLeft(left, right, right); |
| testMergeLeftToRight(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); |
| |
| testMergeRightToLeft(left, right, left); |
| testMergeLeftToRight(left, right, left); |
| } |
| |
| @Test |
| public void testA20UseCase() throws IOException { |
| final Resource left = input.getA2Left(); |
| final Resource right = input.getA2Right(); |
| |
| final Comparison comparison = compare(left, right); |
| testAB2(TestKind.ADD, comparison); |
| |
| testMergeRightToLeft(left, right, null); |
| testMergeLeftToRight(left, right, null); |
| } |
| |
| @Test |
| public void testA21UseCase() throws IOException { |
| final Resource left = input.getA2Left(); |
| final Resource right = input.getA2Right(); |
| |
| final Comparison comparison = compare(right, left); |
| testAB2(TestKind.DELETE, comparison); |
| |
| testMergeRightToLeft(right, left, null); |
| testMergeLeftToRight(right, left, null); |
| } |
| |
| @Test |
| public void testA20UseCase3way() throws IOException { |
| final Resource left = input.getA2Left(); |
| final Resource right = input.getA2Right(); |
| |
| final Comparison comparison = compare(left, right, right); |
| testAB2(TestKind.ADD, comparison); |
| |
| testMergeRightToLeft(left, right, right); |
| testMergeLeftToRight(left, right, right); |
| } |
| |
| @Test |
| public void testA21UseCase3way() throws IOException { |
| final Resource left = input.getA2Left(); |
| final Resource right = input.getA2Right(); |
| |
| final Comparison comparison = compare(left, right, left); |
| testAB2(TestKind.DELETE, comparison); |
| |
| testMergeRightToLeft(left, right, left); |
| testMergeLeftToRight(left, right, left); |
| } |
| |
| @Test |
| public void testA30UseCase() throws IOException { |
| final Resource left = input.getA3Left(); |
| final Resource right = input.getA3Right(); |
| |
| final Comparison comparison = compare(left, right); |
| testAB3(TestKind.ADD, comparison); |
| |
| testMergeRightToLeft(left, right, null); |
| testMergeLeftToRight(left, right, null); |
| } |
| |
| @Test |
| public void testA31UseCase() throws IOException { |
| final Resource left = input.getA3Left(); |
| final Resource right = input.getA3Right(); |
| |
| final Comparison comparison = compare(right, left); |
| testAB3(TestKind.DELETE, comparison); |
| |
| testMergeRightToLeft(right, left, null); |
| testMergeLeftToRight(right, left, null); |
| } |
| |
| @Test |
| public void testA30UseCase3way() throws IOException { |
| final Resource left = input.getA3Left(); |
| final Resource right = input.getA3Right(); |
| |
| final Comparison comparison = compare(left, right, right); |
| testAB3(TestKind.ADD, comparison); |
| |
| testMergeRightToLeft(left, right, right); |
| testMergeLeftToRight(left, right, right); |
| } |
| |
| @Test |
| public void testA31UseCase3way() throws IOException { |
| final Resource left = input.getA3Left(); |
| final Resource right = input.getA3Right(); |
| |
| final Comparison comparison = compare(left, right, left); |
| testAB3(TestKind.DELETE, comparison); |
| |
| testMergeRightToLeft(left, right, left); |
| testMergeLeftToRight(left, right, left); |
| } |
| |
| @Test |
| public void testA40UseCase() throws IOException { |
| final Resource left = input.getA4Left(); |
| final Resource right = input.getA4Right(); |
| |
| final Comparison comparison = compare(left, right); |
| testAB4(TestKind.ADD, comparison); |
| |
| testMergeRightToLeft(left, right, null); |
| testMergeLeftToRight(left, right, null); |
| } |
| |
| @Test |
| public void testA41UseCase() throws IOException { |
| final Resource left = input.getA4Left(); |
| final Resource right = input.getA4Right(); |
| |
| final Comparison comparison = compare(right, left); |
| testAB4(TestKind.DELETE, comparison); |
| |
| testMergeRightToLeft(right, left, null); |
| testMergeLeftToRight(right, left, null); |
| } |
| |
| @Test |
| public void testA40UseCase3way() throws IOException { |
| final Resource left = input.getA4Left(); |
| final Resource right = input.getA4Right(); |
| |
| final Comparison comparison = compare(left, right, right); |
| testAB4(TestKind.ADD, comparison); |
| |
| testMergeRightToLeft(left, right, right); |
| testMergeLeftToRight(left, right, right); |
| } |
| |
| @Test |
| public void testA41UseCase3way() throws IOException { |
| final Resource left = input.getA4Left(); |
| final Resource right = input.getA4Right(); |
| |
| final Comparison comparison = compare(left, right, left); |
| testAB4(TestKind.DELETE, comparison); |
| |
| testMergeRightToLeft(left, right, left); |
| testMergeLeftToRight(left, right, left); |
| } |
| |
| @Test |
| public void testA50UseCase() throws IOException { |
| final Resource left = input.getA5Left(); |
| final Resource right = input.getA5Right(); |
| |
| final Comparison comparison = compare(left, right); |
| testAB5(TestKind.ADD, comparison); |
| |
| testMergeRightToLeft(left, right, null); |
| testMergeLeftToRight(left, right, null); |
| } |
| |
| @Test |
| public void testA51UseCase() throws IOException { |
| final Resource left = input.getA5Left(); |
| final Resource right = input.getA5Right(); |
| |
| final Comparison comparison = compare(right, left); |
| testAB5(TestKind.DELETE, comparison); |
| |
| testMergeRightToLeft(right, left, null); |
| testMergeLeftToRight(right, left, null); |
| } |
| |
| @Test |
| public void testA50UseCase3way() throws IOException { |
| final Resource left = input.getA5Left(); |
| final Resource right = input.getA5Right(); |
| |
| final Comparison comparison = compare(left, right, right); |
| testAB5(TestKind.ADD, comparison); |
| |
| testMergeRightToLeft(left, right, right); |
| testMergeLeftToRight(left, right, right); |
| } |
| |
| @Test |
| public void testA51UseCase3way() throws IOException { |
| final Resource left = input.getA5Left(); |
| final Resource right = input.getA5Right(); |
| |
| final Comparison comparison = compare(left, right, left); |
| testAB5(TestKind.DELETE, comparison); |
| |
| testMergeRightToLeft(left, right, left); |
| testMergeLeftToRight(left, right, left); |
| } |
| |
| @Test |
| public void testA60UseCase() throws IOException { |
| final Resource left = input.getA6Left(); |
| final Resource right = input.getA6Right(); |
| |
| final Comparison comparison = compare(left, right); |
| testAB6(TestKind.ADD, comparison); |
| |
| testMergeRightToLeft(left, right, null); |
| testMergeLeftToRight(left, right, null); |
| } |
| |
| @Test |
| public void testA61UseCase() throws IOException { |
| final Resource left = input.getA6Left(); |
| final Resource right = input.getA6Right(); |
| |
| final Comparison comparison = compare(right, left); |
| testAB6(TestKind.DELETE, comparison); |
| |
| testMergeRightToLeft(right, left, null); |
| testMergeLeftToRight(right, left, null); |
| } |
| |
| @Test |
| public void testA60UseCase3way() throws IOException { |
| final Resource left = input.getA6Left(); |
| final Resource right = input.getA6Right(); |
| |
| final Comparison comparison = compare(left, right, right); |
| testAB6(TestKind.ADD, comparison); |
| |
| testMergeRightToLeft(left, right, right); |
| testMergeLeftToRight(left, right, right); |
| } |
| |
| @Test |
| public void testA61UseCase3way() throws IOException { |
| final Resource left = input.getA6Left(); |
| final Resource right = input.getA6Right(); |
| |
| final Comparison comparison = compare(left, right, left); |
| testAB6(TestKind.DELETE, comparison); |
| |
| testMergeRightToLeft(left, right, left); |
| testMergeLeftToRight(left, right, left); |
| } |
| |
| @Test |
| public void testA70UseCase() throws IOException { |
| final Resource left = input.getA7Left(); |
| final Resource right = input.getA7Right(); |
| |
| final Comparison comparison = compare(left, right); |
| testAB7(TestKind.ADD, comparison); |
| |
| testMergeRightToLeft(left, right, null); |
| testMergeLeftToRight(left, right, null); |
| } |
| |
| @Test |
| public void testA71UseCase() throws IOException { |
| final Resource left = input.getA7Left(); |
| final Resource right = input.getA7Right(); |
| |
| final Comparison comparison = compare(right, left); |
| testAB7(TestKind.DELETE, comparison); |
| |
| testMergeRightToLeft(right, left, null); |
| testMergeLeftToRight(right, left, null); |
| } |
| |
| @Test |
| public void testA70UseCase3way() throws IOException { |
| final Resource left = input.getA7Left(); |
| final Resource right = input.getA7Right(); |
| |
| final Comparison comparison = compare(left, right, right); |
| testAB7(TestKind.ADD, comparison); |
| |
| testMergeRightToLeft(left, right, right); |
| testMergeLeftToRight(left, right, right); |
| } |
| |
| @Test |
| public void testA71UseCase3way() throws IOException { |
| final Resource left = input.getA7Left(); |
| final Resource right = input.getA7Right(); |
| |
| final Comparison comparison = compare(left, right, left); |
| testAB7(TestKind.DELETE, comparison); |
| |
| testMergeRightToLeft(left, right, left); |
| testMergeLeftToRight(left, right, left); |
| } |
| |
| @Test |
| public void testA80UseCase() throws IOException { |
| final Resource left = input.getA8Left(); |
| final Resource right = input.getA8Right(); |
| |
| final Comparison comparison = compare(left, right); |
| testAB8(TestKind.ADD, comparison); |
| |
| testMergeRightToLeft(left, right, null); |
| testMergeLeftToRight(left, right, null); |
| } |
| |
| @Test |
| public void testA81UseCase() throws IOException { |
| final Resource left = input.getA8Left(); |
| final Resource right = input.getA8Right(); |
| |
| final Comparison comparison = compare(right, left); |
| testAB8(TestKind.DELETE, comparison); |
| |
| testMergeRightToLeft(right, left, null); |
| testMergeLeftToRight(right, left, null); |
| } |
| |
| @Test |
| public void testA80UseCase3way() throws IOException { |
| final Resource left = input.getA8Left(); |
| final Resource right = input.getA8Right(); |
| |
| final Comparison comparison = compare(left, right, right); |
| testAB8(TestKind.ADD, comparison); |
| |
| testMergeRightToLeft(left, right, right); |
| testMergeLeftToRight(left, right, right); |
| } |
| |
| @Test |
| public void testA81UseCase3way() throws IOException { |
| final Resource left = input.getA8Left(); |
| final Resource right = input.getA8Right(); |
| |
| final Comparison comparison = compare(left, right, left); |
| testAB8(TestKind.DELETE, comparison); |
| |
| testMergeRightToLeft(left, right, left); |
| testMergeLeftToRight(left, right, left); |
| } |
| |
| @Test |
| public void testA90UseCase() throws IOException { |
| final Resource left = input.getA9Left(); |
| final Resource right = input.getA9Right(); |
| |
| final Comparison comparison = compare(left, right); |
| testAB9(TestKind.ADD, comparison); |
| |
| testMergeRightToLeft(left, right, null); |
| testMergeLeftToRight(left, right, null); |
| } |
| |
| @Test |
| public void testA91UseCase() throws IOException { |
| final Resource left = input.getA9Left(); |
| final Resource right = input.getA9Right(); |
| |
| final Comparison comparison = compare(right, left); |
| testAB9(TestKind.DELETE, comparison); |
| |
| testMergeRightToLeft(right, left, null); |
| testMergeLeftToRight(right, left, null); |
| } |
| |
| @Test |
| public void testA90UseCase3way() throws IOException { |
| final Resource left = input.getA9Left(); |
| final Resource right = input.getA9Right(); |
| |
| final Comparison comparison = compare(left, right, right); |
| testAB9(TestKind.ADD, comparison); |
| |
| testMergeRightToLeft(left, right, right); |
| testMergeLeftToRight(left, right, right); |
| } |
| |
| @Test |
| public void testA91UseCase3way() throws IOException { |
| final Resource left = input.getA9Left(); |
| final Resource right = input.getA9Right(); |
| |
| final Comparison comparison = compare(left, right, left); |
| testAB9(TestKind.DELETE, comparison); |
| |
| testMergeRightToLeft(left, right, left); |
| testMergeLeftToRight(left, right, left); |
| } |
| |
| @Test |
| public void testA100UseCase() throws IOException { |
| final Resource left = input.getA10Left(); |
| final Resource right = input.getA10Right(); |
| |
| final Comparison comparison = compare(left, right); |
| testAB10(TestKind.ADD, comparison); |
| |
| testMergeRightToLeft(left, right, null); |
| testMergeLeftToRight(left, right, null); |
| } |
| |
| @Test |
| public void testA101UseCase() throws IOException { |
| final Resource left = input.getA10Left(); |
| final Resource right = input.getA10Right(); |
| |
| final Comparison comparison = compare(right, left); |
| testAB10(TestKind.DELETE, comparison); |
| |
| testMergeRightToLeft(right, left, null); |
| testMergeLeftToRight(right, left, null); |
| } |
| |
| @Test |
| public void testA100UseCase3way() throws IOException { |
| final Resource left = input.getA10Left(); |
| final Resource right = input.getA10Right(); |
| |
| final Comparison comparison = compare(left, right, right); |
| testAB10(TestKind.ADD, comparison); |
| |
| testMergeRightToLeft(left, right, right); |
| testMergeLeftToRight(left, right, right); |
| } |
| |
| @Test |
| public void testA101UseCase3way() throws IOException { |
| final Resource left = input.getA10Left(); |
| final Resource right = input.getA10Right(); |
| |
| final Comparison comparison = compare(left, right, left); |
| testAB10(TestKind.DELETE, comparison); |
| |
| testMergeRightToLeft(left, right, left); |
| testMergeLeftToRight(left, right, left); |
| } |
| |
| @Test |
| public void testA110UseCase3way() throws IOException { |
| final Resource left = input.getA11Left(); |
| final Resource right = input.getA11Right(); |
| final Resource ancestor = input.getA11Ancestor(); |
| |
| final Comparison comparison = compare(left, right, ancestor); |
| testAB11(comparison); |
| |
| testMergeRightToLeft(left, right, ancestor, true); |
| testMergeLeftToRight(left, right, ancestor, true); |
| } |
| |
| 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(8, differences.size()); |
| |
| Predicate<? super Diff> addProfileApplicationDescription = null; |
| Predicate<? super Diff> addAppliedProfileInProfileApplicationDescription = null; |
| Predicate<? super Diff> addUMLAnnotationDescription = null; |
| Predicate<? super Diff> addReferencesInUMLAnnotationDescription = null; |
| Predicate<? super Diff> addStereotypeApplicationDescription = null; |
| Predicate<? super Diff> addRefBaseClassDescription = null; |
| |
| if (kind.equals(TestKind.DELETE)) { |
| addProfileApplicationDescription = and(instanceOf(ReferenceChange.class), |
| ofKind(DifferenceKind.DELETE), |
| onRealFeature(UMLPackage.Literals.PACKAGE__PROFILE_APPLICATION)); |
| |
| // addAppliedProfileInProfileApplicationDescription = and(instanceOf(ReferenceChange.class), |
| // ofKind(DifferenceKind.CHANGE), |
| // onRealFeature(UMLPackage.Literals.PROFILE_APPLICATION__APPLIED_PROFILE), |
| // not(isChangeAdd())); |
| |
| addUMLAnnotationDescription = and(instanceOf(ReferenceChange.class), |
| ofKind(DifferenceKind.DELETE), |
| onRealFeature(EcorePackage.Literals.EMODEL_ELEMENT__EANNOTATIONS)); |
| |
| addReferencesInUMLAnnotationDescription = and(instanceOf(ReferenceChange.class), |
| ofKind(DifferenceKind.DELETE), |
| onRealFeature(EcorePackage.Literals.EANNOTATION__REFERENCES)); |
| } else { |
| addProfileApplicationDescription = and(instanceOf(ReferenceChange.class), |
| ofKind(DifferenceKind.ADD), |
| onRealFeature(UMLPackage.Literals.PACKAGE__PROFILE_APPLICATION)); |
| |
| // addAppliedProfileInProfileApplicationDescription = and(instanceOf(ReferenceChange.class), |
| // ofKind(DifferenceKind.CHANGE), |
| // onRealFeature(UMLPackage.Literals.PROFILE_APPLICATION__APPLIED_PROFILE), isChangeAdd()); |
| |
| addUMLAnnotationDescription = and(instanceOf(ReferenceChange.class), ofKind(DifferenceKind.ADD), |
| onRealFeature(EcorePackage.Literals.EMODEL_ELEMENT__EANNOTATIONS)); |
| |
| addReferencesInUMLAnnotationDescription = and(instanceOf(ReferenceChange.class), |
| ofKind(DifferenceKind.ADD), onRealFeature(EcorePackage.Literals.EANNOTATION__REFERENCES)); |
| } |
| |
| addAppliedProfileInProfileApplicationDescription = and(instanceOf(ReferenceChange.class), |
| ofKind(DifferenceKind.CHANGE), onFeature("appliedProfile")); |
| |
| addStereotypeApplicationDescription = instanceOf(ResourceAttachmentChange.class); |
| addRefBaseClassDescription = and(instanceOf(ReferenceChange.class), ofKind(DifferenceKind.CHANGE), |
| onFeature("base_Class")); |
| |
| final Diff addProfileApplication = Iterators.find(differences.iterator(), |
| addProfileApplicationDescription); |
| final Diff addAppliedProfileInProfileApplication = Iterators.find(differences.iterator(), |
| addAppliedProfileInProfileApplicationDescription); |
| final Diff addUMLAnnotation = Iterators.find(differences.iterator(), addUMLAnnotationDescription); |
| final Diff addReferencesInUMLAnnotation = Iterators.find(differences.iterator(), |
| addReferencesInUMLAnnotationDescription); |
| final Diff addStereotypeApplication = Iterators.find(differences.iterator(), |
| addStereotypeApplicationDescription); |
| final Diff addRefBaseClass = Iterators.find(differences.iterator(), addRefBaseClassDescription); |
| |
| assertNotNull(addProfileApplication); |
| assertNotNull(addAppliedProfileInProfileApplication); |
| assertNotNull(addUMLAnnotation); |
| assertNotNull(addReferencesInUMLAnnotation); |
| assertNotNull(addStereotypeApplication); |
| assertNotNull(addRefBaseClass); |
| |
| // CHECK EXTENSION |
| assertEquals(1, count(differences, instanceOf(ProfileApplicationChange.class))); |
| assertEquals(1, count(differences, instanceOf(StereotypeApplicationChange.class))); |
| Diff addUMLProfileApplication = null; |
| Diff addUMLStereotypeApplication = null; |
| if (kind.equals(TestKind.ADD)) { |
| addUMLProfileApplication = Iterators.find(differences.iterator(), |
| and(instanceOf(ProfileApplicationChange.class), ofKind(DifferenceKind.ADD))); |
| addUMLStereotypeApplication = Iterators.find(differences.iterator(), |
| and(instanceOf(StereotypeApplicationChange.class), ofKind(DifferenceKind.ADD))); |
| } else { |
| addUMLProfileApplication = Iterators.find(differences.iterator(), |
| and(instanceOf(ProfileApplicationChange.class), ofKind(DifferenceKind.DELETE))); |
| addUMLStereotypeApplication = Iterators.find(differences.iterator(), |
| and(instanceOf(StereotypeApplicationChange.class), ofKind(DifferenceKind.DELETE))); |
| } |
| assertNotNull(addUMLProfileApplication); |
| assertEquals(4, addUMLProfileApplication.getRefinedBy().size()); |
| assertTrue(addUMLProfileApplication.getRefinedBy().contains(addReferencesInUMLAnnotation)); |
| assertTrue(addUMLProfileApplication.getRefinedBy().contains(addAppliedProfileInProfileApplication)); |
| assertTrue(addUMLProfileApplication.getRefinedBy().contains(addProfileApplication)); |
| assertTrue(addUMLProfileApplication.getRefinedBy().contains(addUMLAnnotation)); |
| |
| assertNotNull(addUMLStereotypeApplication); |
| assertEquals(2, addUMLStereotypeApplication.getRefinedBy().size()); |
| assertTrue(addUMLStereotypeApplication.getRefinedBy().contains(addStereotypeApplication)); |
| assertTrue(addUMLStereotypeApplication.getRefinedBy().contains(addRefBaseClass)); |
| |
| // CHECK REQUIREMENT |
| if (kind.equals(TestKind.ADD)) { |
| |
| assertEquals(0, addProfileApplication.getRequires().size()); |
| |
| assertEquals(1, addUMLAnnotation.getRequires().size()); |
| assertTrue(addUMLAnnotation.getRequires().contains(addProfileApplication)); |
| |
| assertEquals(1, addReferencesInUMLAnnotation.getRequires().size()); |
| assertTrue(addReferencesInUMLAnnotation.getRequires().contains(addUMLAnnotation)); |
| |
| assertEquals(0, addUMLProfileApplication.getRequires().size()); |
| |
| assertEquals(1, addUMLStereotypeApplication.getRequires().size()); |
| assertTrue(addUMLStereotypeApplication.getRequires().contains(addUMLProfileApplication)); |
| |
| } else { |
| assertEquals(2, addProfileApplication.getRequires().size()); |
| assertTrue(addProfileApplication.getRequires().contains(addAppliedProfileInProfileApplication)); |
| assertTrue(addProfileApplication.getRequires().contains(addUMLAnnotation)); |
| |
| assertEquals(1, addUMLAnnotation.getRequires().size()); |
| assertTrue(addUMLAnnotation.getRequires().contains(addReferencesInUMLAnnotation)); |
| |
| assertEquals(0, addReferencesInUMLAnnotation.getRequires().size()); |
| |
| assertEquals(1, addUMLProfileApplication.getRequires().size()); |
| assertTrue(addUMLProfileApplication.getRequires().contains(addUMLStereotypeApplication)); |
| |
| assertEquals(0, addUMLStereotypeApplication.getRequires().size()); |
| |
| } |
| |
| // CHECK EQUIVALENCE |
| assertEquals(0, comparison.getEquivalences().size()); |
| |
| testIntersections(comparison); |
| |
| } |
| |
| private void testAB2(TestKind kind, final Comparison comparison) { |
| final List<Diff> differences = comparison.getDifferences(); |
| |
| // We should have no less and no more than 2 differences |
| assertEquals(2, differences.size()); |
| |
| Predicate<? super Diff> addAttributeDescription = null; |
| |
| if (kind.equals(TestKind.DELETE)) { |
| addAttributeDescription = and(instanceOf(AttributeChange.class), ofKind(DifferenceKind.DELETE), |
| onFeature("manyValuedAttribute")); |
| } else { |
| addAttributeDescription = and(instanceOf(AttributeChange.class), ofKind(DifferenceKind.ADD), |
| onFeature("manyValuedAttribute")); |
| } |
| |
| final Diff addAttribute = Iterators.find(differences.iterator(), addAttributeDescription); |
| assertNotNull(addAttribute); |
| |
| testIntersections(comparison); |
| |
| } |
| |
| private void testAB3(TestKind kind, final Comparison comparison) { |
| final List<Diff> differences = comparison.getDifferences(); |
| |
| assertEquals(10, differences.size()); |
| |
| Predicate<? super Diff> addProfileApplicationDescription = null; |
| Predicate<? super Diff> addAppliedProfileInProfileApplicationDescription = null; |
| Predicate<? super Diff> addUMLAnnotationDescription = null; |
| Predicate<? super Diff> addReferencesInUMLAnnotationDescription = null; |
| Predicate<? super Diff> addStereotypeApplicationDescription = null; |
| Predicate<? super Diff> addModelDescription = null; |
| Predicate<? super Diff> addClassDescription = null; |
| Predicate<? super Diff> addRefBaseClassDescription = null; |
| |
| if (kind.equals(TestKind.DELETE)) { |
| addProfileApplicationDescription = and(instanceOf(ReferenceChange.class), |
| ofKind(DifferenceKind.DELETE), |
| onRealFeature(UMLPackage.Literals.PACKAGE__PROFILE_APPLICATION)); |
| |
| // addAppliedProfileInProfileApplicationDescription = and(instanceOf(ReferenceChange.class), |
| // ofKind(DifferenceKind.CHANGE), |
| // onRealFeature(UMLPackage.Literals.PROFILE_APPLICATION__APPLIED_PROFILE), |
| // not(isChangeAdd())); |
| |
| addUMLAnnotationDescription = and(instanceOf(ReferenceChange.class), |
| ofKind(DifferenceKind.DELETE), |
| onRealFeature(EcorePackage.Literals.EMODEL_ELEMENT__EANNOTATIONS)); |
| |
| addReferencesInUMLAnnotationDescription = and(instanceOf(ReferenceChange.class), |
| ofKind(DifferenceKind.DELETE), |
| onRealFeature(EcorePackage.Literals.EANNOTATION__REFERENCES)); |
| addModelDescription = removed("model.MyNiceModel"); |
| addClassDescription = removed("model.MyNiceModel.Class1"); |
| |
| } else { |
| addProfileApplicationDescription = and(instanceOf(ReferenceChange.class), |
| ofKind(DifferenceKind.ADD), |
| onRealFeature(UMLPackage.Literals.PACKAGE__PROFILE_APPLICATION)); |
| |
| // addAppliedProfileInProfileApplicationDescription = and(instanceOf(ReferenceChange.class), |
| // ofKind(DifferenceKind.CHANGE), |
| // onRealFeature(UMLPackage.Literals.PROFILE_APPLICATION__APPLIED_PROFILE), isChangeAdd()); |
| |
| addUMLAnnotationDescription = and(instanceOf(ReferenceChange.class), ofKind(DifferenceKind.ADD), |
| onRealFeature(EcorePackage.Literals.EMODEL_ELEMENT__EANNOTATIONS)); |
| |
| addReferencesInUMLAnnotationDescription = and(instanceOf(ReferenceChange.class), |
| ofKind(DifferenceKind.ADD), onRealFeature(EcorePackage.Literals.EANNOTATION__REFERENCES)); |
| addModelDescription = added("model.MyNiceModel"); |
| addClassDescription = added("model.MyNiceModel.Class1"); |
| } |
| |
| addAppliedProfileInProfileApplicationDescription = and(instanceOf(ReferenceChange.class), |
| ofKind(DifferenceKind.CHANGE), onFeature("appliedProfile")); |
| |
| addStereotypeApplicationDescription = instanceOf(ResourceAttachmentChange.class); |
| addRefBaseClassDescription = and(instanceOf(ReferenceChange.class), ofKind(DifferenceKind.CHANGE), |
| onFeature("base_Class")); |
| |
| final Diff addProfileApplication = Iterators.find(differences.iterator(), |
| addProfileApplicationDescription); |
| final Diff addAppliedProfileInProfileApplication = Iterators.find(differences.iterator(), |
| addAppliedProfileInProfileApplicationDescription); |
| final Diff addUMLAnnotation = Iterators.find(differences.iterator(), addUMLAnnotationDescription); |
| final Diff addReferencesInUMLAnnotation = Iterators.find(differences.iterator(), |
| addReferencesInUMLAnnotationDescription); |
| final Diff addStereotypeApplication = Iterators.find(differences.iterator(), |
| addStereotypeApplicationDescription); |
| final Diff addModel = Iterators.find(differences.iterator(), addModelDescription); |
| final Diff addClass = Iterators.find(differences.iterator(), addClassDescription); |
| final Diff addRefBaseClass = Iterators.find(differences.iterator(), addRefBaseClassDescription); |
| |
| assertNotNull(addProfileApplication); |
| assertNotNull(addAppliedProfileInProfileApplication); |
| assertNotNull(addUMLAnnotation); |
| assertNotNull(addReferencesInUMLAnnotation); |
| assertNotNull(addStereotypeApplication); |
| assertNotNull(addModel); |
| assertNotNull(addClass); |
| assertNotNull(addRefBaseClass); |
| |
| // CHECK EXTENSION |
| assertEquals(1, count(differences, instanceOf(ProfileApplicationChange.class))); |
| assertEquals(1, count(differences, instanceOf(StereotypeApplicationChange.class))); |
| Diff addUMLProfileApplication = null; |
| Diff addUMLStereotypeApplication = null; |
| if (kind.equals(TestKind.ADD)) { |
| addUMLProfileApplication = Iterators.find(differences.iterator(), |
| and(instanceOf(ProfileApplicationChange.class), ofKind(DifferenceKind.ADD))); |
| addUMLStereotypeApplication = Iterators.find(differences.iterator(), |
| and(instanceOf(StereotypeApplicationChange.class), ofKind(DifferenceKind.ADD))); |
| } else { |
| addUMLProfileApplication = Iterators.find(differences.iterator(), |
| and(instanceOf(ProfileApplicationChange.class), ofKind(DifferenceKind.DELETE))); |
| addUMLStereotypeApplication = Iterators.find(differences.iterator(), |
| and(instanceOf(StereotypeApplicationChange.class), ofKind(DifferenceKind.DELETE))); |
| } |
| assertNotNull(addUMLProfileApplication); |
| assertEquals(4, addUMLProfileApplication.getRefinedBy().size()); |
| assertTrue(addUMLProfileApplication.getRefinedBy().contains(addReferencesInUMLAnnotation)); |
| assertTrue(addUMLProfileApplication.getRefinedBy().contains(addAppliedProfileInProfileApplication)); |
| assertTrue(addUMLProfileApplication.getRefinedBy().contains(addProfileApplication)); |
| assertTrue(addUMLProfileApplication.getRefinedBy().contains(addUMLAnnotation)); |
| |
| assertNotNull(addUMLStereotypeApplication); |
| assertEquals(2, addUMLStereotypeApplication.getRefinedBy().size()); |
| assertTrue(addUMLStereotypeApplication.getRefinedBy().contains(addStereotypeApplication)); |
| assertTrue(addUMLStereotypeApplication.getRefinedBy().contains(addRefBaseClass)); |
| |
| // CHECK REQUIREMENT |
| if (kind.equals(TestKind.ADD)) { |
| |
| assertEquals(1, addProfileApplication.getRequires().size()); |
| assertTrue(addProfileApplication.getRequires().contains(addModel)); |
| |
| assertEquals(1, addUMLAnnotation.getRequires().size()); |
| assertTrue(addUMLAnnotation.getRequires().contains(addProfileApplication)); |
| |
| assertEquals(1, addReferencesInUMLAnnotation.getRequires().size()); |
| assertTrue(addReferencesInUMLAnnotation.getRequires().contains(addUMLAnnotation)); |
| |
| assertEquals(1, addUMLProfileApplication.getRequires().size()); |
| |
| assertEquals(2, addUMLStereotypeApplication.getRequires().size()); |
| assertTrue(addUMLStereotypeApplication.getRequires().contains(addUMLProfileApplication)); |
| |
| } else { |
| assertEquals(2, addProfileApplication.getRequires().size()); |
| assertTrue(addProfileApplication.getRequires().contains(addAppliedProfileInProfileApplication)); |
| assertTrue(addProfileApplication.getRequires().contains(addUMLAnnotation)); |
| |
| assertEquals(1, addUMLAnnotation.getRequires().size()); |
| assertTrue(addUMLAnnotation.getRequires().contains(addReferencesInUMLAnnotation)); |
| |
| assertEquals(0, addReferencesInUMLAnnotation.getRequires().size()); |
| |
| assertEquals(1, addUMLProfileApplication.getRequires().size()); |
| assertTrue(addUMLProfileApplication.getRequires().contains(addUMLStereotypeApplication)); |
| |
| assertEquals(0, addUMLStereotypeApplication.getRequires().size()); |
| |
| } |
| |
| // CHECK EQUIVALENCE |
| assertEquals(0, comparison.getEquivalences().size()); |
| |
| testIntersections(comparison); |
| } |
| |
| private void testAB4(TestKind kind, final Comparison comparison) { |
| final List<Diff> differences = comparison.getDifferences(); |
| |
| // We should have no less and no more than 4 differences |
| assertEquals(4, differences.size()); |
| |
| Predicate<? super Diff> addStereotypeApplicationDescription = null; |
| Predicate<? super Diff> addClassDescription = null; |
| |
| Diff addUMLStereotypeApplication = null; |
| if (kind.equals(TestKind.DELETE)) { |
| addClassDescription = removed("model.Class0"); |
| addUMLStereotypeApplication = Iterators.find(differences.iterator(), |
| and(instanceOf(StereotypeApplicationChange.class), ofKind(DifferenceKind.DELETE))); |
| } else { |
| addClassDescription = added("model.Class0"); |
| addUMLStereotypeApplication = Iterators.find(differences.iterator(), |
| and(instanceOf(StereotypeApplicationChange.class), ofKind(DifferenceKind.ADD))); |
| } |
| addStereotypeApplicationDescription = instanceOf(ResourceAttachmentChange.class); |
| |
| final Diff addClass = Iterators.find(differences.iterator(), addClassDescription); |
| final Diff addStereotypeApplication = Iterators.find(differences.iterator(), |
| addStereotypeApplicationDescription); |
| assertNotNull(addClass); |
| assertNotNull(addStereotypeApplication); |
| assertNotNull(addUMLStereotypeApplication); |
| |
| testIntersections(comparison); |
| } |
| |
| private void testAB5(TestKind kind, final Comparison comparison) { |
| final List<Diff> differences = comparison.getDifferences(); |
| |
| // We should have no less and no more than 4 differences |
| assertEquals(4, differences.size()); |
| |
| Predicate<? super Diff> changeAttributeDescription1 = null; |
| Predicate<? super Diff> changeAttributeDescription2 = null; |
| |
| changeAttributeDescription1 = and(instanceOf(AttributeChange.class), ofKind(DifferenceKind.CHANGE), |
| onFeature("xmlName"), valueIs("clazz")); |
| changeAttributeDescription2 = and(instanceOf(AttributeChange.class), ofKind(DifferenceKind.CHANGE), |
| onFeature("className"), valueIs("theEClassName")); |
| |
| final Diff changeAttribute1 = Iterators.find(differences.iterator(), changeAttributeDescription1); |
| final Diff changeAttribute2 = Iterators.find(differences.iterator(), changeAttributeDescription2); |
| final UnmodifiableIterator<Diff> changeUMLStereotypeProperties = Iterators.filter( |
| differences.iterator(), |
| and(instanceOf(StereotypeAttributeChange.class), ofKind(DifferenceKind.CHANGE))); |
| |
| assertTrue(changeUMLStereotypeProperties.hasNext()); |
| final Diff changeUMLStereotypeProperty1 = changeUMLStereotypeProperties.next(); |
| assertTrue(changeUMLStereotypeProperties.hasNext()); |
| final Diff changeUMLStereotypeProperty2 = changeUMLStereotypeProperties.next(); |
| |
| assertNotNull(changeAttribute1); |
| assertNotNull(changeAttribute2); |
| assertNotNull(changeUMLStereotypeProperty1); |
| assertNotNull(changeUMLStereotypeProperty2); |
| |
| assertEquals(1, changeUMLStereotypeProperty1.getRefinedBy().size()); |
| assertTrue(changeUMLStereotypeProperty1.getRefinedBy().contains(changeAttribute1)); |
| assertEquals(1, changeUMLStereotypeProperty2.getRefinedBy().size()); |
| assertTrue(changeUMLStereotypeProperty2.getRefinedBy().contains(changeAttribute2)); |
| |
| testIntersections(comparison); |
| |
| } |
| |
| private void testAB6(TestKind kind, final Comparison comparison) { |
| final List<Diff> differences = comparison.getDifferences(); |
| |
| // We should have no less and no more than 2 differences |
| assertEquals(2, differences.size()); |
| |
| Predicate<? super Diff> addStereotypeRefDescription = null; |
| Predicate<? super Diff> changeUMLStereotypeDescription = null; |
| |
| if (kind.equals(TestKind.ADD)) { |
| addStereotypeRefDescription = and(instanceOf(ReferenceChange.class), ofKind(DifferenceKind.ADD), |
| onFeature("manyValuedReference")); |
| } else { |
| addStereotypeRefDescription = and(instanceOf(ReferenceChange.class), |
| ofKind(DifferenceKind.DELETE), onFeature("manyValuedReference")); |
| } |
| changeUMLStereotypeDescription = and(instanceOf(StereotypeReferenceChange.class), |
| ofKind(DifferenceKind.CHANGE)); |
| |
| final Diff addStereotypeRef = Iterators.find(differences.iterator(), addStereotypeRefDescription); |
| final Diff changeUMLStereotype = Iterators.find(differences.iterator(), |
| changeUMLStereotypeDescription); |
| |
| assertNotNull(addStereotypeRef); |
| assertNotNull(changeUMLStereotype); |
| |
| assertEquals(1, changeUMLStereotype.getRefinedBy().size()); |
| assertTrue(changeUMLStereotype.getRefinedBy().contains(addStereotypeRef)); |
| |
| testIntersections(comparison); |
| |
| } |
| |
| private void testAB7(TestKind kind, final Comparison comparison) { |
| final List<Diff> differences = comparison.getDifferences(); |
| |
| // We should have no less and no more than 2 differences |
| assertEquals(2, differences.size()); |
| |
| Predicate<? super Diff> moveStereotypeRefDescription = null; |
| Predicate<? super Diff> changeUMLStereotypeDescription = null; |
| |
| moveStereotypeRefDescription = and(instanceOf(ReferenceChange.class), ofKind(DifferenceKind.MOVE), |
| onFeature("manyValuedReference")); |
| changeUMLStereotypeDescription = and(instanceOf(StereotypeReferenceChange.class), |
| ofKind(DifferenceKind.CHANGE)); |
| |
| final Diff moveStereotypeRef = Iterators.find(differences.iterator(), moveStereotypeRefDescription); |
| final Diff changeUMLStereotype = Iterators.find(differences.iterator(), |
| changeUMLStereotypeDescription); |
| |
| assertNotNull(moveStereotypeRef); |
| assertNotNull(changeUMLStereotype); |
| |
| assertEquals(1, changeUMLStereotype.getRefinedBy().size()); |
| assertTrue(changeUMLStereotype.getRefinedBy().contains(moveStereotypeRef)); |
| |
| testIntersections(comparison); |
| |
| } |
| |
| private void testAB8(TestKind kind, final Comparison comparison) { |
| final List<Diff> differences = comparison.getDifferences(); |
| |
| // We should have no less and no more than 2 differences |
| assertEquals(2, differences.size()); |
| |
| Predicate<? super Diff> changeStereotypeRefDescription = null; |
| Predicate<? super Diff> changeUMLStereotypeDescription = null; |
| |
| if (kind.equals(TestKind.ADD)) { |
| changeStereotypeRefDescription = and(instanceOf(ReferenceChange.class), |
| ofKind(DifferenceKind.CHANGE), onFeature("singleValuedReference"), |
| valueNameMatches("class0")); |
| } else { |
| changeStereotypeRefDescription = and(instanceOf(ReferenceChange.class), |
| ofKind(DifferenceKind.CHANGE), onFeature("singleValuedReference"), |
| valueNameMatches("class1")); |
| } |
| changeUMLStereotypeDescription = and(instanceOf(StereotypeReferenceChange.class), |
| ofKind(DifferenceKind.CHANGE)); |
| |
| final Diff changeStereotypeRef = Iterators.find(differences.iterator(), |
| changeStereotypeRefDescription); |
| final Diff changeUMLStereotype = Iterators.find(differences.iterator(), |
| changeUMLStereotypeDescription); |
| |
| assertNotNull(changeStereotypeRef); |
| assertNotNull(changeUMLStereotype); |
| |
| assertEquals(1, changeUMLStereotype.getRefinedBy().size()); |
| assertTrue(changeUMLStereotype.getRefinedBy().contains(changeStereotypeRef)); |
| |
| testIntersections(comparison); |
| } |
| |
| private void testAB9(TestKind kind, final Comparison comparison) { |
| final List<Diff> differences = comparison.getDifferences(); |
| |
| // We should have no less and no more than 2 differences |
| assertEquals(2, differences.size()); |
| |
| Predicate<? super Diff> changeStereotypeRefDescription = null; |
| Predicate<? super Diff> changeUMLStereotypeDescription = null; |
| |
| changeStereotypeRefDescription = and(instanceOf(ReferenceChange.class), ofKind(DifferenceKind.CHANGE), |
| onFeature("singleValuedReference"), valueNameMatches("class0")); |
| |
| changeUMLStereotypeDescription = and(instanceOf(StereotypeReferenceChange.class), |
| ofKind(DifferenceKind.CHANGE)); |
| |
| final Diff changeStereotypeRef = Iterators.find(differences.iterator(), |
| changeStereotypeRefDescription); |
| final Diff changeUMLStereotype = Iterators.find(differences.iterator(), |
| changeUMLStereotypeDescription); |
| |
| assertNotNull(changeStereotypeRef); |
| assertNotNull(changeUMLStereotype); |
| |
| assertEquals(1, changeUMLStereotype.getRefinedBy().size()); |
| assertTrue(changeUMLStereotype.getRefinedBy().contains(changeStereotypeRef)); |
| |
| testIntersections(comparison); |
| } |
| |
| private void testAB10(TestKind kind, final Comparison comparison) { |
| final List<Diff> differences = comparison.getDifferences(); |
| |
| // We should have no less and no more than 2 differences |
| assertEquals(2, differences.size()); |
| |
| Predicate<? super Diff> changeStereotypeRefDescription = null; |
| Predicate<? super Diff> changeUMLStereotypeDescription = null; |
| |
| if (kind.equals(TestKind.ADD)) { |
| changeStereotypeRefDescription = and(instanceOf(AttributeChange.class), |
| ofKind(DifferenceKind.CHANGE), onFeature("singleValuedAttribute"), valueIs("myValue")); |
| } else { |
| changeStereotypeRefDescription = and(instanceOf(AttributeChange.class), |
| ofKind(DifferenceKind.CHANGE), onFeature("singleValuedAttribute"), valueIs("oldValue")); |
| } |
| |
| changeUMLStereotypeDescription = and(instanceOf(StereotypeAttributeChange.class), |
| ofKind(DifferenceKind.CHANGE)); |
| |
| final Diff changeStereotypeRef = Iterators.find(differences.iterator(), |
| changeStereotypeRefDescription); |
| final Diff changeUMLStereotype = Iterators.find(differences.iterator(), |
| changeUMLStereotypeDescription); |
| |
| assertNotNull(changeStereotypeRef); |
| assertNotNull(changeUMLStereotype); |
| |
| assertEquals(1, changeUMLStereotype.getRefinedBy().size()); |
| assertTrue(changeUMLStereotype.getRefinedBy().contains(changeStereotypeRef)); |
| |
| testIntersections(comparison); |
| } |
| |
| private void testAB11(final Comparison comparison) { |
| final List<Diff> differences = comparison.getDifferences(); |
| // We should have no less and no more than 2 differences |
| assertEquals(2, differences.size()); |
| |
| Predicate<? super Diff> changeStereotypeRefDescription = null; |
| Predicate<? super Diff> changeUMLStereotypeDescription = null; |
| |
| changeStereotypeRefDescription = and(instanceOf(AttributeChange.class), |
| ofKind(DifferenceKind.CHANGE)); |
| changeUMLStereotypeDescription = and(instanceOf(StereotypeAttributeChange.class), |
| ofKind(DifferenceKind.CHANGE)); |
| |
| final Diff changeStereotypeRef = Iterators.find(differences.iterator(), |
| changeStereotypeRefDescription); |
| final Diff changeUMLStereotype = Iterators.find(differences.iterator(), |
| changeUMLStereotypeDescription); |
| |
| assertNotNull(changeStereotypeRef); |
| assertNotNull(changeUMLStereotype); |
| |
| assertEquals(1, changeUMLStereotype.getRefinedBy().size()); |
| assertTrue(changeUMLStereotype.getRefinedBy().contains(changeStereotypeRef)); |
| |
| testIntersections(comparison); |
| } |
| |
| @Override |
| protected AbstractUMLInputData getInput() { |
| return input; |
| } |
| |
| } |
