diff options
15 files changed, 611 insertions, 0 deletions
diff --git a/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/ConflictMergeTest.java b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/ConflictMergeTest.java index 11495369d..9c06e5476 100644 --- a/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/ConflictMergeTest.java +++ b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/ConflictMergeTest.java @@ -12,6 +12,7 @@ package org.eclipse.emf.compare.tests.merge; import static com.google.common.base.Predicates.and; import static com.google.common.base.Predicates.not; +import static org.eclipse.emf.compare.utils.EMFComparePredicates.addedToAttribute; import static org.eclipse.emf.compare.utils.EMFComparePredicates.fromSide; import static org.eclipse.emf.compare.utils.EMFComparePredicates.hasState; import static org.eclipse.emf.compare.utils.EMFComparePredicates.ofKind; @@ -23,9 +24,11 @@ import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import com.google.common.collect.Iterators; +import com.google.common.collect.Lists; import com.google.common.collect.UnmodifiableIterator; import java.io.IOException; +import java.util.Collection; import java.util.Iterator; import java.util.List; @@ -42,6 +45,7 @@ import org.eclipse.emf.compare.scope.DefaultComparisonScope; import org.eclipse.emf.compare.scope.IComparisonScope; import org.eclipse.emf.compare.tests.merge.data.IndividualDiffInputData; import org.eclipse.emf.compare.tests.nodes.Node; +import org.eclipse.emf.compare.tests.nodes.NodeEnum; import org.eclipse.emf.ecore.EAttribute; import org.eclipse.emf.ecore.EClass; import org.eclipse.emf.ecore.EClassifier; @@ -394,6 +398,65 @@ public class ConflictMergeTest { } @Test + public void testLeftAddRightDelete_LtR_EEnum() throws IOException { + final Resource left = input.getLeftAddRightDeleteLeftEEnumConflictScope(); + final Resource right = input.getLeftAddRightDeleteRightEEnumConflictScope(); + final Resource origin = input.getLeftAddRightDeleteOriginEEnumConflictScope(); + + final IComparisonScope scope = new DefaultComparisonScope(left, right, origin); + Comparison comparison = EMFCompare.builder().build().compare(scope); + + List<Diff> differences = comparison.getDifferences(); + assertEquals(3, differences.size()); + + final String featureName = "multiValueEEnumAttribute"; + final Diff diffA = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), + addedToAttribute("root.origin", featureName, NodeEnum.A))); + final Diff diffB = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), + addedToAttribute("root.origin", featureName, NodeEnum.B))); + + mergerRegistry.getHighestRankingMerger(diffA).copyLeftToRight(diffA, new BasicMonitor()); + + final EObject rightElement = getNodeNamed(right, "origin"); + assertNotNull(rightElement); + final EStructuralFeature feature = rightElement.eClass().getEStructuralFeature(featureName); + assertNotNull(feature); + Object featureValue = rightElement.eGet(feature); + assertTrue(featureValue instanceof Collection<?>); + assertTrue(((Collection<?>)featureValue).containsAll(Lists.newArrayList(NodeEnum.A))); + + mergerRegistry.getHighestRankingMerger(diffB).copyLeftToRight(diffB, new BasicMonitor()); + + featureValue = rightElement.eGet(feature); + assertTrue(featureValue instanceof Collection<?>); + assertTrue(((Collection<?>)featureValue).containsAll(Lists.newArrayList(NodeEnum.A, NodeEnum.B))); + + assertFalse(Iterators.any(differences.iterator(), not(hasState(DifferenceState.MERGED)))); + } + + @Test + public void testLeftAddRightDelete_RtL_EEnum() throws IOException { + final Resource left = input.getLeftAddRightDeleteLeftEEnumConflictScope(); + final Resource right = input.getLeftAddRightDeleteRightEEnumConflictScope(); + final Resource origin = input.getLeftAddRightDeleteOriginEEnumConflictScope(); + + final IComparisonScope scope = new DefaultComparisonScope(left, right, origin); + Comparison comparison = EMFCompare.builder().build().compare(scope); + + List<Diff> differences = comparison.getDifferences(); + assertEquals(3, differences.size()); + + final Diff diffDelete = Iterators.find(differences.iterator(), fromSide(DifferenceSource.RIGHT)); + + mergerRegistry.getHighestRankingMerger(diffDelete).copyRightToLeft(diffDelete, new BasicMonitor()); + + final EObject rightElement = getNodeNamed(left, "origin"); + assertNull(rightElement); + + assertFalse(Iterators.any(differences.iterator(), not(hasState(DifferenceState.MERGED)))); + } + + @Test public void testLeftAddRightDelete_RtL_1() throws IOException { // Conflict between B[eSuperTypes add] from left side and B[eClassifiers delete] from right side @@ -1532,6 +1595,74 @@ public class ConflictMergeTest { assertFalse(Iterators.any(differences.iterator(), not(hasState(DifferenceState.MERGED)))); } + @Test + public void testLeftSetRightSetEEnum_LtR() throws IOException { + // Conflict between two single value attribute with an eenum type + final Resource left = input.getLeftSetRightSetLeftEEnumConflictScope(); + final Resource right = input.getLeftSetRightSetRightEEnumConflictScope(); + final Resource origin = input.getLeftSetRightSetOriginEEnumConflictScope(); + + final IComparisonScope scope = new DefaultComparisonScope(left, right, origin); + Comparison comparison = EMFCompare.builder().build().compare(scope); + + List<Diff> differences = comparison.getDifferences(); + assertEquals(2, differences.size()); + + final Diff diff = Iterators.find(differences.iterator(), fromSide(DifferenceSource.LEFT)); + + // Merge the left diff should also merge the right diff + mergerRegistry.getHighestRankingMerger(diff).copyLeftToRight(diff, new BasicMonitor()); + + final String featureName = "singlevalueEEnumAttribute"; + final EObject rightNode = getNodeNamed(right, "root"); + assertNotNull(rightNode); + final EStructuralFeature feature = rightNode.eClass().getEStructuralFeature(featureName); + assertNotNull(feature); + final Object rightValue = rightNode.eGet(feature); + assertEquals(NodeEnum.B, rightValue); + + final EObject leftNode = getNodeNamed(left, "root"); + assertNotNull(rightNode); + final Object leftValue = leftNode.eGet(feature); + assertEquals(NodeEnum.B, leftValue); + + assertFalse(Iterators.any(differences.iterator(), not(hasState(DifferenceState.MERGED)))); + } + + @Test + public void testLeftSetRightSetEEnum_RtL() throws IOException { + // Conflict between two single value attribute with an eenum type + final Resource left = input.getLeftSetRightSetLeftEEnumConflictScope(); + final Resource right = input.getLeftSetRightSetRightEEnumConflictScope(); + final Resource origin = input.getLeftSetRightSetOriginEEnumConflictScope(); + + final IComparisonScope scope = new DefaultComparisonScope(left, right, origin); + Comparison comparison = EMFCompare.builder().build().compare(scope); + + List<Diff> differences = comparison.getDifferences(); + assertEquals(2, differences.size()); + + final Diff diff = Iterators.find(differences.iterator(), fromSide(DifferenceSource.RIGHT)); + + // Merge the left diff should also merge the right diff + mergerRegistry.getHighestRankingMerger(diff).copyRightToLeft(diff, new BasicMonitor()); + + final String featureName = "singlevalueEEnumAttribute"; + final EObject rightNode = getNodeNamed(right, "root"); + assertNotNull(rightNode); + final EStructuralFeature feature = rightNode.eClass().getEStructuralFeature(featureName); + assertNotNull(feature); + final Object rightValue = rightNode.eGet(feature); + assertEquals(NodeEnum.C, rightValue); + + final EObject leftNode = getNodeNamed(left, "root"); + assertNotNull(rightNode); + final Object leftValue = leftNode.eGet(feature); + assertEquals(NodeEnum.C, leftValue); + + assertFalse(Iterators.any(differences.iterator(), not(hasState(DifferenceState.MERGED)))); + } + private EObject getNodeNamed(Resource res, String name) { final Iterator<EObject> iterator = EcoreUtil.getAllProperContents(res, false); while (iterator.hasNext()) { diff --git a/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/IndividualMergeTest.java b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/IndividualMergeTest.java index 490239014..e41f89353 100644 --- a/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/IndividualMergeTest.java +++ b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/IndividualMergeTest.java @@ -29,6 +29,7 @@ import static org.junit.Assert.assertSame; import static org.junit.Assert.assertTrue; import com.google.common.collect.Iterators; +import com.google.common.collect.Lists; import java.io.IOException; import java.util.Collection; @@ -45,6 +46,7 @@ import org.eclipse.emf.compare.merge.IMerger; import org.eclipse.emf.compare.scope.DefaultComparisonScope; import org.eclipse.emf.compare.scope.IComparisonScope; import org.eclipse.emf.compare.tests.merge.data.IndividualDiffInputData; +import org.eclipse.emf.compare.tests.nodes.NodeEnum; import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.EStructuralFeature; import org.eclipse.emf.ecore.resource.Resource; @@ -142,6 +144,181 @@ public class IndividualMergeTest { } @Test + public void testAttributeEEnumMonoChange2WayLtR() throws IOException { + final Resource left = input.getAttributeMonoEEnumChangeLeft(); + final Resource right = input.getAttributeMonoEEnumChangeRight(); + + final IComparisonScope scope = new DefaultComparisonScope(left, right, null); + Comparison comparison = EMFCompare.builder().build().compare(scope); + + final List<Diff> differences = comparison.getDifferences(); + assertEquals(1, differences.size()); + + final String featureName = "singlevalueEEnumAttribute"; + final Diff diff = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), + changedAttribute("root", featureName, NodeEnum.A, NodeEnum.B))); + + mergerRegistry.getHighestRankingMerger(diff).copyLeftToRight(diff, new BasicMonitor()); + final EObject originNode = getNodeNamed(right, "root"); + assertNotNull(originNode); + final EStructuralFeature feature = originNode.eClass().getEStructuralFeature(featureName); + assertNotNull(feature); + + assertEquals(NodeEnum.B, originNode.eGet(feature)); + + comparison = EMFCompare.builder().build().compare(scope); + assertEquals(0, comparison.getDifferences().size()); + } + + @Test + public void testAttributeEEnumMonoChange2WayRtL() throws IOException { + final Resource left = input.getAttributeMonoEEnumChangeLeft(); + final Resource right = input.getAttributeMonoEEnumChangeRight(); + + final IComparisonScope scope = new DefaultComparisonScope(left, right, null); + Comparison comparison = EMFCompare.builder().build().compare(scope); + + final List<Diff> differences = comparison.getDifferences(); + assertEquals(1, differences.size()); + + final String featureName = "singlevalueEEnumAttribute"; + final Diff diff = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), + changedAttribute("root", featureName, NodeEnum.A, NodeEnum.B))); + + mergerRegistry.getHighestRankingMerger(diff).copyRightToLeft(diff, new BasicMonitor()); + final EObject originNode = getNodeNamed(left, "root"); + assertNotNull(originNode); + final EStructuralFeature feature = originNode.eClass().getEStructuralFeature(featureName); + assertNotNull(feature); + + assertEquals(NodeEnum.A, originNode.eGet(feature)); + + comparison = EMFCompare.builder().build().compare(scope); + assertEquals(0, comparison.getDifferences().size()); + } + + @Test + public void testAttributeEEnumMonoChange3WayLeftChangeLtR() throws IOException { + final Resource left = input.getAttributeMonoEEnumChangeLeft(); + final Resource right = input.getAttributeMonoEEnumChangeRight(); + final Resource origin = input.getAttributeMonoEEnumChangeOrigin(); + + IComparisonScope scope = new DefaultComparisonScope(left, right, origin); + Comparison comparison = EMFCompare.builder().build().compare(scope); + + final List<Diff> differences = comparison.getDifferences(); + assertEquals(1, differences.size()); + + final String featureName = "singlevalueEEnumAttribute"; + final Diff diff = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), + changedAttribute("root", featureName, NodeEnum.A, NodeEnum.B))); + + mergerRegistry.getHighestRankingMerger(diff).copyLeftToRight(diff, new BasicMonitor()); + final EObject originNode = getNodeNamed(right, "root"); + assertNotNull(originNode); + final EStructuralFeature feature = originNode.eClass().getEStructuralFeature(featureName); + assertNotNull(feature); + + assertEquals(NodeEnum.B, originNode.eGet(feature)); + + // We should have no difference between left and right ... though they might be different from origin + scope = new DefaultComparisonScope(left, right, null); + comparison = EMFCompare.builder().build().compare(scope); + assertEquals(0, comparison.getDifferences().size()); + } + + @Test + public void testAttributeEEnumMonoChange3WayLeftChangeRtL() throws IOException { + final Resource left = input.getAttributeMonoEEnumChangeLeft(); + final Resource right = input.getAttributeMonoEEnumChangeRight(); + final Resource origin = input.getAttributeMonoEEnumChangeOrigin(); + + IComparisonScope scope = new DefaultComparisonScope(left, right, origin); + Comparison comparison = EMFCompare.builder().build().compare(scope); + + final List<Diff> differences = comparison.getDifferences(); + assertEquals(1, differences.size()); + + final String featureName = "singlevalueEEnumAttribute"; + final Diff diff = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), + changedAttribute("root", featureName, NodeEnum.A, NodeEnum.B))); + + mergerRegistry.getHighestRankingMerger(diff).copyRightToLeft(diff, new BasicMonitor()); + final EObject originNode = getNodeNamed(right, "root"); + assertNotNull(originNode); + final EStructuralFeature feature = originNode.eClass().getEStructuralFeature(featureName); + assertNotNull(feature); + + assertEquals(NodeEnum.A, originNode.eGet(feature)); + + // We should have no difference between left and right ... though they might be different from origin + scope = new DefaultComparisonScope(left, right, null); + comparison = EMFCompare.builder().build().compare(scope); + assertEquals(0, comparison.getDifferences().size()); + } + + @Test + public void testAttributeEEnumMonoChange3WayRightChangeLtR() throws IOException { + // In order to have changes on the right side, we'll invert right and left + final Resource left = input.getAttributeMonoEEnumChangeRight(); + final Resource right = input.getAttributeMonoEEnumChangeLeft(); + final Resource origin = input.getAttributeMonoEEnumChangeOrigin(); + + IComparisonScope scope = new DefaultComparisonScope(left, right, origin); + Comparison comparison = EMFCompare.builder().build().compare(scope); + + final List<Diff> differences = comparison.getDifferences(); + assertEquals(1, differences.size()); + + final String featureName = "singlevalueEEnumAttribute"; + final Diff diff = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.RIGHT), + changedAttribute("root", featureName, NodeEnum.A, NodeEnum.B))); + + mergerRegistry.getHighestRankingMerger(diff).copyLeftToRight(diff, new BasicMonitor()); + final EObject originNode = getNodeNamed(right, "root"); + assertNotNull(originNode); + final EStructuralFeature feature = originNode.eClass().getEStructuralFeature(featureName); + assertNotNull(feature); + + assertEquals(NodeEnum.A, originNode.eGet(feature)); + + // We should have no difference between left and right ... though they might be different from origin + scope = new DefaultComparisonScope(left, right, null); + comparison = EMFCompare.builder().build().compare(scope); + assertEquals(0, comparison.getDifferences().size()); + } + + @Test + public void testAttributeEEnumMonoChange3WayRightChangeRtL() throws IOException { + final Resource left = input.getAttributeMonoEEnumChangeRight(); + final Resource right = input.getAttributeMonoEEnumChangeLeft(); + final Resource origin = input.getAttributeMonoEEnumChangeOrigin(); + + IComparisonScope scope = new DefaultComparisonScope(left, right, origin); + Comparison comparison = EMFCompare.builder().build().compare(scope); + + final List<Diff> differences = comparison.getDifferences(); + assertEquals(1, differences.size()); + + final String featureName = "singlevalueEEnumAttribute"; + final Diff diff = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.RIGHT), + changedAttribute("root", featureName, NodeEnum.A, NodeEnum.B))); + + mergerRegistry.getHighestRankingMerger(diff).copyRightToLeft(diff, new BasicMonitor()); + final EObject originNode = getNodeNamed(right, "root"); + assertNotNull(originNode); + final EStructuralFeature feature = originNode.eClass().getEStructuralFeature(featureName); + assertNotNull(feature); + + assertEquals(NodeEnum.B, originNode.eGet(feature)); + + // We should have no difference between left and right ... though they might be different from origin + scope = new DefaultComparisonScope(left, right, null); + comparison = EMFCompare.builder().build().compare(scope); + assertEquals(0, comparison.getDifferences().size()); + } + + @Test public void testAttributeMonoChange3WayLeftChangeRtL() throws IOException { final Resource left = input.getAttributeMonoChangeLeft(); final Resource right = input.getAttributeMonoChangeRight(); @@ -574,6 +751,226 @@ public class IndividualMergeTest { } @Test + public void testAttributeEEnumMultiAdd2WayLtR() throws IOException { + final Resource left = input.getAttributeEEnumMultiAddLeft(); + final Resource right = input.getAttributeEEnumMultiAddRight(); + + final IComparisonScope scope = new DefaultComparisonScope(left, right, null); + Comparison comparison = EMFCompare.builder().build().compare(scope); + + final List<Diff> differences = comparison.getDifferences(); + assertEquals(3, differences.size()); + + final String featureName = "multiValueEEnumAttribute"; + final Diff diff = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), + addedToAttribute("root", featureName, NodeEnum.A))); + final Diff diff2 = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), + addedToAttribute("root", featureName, NodeEnum.B))); + final Diff diff3 = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), + addedToAttribute("root", featureName, NodeEnum.C))); + + mergerRegistry.getHighestRankingMerger(diff).copyLeftToRight(diff, new BasicMonitor()); + mergerRegistry.getHighestRankingMerger(diff2).copyLeftToRight(diff2, new BasicMonitor()); + mergerRegistry.getHighestRankingMerger(diff3).copyLeftToRight(diff3, new BasicMonitor()); + + final EObject originNode = getNodeNamed(right, "root"); + assertNotNull(originNode); + final EStructuralFeature feature = originNode.eClass().getEStructuralFeature(featureName); + assertNotNull(feature); + + final Object featureValue = originNode.eGet(feature); + assertTrue(featureValue instanceof List<?>); + assertEquals(featureValue, Lists.newArrayList(NodeEnum.A, NodeEnum.B, NodeEnum.C)); + + comparison = EMFCompare.builder().build().compare(scope); + assertEquals(0, comparison.getDifferences().size()); + } + + @Test + public void testAttributeEEnumMultiAdd2WayRtL() throws IOException { + final Resource left = input.getAttributeEEnumMultiAddLeft(); + final Resource right = input.getAttributeEEnumMultiAddRight(); + + final IComparisonScope scope = new DefaultComparisonScope(left, right, null); + Comparison comparison = EMFCompare.builder().build().compare(scope); + + final List<Diff> differences = comparison.getDifferences(); + assertEquals(3, differences.size()); + + final String featureName = "multiValueEEnumAttribute"; + final Diff diff = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), + addedToAttribute("root", featureName, NodeEnum.A))); + final Diff diff2 = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), + addedToAttribute("root", featureName, NodeEnum.B))); + final Diff diff3 = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), + addedToAttribute("root", featureName, NodeEnum.C))); + + mergerRegistry.getHighestRankingMerger(diff).copyRightToLeft(diff, new BasicMonitor()); + mergerRegistry.getHighestRankingMerger(diff2).copyRightToLeft(diff2, new BasicMonitor()); + mergerRegistry.getHighestRankingMerger(diff3).copyRightToLeft(diff3, new BasicMonitor()); + + final EObject originNode = getNodeNamed(right, "root"); + assertNotNull(originNode); + final EStructuralFeature feature = originNode.eClass().getEStructuralFeature(featureName); + assertNotNull(feature); + + final Object featureValue = originNode.eGet(feature); + assertTrue(featureValue instanceof Collection<?>); + assertTrue(((Collection<?>)featureValue).isEmpty()); + + comparison = EMFCompare.builder().build().compare(scope); + assertEquals(0, comparison.getDifferences().size()); + } + + @Test + public void testAttributeEEnumMultiAdd3WayLeftChangeLtR() throws IOException { + final Resource left = input.getAttributeEEnumMultiAddLeft(); + final Resource right = input.getAttributeEEnumMultiAddRight(); + final Resource origin = input.getAttributeEEnumMultiAddOrigin(); + + IComparisonScope scope = new DefaultComparisonScope(left, right, origin); + Comparison comparison = EMFCompare.builder().build().compare(scope); + + final List<Diff> differences = comparison.getDifferences(); + assertEquals(3, differences.size()); + + final String featureName = "multiValueEEnumAttribute"; + final Diff diff = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), + addedToAttribute("root", featureName, NodeEnum.A))); + final Diff diff2 = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), + addedToAttribute("root", featureName, NodeEnum.B))); + final Diff diff3 = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), + addedToAttribute("root", featureName, NodeEnum.C))); + + mergerRegistry.getHighestRankingMerger(diff).copyLeftToRight(diff, new BasicMonitor()); + mergerRegistry.getHighestRankingMerger(diff2).copyLeftToRight(diff2, new BasicMonitor()); + mergerRegistry.getHighestRankingMerger(diff3).copyLeftToRight(diff3, new BasicMonitor()); + final EObject originNode = getNodeNamed(right, "root"); + assertNotNull(originNode); + final EStructuralFeature feature = originNode.eClass().getEStructuralFeature(featureName); + assertNotNull(feature); + + final Object featureValue = originNode.eGet(feature); + assertTrue(featureValue instanceof Collection<?>); + assertTrue(((Collection<?>)featureValue).containsAll(Lists.newArrayList(NodeEnum.A, NodeEnum.B, + NodeEnum.C))); + + // We should have no difference between left and right ... though they might be different from origin + scope = new DefaultComparisonScope(left, right, null); + comparison = EMFCompare.builder().build().compare(scope); + assertEquals(0, comparison.getDifferences().size()); + } + + @Test + public void testAttributeEEnumMultiAdd3WayLeftChangeRtL() throws IOException { + final Resource left = input.getAttributeEEnumMultiAddLeft(); + final Resource right = input.getAttributeEEnumMultiAddRight(); + final Resource origin = input.getAttributeEEnumMultiAddOrigin(); + + IComparisonScope scope = new DefaultComparisonScope(left, right, origin); + Comparison comparison = EMFCompare.builder().build().compare(scope); + + final List<Diff> differences = comparison.getDifferences(); + assertEquals(3, differences.size()); + + final String featureName = "multiValueEEnumAttribute"; + final Diff diff = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), + addedToAttribute("root", featureName, NodeEnum.A))); + final Diff diff2 = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), + addedToAttribute("root", featureName, NodeEnum.B))); + final Diff diff3 = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), + addedToAttribute("root", featureName, NodeEnum.C))); + + mergerRegistry.getHighestRankingMerger(diff).copyRightToLeft(diff, new BasicMonitor()); + mergerRegistry.getHighestRankingMerger(diff2).copyRightToLeft(diff2, new BasicMonitor()); + mergerRegistry.getHighestRankingMerger(diff3).copyRightToLeft(diff3, new BasicMonitor()); + final EObject originNode = getNodeNamed(right, "root"); + assertNotNull(originNode); + final EStructuralFeature feature = originNode.eClass().getEStructuralFeature(featureName); + assertNotNull(feature); + + final Object featureValue = originNode.eGet(feature); + assertTrue(featureValue instanceof Collection<?>); + assertTrue(((Collection<?>)featureValue).isEmpty()); + + // We should have no difference between left and right ... though they might be different from origin + scope = new DefaultComparisonScope(left, right, null); + comparison = EMFCompare.builder().build().compare(scope); + assertEquals(0, comparison.getDifferences().size()); + } + + @Test + public void testAttributeEEnumMultiAdd3WayRightChangeLtR() throws IOException { + final Resource left = input.getAttributeEEnumMultiAddRight(); + final Resource right = input.getAttributeEEnumMultiAddLeft(); + final Resource origin = input.getAttributeEEnumMultiAddOrigin(); + + IComparisonScope scope = new DefaultComparisonScope(left, right, origin); + Comparison comparison = EMFCompare.builder().build().compare(scope); + + final List<Diff> differences = comparison.getDifferences(); + assertEquals(3, differences.size()); + + final String featureName = "multiValueEEnumAttribute"; + final Diff diff = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.RIGHT), + addedToAttribute("root", featureName, NodeEnum.A))); + final Diff diff2 = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.RIGHT), + addedToAttribute("root", featureName, NodeEnum.B))); + final Diff diff3 = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.RIGHT), + addedToAttribute("root", featureName, NodeEnum.C))); + + mergerRegistry.getHighestRankingMerger(diff).copyLeftToRight(diff, new BasicMonitor()); + mergerRegistry.getHighestRankingMerger(diff2).copyLeftToRight(diff2, new BasicMonitor()); + mergerRegistry.getHighestRankingMerger(diff3).copyLeftToRight(diff3, new BasicMonitor()); + final EObject originNode = getNodeNamed(right, "root"); + assertNotNull(originNode); + final EStructuralFeature feature = originNode.eClass().getEStructuralFeature(featureName); + assertNotNull(feature); + + final Object featureValue = originNode.eGet(feature); + assertTrue(featureValue instanceof Collection<?>); + assertTrue(((Collection<?>)featureValue).isEmpty()); + + // We should have no difference between left and right ... though they might be different from origin + scope = new DefaultComparisonScope(left, right, null); + comparison = EMFCompare.builder().build().compare(scope); + assertEquals(0, comparison.getDifferences().size()); + } + + @Test + public void testAttributeEEnumMultiAdd3WayRightChangeRtL() throws IOException { + // In order to have changes on the right side, we'll invert right and left + final Resource left = input.getAttributeMultiAddRight(); + final Resource right = input.getAttributeMultiAddLeft(); + final Resource origin = input.getAttributeMultiAddOrigin(); + + IComparisonScope scope = new DefaultComparisonScope(left, right, origin); + Comparison comparison = EMFCompare.builder().build().compare(scope); + + final List<Diff> differences = comparison.getDifferences(); + assertEquals(1, differences.size()); + + final String featureName = "multiValuedAttribute"; + final Diff diff = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.RIGHT), + addedToAttribute("root.origin", featureName, "value1"))); + + mergerRegistry.getHighestRankingMerger(diff).copyRightToLeft(diff, new BasicMonitor()); + final EObject originNode = getNodeNamed(left, "origin"); + assertNotNull(originNode); + final EStructuralFeature feature = originNode.eClass().getEStructuralFeature(featureName); + assertNotNull(feature); + + final Object featureValue = originNode.eGet(feature); + assertTrue(featureValue instanceof Collection<?>); + assertTrue(((Collection<?>)featureValue).contains("value1")); + + // We should have no difference between left and right ... though they might be different from origin + scope = new DefaultComparisonScope(left, right, null); + comparison = EMFCompare.builder().build().compare(scope); + assertEquals(0, comparison.getDifferences().size()); + } + + @Test public void testAttributeMultiAdd2WayLtR() throws IOException { final Resource left = input.getAttributeMultiAddLeft(); final Resource right = input.getAttributeMultiAddRight(); diff --git a/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/IndividualDiffInputData.java b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/IndividualDiffInputData.java index 0fd2f79a0..c1775ba48 100644 --- a/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/IndividualDiffInputData.java +++ b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/IndividualDiffInputData.java @@ -35,6 +35,18 @@ public class IndividualDiffInputData extends AbstractInputData { return loadFromClassLoader("fullscope/attributemonochange/right.nodes"); } + public Resource getAttributeMonoEEnumChangeLeft() throws IOException { + return loadFromClassLoader("fullscope/attributemonochange/eenum/left.nodes"); + } + + public Resource getAttributeMonoEEnumChangeOrigin() throws IOException { + return loadFromClassLoader("fullscope/attributemonochange/eenum/origin.nodes"); + } + + public Resource getAttributeMonoEEnumChangeRight() throws IOException { + return loadFromClassLoader("fullscope/attributemonochange/eenum/right.nodes"); + } + public Resource getAttributeMonoSetLeft() throws IOException { return loadFromClassLoader("fullscope/attributemonoset/left.nodes"); } @@ -71,6 +83,18 @@ public class IndividualDiffInputData extends AbstractInputData { return loadFromClassLoader("fullscope/attributemultiadd/right.nodes"); } + public Resource getAttributeEEnumMultiAddLeft() throws IOException { + return loadFromClassLoader("fullscope/attributemultiadd/eenum/left.nodes"); + } + + public Resource getAttributeEEnumMultiAddOrigin() throws IOException { + return loadFromClassLoader("fullscope/attributemultiadd/eenum/origin.nodes"); + } + + public Resource getAttributeEEnumMultiAddRight() throws IOException { + return loadFromClassLoader("fullscope/attributemultiadd/eenum/right.nodes"); + } + public Resource getAttributeMultiDelLeft() throws IOException { return loadFromClassLoader("fullscope/attributemultidel/left.nodes"); } @@ -726,4 +750,28 @@ public class IndividualDiffInputData extends AbstractInputData { public Resource getFeatureMapContainmentMoveInside(ResourceSet resourceSet) throws IOException { return loadFromClassLoader("featuremapscope/containment/moveinandout/inside.nodes", resourceSet); } + + public Resource getLeftSetRightSetOriginEEnumConflictScope() throws IOException { + return loadFromClassLoader("conflictscope/leftset_rightset/origin.nodes"); + } + + public Resource getLeftSetRightSetLeftEEnumConflictScope() throws IOException { + return loadFromClassLoader("conflictscope/leftset_rightset/left.nodes"); + } + + public Resource getLeftSetRightSetRightEEnumConflictScope() throws IOException { + return loadFromClassLoader("conflictscope/leftset_rightset/right.nodes"); + } + + public Resource getLeftAddRightDeleteOriginEEnumConflictScope() throws IOException { + return loadFromClassLoader("conflictscope/leftadd_rightdelete/eenum/origin.nodes"); + } + + public Resource getLeftAddRightDeleteLeftEEnumConflictScope() throws IOException { + return loadFromClassLoader("conflictscope/leftadd_rightdelete/eenum/left.nodes"); + } + + public Resource getLeftAddRightDeleteRightEEnumConflictScope() throws IOException { + return loadFromClassLoader("conflictscope/leftadd_rightdelete/eenum/right.nodes"); + } } diff --git a/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/conflictscope/leftadd_rightdelete/eenum/left.nodes b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/conflictscope/leftadd_rightdelete/eenum/left.nodes new file mode 100644 index 000000000..ff3afa856 --- /dev/null +++ b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/conflictscope/leftadd_rightdelete/eenum/left.nodes @@ -0,0 +1,7 @@ +<?xml version="1.0" encoding="UTF-8"?> +<nodes:Node xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:nodes="http://www.eclipse.org/emf/compare/tests/nodes" xmi:id="_FXA7gICFEeSu5PbwwW1jRA" name="root"> + <containmentRef1 xsi:type="nodes:NodeMultiValueEEnumAttribute" xmi:id="_Hdzo4ICFEeSu5PbwwW1jRA" name="origin"> + <multiValueEEnumAttribute>A</multiValueEEnumAttribute> + <multiValueEEnumAttribute>B</multiValueEEnumAttribute> + </containmentRef1> +</nodes:Node> diff --git a/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/conflictscope/leftadd_rightdelete/eenum/origin.nodes b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/conflictscope/leftadd_rightdelete/eenum/origin.nodes new file mode 100644 index 000000000..493190f5c --- /dev/null +++ b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/conflictscope/leftadd_rightdelete/eenum/origin.nodes @@ -0,0 +1,4 @@ +<?xml version="1.0" encoding="UTF-8"?> +<nodes:Node xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:nodes="http://www.eclipse.org/emf/compare/tests/nodes" xmi:id="_FXA7gICFEeSu5PbwwW1jRA" name="root"> + <containmentRef1 xsi:type="nodes:NodeMultiValueEEnumAttribute" xmi:id="_Hdzo4ICFEeSu5PbwwW1jRA" name="origin"/> +</nodes:Node> diff --git a/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/conflictscope/leftadd_rightdelete/eenum/right.nodes b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/conflictscope/leftadd_rightdelete/eenum/right.nodes new file mode 100644 index 000000000..d3b827a7f --- /dev/null +++ b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/conflictscope/leftadd_rightdelete/eenum/right.nodes @@ -0,0 +1,2 @@ +<?xml version="1.0" encoding="UTF-8"?> +<nodes:Node xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:nodes="http://www.eclipse.org/emf/compare/tests/nodes" xmi:id="_FXA7gICFEeSu5PbwwW1jRA" name="root"/> diff --git a/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/conflictscope/leftset_rightset/left.nodes b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/conflictscope/leftset_rightset/left.nodes new file mode 100644 index 000000000..adde76254 --- /dev/null +++ b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/conflictscope/leftset_rightset/left.nodes @@ -0,0 +1,2 @@ +<?xml version="1.0" encoding="UTF-8"?> +<nodes:NodeSingleValueEEnumAttribute xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:nodes="http://www.eclipse.org/emf/compare/tests/nodes" xmi:id="_HW-bcH-xEeSlgO02iyoRkw" name="root" singlevalueEEnumAttribute="B"/> diff --git a/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/conflictscope/leftset_rightset/origin.nodes b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/conflictscope/leftset_rightset/origin.nodes new file mode 100644 index 000000000..767f2eecf --- /dev/null +++ b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/conflictscope/leftset_rightset/origin.nodes @@ -0,0 +1,2 @@ +<?xml version="1.0" encoding="UTF-8"?> +<nodes:NodeSingleValueEEnumAttribute xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:nodes="http://www.eclipse.org/emf/compare/tests/nodes" xmi:id="_HW-bcH-xEeSlgO02iyoRkw" name="root"/> diff --git a/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/conflictscope/leftset_rightset/right.nodes b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/conflictscope/leftset_rightset/right.nodes new file mode 100644 index 000000000..f07fd01df --- /dev/null +++ b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/conflictscope/leftset_rightset/right.nodes @@ -0,0 +1,2 @@ +<?xml version="1.0" encoding="UTF-8"?> +<nodes:NodeSingleValueEEnumAttribute xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:nodes="http://www.eclipse.org/emf/compare/tests/nodes" xmi:id="_HW-bcH-xEeSlgO02iyoRkw" name="root" singlevalueEEnumAttribute="C"/> diff --git a/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/fullscope/attributemonochange/eenum/left.nodes b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/fullscope/attributemonochange/eenum/left.nodes new file mode 100644 index 000000000..adde76254 --- /dev/null +++ b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/fullscope/attributemonochange/eenum/left.nodes @@ -0,0 +1,2 @@ +<?xml version="1.0" encoding="UTF-8"?> +<nodes:NodeSingleValueEEnumAttribute xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:nodes="http://www.eclipse.org/emf/compare/tests/nodes" xmi:id="_HW-bcH-xEeSlgO02iyoRkw" name="root" singlevalueEEnumAttribute="B"/> diff --git a/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/fullscope/attributemonochange/eenum/origin.nodes b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/fullscope/attributemonochange/eenum/origin.nodes new file mode 100644 index 000000000..767f2eecf --- /dev/null +++ b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/fullscope/attributemonochange/eenum/origin.nodes @@ -0,0 +1,2 @@ +<?xml version="1.0" encoding="UTF-8"?> +<nodes:NodeSingleValueEEnumAttribute xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:nodes="http://www.eclipse.org/emf/compare/tests/nodes" xmi:id="_HW-bcH-xEeSlgO02iyoRkw" name="root"/> diff --git a/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/fullscope/attributemonochange/eenum/right.nodes b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/fullscope/attributemonochange/eenum/right.nodes new file mode 100644 index 000000000..767f2eecf --- /dev/null +++ b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/fullscope/attributemonochange/eenum/right.nodes @@ -0,0 +1,2 @@ +<?xml version="1.0" encoding="UTF-8"?> +<nodes:NodeSingleValueEEnumAttribute xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:nodes="http://www.eclipse.org/emf/compare/tests/nodes" xmi:id="_HW-bcH-xEeSlgO02iyoRkw" name="root"/> diff --git a/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/fullscope/attributemultiadd/eenum/left.nodes b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/fullscope/attributemultiadd/eenum/left.nodes new file mode 100644 index 000000000..ad52ebafe --- /dev/null +++ b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/fullscope/attributemultiadd/eenum/left.nodes @@ -0,0 +1,6 @@ +<?xml version="1.0" encoding="UTF-8"?> +<nodes:NodeMultiValueEEnumAttribute xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:nodes="http://www.eclipse.org/emf/compare/tests/nodes" xmi:id="_13goAH-9EeSlgO02iyoRkw" name="root"> + <multiValueEEnumAttribute>A</multiValueEEnumAttribute> + <multiValueEEnumAttribute>B</multiValueEEnumAttribute> + <multiValueEEnumAttribute>C</multiValueEEnumAttribute> +</nodes:NodeMultiValueEEnumAttribute> diff --git a/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/fullscope/attributemultiadd/eenum/origin.nodes b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/fullscope/attributemultiadd/eenum/origin.nodes new file mode 100644 index 000000000..479acbba4 --- /dev/null +++ b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/fullscope/attributemultiadd/eenum/origin.nodes @@ -0,0 +1,2 @@ +<?xml version="1.0" encoding="UTF-8"?> +<nodes:NodeMultiValueEEnumAttribute xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:nodes="http://www.eclipse.org/emf/compare/tests/nodes" xmi:id="_13goAH-9EeSlgO02iyoRkw" name="root"/> diff --git a/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/fullscope/attributemultiadd/eenum/right.nodes b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/fullscope/attributemultiadd/eenum/right.nodes new file mode 100644 index 000000000..479acbba4 --- /dev/null +++ b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/merge/data/fullscope/attributemultiadd/eenum/right.nodes @@ -0,0 +1,2 @@ +<?xml version="1.0" encoding="UTF-8"?> +<nodes:NodeMultiValueEEnumAttribute xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:nodes="http://www.eclipse.org/emf/compare/tests/nodes" xmi:id="_13goAH-9EeSlgO02iyoRkw" name="root"/> |