/*******************************************************************************
* Copyright (c) 2012, 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
*******************************************************************************/
package org.eclipse.emf.compare.uml2.tests.implications;
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.addedToReference;
import static org.eclipse.emf.compare.utils.EMFComparePredicates.changedReference;
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.onFeature;
import static org.eclipse.emf.compare.utils.EMFComparePredicates.removed;
import static org.eclipse.emf.compare.utils.EMFComparePredicates.removedFromReference;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
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.common.util.BasicMonitor;
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.AssociationChange;
import org.eclipse.emf.compare.uml2.internal.MultiplicityElementChange;
import org.eclipse.emf.compare.uml2.tests.AbstractUMLInputData;
import org.eclipse.emf.compare.uml2.tests.AbstractUMLTest;
import org.eclipse.emf.compare.uml2.tests.implications.data.ImplicationsInputData;
import org.eclipse.emf.ecore.resource.Resource;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
@SuppressWarnings("nls")
public class ImplicationsAssociationTest extends AbstractUMLTest {
// 16 diffs of interest and 4 MultiplicityElementChanges
private static final int NB_DIFFS = 20;
private ImplicationsInputData input = new ImplicationsInputData();
@BeforeClass
public static void setupClass() {
fillRegistries();
}
@AfterClass
public static void teardownClass() {
resetRegistries();
}
private DiffsOfInterest getDiffs(Comparison comparison, TestKind kind) {
final List<Diff> differences = comparison.getDifferences();
Predicate<? super Diff> addAssociationDescription = null;
Predicate<? super Diff> addNavigableOwnedEndClass1InAssociationDescription = null;
Predicate<? super Diff> addNavigableOwnedEndClass2InAssociationDescription = null;
Predicate<? super Diff> addRefAssociationInPropertyClass1Description = null;
Predicate<? super Diff> addRefTypeInPropertyClass1Description = null;
Predicate<? super Diff> addRefAssociationInPropertyClass2Description = null;
Predicate<? super Diff> addRefTypeInPropertyClass2Description = null;
Predicate<? super Diff> addLiteralIntegerInClass1Description = null;
Predicate<? super Diff> addUnlimitedNaturalInClass1Description = null;
Predicate<? super Diff> addLiteralIntegerInClass2Description = null;
Predicate<? super Diff> addUnlimitedNaturalInClass2Description = null;
Predicate<? super Diff> addMemberEndClass1InAssociationDescription = null;
Predicate<? super Diff> addMemberEndClass2InAssociationDescription = null;
Predicate<? super Diff> addOwnedEndClass1Description = null;
Predicate<? super Diff> addOwnedEndClass2Description = null;
if (kind.equals(TestKind.DELETE)) {
addAssociationDescription = removed("myModel.class1sToClass2s"); //$NON-NLS-1$
addNavigableOwnedEndClass1InAssociationDescription = removedFromReference(
"myModel.class1sToClass2s", "navigableOwnedEnd", "myModel.class1sToClass2s.class1s");
addNavigableOwnedEndClass2InAssociationDescription = removedFromReference(
"myModel.class1sToClass2s", "navigableOwnedEnd", "myModel.class1sToClass2s.class2s");
addRefAssociationInPropertyClass1Description = changedReference(
"myModel.class1sToClass2s.class1s", "association", "myModel.class1sToClass2s", null);
addRefTypeInPropertyClass1Description = changedReference("myModel.class1sToClass2s.class1s",
"type", "myModel.Class1", null);
addRefAssociationInPropertyClass2Description = changedReference(
"myModel.class1sToClass2s.class2s", "association", "myModel.class1sToClass2s", null);
addRefTypeInPropertyClass2Description = changedReference("myModel.class1sToClass2s.class2s",
"type", "myModel.Class2", null);
addLiteralIntegerInClass1Description = removedLowerValueIn("myModel.class1sToClass2s.class1s");
addUnlimitedNaturalInClass1Description = removedUpperValueIn("myModel.class1sToClass2s.class1s");
addLiteralIntegerInClass2Description = removedLowerValueIn("myModel.class1sToClass2s.class2s");
addUnlimitedNaturalInClass2Description = removedUpperValueIn("myModel.class1sToClass2s.class2s");
addMemberEndClass1InAssociationDescription = removedFromReference("myModel.class1sToClass2s",
"memberEnd", "myModel.class1sToClass2s.class1s");
addMemberEndClass2InAssociationDescription = removedFromReference("myModel.class1sToClass2s",
"memberEnd", "myModel.class1sToClass2s.class2s");
addOwnedEndClass1Description = removedFromReference("myModel.class1sToClass2s", "ownedEnd",
"myModel.class1sToClass2s.class1s");
addOwnedEndClass2Description = removedFromReference("myModel.class1sToClass2s", "ownedEnd",
"myModel.class1sToClass2s.class2s");
} else {
addAssociationDescription = added("myModel.class1sToClass2s"); //$NON-NLS-1$
addNavigableOwnedEndClass1InAssociationDescription = addedToReference("myModel.class1sToClass2s",
"navigableOwnedEnd", "myModel.class1sToClass2s.class1s");
addNavigableOwnedEndClass2InAssociationDescription = addedToReference("myModel.class1sToClass2s",
"navigableOwnedEnd", "myModel.class1sToClass2s.class2s");
addRefAssociationInPropertyClass1Description = changedReference(
"myModel.class1sToClass2s.class1s", "association", null, "myModel.class1sToClass2s");
addRefTypeInPropertyClass1Description = changedReference("myModel.class1sToClass2s.class1s",
"type", null, "myModel.Class1");
addRefAssociationInPropertyClass2Description = changedReference(
"myModel.class1sToClass2s.class2s", "association", null, "myModel.class1sToClass2s");
addRefTypeInPropertyClass2Description = changedReference("myModel.class1sToClass2s.class2s",
"type", null, "myModel.Class2");
addLiteralIntegerInClass1Description = addedLowerValueIn("myModel.class1sToClass2s.class1s");
addUnlimitedNaturalInClass1Description = addedUpperValueIn("myModel.class1sToClass2s.class1s");
addLiteralIntegerInClass2Description = addedLowerValueIn("myModel.class1sToClass2s.class2s");
addUnlimitedNaturalInClass2Description = addedUpperValueIn("myModel.class1sToClass2s.class2s");
addMemberEndClass1InAssociationDescription = addedToReference("myModel.class1sToClass2s",
"memberEnd", "myModel.class1sToClass2s.class1s");
addMemberEndClass2InAssociationDescription = addedToReference("myModel.class1sToClass2s",
"memberEnd", "myModel.class1sToClass2s.class2s");
addOwnedEndClass1Description = addedToReference("myModel.class1sToClass2s", "ownedEnd",
"myModel.class1sToClass2s.class1s");
addOwnedEndClass2Description = addedToReference("myModel.class1sToClass2s", "ownedEnd",
"myModel.class1sToClass2s.class2s");
}
DiffsOfInterest diffs = new DiffsOfInterest();
diffs.addAssociation = Iterators.find(differences.iterator(), addAssociationDescription, null);
diffs.addNavigableOwnedEndClass1InAssociation = Iterators.find(differences.iterator(),
addNavigableOwnedEndClass1InAssociationDescription, null);
diffs.addNavigableOwnedEndClass2InAssociation = Iterators.find(differences.iterator(),
addNavigableOwnedEndClass2InAssociationDescription, null);
diffs.addMemberEndClass1InAssociation = Iterators.find(differences.iterator(),
addMemberEndClass1InAssociationDescription, null);
diffs.addMemberEndClass2InAssociation = Iterators.find(differences.iterator(),
addMemberEndClass2InAssociationDescription, null);
diffs.addOwnedEndClass1InAssociation = Iterators.find(differences.iterator(),
addOwnedEndClass1Description, null);
diffs.addOwnedEndClass2InAssociation = Iterators.find(differences.iterator(),
addOwnedEndClass2Description, null);
diffs.addUMLAssociation = Iterators.find(differences.iterator(), instanceOf(AssociationChange.class),
null);
diffs.addRefAssociationInPropertyClass1 = Iterators.find(differences.iterator(),
addRefAssociationInPropertyClass1Description, null);
diffs.addRefTypeInPropertyClass1 = Iterators.find(differences.iterator(),
addRefTypeInPropertyClass1Description, null);
diffs.addRefAssociationInPropertyClass2 = Iterators.find(differences.iterator(),
addRefAssociationInPropertyClass2Description, null);
diffs.addRefTypeInPropertyClass2 = Iterators.find(differences.iterator(),
addRefTypeInPropertyClass2Description, null);
diffs.addLiteralIntegerInClass1 = Iterators.find(differences.iterator(),
addLiteralIntegerInClass1Description, null);
diffs.addUnlimitedNaturalInClass1 = Iterators.find(differences.iterator(),
addUnlimitedNaturalInClass1Description, null);
diffs.addLiteralIntegerInClass2 = Iterators.find(differences.iterator(),
addLiteralIntegerInClass2Description, null);
diffs.addUnlimitedNaturalInClass2 = Iterators.find(differences.iterator(),
addUnlimitedNaturalInClass2Description, null);
return diffs;
}
@Test
public void testA10UseCase() throws IOException {
final Resource left = input.getA1Left();
final Resource right = input.getA1Right();
Comparison comparison = compare(left, right);
testAB1(TestKind.ADD, comparison);
}
@Test
// local ADD
public void testA10UseCase3way1() throws IOException {
final Resource left = input.getA1Left();
final Resource right = input.getA1Right();
Comparison comparison = compare(left, right, right);
testAB1(TestKind.ADD, comparison);
}
@Test
// remote ADD
public void testA10UseCase3way2() throws IOException {
final Resource left = input.getA1Right();
final Resource right = input.getA1Left();
Comparison comparison = compare(left, right, left);
testAB1(TestKind.ADD, comparison);
}
@Test
public void testA10MergeLtR1UseCase() throws IOException {
final Resource left = input.getA1Left();
final Resource right = input.getA1Right();
Comparison comparison = compare(left, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.ADD);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addNavigableOwnedEndClass1InAssociation)
.copyLeftToRight(diffs.addNavigableOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.ADD);
checkMergeAddNavigableOwnedEnd(comparison, diffs);
}
private void checkMergeAddNavigableOwnedEnd(Comparison comparison, DiffsOfInterest diffs) {
assertEquals(NB_DIFFS - 6, comparison.getDifferences().size());
assertNull(diffs.addNavigableOwnedEndClass1InAssociation);
assertNull(diffs.addOwnedEndClass1InAssociation);
assertNull(diffs.addMemberEndClass1InAssociation);
assertNull(diffs.addRefAssociationInPropertyClass1);
assertNull(diffs.addAssociation);
assertNull(diffs.addUMLAssociation);
}
@Test
public void testA10MergeLtR1UseCase3way1() throws IOException {
final Resource left = input.getA1Left();
final Resource right = input.getA1Right();
Comparison comparison = compare(left, right, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.ADD);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addNavigableOwnedEndClass1InAssociation)
.copyLeftToRight(diffs.addNavigableOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.ADD);
checkMergeAddNavigableOwnedEnd(comparison, diffs);
}
@Test
public void testA10MergeLtR1UseCase3way2() throws IOException {
final Resource left = input.getA1Right();
final Resource right = input.getA1Left();
Comparison comparison = compare(left, right, left);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.ADD);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addNavigableOwnedEndClass1InAssociation)
.copyLeftToRight(diffs.addNavigableOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.ADD);
checkMergeDeleteNavigableOwnedEnd(comparison, diffs);
}
private void checkMergeDeleteNavigableOwnedEnd(Comparison comparison, DiffsOfInterest diffs) {
// 7 diffs of interest + 2 MultiplicityElementChanges
assertEquals(NB_DIFFS - 9, comparison.getDifferences().size());
assertNull(diffs.addNavigableOwnedEndClass1InAssociation);
assertNull(diffs.addOwnedEndClass1InAssociation);
assertNull(diffs.addMemberEndClass1InAssociation);
assertNull(diffs.addRefAssociationInPropertyClass1);
assertNull(diffs.addLiteralIntegerInClass1);
assertNull(diffs.addUnlimitedNaturalInClass1);
assertNull(diffs.addRefTypeInPropertyClass1);
}
@Test
public void testA10MergeLtR2UseCase() throws IOException {
final Resource left = input.getA1Left();
final Resource right = input.getA1Right();
Comparison comparison = compare(left, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.ADD);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addOwnedEndClass1InAssociation)
.copyLeftToRight(diffs.addOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.ADD);
checkMergeAddOwnedEnd(comparison, diffs);
}
private void checkMergeAddOwnedEnd(Comparison comparison, DiffsOfInterest diffs) {
assertEquals(NB_DIFFS - 6, comparison.getDifferences().size());
assertNull(diffs.addOwnedEndClass1InAssociation);
assertNull(diffs.addMemberEndClass1InAssociation);
assertNull(diffs.addNavigableOwnedEndClass1InAssociation);
assertNull(diffs.addRefAssociationInPropertyClass1);
assertNull(diffs.addAssociation);
assertNull(diffs.addUMLAssociation);
}
@Test
public void testA10MergeLtR2UseCase3way1() throws IOException {
final Resource left = input.getA1Left();
final Resource right = input.getA1Right();
Comparison comparison = compare(left, right, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.ADD);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addOwnedEndClass1InAssociation)
.copyLeftToRight(diffs.addOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.ADD);
checkMergeAddOwnedEnd(comparison, diffs);
}
@Test
public void testA10MergeLtR2UseCase3way2() throws IOException {
final Resource left = input.getA1Right();
final Resource right = input.getA1Left();
Comparison comparison = compare(left, right, left);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.ADD);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addOwnedEndClass1InAssociation)
.copyLeftToRight(diffs.addOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.ADD);
checkMergeDeleteOwnedEnd(comparison, diffs);
}
private void checkMergeDeleteOwnedEnd(Comparison comparison, DiffsOfInterest diffs) {
// 7 diffs of interest+ 2 MultiplicityElementChanges
assertEquals(NB_DIFFS - 9, comparison.getDifferences().size());
assertNull(diffs.addOwnedEndClass1InAssociation);
assertNull(diffs.addMemberEndClass1InAssociation);
assertNull(diffs.addRefAssociationInPropertyClass1);
assertNull(diffs.addNavigableOwnedEndClass1InAssociation);
assertNull(diffs.addLiteralIntegerInClass1);
assertNull(diffs.addUnlimitedNaturalInClass1);
assertNull(diffs.addRefTypeInPropertyClass1);
}
@Test
public void testA10MergeLtR3UseCase() throws IOException {
final Resource left = input.getA1Left();
final Resource right = input.getA1Right();
Comparison comparison = compare(left, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.ADD);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addMemberEndClass1InAssociation)
.copyLeftToRight(diffs.addMemberEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.ADD);
checkMergeAddMemberEnd(comparison, diffs);
}
private void checkMergeAddMemberEnd(Comparison comparison, DiffsOfInterest diffs) {
assertEquals(NB_DIFFS - 6, comparison.getDifferences().size());
assertNull(diffs.addMemberEndClass1InAssociation);
assertNull(diffs.addRefAssociationInPropertyClass1);
assertNull(diffs.addOwnedEndClass1InAssociation);
assertNull(diffs.addNavigableOwnedEndClass1InAssociation);
assertNull(diffs.addAssociation);
assertNull(diffs.addUMLAssociation);
}
@Test
public void testA10MergeLtR3UseCase3way1() throws IOException {
final Resource left = input.getA1Left();
final Resource right = input.getA1Right();
Comparison comparison = compare(left, right, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.ADD);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addMemberEndClass1InAssociation)
.copyLeftToRight(diffs.addMemberEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.ADD);
checkMergeAddMemberEnd(comparison, diffs);
}
@Test
public void testA10MergeLtR3UseCase3way2() throws IOException {
final Resource left = input.getA1Right();
final Resource right = input.getA1Left();
Comparison comparison = compare(left, right, left);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.ADD);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addMemberEndClass1InAssociation)
.copyLeftToRight(diffs.addMemberEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.ADD);
checkMergeDeleteOwnedEnd(comparison, diffs);
}
@Test
public void testA10MergeRtL1UseCase() throws IOException {
final Resource left = input.getA1Left();
final Resource right = input.getA1Right();
Comparison comparison = compare(left, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.ADD);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addNavigableOwnedEndClass1InAssociation)
.copyRightToLeft(diffs.addNavigableOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.ADD);
checkMergeDeleteNavigableOwnedEnd(comparison, diffs);
}
@Test
public void testA10MergeRtL1UseCase3way1() throws IOException {
final Resource left = input.getA1Left();
final Resource right = input.getA1Right();
Comparison comparison = compare(left, right, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.ADD);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addNavigableOwnedEndClass1InAssociation)
.copyRightToLeft(diffs.addNavigableOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.ADD);
checkMergeDeleteNavigableOwnedEnd(comparison, diffs);
}
@Test
public void testA10MergeRtL1UseCase3way2() throws IOException {
final Resource left = input.getA1Right();
final Resource right = input.getA1Left();
Comparison comparison = compare(left, right, left);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.ADD);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addNavigableOwnedEndClass1InAssociation)
.copyRightToLeft(diffs.addNavigableOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.ADD);
checkMergeAddNavigableOwnedEnd(comparison, diffs);
}
@Test
public void testA10MergeRtL2UseCase() throws IOException {
final Resource left = input.getA1Left();
final Resource right = input.getA1Right();
Comparison comparison = compare(left, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.ADD);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addOwnedEndClass1InAssociation)
.copyRightToLeft(diffs.addOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.ADD);
checkMergeDeleteOwnedEnd(comparison, diffs);
}
@Test
public void testA10MergeRtL2UseCase3way1() throws IOException {
final Resource left = input.getA1Left();
final Resource right = input.getA1Right();
Comparison comparison = compare(left, right, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.ADD);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addOwnedEndClass1InAssociation)
.copyRightToLeft(diffs.addOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.ADD);
checkMergeDeleteOwnedEnd(comparison, diffs);
}
@Test
public void testA10MergeRtL2UseCase3way2() throws IOException {
final Resource left = input.getA1Right();
final Resource right = input.getA1Left();
Comparison comparison = compare(left, right, left);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.ADD);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addOwnedEndClass1InAssociation)
.copyRightToLeft(diffs.addOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.ADD);
checkMergeAddOwnedEnd(comparison, diffs);
}
@Test
public void testA10MergeRtL3UseCase() throws IOException {
final Resource left = input.getA1Left();
final Resource right = input.getA1Right();
Comparison comparison = compare(left, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.ADD);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addMemberEndClass1InAssociation)
.copyRightToLeft(diffs.addMemberEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.ADD);
checkMergeDeleteOwnedEnd(comparison, diffs);
}
@Test
public void testA10MergeRtL3UseCase3way1() throws IOException {
final Resource left = input.getA1Left();
final Resource right = input.getA1Right();
Comparison comparison = compare(left, right, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.ADD);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addMemberEndClass1InAssociation)
.copyRightToLeft(diffs.addMemberEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.ADD);
checkMergeDeleteOwnedEnd(comparison, diffs);
}
@Test
public void testA10MergeRtL3UseCase3way2() throws IOException {
final Resource left = input.getA1Right();
final Resource right = input.getA1Left();
Comparison comparison = compare(left, right, left);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.ADD);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addMemberEndClass1InAssociation)
.copyRightToLeft(diffs.addMemberEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.ADD);
checkMergeAddMemberEnd(comparison, diffs);
}
@Test
public void testA11UseCase() throws IOException {
final Resource left = input.getA1Right();
final Resource right = input.getA1Left();
Comparison comparison = compare(left, right);
testAB1(TestKind.DELETE, comparison);
}
@Test
// local DELETE
public void testA11UseCase3way1() throws IOException {
final Resource left = input.getA1Right();
final Resource right = input.getA1Left();
Comparison comparison = compare(left, right, right);
testAB1(TestKind.DELETE, comparison);
}
@Test
// remote DELETE
public void testA11UseCase3way2() throws IOException {
final Resource left = input.getA1Left();
final Resource right = input.getA1Right();
Comparison comparison = compare(left, right, left);
testAB1(TestKind.DELETE, comparison);
}
@Test
public void testA11MergeLtR1UseCase() throws IOException {
final Resource left = input.getA1Right();
final Resource right = input.getA1Left();
Comparison comparison = compare(left, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.DELETE);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addNavigableOwnedEndClass1InAssociation)
.copyLeftToRight(diffs.addNavigableOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.DELETE);
checkMergeDeleteNavigableOwnedEnd(comparison, diffs);
}
@Test
public void testA11MergeLtR1UseCase3way1() throws IOException {
final Resource left = input.getA1Right();
final Resource right = input.getA1Left();
Comparison comparison = compare(left, right, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.DELETE);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addNavigableOwnedEndClass1InAssociation)
.copyLeftToRight(diffs.addNavigableOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.DELETE);
checkMergeDeleteNavigableOwnedEnd(comparison, diffs);
}
@Test
public void testA11MergeLtR1UseCase3way2() throws IOException {
final Resource left = input.getA1Left();
final Resource right = input.getA1Right();
Comparison comparison = compare(left, right, left);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.DELETE);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addNavigableOwnedEndClass1InAssociation)
.copyLeftToRight(diffs.addNavigableOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.DELETE);
checkMergeAddNavigableOwnedEnd(comparison, diffs);
}
@Test
public void testA11MergeLtR2UseCase() throws IOException {
final Resource left = input.getA1Right();
final Resource right = input.getA1Left();
Comparison comparison = compare(left, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.DELETE);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addOwnedEndClass1InAssociation)
.copyLeftToRight(diffs.addOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.DELETE);
checkMergeDeleteOwnedEnd(comparison, diffs);
}
@Test
public void testA11MergeLtR2UseCase3way1() throws IOException {
final Resource left = input.getA1Right();
final Resource right = input.getA1Left();
Comparison comparison = compare(left, right, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.DELETE);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addOwnedEndClass1InAssociation)
.copyLeftToRight(diffs.addOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.DELETE);
checkMergeDeleteOwnedEnd(comparison, diffs);
}
@Test
public void testA11MergeLtR2UseCase3way2() throws IOException {
final Resource left = input.getA1Left();
final Resource right = input.getA1Right();
Comparison comparison = compare(left, right, left);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.DELETE);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addOwnedEndClass1InAssociation)
.copyLeftToRight(diffs.addOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.DELETE);
checkMergeAddOwnedEnd(comparison, diffs);
}
@Test
public void testA11MergeLtR3UseCase() throws IOException {
final Resource left = input.getA1Right();
final Resource right = input.getA1Left();
Comparison comparison = compare(left, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.DELETE);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addMemberEndClass1InAssociation)
.copyLeftToRight(diffs.addMemberEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.DELETE);
checkMergeDeleteOwnedEnd(comparison, diffs);
}
@Test
public void testA11MergeLtR3UseCase3way1() throws IOException {
final Resource left = input.getA1Right();
final Resource right = input.getA1Left();
Comparison comparison = compare(left, right, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.DELETE);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addMemberEndClass1InAssociation)
.copyLeftToRight(diffs.addMemberEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.DELETE);
checkMergeDeleteOwnedEnd(comparison, diffs);
}
@Test
public void testA11MergeLtR3UseCase3way2() throws IOException {
final Resource left = input.getA1Left();
final Resource right = input.getA1Right();
Comparison comparison = compare(left, right, left);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.DELETE);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addMemberEndClass1InAssociation)
.copyLeftToRight(diffs.addMemberEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.DELETE);
checkMergeAddMemberEnd(comparison, diffs);
}
@Test
public void testA11MergeRtL1UseCase() throws IOException {
final Resource left = input.getA1Right();
final Resource right = input.getA1Left();
Comparison comparison = compare(left, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.DELETE);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addNavigableOwnedEndClass1InAssociation)
.copyRightToLeft(diffs.addNavigableOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.DELETE);
checkMergeAddNavigableOwnedEnd(comparison, diffs);
}
@Test
public void testA11MergeRtL1UseCase3way1() throws IOException {
final Resource left = input.getA1Right();
final Resource right = input.getA1Left();
Comparison comparison = compare(left, right, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.DELETE);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addNavigableOwnedEndClass1InAssociation)
.copyRightToLeft(diffs.addNavigableOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.DELETE);
checkMergeAddNavigableOwnedEnd(comparison, diffs);
}
@Test
public void testA11MergeRtL1UseCase3way2() throws IOException {
final Resource left = input.getA1Left();
final Resource right = input.getA1Right();
Comparison comparison = compare(left, right, left);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.DELETE);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addNavigableOwnedEndClass1InAssociation)
.copyRightToLeft(diffs.addNavigableOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.DELETE);
checkMergeDeleteNavigableOwnedEnd(comparison, diffs);
}
@Test
public void testA11MergeRtL2UseCase() throws IOException {
final Resource left = input.getA1Right();
final Resource right = input.getA1Left();
Comparison comparison = compare(left, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.DELETE);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addOwnedEndClass1InAssociation)
.copyRightToLeft(diffs.addOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.DELETE);
checkMergeAddOwnedEnd(comparison, diffs);
}
@Test
public void testA11MergeRtL2UseCase3way1() throws IOException {
final Resource left = input.getA1Right();
final Resource right = input.getA1Left();
Comparison comparison = compare(left, right, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.DELETE);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addOwnedEndClass1InAssociation)
.copyRightToLeft(diffs.addOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.DELETE);
checkMergeAddOwnedEnd(comparison, diffs);
}
@Test
public void testA11MergeRtL2UseCase3way2() throws IOException {
final Resource left = input.getA1Left();
final Resource right = input.getA1Right();
Comparison comparison = compare(left, right, left);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.DELETE);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addOwnedEndClass1InAssociation)
.copyRightToLeft(diffs.addOwnedEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.DELETE);
checkMergeDeleteOwnedEnd(comparison, diffs);
}
@Test
public void testA11MergeRtL3UseCase() throws IOException {
final Resource left = input.getA1Right();
final Resource right = input.getA1Left();
Comparison comparison = compare(left, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.DELETE);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addMemberEndClass1InAssociation)
.copyRightToLeft(diffs.addMemberEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.DELETE);
checkMergeAddMemberEnd(comparison, diffs);
}
@Test
public void testA11MergeRtL3UseCase3way1() throws IOException {
final Resource left = input.getA1Right();
final Resource right = input.getA1Left();
Comparison comparison = compare(left, right, right);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.DELETE);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addMemberEndClass1InAssociation)
.copyRightToLeft(diffs.addMemberEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.DELETE);
checkMergeAddMemberEnd(comparison, diffs);
}
@Test
public void testA11MergeRtL3UseCase3way2() throws IOException {
final Resource left = input.getA1Left();
final Resource right = input.getA1Right();
Comparison comparison = compare(left, right, left);
DiffsOfInterest diffs = getDiffs(comparison, TestKind.DELETE);
// ** MERGE **
getMergerRegistry().getHighestRankingMerger(diffs.addMemberEndClass1InAssociation)
.copyRightToLeft(diffs.addMemberEndClass1InAssociation, new BasicMonitor());
comparison = compare(left, right);
diffs = getDiffs(comparison, TestKind.DELETE);
checkMergeDeleteOwnedEnd(comparison, diffs);
}
private void testAB1(TestKind kind, final Comparison comparison) {
final List<Diff> differences = comparison.getDifferences();
// We should have no less and no more than 16 differences
assertEquals(NB_DIFFS, differences.size());
DiffsOfInterest diffs = getDiffs(comparison, kind);
if (kind.equals(TestKind.DELETE)) {
assertEquals(0, diffs.addNavigableOwnedEndClass1InAssociation.getImplies().size());
assertEquals(1, diffs.addNavigableOwnedEndClass1InAssociation.getImpliedBy().size());
assertTrue(diffs.addNavigableOwnedEndClass1InAssociation.getImpliedBy()
.contains(diffs.addOwnedEndClass1InAssociation));
assertEquals(1, diffs.addOwnedEndClass1InAssociation.getImplies().size());
assertTrue(diffs.addOwnedEndClass1InAssociation.getImplies()
.contains(diffs.addNavigableOwnedEndClass1InAssociation));
assertEquals(2, diffs.addOwnedEndClass1InAssociation.getImpliedBy().size());
assertTrue(diffs.addOwnedEndClass1InAssociation.getImpliedBy()
.contains(diffs.addMemberEndClass1InAssociation));
assertTrue(diffs.addOwnedEndClass1InAssociation.getImpliedBy()
.contains(diffs.addRefAssociationInPropertyClass1));
assertEquals(1, diffs.addMemberEndClass1InAssociation.getImplies().size());
assertTrue(diffs.addMemberEndClass1InAssociation.getImplies()
.contains(diffs.addOwnedEndClass1InAssociation));
assertEquals(0, diffs.addMemberEndClass1InAssociation.getImpliedBy().size());
} else {
assertEquals(1, diffs.addNavigableOwnedEndClass1InAssociation.getImplies().size());
assertTrue(diffs.addNavigableOwnedEndClass1InAssociation.getImplies()
.contains(diffs.addOwnedEndClass1InAssociation));
assertEquals(0, diffs.addNavigableOwnedEndClass1InAssociation.getImpliedBy().size());
assertEquals(2, diffs.addOwnedEndClass1InAssociation.getImplies().size());
assertTrue(diffs.addOwnedEndClass1InAssociation.getImplies()
.contains(diffs.addMemberEndClass1InAssociation));
assertTrue(diffs.addOwnedEndClass1InAssociation.getImplies()
.contains(diffs.addRefAssociationInPropertyClass1));
assertEquals(1, diffs.addOwnedEndClass1InAssociation.getImpliedBy().size());
assertTrue(diffs.addOwnedEndClass1InAssociation.getImpliedBy()
.contains(diffs.addNavigableOwnedEndClass1InAssociation));
assertEquals(0, diffs.addMemberEndClass1InAssociation.getImplies().size());
assertEquals(1, diffs.addMemberEndClass1InAssociation.getImpliedBy().size());
assertTrue(diffs.addMemberEndClass1InAssociation.getImpliedBy()
.contains(diffs.addOwnedEndClass1InAssociation));
}
}
@Override
protected AbstractUMLInputData getInput() {
return input;
}
private static Predicate<? super Diff> addedLowerValueIn(final String qualifiedName) {
return and(ofKind(DifferenceKind.ADD), onEObject(qualifiedName), onFeature("lowerValue"),
refinesMultiplicityElementChange());
}
private static Predicate<? super Diff> addedUpperValueIn(final String qualifiedName) {
return and(ofKind(DifferenceKind.ADD), onEObject(qualifiedName), onFeature("upperValue"),
refinesMultiplicityElementChange());
}
private static Predicate<? super Diff> removedLowerValueIn(final String qualifiedName) {
return and(ofKind(DifferenceKind.DELETE), onEObject(qualifiedName), onFeature("lowerValue"),
refinesMultiplicityElementChange());
}
private static Predicate<? super Diff> removedUpperValueIn(final String qualifiedName) {
return and(ofKind(DifferenceKind.DELETE), onEObject(qualifiedName), onFeature("upperValue"),
refinesMultiplicityElementChange());
}
private static Predicate<? super Diff> refinesMultiplicityElementChange() {
return new Predicate<Diff>() {
public boolean apply(Diff input) {
return Iterators.any(input.getRefines().iterator(),
instanceOf(MultiplicityElementChange.class));
}
};
}
private class DiffsOfInterest {
public Diff addAssociation;
public Diff addNavigableOwnedEndClass1InAssociation;
public Diff addNavigableOwnedEndClass2InAssociation;
public Diff addMemberEndClass1InAssociation;
public Diff addMemberEndClass2InAssociation;
public Diff addOwnedEndClass1InAssociation;
public Diff addOwnedEndClass2InAssociation;
public Diff addRefAssociationInPropertyClass1;
public Diff addRefTypeInPropertyClass1;
public Diff addRefAssociationInPropertyClass2;
public Diff addRefTypeInPropertyClass2;
public Diff addLiteralIntegerInClass1;
public Diff addUnlimitedNaturalInClass1;
public Diff addLiteralIntegerInClass2;
public Diff addUnlimitedNaturalInClass2;
public Diff addUMLAssociation;
}
}
