| /******************************************************************************* |
| * Copyright (c) 2013, 2014 Obeo. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Obeo - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.emf.compare.tests.merge; |
| |
| import static com.google.common.base.Predicates.and; |
| import static com.google.common.base.Predicates.not; |
| import static org.eclipse.emf.compare.DifferenceState.DISCARDED; |
| import static org.eclipse.emf.compare.DifferenceState.MERGED; |
| import static org.eclipse.emf.compare.DifferenceState.UNRESOLVED; |
| import static org.eclipse.emf.compare.merge.AbstractMerger.isInTerminalState; |
| 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; |
| import static org.eclipse.emf.compare.utils.EMFComparePredicates.referenceValueMatch; |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNotNull; |
| 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.Arrays; |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.emf.common.util.BasicMonitor; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.compare.Comparison; |
| import org.eclipse.emf.compare.Diff; |
| import org.eclipse.emf.compare.DifferenceKind; |
| import org.eclipse.emf.compare.DifferenceSource; |
| import org.eclipse.emf.compare.EMFCompare; |
| import org.eclipse.emf.compare.merge.BatchMerger; |
| 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.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; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EStructuralFeature; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.junit.Ignore; |
| import org.junit.Test; |
| |
| @SuppressWarnings("nls") |
| public class ConflictMergeTest { |
| |
| private IndividualDiffInputData input = new IndividualDiffInputData(); |
| |
| private final BatchMerger batchMerger = new BatchMerger(IMerger.RegistryImpl.createStandaloneInstance()); |
| |
| @SuppressWarnings("unchecked") |
| @Test |
| public void testLeftAddRightAdd_LtR_1() throws IOException { |
| // Conflict between C[containmentRef1 add] from left side and C[containmentRef1 add] from right side |
| |
| final Resource left = input.getLeftAddRightAddLeftConflictScope(); |
| final Resource right = input.getLeftAddRightAddRightConflictScope(); |
| final Resource origin = input.getLeftAddRightAddOriginConflictScope(); |
| |
| final IComparisonScope scope = new DefaultComparisonScope(left, right, origin); |
| Comparison comparison = EMFCompare.builder().build().compare(scope); |
| |
| List<Diff> differences = comparison.getDifferences(); |
| assertEquals(6, differences.size()); |
| |
| final String featureName = "containmentRef1"; |
| |
| final Diff diffNodeCLeft = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), |
| ofKind(DifferenceKind.ADD), referenceValueMatch(featureName, "root.A.C", true))); |
| final Diff diffNodeCRight = Iterators.find(differences.iterator(), |
| and(fromSide(DifferenceSource.RIGHT), ofKind(DifferenceKind.ADD), |
| referenceValueMatch(featureName, "root.B.C", true))); |
| final Diff diffNodeDLeft = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), |
| ofKind(DifferenceKind.ADD), referenceValueMatch(featureName, "root.A.C.D", true))); |
| final Diff diffNodeDRight = Iterators.find(differences.iterator(), |
| and(fromSide(DifferenceSource.RIGHT), ofKind(DifferenceKind.ADD), |
| referenceValueMatch(featureName, "root.B.C.D", true))); |
| final Diff diffNodeELeft = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), |
| ofKind(DifferenceKind.ADD), referenceValueMatch(featureName, "root.A.C.E", true))); |
| final Diff diffNodeFRight = Iterators.find(differences.iterator(), |
| and(fromSide(DifferenceSource.RIGHT), ofKind(DifferenceKind.ADD), |
| referenceValueMatch(featureName, "root.B.C.F", true))); |
| |
| // Merge C[containmentRef1 add] from left side from left to right : C[containmentRef1 add] from right |
| // side will be merge from left to right too. |
| batchMerger.copyAllLeftToRight(Arrays.asList(diffNodeCLeft), new BasicMonitor()); |
| |
| final EObject rightNodeC = getNodeNamed(right, "C"); |
| assertNotNull(rightNodeC); |
| final EObject rightNodeA = getNodeNamed(right, "A"); |
| assertNotNull(rightNodeA); |
| final EObject rightNodeB = getNodeNamed(right, "B"); |
| assertNotNull(rightNodeB); |
| final EObject rightNodeD = getNodeNamed(right, "D"); |
| assertNull(rightNodeD); |
| final EObject rightNodeF = getNodeNamed(right, "F"); |
| assertNull(rightNodeF); |
| final EStructuralFeature feature = rightNodeA.eClass().getEStructuralFeature(featureName); |
| assertNotNull(feature); |
| final EList<Node> containmentRef1s = ((Node)rightNodeA).getContainmentRef1(); |
| assertTrue(containmentRef1s.contains(rightNodeC)); |
| final EList<Node> bContainmentRef1s = ((Node)rightNodeB).getContainmentRef1(); |
| assertFalse(bContainmentRef1s.contains(rightNodeC)); |
| |
| assertEquals(MERGED, diffNodeCLeft.getState()); |
| assertEquals(DISCARDED, diffNodeCRight.getState()); |
| assertEquals(MERGED, diffNodeDLeft.getState()); |
| assertEquals(MERGED, diffNodeDRight.getState()); |
| assertEquals(UNRESOLVED, diffNodeELeft.getState()); |
| assertEquals(DISCARDED, diffNodeFRight.getState()); |
| } |
| |
| @SuppressWarnings("unchecked") |
| @Test |
| @Ignore("Test was already broken although it didn't fail. Fix it and make sure the result of the merge is correct.") |
| public void testLeftAddRightAdd_LtR_2() throws IOException { |
| // Conflict between C[containmentRef1 add] from left side and C[containmentRef1 add] from right side |
| |
| final Resource left = input.getLeftAddRightAddLeftConflictScope(); |
| final Resource right = input.getLeftAddRightAddRightConflictScope(); |
| final Resource origin = input.getLeftAddRightAddOriginConflictScope(); |
| |
| final IComparisonScope scope = new DefaultComparisonScope(left, right, origin); |
| Comparison comparison = EMFCompare.builder().build().compare(scope); |
| |
| List<Diff> differences = comparison.getDifferences(); |
| assertEquals(6, differences.size()); |
| |
| final String featureName = "containmentRef1"; |
| |
| final Diff diffNodeCLeft = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), |
| ofKind(DifferenceKind.ADD), referenceValueMatch(featureName, "root.A.C", true))); |
| final Diff diffNodeCRight = Iterators.find(differences.iterator(), |
| and(fromSide(DifferenceSource.RIGHT), ofKind(DifferenceKind.ADD), |
| referenceValueMatch(featureName, "root.B.C", true))); |
| final Diff diffNodeDLeft = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), |
| ofKind(DifferenceKind.ADD), referenceValueMatch(featureName, "root.A.C.D", true))); |
| final Diff diffNodeDRight = Iterators.find(differences.iterator(), |
| and(fromSide(DifferenceSource.RIGHT), ofKind(DifferenceKind.ADD), |
| referenceValueMatch(featureName, "root.B.C.D", true))); |
| final Diff diffNodeELeft = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), |
| ofKind(DifferenceKind.ADD), referenceValueMatch(featureName, "root.A.C.E", true))); |
| final Diff diffNodeFRight = Iterators.find(differences.iterator(), |
| and(fromSide(DifferenceSource.RIGHT), ofKind(DifferenceKind.ADD), |
| referenceValueMatch(featureName, "root.B.C.F", true))); |
| |
| // Merge C[containmentRef1 add] from right side from left to right : C[containmentRef1 add] from left |
| // side will not be merge |
| batchMerger.copyAllLeftToRight(Arrays.asList(diffNodeCRight), new BasicMonitor()); |
| |
| final EObject rightNodeC = getNodeNamed(right, "C"); |
| assertNull(rightNodeC); |
| final EObject rightNodeA = getNodeNamed(right, "A"); |
| assertNotNull(rightNodeA); |
| final EObject rightNodeB = getNodeNamed(right, "B"); |
| assertNotNull(rightNodeB); |
| final EObject rightNodeD = getNodeNamed(right, "D"); |
| assertNull(rightNodeD); |
| final EObject rightNodeF = getNodeNamed(right, "F"); |
| assertNull(rightNodeF); |
| final EStructuralFeature feature = rightNodeA.eClass().getEStructuralFeature(featureName); |
| assertNotNull(feature); |
| final EList<Node> aContainmentRef1s = ((Node)rightNodeA).getContainmentRef1(); |
| assertFalse(aContainmentRef1s.contains(rightNodeC)); |
| final EList<Node> bContainmentRef1s = ((Node)rightNodeB).getContainmentRef1(); |
| assertFalse(bContainmentRef1s.contains(rightNodeC)); |
| |
| assertEquals(UNRESOLVED, diffNodeCLeft.getState()); |
| assertEquals(MERGED, diffNodeCRight.getState()); |
| assertEquals(MERGED, diffNodeDLeft.getState()); |
| assertEquals(MERGED, diffNodeDRight.getState()); |
| assertEquals(UNRESOLVED, diffNodeELeft.getState()); |
| assertEquals(MERGED, diffNodeFRight.getState()); |
| } |
| |
| @SuppressWarnings("unchecked") |
| @Test |
| @Ignore("Test was already broken although it didn't fail. Fix it and make sure the result of the merge is correct.") |
| public void testLeftAddRightAdd_RtL_1() throws IOException { |
| // Conflict between C[containmentRef1 add] from left side and C[containmentRef1 add] from right side |
| |
| final Resource left = input.getLeftAddRightAddLeftConflictScope(); |
| final Resource right = input.getLeftAddRightAddRightConflictScope(); |
| final Resource origin = input.getLeftAddRightAddOriginConflictScope(); |
| |
| final IComparisonScope scope = new DefaultComparisonScope(left, right, origin); |
| Comparison comparison = EMFCompare.builder().build().compare(scope); |
| |
| List<Diff> differences = comparison.getDifferences(); |
| assertEquals(6, differences.size()); |
| |
| final String featureName = "containmentRef1"; |
| |
| final Diff diffNodeCLeft = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), |
| ofKind(DifferenceKind.ADD), referenceValueMatch(featureName, "root.A.C", true))); |
| final Diff diffNodeCRight = Iterators.find(differences.iterator(), |
| and(fromSide(DifferenceSource.RIGHT), ofKind(DifferenceKind.ADD), |
| referenceValueMatch(featureName, "root.B.C", true))); |
| final Diff diffNodeDLeft = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), |
| ofKind(DifferenceKind.ADD), referenceValueMatch(featureName, "root.A.C.D", true))); |
| final Diff diffNodeDRight = Iterators.find(differences.iterator(), |
| and(fromSide(DifferenceSource.RIGHT), ofKind(DifferenceKind.ADD), |
| referenceValueMatch(featureName, "root.B.C.D", true))); |
| final Diff diffNodeELeft = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), |
| ofKind(DifferenceKind.ADD), referenceValueMatch(featureName, "root.A.C.E", true))); |
| final Diff diffNodeFRight = Iterators.find(differences.iterator(), |
| and(fromSide(DifferenceSource.RIGHT), ofKind(DifferenceKind.ADD), |
| referenceValueMatch(featureName, "root.B.C.F", true))); |
| |
| // Merge C[containmentRef1 add] from left side from right to left : C[containmentRef1 add] from right |
| // side will not be merge. |
| batchMerger.copyAllRightToLeft(Arrays.asList(diffNodeCLeft), new BasicMonitor()); |
| |
| final EObject leftNodeC = getNodeNamed(left, "C"); |
| assertNull(leftNodeC); |
| final EObject leftNodeA = getNodeNamed(left, "A"); |
| assertNotNull(leftNodeA); |
| final EObject leftNodeB = getNodeNamed(left, "B"); |
| assertNotNull(leftNodeB); |
| final EObject leftNodeD = getNodeNamed(left, "D"); |
| assertNull(leftNodeD); |
| final EObject leftNodeF = getNodeNamed(left, "F"); |
| assertNull(leftNodeF); |
| final EStructuralFeature feature = leftNodeA.eClass().getEStructuralFeature(featureName); |
| assertNotNull(feature); |
| final EList<Node> containmentRef1s = ((Node)leftNodeA).getContainmentRef1(); |
| assertFalse(containmentRef1s.contains(leftNodeC)); |
| final EList<Node> bContainmentRef1s = ((Node)leftNodeB).getContainmentRef1(); |
| assertFalse(bContainmentRef1s.contains(leftNodeC)); |
| |
| assertEquals(MERGED, diffNodeCLeft.getState()); |
| assertEquals(UNRESOLVED, diffNodeCRight.getState()); |
| assertEquals(MERGED, diffNodeDLeft.getState()); |
| assertEquals(MERGED, diffNodeDRight.getState()); |
| assertEquals(MERGED, diffNodeELeft.getState()); |
| assertEquals(UNRESOLVED, diffNodeFRight.getState()); |
| } |
| |
| @SuppressWarnings("unchecked") |
| @Test |
| public void testLeftAddRightAdd_RtL_2() throws IOException { |
| // Conflict between C[containmentRef1 add] from left side and C[containmentRef1 add] from right side |
| |
| final Resource left = input.getLeftAddRightAddLeftConflictScope(); |
| final Resource right = input.getLeftAddRightAddRightConflictScope(); |
| final Resource origin = input.getLeftAddRightAddOriginConflictScope(); |
| |
| final IComparisonScope scope = new DefaultComparisonScope(left, right, origin); |
| Comparison comparison = EMFCompare.builder().build().compare(scope); |
| |
| List<Diff> differences = comparison.getDifferences(); |
| assertEquals(6, differences.size()); |
| |
| final String featureName = "containmentRef1"; |
| |
| final Diff diffNodeCLeft = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), |
| ofKind(DifferenceKind.ADD), referenceValueMatch(featureName, "root.A.C", true))); |
| final Diff diffNodeCRight = Iterators.find(differences.iterator(), |
| and(fromSide(DifferenceSource.RIGHT), ofKind(DifferenceKind.ADD), |
| referenceValueMatch(featureName, "root.B.C", true))); |
| final Diff diffNodeDLeft = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), |
| ofKind(DifferenceKind.ADD), referenceValueMatch(featureName, "root.A.C.D", true))); |
| final Diff diffNodeDRight = Iterators.find(differences.iterator(), |
| and(fromSide(DifferenceSource.RIGHT), ofKind(DifferenceKind.ADD), |
| referenceValueMatch(featureName, "root.B.C.D", true))); |
| final Diff diffNodeELeft = Iterators.find(differences.iterator(), and(fromSide(DifferenceSource.LEFT), |
| ofKind(DifferenceKind.ADD), referenceValueMatch(featureName, "root.A.C.E", true))); |
| final Diff diffNodeFRight = Iterators.find(differences.iterator(), |
| and(fromSide(DifferenceSource.RIGHT), ofKind(DifferenceKind.ADD), |
| referenceValueMatch(featureName, "root.B.C.F", true))); |
| |
| // Merge C[containmentRef1 add] from right side from right to left : C[containmentRef1 add] from left |
| // side will be merge from right to left too. |
| batchMerger.copyAllRightToLeft(Arrays.asList(diffNodeCRight), new BasicMonitor()); |
| |
| final EObject leftNodeC = getNodeNamed(left, "C"); |
| assertNotNull(leftNodeC); |
| final EObject leftNodeA = getNodeNamed(left, "A"); |
| assertNotNull(leftNodeA); |
| final EObject leftNodeB = getNodeNamed(left, "B"); |
| assertNotNull(leftNodeB); |
| final EObject leftNodeD = getNodeNamed(left, "D"); |
| assertNull(leftNodeD); |
| final EObject leftNodeF = getNodeNamed(left, "F"); |
| assertNull(leftNodeF); |
| final EStructuralFeature feature = leftNodeA.eClass().getEStructuralFeature(featureName); |
| assertNotNull(feature); |
| final EList<Node> containmentRef1s = ((Node)leftNodeA).getContainmentRef1(); |
| assertFalse(containmentRef1s.contains(leftNodeC)); |
| final EList<Node> bContainmentRef1s = ((Node)leftNodeB).getContainmentRef1(); |
| assertTrue(bContainmentRef1s.contains(leftNodeC)); |
| |
| assertEquals(DISCARDED, diffNodeCLeft.getState()); |
| assertEquals(MERGED, diffNodeCRight.getState()); |
| assertEquals(MERGED, diffNodeDLeft.getState()); |
| assertEquals(MERGED, diffNodeDRight.getState()); |
| assertEquals(DISCARDED, diffNodeELeft.getState()); |
| assertEquals(UNRESOLVED, diffNodeFRight.getState()); |
| } |
| |
| @Test |
| public void testLeftAddRightDelete_LtR_1() throws IOException { |
| // Conflict between B[eSuperTypes add] from left side and B[eClassifiers delete] from right side |
| |
| final Resource left = input.getLeftAddRightDeleteLeftConflictScope(); |
| final Resource right = input.getLeftAddRightDeleteRightConflictScope(); |
| final Resource origin = input.getLeftAddRightDeleteOriginConflictScope(); |
| |
| 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 B[eSuperTypes add] from left to right : B[eClassifiers delete] will be merge from left to |
| // right too. |
| batchMerger.copyAllLeftToRight(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eSuperTypes"; |
| final EObject rightEClassB = getNodeNamed(right, "B"); |
| assertNotNull(rightEClassB); |
| final EObject rightEClassA = getNodeNamed(right, "A"); |
| assertNotNull(rightEClassA); |
| final EStructuralFeature feature = rightEClassA.eClass().getEStructuralFeature(featureName); |
| assertNotNull(feature); |
| final EList<EClass> eSuperTypes = ((EClass)rightEClassA).getESuperTypes(); |
| assertTrue(eSuperTypes.contains(rightEClassB)); |
| |
| assertFalse(Iterators.any(differences.iterator(), not(hasState(MERGED, DISCARDED)))); |
| } |
| |
| @Test |
| public void testLeftAddRightDelete_LtR_2() throws IOException { |
| // Conflict between B[eSuperTypes add] from left side and B[eClassifiers delete] from right side |
| |
| final Resource left = input.getLeftAddRightDeleteLeftConflictScope(); |
| final Resource right = input.getLeftAddRightDeleteRightConflictScope(); |
| final Resource origin = input.getLeftAddRightDeleteOriginConflictScope(); |
| |
| 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 B[eClassifiers delete] from left to right : B[eSuperTypes add] will not be merge. |
| batchMerger.copyAllLeftToRight(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eSuperTypes"; |
| final EObject rightEClassB = getNodeNamed(right, "B"); |
| assertNotNull(rightEClassB); |
| final EObject rightEClassA = getNodeNamed(right, "A"); |
| assertNotNull(rightEClassA); |
| final EStructuralFeature feature = rightEClassA.eClass().getEStructuralFeature(featureName); |
| assertNotNull(feature); |
| final EList<EClass> eSuperTypes = ((EClass)rightEClassA).getESuperTypes(); |
| assertTrue(eSuperTypes.isEmpty()); |
| |
| for (Diff currentDiff : differences) { |
| if (currentDiff.getSource() == DifferenceSource.RIGHT) { |
| assertTrue(isInTerminalState(currentDiff)); |
| } else { |
| assertTrue(currentDiff.getState() == UNRESOLVED); |
| } |
| } |
| } |
| |
| @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))); |
| |
| batchMerger.copyAllLeftToRight(Arrays.asList(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))); |
| |
| batchMerger.copyAllLeftToRight(Arrays.asList(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(MERGED, DISCARDED)))); |
| } |
| |
| @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)); |
| |
| batchMerger.copyAllRightToLeft(Arrays.asList(diffDelete), new BasicMonitor()); |
| |
| final EObject rightElement = getNodeNamed(left, "origin"); |
| assertNull(rightElement); |
| |
| assertFalse(Iterators.any(differences.iterator(), not(hasState(MERGED, DISCARDED)))); |
| } |
| |
| @Test |
| public void testLeftAddRightDelete_RtL_1() throws IOException { |
| // Conflict between B[eSuperTypes add] from left side and B[eClassifiers delete] from right side |
| |
| final Resource left = input.getLeftAddRightDeleteLeftConflictScope(); |
| final Resource right = input.getLeftAddRightDeleteRightConflictScope(); |
| final Resource origin = input.getLeftAddRightDeleteOriginConflictScope(); |
| |
| 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 B[eSuperTypes add] from right to left : B[eClassifiers delete] will not be merge |
| batchMerger.copyAllRightToLeft(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eSuperTypes"; |
| final EObject leftEClassB = getNodeNamed(left, "B"); |
| assertNotNull(leftEClassB); |
| final EObject leftEClassA = getNodeNamed(left, "A"); |
| assertNotNull(leftEClassA); |
| final EStructuralFeature feature = leftEClassA.eClass().getEStructuralFeature(featureName); |
| assertNotNull(feature); |
| final EList<EClass> eSuperTypes = ((EClass)leftEClassA).getESuperTypes(); |
| assertTrue(eSuperTypes.isEmpty()); |
| |
| for (Diff currentDiff : differences) { |
| if (currentDiff.getSource() == DifferenceSource.LEFT) { |
| assertTrue(isInTerminalState(currentDiff)); |
| } else { |
| assertTrue(currentDiff.getState() == UNRESOLVED); |
| } |
| } |
| } |
| |
| @Test |
| public void testLeftAddRightDelete_RtL_2() throws IOException { |
| // Conflict between B[eSuperTypes add] from left side and B[eClassifiers delete] from right side |
| |
| final Resource left = input.getLeftAddRightDeleteLeftConflictScope(); |
| final Resource right = input.getLeftAddRightDeleteRightConflictScope(); |
| final Resource origin = input.getLeftAddRightDeleteOriginConflictScope(); |
| |
| 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 B[eClassifiers delete] from right to left : B[eSuperTypes add] will be merge from right to |
| // left too. |
| batchMerger.copyAllRightToLeft(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eSuperTypes"; |
| final EObject leftEClassB = getNodeNamed(left, "B"); |
| assertNull(leftEClassB); |
| final EObject leftEClassA = getNodeNamed(left, "A"); |
| assertNotNull(leftEClassA); |
| final EStructuralFeature feature = leftEClassA.eClass().getEStructuralFeature(featureName); |
| assertNotNull(feature); |
| final EList<EClass> eSuperTypes = ((EClass)leftEClassA).getESuperTypes(); |
| assertTrue(eSuperTypes.isEmpty()); |
| |
| assertFalse(Iterators.any(differences.iterator(), not(hasState(MERGED, DISCARDED)))); |
| } |
| |
| @Test |
| public void testLeftDeleteRightAdd_LtR_1() throws IOException { |
| // Conflict between B[eClassifiers delete] from left side and B[eSuperTypes add] from right side |
| |
| final Resource left = input.getLeftDeleteRightAddLeftConflictScope(); |
| final Resource right = input.getLeftDeleteRightAddRightConflictScope(); |
| final Resource origin = input.getLeftDeleteRightAddOriginConflictScope(); |
| |
| 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 B[eClassifiers delete] from left to right : B[eSuperTypes add] will be merge from left to |
| // right too. |
| batchMerger.copyAllLeftToRight(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eSuperTypes"; |
| final EObject rightEClassB = getNodeNamed(right, "B"); |
| assertNull(rightEClassB); |
| final EObject rightEClassA = getNodeNamed(right, "A"); |
| assertNotNull(rightEClassA); |
| final EStructuralFeature feature = rightEClassA.eClass().getEStructuralFeature(featureName); |
| assertNotNull(feature); |
| final EList<EClass> eSuperTypes = ((EClass)rightEClassA).getESuperTypes(); |
| assertTrue(eSuperTypes.isEmpty()); |
| |
| assertFalse(Iterators.any(differences.iterator(), not(hasState(MERGED, DISCARDED)))); |
| } |
| |
| @Test |
| public void testLeftDeleteRightAdd_LtR_2() throws IOException { |
| // Conflict between B[eClassifiers delete] from left side and B[eSuperTypes add] from right side |
| |
| final Resource left = input.getLeftDeleteRightAddLeftConflictScope(); |
| final Resource right = input.getLeftDeleteRightAddRightConflictScope(); |
| final Resource origin = input.getLeftDeleteRightAddOriginConflictScope(); |
| |
| 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 B[eSuperTypes add] from left to right : B[eClassifiers delete] will not be merge. |
| batchMerger.copyAllLeftToRight(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eSuperTypes"; |
| final EObject rightEClassB = getNodeNamed(right, "B"); |
| assertNotNull(rightEClassB); |
| final EObject rightEClassA = getNodeNamed(right, "A"); |
| assertNotNull(rightEClassA); |
| final EStructuralFeature feature = rightEClassA.eClass().getEStructuralFeature(featureName); |
| assertNotNull(feature); |
| final EList<EClass> eSuperTypes = ((EClass)rightEClassA).getESuperTypes(); |
| assertTrue(eSuperTypes.isEmpty()); |
| |
| for (Diff currentDiff : differences) { |
| if (currentDiff.getSource() == DifferenceSource.RIGHT) { |
| assertTrue(isInTerminalState(currentDiff)); |
| } else { |
| assertTrue(currentDiff.getState() == UNRESOLVED); |
| } |
| } |
| } |
| |
| @Test |
| public void testLeftDeleteRightAdd_RtL_1() throws IOException { |
| // Conflict between B[eClassifiers delete] from left side and B[eSuperTypes add] from right side |
| |
| final Resource left = input.getLeftDeleteRightAddLeftConflictScope(); |
| final Resource right = input.getLeftDeleteRightAddRightConflictScope(); |
| final Resource origin = input.getLeftDeleteRightAddOriginConflictScope(); |
| |
| 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 B[eClassifiers delete] from right to left : B[eSuperTypes add] will not be merge. |
| batchMerger.copyAllRightToLeft(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eSuperTypes"; |
| final EObject leftEClassB = getNodeNamed(left, "B"); |
| assertNotNull(leftEClassB); |
| final EObject leftEClassA = getNodeNamed(left, "A"); |
| assertNotNull(leftEClassA); |
| final EStructuralFeature feature = leftEClassA.eClass().getEStructuralFeature(featureName); |
| assertNotNull(feature); |
| final EList<EClass> eSuperTypes = ((EClass)leftEClassA).getESuperTypes(); |
| assertTrue(eSuperTypes.isEmpty()); |
| |
| for (Diff currentDiff : differences) { |
| if (currentDiff.getSource() == DifferenceSource.LEFT) { |
| assertTrue(isInTerminalState(currentDiff)); |
| } else { |
| assertTrue(currentDiff.getState() == UNRESOLVED); |
| } |
| } |
| } |
| |
| @Test |
| public void testLeftDeleteRightAdd_RtL_2() throws IOException { |
| // Conflict between B[eClassifiers delete] from left side and B[eSuperTypes add] from right side |
| |
| final Resource left = input.getLeftDeleteRightAddLeftConflictScope(); |
| final Resource right = input.getLeftDeleteRightAddRightConflictScope(); |
| final Resource origin = input.getLeftDeleteRightAddOriginConflictScope(); |
| |
| 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 B[eSuperTypes add] from right to left : B[eClassifiers delete] will be merge from right to |
| // left too. |
| batchMerger.copyAllRightToLeft(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eSuperTypes"; |
| final EObject leftEClassB = getNodeNamed(left, "B"); |
| assertNotNull(leftEClassB); |
| final EObject leftEClassA = getNodeNamed(left, "A"); |
| assertNotNull(leftEClassA); |
| final EStructuralFeature feature = leftEClassA.eClass().getEStructuralFeature(featureName); |
| assertNotNull(feature); |
| final EList<EClass> eSuperTypes = ((EClass)leftEClassA).getESuperTypes(); |
| assertTrue(eSuperTypes.contains(leftEClassB)); |
| |
| assertFalse(Iterators.any(differences.iterator(), not(hasState(MERGED, DISCARDED)))); |
| } |
| |
| @Test |
| public void testLeftDeleteRightSet_LtR_1() throws IOException { |
| // Conflict between A[eClassifiers delete] from left side and true[abstract set]/true[interface set] |
| // from right side |
| |
| final Resource left = input.getLeftDeleteRightSetLeftConflictScope(); |
| final Resource right = input.getLeftDeleteRightSetRightConflictScope(); |
| final Resource origin = input.getLeftDeleteRightSetOriginConflictScope(); |
| |
| 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 diff = Iterators.find(differences.iterator(), fromSide(DifferenceSource.LEFT)); |
| |
| // Merge A[eClassifiers delete] from left to right : true[abstract set]/true[interface set] will be |
| // merge from left to right too. |
| batchMerger.copyAllLeftToRight(Arrays.asList(diff), new BasicMonitor()); |
| |
| final EObject rightEClassA = getNodeNamed(right, "A"); |
| assertNull(rightEClassA); |
| |
| assertFalse(Iterators.any(differences.iterator(), not(hasState(MERGED, DISCARDED)))); |
| } |
| |
| @Test |
| public void testLeftDeleteRightSet_LtR_2() throws IOException { |
| // Conflict between A[eClassifiers delete] from left side and true[abstract set]/true[interface set] |
| // from right side |
| |
| final Resource left = input.getLeftDeleteRightSetLeftConflictScope(); |
| final Resource right = input.getLeftDeleteRightSetRightConflictScope(); |
| final Resource origin = input.getLeftDeleteRightSetOriginConflictScope(); |
| |
| 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 UnmodifiableIterator<Diff> diffs = Iterators.filter(differences.iterator(), |
| fromSide(DifferenceSource.RIGHT)); |
| |
| // Merge true[abstract set]/true[interface set] from left to right : A[eClassifiers delete] will not |
| // be merge. |
| Diff abstract_ = diffs.next(); |
| batchMerger.copyAllLeftToRight(Arrays.asList(abstract_), new BasicMonitor()); |
| |
| final EObject rightEClassA = getNodeNamed(right, "A"); |
| assertNotNull(rightEClassA); |
| assertFalse(((EClass)rightEClassA).isAbstract()); |
| assertTrue(((EClass)rightEClassA).isInterface()); |
| |
| Diff interface_ = diffs.next(); |
| batchMerger.copyAllLeftToRight(Arrays.asList(interface_), new BasicMonitor()); |
| |
| assertNotNull(rightEClassA); |
| assertFalse(((EClass)rightEClassA).isAbstract()); |
| assertFalse(((EClass)rightEClassA).isInterface()); |
| |
| for (Diff currentDiff : differences) { |
| if (currentDiff.getSource() == DifferenceSource.RIGHT) { |
| assertTrue(isInTerminalState(currentDiff)); |
| } else { |
| assertTrue(currentDiff.getState() == UNRESOLVED); |
| } |
| } |
| } |
| |
| @Test |
| public void testLeftDeleteRightSet_RtL_1() throws IOException { |
| // Conflict between A[eClassifiers delete] from left side and true[abstract set]/true[interface set] |
| // from right side |
| |
| final Resource left = input.getLeftDeleteRightSetLeftConflictScope(); |
| final Resource right = input.getLeftDeleteRightSetRightConflictScope(); |
| final Resource origin = input.getLeftDeleteRightSetOriginConflictScope(); |
| |
| 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 diff = Iterators.find(differences.iterator(), fromSide(DifferenceSource.LEFT)); |
| |
| // Merge A[eClassifiers delete] from right to left : true[abstract set]/true[interface set] will not |
| // be merge. |
| batchMerger.copyAllRightToLeft(Arrays.asList(diff), new BasicMonitor()); |
| |
| final EObject leftEClassA = getNodeNamed(left, "A"); |
| assertNotNull(leftEClassA); |
| assertFalse(((EClass)leftEClassA).isAbstract()); |
| assertFalse(((EClass)leftEClassA).isInterface()); |
| |
| for (Diff currentDiff : differences) { |
| if (currentDiff.getSource() == DifferenceSource.LEFT) { |
| assertTrue(isInTerminalState(currentDiff)); |
| } else { |
| assertTrue(currentDiff.getState() == UNRESOLVED); |
| } |
| } |
| } |
| |
| @Test |
| public void testLeftDeleteRightSet_RtL_2() throws IOException { |
| // Conflict between A[eClassifiers delete] from left side and true[abstract set]/true[interface set] |
| // from right side |
| |
| final Resource left = input.getLeftDeleteRightSetLeftConflictScope(); |
| final Resource right = input.getLeftDeleteRightSetRightConflictScope(); |
| final Resource origin = input.getLeftDeleteRightSetOriginConflictScope(); |
| |
| 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 UnmodifiableIterator<Diff> diffs = Iterators.filter(differences.iterator(), |
| fromSide(DifferenceSource.RIGHT)); |
| |
| // Merge true[abstract set]/true[interface set] from right to left : A[eClassifiers delete] will be |
| // merge from right to left too. |
| Diff abstract_ = diffs.next(); |
| batchMerger.copyAllRightToLeft(Arrays.asList(abstract_), new BasicMonitor()); |
| |
| final EObject leftEClassA = getNodeNamed(left, "A"); |
| assertNotNull(leftEClassA); |
| assertTrue(((EClass)leftEClassA).isAbstract()); |
| assertFalse(((EClass)leftEClassA).isInterface()); |
| |
| Diff interface_ = diffs.next(); |
| batchMerger.copyAllRightToLeft(Arrays.asList(interface_), new BasicMonitor()); |
| |
| assertNotNull(leftEClassA); |
| assertTrue(((EClass)leftEClassA).isAbstract()); |
| assertTrue(((EClass)leftEClassA).isInterface()); |
| |
| assertFalse(Iterators.any(differences.iterator(), not(hasState(MERGED, DISCARDED)))); |
| } |
| |
| @Test |
| public void testLeftSetRightDelete_LtR_1() throws IOException { |
| // Conflict between true[abstract set]/true[interface set] from left side and A[eClassifiers delete] |
| // from right side |
| |
| final Resource left = input.getLeftSetRightDeleteLeftConflictScope(); |
| final Resource right = input.getLeftSetRightDeleteRightConflictScope(); |
| final Resource origin = input.getLeftSetRightDeleteOriginConflictScope(); |
| |
| 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 UnmodifiableIterator<Diff> diffs = Iterators.filter(differences.iterator(), |
| fromSide(DifferenceSource.LEFT)); |
| |
| // Merge true[abstract set]/true[interface set] from left to right : A[eClassifiers delete] will be |
| // merge from left to right too. |
| Diff abstract_ = diffs.next(); |
| batchMerger.copyAllLeftToRight(Arrays.asList(abstract_), new BasicMonitor()); |
| |
| final EObject rightEClassA = getNodeNamed(right, "A"); |
| assertNotNull(rightEClassA); |
| assertTrue(((EClass)rightEClassA).isAbstract()); |
| assertFalse(((EClass)rightEClassA).isInterface()); |
| |
| Diff interface_ = diffs.next(); |
| batchMerger.copyAllLeftToRight(Arrays.asList(interface_), new BasicMonitor()); |
| |
| assertNotNull(rightEClassA); |
| assertTrue(((EClass)rightEClassA).isAbstract()); |
| assertTrue(((EClass)rightEClassA).isInterface()); |
| |
| assertFalse(Iterators.any(differences.iterator(), not(hasState(MERGED, DISCARDED)))); |
| } |
| |
| @Test |
| public void testLeftSetRightDelete_LtR_2() throws IOException { |
| // Conflict between true[abstract set]/true[interface set] from left side and A[eClassifiers delete] |
| // from right side |
| |
| final Resource left = input.getLeftSetRightDeleteLeftConflictScope(); |
| final Resource right = input.getLeftSetRightDeleteRightConflictScope(); |
| final Resource origin = input.getLeftSetRightDeleteOriginConflictScope(); |
| |
| 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 diff = Iterators.find(differences.iterator(), fromSide(DifferenceSource.RIGHT)); |
| |
| // Merge A[eClassifiers delete] from left to right : true[abstract set]/true[interface set] will not |
| // be merge. |
| batchMerger.copyAllLeftToRight(Arrays.asList(diff), new BasicMonitor()); |
| |
| final EObject rightEClassA = getNodeNamed(right, "A"); |
| assertNotNull(rightEClassA); |
| assertFalse(((EClass)rightEClassA).isAbstract()); |
| assertFalse(((EClass)rightEClassA).isInterface()); |
| |
| for (Diff currentDiff : differences) { |
| if (currentDiff.getSource() == DifferenceSource.RIGHT) { |
| assertTrue(isInTerminalState(currentDiff)); |
| } else { |
| assertTrue(currentDiff.getState() == UNRESOLVED); |
| } |
| } |
| } |
| |
| @Test |
| public void testLeftSetRightDelete_RtL_1() throws IOException { |
| // Conflict between true[abstract set]/true[interface set] from left side and A[eClassifiers delete] |
| // from right side |
| |
| final Resource left = input.getLeftSetRightDeleteLeftConflictScope(); |
| final Resource right = input.getLeftSetRightDeleteRightConflictScope(); |
| final Resource origin = input.getLeftSetRightDeleteOriginConflictScope(); |
| |
| 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 UnmodifiableIterator<Diff> diffs = Iterators.filter(differences.iterator(), |
| fromSide(DifferenceSource.LEFT)); |
| |
| // Merge true[abstract set]/true[interface set] from right to left : A[eClassifiers delete] will not |
| // be merge. |
| Diff abstract_ = diffs.next(); |
| batchMerger.copyAllRightToLeft(Arrays.asList(abstract_), new BasicMonitor()); |
| |
| final EObject leftEClassA = getNodeNamed(left, "A"); |
| assertNotNull(leftEClassA); |
| assertFalse(((EClass)leftEClassA).isAbstract()); |
| assertTrue(((EClass)leftEClassA).isInterface()); |
| |
| Diff interface_ = diffs.next(); |
| batchMerger.copyAllRightToLeft(Arrays.asList(interface_), new BasicMonitor()); |
| |
| assertNotNull(leftEClassA); |
| assertFalse(((EClass)leftEClassA).isAbstract()); |
| assertFalse(((EClass)leftEClassA).isInterface()); |
| |
| for (Diff currentDiff : differences) { |
| if (currentDiff.getSource() == DifferenceSource.LEFT) { |
| assertTrue(isInTerminalState(currentDiff)); |
| } else { |
| assertTrue(currentDiff.getState() == UNRESOLVED); |
| } |
| } |
| } |
| |
| @Test |
| public void testLeftSetRightDelete_RtL_2() throws IOException { |
| // Conflict between true[abstract set]/true[interface set] from left side and A[eClassifiers delete] |
| // from right side |
| |
| final Resource left = input.getLeftSetRightDeleteLeftConflictScope(); |
| final Resource right = input.getLeftSetRightDeleteRightConflictScope(); |
| final Resource origin = input.getLeftSetRightDeleteOriginConflictScope(); |
| |
| 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 diff = Iterators.find(differences.iterator(), fromSide(DifferenceSource.RIGHT)); |
| |
| // Merge A[eClassifiers delete] from right to left : true[abstract set]/true[interface set] will be |
| // merge from right to left too. |
| batchMerger.copyAllRightToLeft(Arrays.asList(diff), new BasicMonitor()); |
| |
| final EObject leftEClassA = getNodeNamed(left, "A"); |
| assertNull(leftEClassA); |
| |
| assertFalse(Iterators.any(differences.iterator(), not(hasState(MERGED, DISCARDED)))); |
| } |
| |
| @Test |
| public void testLeftSetRightUnset_LtR_1() throws IOException { |
| // Conflict between EBoolean[boolean] [eType set] from left side and EString[java.lang.String] [eType |
| // unset] from right side |
| |
| final Resource left = input.getLeftSetRightUnsetLeftConflictScope(); |
| final Resource right = input.getLeftSetRightUnsetRightConflictScope(); |
| final Resource origin = input.getLeftSetRightUnsetOriginConflictScope(); |
| |
| 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 EBoolean[boolean] [eType set] from left to right : EString[java.lang.String] [eType unset] |
| // will be merge from left to right too. |
| batchMerger.copyAllLeftToRight(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eType"; |
| final EObject rightEAttributeName = getNodeNamed(right, "name"); |
| assertNotNull(rightEAttributeName); |
| final EStructuralFeature feature = rightEAttributeName.eClass().getEStructuralFeature(featureName); |
| assertNotNull(feature); |
| final EClassifier eType = ((EAttribute)rightEAttributeName).getEType(); |
| assertNotNull(eType); |
| assertEquals(eType.getName(), "EBoolean"); |
| |
| assertFalse(Iterators.any(differences.iterator(), not(hasState(MERGED, DISCARDED)))); |
| } |
| |
| @Test |
| public void testLeftSetRightUnset_LtR_2() throws IOException { |
| // Conflict between EBoolean[boolean] [eType set] from left side and EString[java.lang.String] [eType |
| // unset] from right side |
| |
| final Resource left = input.getLeftSetRightUnsetLeftConflictScope(); |
| final Resource right = input.getLeftSetRightUnsetRightConflictScope(); |
| final Resource origin = input.getLeftSetRightUnsetOriginConflictScope(); |
| |
| 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 EString[java.lang.String] [eType unset] from left to right : EBoolean[boolean] [eType set] |
| // will not be merge. |
| batchMerger.copyAllLeftToRight(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eType"; |
| final EObject rightEAttributeName = getNodeNamed(right, "name"); |
| assertNotNull(rightEAttributeName); |
| final EStructuralFeature feature = rightEAttributeName.eClass().getEStructuralFeature(featureName); |
| assertNotNull(feature); |
| final EClassifier eType = ((EAttribute)rightEAttributeName).getEType(); |
| assertNotNull(eType); |
| assertEquals(eType.getName(), "EString"); |
| |
| for (Diff currentDiff : differences) { |
| if (currentDiff.getSource() == DifferenceSource.RIGHT) { |
| assertTrue(isInTerminalState(currentDiff)); |
| } else { |
| assertTrue(currentDiff.getState() == UNRESOLVED); |
| } |
| } |
| } |
| |
| @Test |
| public void testLeftSetRightUnset_RtL_1() throws IOException { |
| // Conflict between EBoolean[boolean] [eType set] from left side and EString[java.lang.String] [eType |
| // unset] from right side |
| |
| final Resource left = input.getLeftSetRightUnsetLeftConflictScope(); |
| final Resource right = input.getLeftSetRightUnsetRightConflictScope(); |
| final Resource origin = input.getLeftSetRightUnsetOriginConflictScope(); |
| |
| 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 EBoolean[boolean] [eType set] from right to left : EString[java.lang.String] [eType unset] |
| // will not be merge. |
| batchMerger.copyAllRightToLeft(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eType"; |
| final EObject leftEAttributeName = getNodeNamed(left, "name"); |
| assertNotNull(leftEAttributeName); |
| final EStructuralFeature feature = leftEAttributeName.eClass().getEStructuralFeature(featureName); |
| assertNotNull(feature); |
| final EClassifier eType = ((EAttribute)leftEAttributeName).getEType(); |
| assertNotNull(eType); |
| assertEquals(eType.getName(), "EString"); |
| |
| for (Diff currentDiff : differences) { |
| if (currentDiff.getSource() == DifferenceSource.LEFT) { |
| assertTrue(isInTerminalState(currentDiff)); |
| } else { |
| assertTrue(currentDiff.getState() == UNRESOLVED); |
| } |
| } |
| } |
| |
| @Test |
| public void testLeftSetRightUnset_RtL_2() throws IOException { |
| // Conflict between EBoolean[boolean] [eType set] from left side and EString[java.lang.String] [eType |
| // unset] from right side |
| |
| final Resource left = input.getLeftSetRightUnsetLeftConflictScope(); |
| final Resource right = input.getLeftSetRightUnsetRightConflictScope(); |
| final Resource origin = input.getLeftSetRightUnsetOriginConflictScope(); |
| |
| 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 EString[java.lang.String] [eType unset] from right to left : EBoolean[boolean] [eType set] |
| // will also be merged |
| batchMerger.copyAllRightToLeft(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eType"; |
| final EObject leftEAttributeName = getNodeNamed(left, "name"); |
| assertNotNull(leftEAttributeName); |
| final EStructuralFeature feature = leftEAttributeName.eClass().getEStructuralFeature(featureName); |
| assertNotNull(feature); |
| final EClassifier eType = ((EAttribute)leftEAttributeName).getEType(); |
| assertNull(eType); |
| |
| assertFalse(Iterators.any(differences.iterator(), not(hasState(MERGED, DISCARDED)))); |
| } |
| |
| @Test |
| public void testLeftUnsetRightSet_LtR_1() throws IOException { |
| // Conflict between EBoolean[boolean] [eType set] from left side and EString[java.lang.String] [eType |
| // unset] from right side |
| |
| final Resource left = input.getLeftUnsetRightSetLeftConflictScope(); |
| final Resource right = input.getLeftUnsetRightSetRightConflictScope(); |
| final Resource origin = input.getLeftUnsetRightSetOriginConflictScope(); |
| |
| 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 EString[java.lang.String] [eType unset] from left to right : EBoolean[boolean] [eType set] |
| // will be merge from left to right too. |
| batchMerger.copyAllLeftToRight(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eType"; |
| final EObject rightEAttributeName = getNodeNamed(right, "name"); |
| assertNotNull(rightEAttributeName); |
| final EStructuralFeature feature = rightEAttributeName.eClass().getEStructuralFeature(featureName); |
| assertNotNull(feature); |
| final EClassifier eType = ((EAttribute)rightEAttributeName).getEType(); |
| assertNull(eType); |
| |
| assertFalse(Iterators.any(differences.iterator(), not(hasState(MERGED, DISCARDED)))); |
| } |
| |
| @Test |
| public void testLeftUnsetRightSet_LtR_2() throws IOException { |
| // Conflict between EBoolean[boolean] [eType set] from left side and EString[java.lang.String] [eType |
| // unset] from right side |
| |
| final Resource left = input.getLeftUnsetRightSetLeftConflictScope(); |
| final Resource right = input.getLeftUnsetRightSetRightConflictScope(); |
| final Resource origin = input.getLeftUnsetRightSetOriginConflictScope(); |
| |
| 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 EBoolean[boolean] [eType set] from left to right : EString[java.lang.String] [eType unset] |
| // will not be merge. |
| batchMerger.copyAllLeftToRight(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eType"; |
| final EObject rightEAttributeName = getNodeNamed(right, "name"); |
| assertNotNull(rightEAttributeName); |
| final EStructuralFeature feature = rightEAttributeName.eClass().getEStructuralFeature(featureName); |
| assertNotNull(feature); |
| final EClassifier eType = ((EAttribute)rightEAttributeName).getEType(); |
| assertNotNull(eType); |
| assertEquals(eType.getName(), "EString"); |
| |
| for (Diff currentDiff : differences) { |
| if (currentDiff.getSource() == DifferenceSource.RIGHT) { |
| assertTrue(isInTerminalState(currentDiff)); |
| } else { |
| assertTrue(currentDiff.getState() == UNRESOLVED); |
| } |
| } |
| } |
| |
| @Test |
| public void testLeftUnsetRightSet_RtL_1() throws IOException { |
| // Conflict between EBoolean[boolean] [eType set] from left side and EString[java.lang.String] [eType |
| // unset] from right side |
| |
| final Resource left = input.getLeftUnsetRightSetLeftConflictScope(); |
| final Resource right = input.getLeftUnsetRightSetRightConflictScope(); |
| final Resource origin = input.getLeftUnsetRightSetOriginConflictScope(); |
| |
| 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 EString[java.lang.String] [eType unset] from right to left : EBoolean[boolean] [eType set] |
| // will not be merge. |
| batchMerger.copyAllRightToLeft(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eType"; |
| final EObject leftEAttributeName = getNodeNamed(left, "name"); |
| assertNotNull(leftEAttributeName); |
| final EStructuralFeature feature = leftEAttributeName.eClass().getEStructuralFeature(featureName); |
| assertNotNull(feature); |
| final EClassifier eType = ((EAttribute)leftEAttributeName).getEType(); |
| assertNotNull(eType); |
| assertEquals(eType.getName(), "EString"); |
| |
| for (Diff currentDiff : differences) { |
| if (currentDiff.getSource() == DifferenceSource.LEFT) { |
| assertTrue(isInTerminalState(currentDiff)); |
| } else { |
| assertTrue(currentDiff.getState() == UNRESOLVED); |
| } |
| } |
| } |
| |
| @Test |
| public void testLeftUnsetRightSet_RtL_2() throws IOException { |
| // Conflict between EBoolean[boolean] [eType set] from left side and EString[java.lang.String] [eType |
| // unset] from right side |
| |
| final Resource left = input.getLeftUnsetRightSetLeftConflictScope(); |
| final Resource right = input.getLeftUnsetRightSetRightConflictScope(); |
| final Resource origin = input.getLeftUnsetRightSetOriginConflictScope(); |
| |
| 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 EBoolean[boolean] [eType set] from right to left : EString[java.lang.String] [eType unset] |
| // will be merge from right to left too. |
| batchMerger.copyAllRightToLeft(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eType"; |
| final EObject leftEAttributeName = getNodeNamed(left, "name"); |
| assertNotNull(leftEAttributeName); |
| final EStructuralFeature feature = leftEAttributeName.eClass().getEStructuralFeature(featureName); |
| assertNotNull(feature); |
| final EClassifier eType = ((EAttribute)leftEAttributeName).getEType(); |
| assertNotNull(eType); |
| assertEquals(eType.getName(), "EBoolean"); |
| |
| assertFalse(Iterators.any(differences.iterator(), not(hasState(MERGED, DISCARDED)))); |
| } |
| |
| @Test |
| public void testLeftDeleteRightMove_LtR_1() throws IOException { |
| // Conflict between B[eClassifiers delete] from left side and name : EString [eStructuralFeatures |
| // move] from right side |
| |
| final Resource left = input.getLeftDeleteRightMoveLeftConflictScope(); |
| final Resource right = input.getLeftDeleteRightMoveRightConflictScope(); |
| final Resource origin = input.getLeftDeleteRightMoveOriginConflictScope(); |
| |
| 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 B[eClassifiers delete] from left to right : EString [eStructuralFeatures move] |
| // will be merge from left to right too. |
| batchMerger.copyAllLeftToRight(Arrays.asList(diff), new BasicMonitor()); |
| |
| final EObject rightEClassB = getNodeNamed(right, "B"); |
| assertNull(rightEClassB); |
| |
| assertFalse(Iterators.any(differences.iterator(), not(hasState(MERGED, DISCARDED)))); |
| } |
| |
| @Test |
| public void testLeftDeleteRightMove_LtR_2() throws IOException { |
| // Conflict between B[eClassifiers delete] from left side and name : EString [eStructuralFeatures |
| // move] from right side |
| |
| final Resource left = input.getLeftDeleteRightMoveLeftConflictScope(); |
| final Resource right = input.getLeftDeleteRightMoveRightConflictScope(); |
| final Resource origin = input.getLeftDeleteRightMoveOriginConflictScope(); |
| |
| 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 EString [eStructuralFeatures move] from left to right : B[eClassifiers delete] |
| // will not be merged |
| batchMerger.copyAllLeftToRight(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eStructuralFeatures"; |
| final EObject rightEClassB = getNodeNamed(right, "B"); |
| assertNotNull(rightEClassB); |
| final EStructuralFeature featureB = rightEClassB.eClass().getEStructuralFeature(featureName); |
| assertNotNull(featureB); |
| final EStructuralFeature eStructuralFeatureNameB = ((EClass)rightEClassB) |
| .getEStructuralFeature("name"); |
| assertNull(eStructuralFeatureNameB); |
| |
| final EObject rightEClassA = getNodeNamed(right, "A"); |
| assertNotNull(rightEClassA); |
| final EStructuralFeature featureA = rightEClassA.eClass().getEStructuralFeature(featureName); |
| assertNotNull(featureA); |
| final EStructuralFeature eStructuralFeatureNameA = ((EClass)rightEClassA) |
| .getEStructuralFeature("name"); |
| assertNotNull(eStructuralFeatureNameA); |
| |
| for (Diff currentDiff : differences) { |
| if (currentDiff.getSource() == DifferenceSource.RIGHT) { |
| assertTrue(isInTerminalState(currentDiff)); |
| } else { |
| assertTrue(currentDiff.getState() == UNRESOLVED); |
| } |
| } |
| } |
| |
| @Test |
| public void testLeftDeleteRightMove_RtL_1() throws IOException { |
| // Conflict between B[eClassifiers delete] from left side and name : EString [eStructuralFeatures |
| // move] from right side |
| |
| final Resource left = input.getLeftDeleteRightMoveLeftConflictScope(); |
| final Resource right = input.getLeftDeleteRightMoveRightConflictScope(); |
| final Resource origin = input.getLeftDeleteRightMoveOriginConflictScope(); |
| |
| 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 B[eClassifiers delete] from right to left : EString [eStructuralFeatures move] |
| // will not be merge. |
| batchMerger.copyAllRightToLeft(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eStructuralFeatures"; |
| final EObject leftEClassB = getNodeNamed(left, "B"); |
| assertNotNull(leftEClassB); |
| final EStructuralFeature featureB = leftEClassB.eClass().getEStructuralFeature(featureName); |
| assertNotNull(featureB); |
| final EStructuralFeature eStructuralFeatureNameB = ((EClass)leftEClassB) |
| .getEStructuralFeature("name"); |
| assertNull(eStructuralFeatureNameB); |
| |
| final EObject leftEClassA = getNodeNamed(left, "A"); |
| assertNotNull(leftEClassA); |
| final EStructuralFeature featureA = leftEClassA.eClass().getEStructuralFeature(featureName); |
| assertNotNull(featureA); |
| final EStructuralFeature eStructuralFeatureNameA = ((EClass)leftEClassA) |
| .getEStructuralFeature("name"); |
| assertNotNull(eStructuralFeatureNameA); |
| |
| for (Diff currentDiff : differences) { |
| if (currentDiff.getSource() == DifferenceSource.LEFT) { |
| assertTrue(isInTerminalState(currentDiff)); |
| } else { |
| assertTrue(currentDiff.getState() == UNRESOLVED); |
| } |
| } |
| } |
| |
| @Test |
| public void testLeftDeleteRightMove_RtL_2() throws IOException { |
| // Conflict between B[eClassifiers delete] from left side and name : EString [eStructuralFeatures |
| // move] from right side |
| |
| final Resource left = input.getLeftDeleteRightMoveLeftConflictScope(); |
| final Resource right = input.getLeftDeleteRightMoveRightConflictScope(); |
| final Resource origin = input.getLeftDeleteRightMoveOriginConflictScope(); |
| |
| 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 EString [eStructuralFeatures move] from right to left : B[eClassifiers delete] |
| // will be merge too. |
| batchMerger.copyAllRightToLeft(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eStructuralFeatures"; |
| final EObject leftEClassB = getNodeNamed(left, "B"); |
| assertNotNull(leftEClassB); |
| final EStructuralFeature featureB = leftEClassB.eClass().getEStructuralFeature(featureName); |
| assertNotNull(featureB); |
| final EStructuralFeature eStructuralFeatureNameB = ((EClass)leftEClassB) |
| .getEStructuralFeature("name"); |
| assertNotNull(eStructuralFeatureNameB); |
| final EObject leftEClassA = getNodeNamed(left, "A"); |
| assertNotNull(leftEClassA); |
| final EStructuralFeature featureA = leftEClassA.eClass().getEStructuralFeature(featureName); |
| assertNotNull(featureA); |
| final EStructuralFeature eStructuralFeatureNameA = ((EClass)leftEClassA) |
| .getEStructuralFeature("name"); |
| assertNull(eStructuralFeatureNameA); |
| |
| assertFalse(Iterators.any(differences.iterator(), not(hasState(MERGED, DISCARDED)))); |
| } |
| |
| @Test |
| public void testLeftMoveRightDelete_LtR_1() throws IOException { |
| // Conflict name : EString [eStructuralFeatures move] between from left side and |
| // B[eClassifiers delete] from right side |
| |
| final Resource left = input.getLeftMoveRightDeleteLeftConflictScope(); |
| final Resource right = input.getLeftMoveRightDeleteRightConflictScope(); |
| final Resource origin = input.getLeftMoveRightDeleteOriginConflictScope(); |
| |
| 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)); |
| assertNotNull(diff); |
| assertNotNull(diff.getConflict()); |
| |
| final Diff move = Iterators.find(differences.iterator(), ofKind(DifferenceKind.MOVE)); |
| assertNotNull(move); |
| |
| // Merge EString [eStructuralFeatures move] from left to right : B[eClassifiers delete] |
| // will be merge from left to right. |
| batchMerger.copyAllLeftToRight(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eStructuralFeatures"; |
| final EObject rightEClassB = getNodeNamed(right, "B"); |
| assertNotNull(rightEClassB); |
| |
| final EObject rightEClassA = getNodeNamed(right, "A"); |
| assertNotNull(rightEClassA); |
| final EStructuralFeature featureA = rightEClassA.eClass().getEStructuralFeature(featureName); |
| assertNotNull(featureA); |
| final EStructuralFeature eStructuralFeatureNameA = ((EClass)rightEClassA) |
| .getEStructuralFeature("name"); |
| assertNull(eStructuralFeatureNameA); |
| final EStructuralFeature featureB = rightEClassB.eClass().getEStructuralFeature(featureName); |
| assertNotNull(featureB); |
| final EStructuralFeature eStructuralFeatureNameB = ((EClass)rightEClassB) |
| .getEStructuralFeature("name"); |
| assertNotNull(eStructuralFeatureNameB); |
| |
| assertFalse(Iterators.any(differences.iterator(), not(hasState(MERGED, DISCARDED)))); |
| } |
| |
| @Test |
| public void testLeftMoveRightDelete_LtR_2() throws IOException { |
| // Conflict name : EString [eStructuralFeatures move] between from left side and |
| // B[eClassifiers delete] from right side |
| |
| final Resource left = input.getLeftMoveRightDeleteLeftConflictScope(); |
| final Resource right = input.getLeftMoveRightDeleteRightConflictScope(); |
| final Resource origin = input.getLeftMoveRightDeleteOriginConflictScope(); |
| |
| 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)); |
| assertNotNull(diff); |
| assertNotNull(diff.getConflict()); |
| |
| final Diff move = Iterators.find(differences.iterator(), ofKind(DifferenceKind.MOVE)); |
| assertNotNull(move); |
| |
| // Merge B[eClassifiers delete] from left to right : EString [eStructuralFeatures move] |
| // will not be merge. |
| batchMerger.copyAllLeftToRight(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eStructuralFeatures"; |
| final EObject rightEClassB = getNodeNamed(right, "B"); |
| assertNotNull(rightEClassB); |
| final EStructuralFeature featureB = rightEClassB.eClass().getEStructuralFeature(featureName); |
| assertNotNull(featureB); |
| final EStructuralFeature eStructuralFeatureNameB = ((EClass)rightEClassB) |
| .getEStructuralFeature("name"); |
| assertNull(eStructuralFeatureNameB); |
| |
| final EObject rightEClassA = getNodeNamed(right, "A"); |
| assertNotNull(rightEClassA); |
| final EStructuralFeature featureA = rightEClassA.eClass().getEStructuralFeature(featureName); |
| assertNotNull(featureA); |
| final EStructuralFeature eStructuralFeatureNameA = ((EClass)rightEClassA) |
| .getEStructuralFeature("name"); |
| assertNotNull(eStructuralFeatureNameA); |
| |
| for (Diff currentDiff : differences) { |
| if (currentDiff.getSource() == DifferenceSource.RIGHT) { |
| assertTrue(isInTerminalState(currentDiff)); |
| } else { |
| assertTrue(currentDiff.getState() == UNRESOLVED); |
| } |
| } |
| } |
| |
| @Test |
| public void testLeftMoveRightDelete_RtL_1() throws IOException { |
| // Conflict name : EString [eStructuralFeatures move] between from left side and |
| // B[eClassifiers delete] from right side |
| |
| final Resource left = input.getLeftMoveRightDeleteLeftConflictScope(); |
| final Resource right = input.getLeftMoveRightDeleteRightConflictScope(); |
| final Resource origin = input.getLeftMoveRightDeleteOriginConflictScope(); |
| |
| 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)); |
| assertNotNull(diff); |
| assertNotNull(diff.getConflict()); |
| |
| final Diff move = Iterators.find(differences.iterator(), ofKind(DifferenceKind.MOVE)); |
| assertNotNull(move); |
| |
| // Merge EString [eStructuralFeatures move] from right to left : B[eClassifiers delete] |
| // will not be merge. |
| batchMerger.copyAllRightToLeft(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eStructuralFeatures"; |
| final EObject leftEClassB = getNodeNamed(left, "B"); |
| assertNotNull(leftEClassB); |
| final EStructuralFeature featureB = leftEClassB.eClass().getEStructuralFeature(featureName); |
| assertNotNull(featureB); |
| final EStructuralFeature eStructuralFeatureNameB = ((EClass)leftEClassB) |
| .getEStructuralFeature("name"); |
| assertNull(eStructuralFeatureNameB); |
| |
| final EObject leftEClassA = getNodeNamed(left, "A"); |
| assertNotNull(leftEClassA); |
| final EStructuralFeature featureA = leftEClassA.eClass().getEStructuralFeature(featureName); |
| assertNotNull(featureA); |
| final EStructuralFeature eStructuralFeatureNameA = ((EClass)leftEClassA) |
| .getEStructuralFeature("name"); |
| assertNotNull(eStructuralFeatureNameA); |
| |
| for (Diff currentDiff : differences) { |
| if (currentDiff.getSource() == DifferenceSource.LEFT) { |
| assertTrue(isInTerminalState(currentDiff)); |
| } else { |
| assertTrue(currentDiff.getState() == UNRESOLVED); |
| } |
| } |
| } |
| |
| @Test |
| public void testLeftMoveRightDelete_RtL_2() throws IOException { |
| // Conflict name : EString [eStructuralFeatures move] between from left side and |
| // B[eClassifiers delete] from right side |
| |
| final Resource left = input.getLeftMoveRightDeleteLeftConflictScope(); |
| final Resource right = input.getLeftMoveRightDeleteRightConflictScope(); |
| final Resource origin = input.getLeftMoveRightDeleteOriginConflictScope(); |
| |
| 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)); |
| assertNotNull(diff); |
| assertNotNull(diff.getConflict()); |
| |
| final Diff move = Iterators.find(differences.iterator(), ofKind(DifferenceKind.MOVE)); |
| assertNotNull(move); |
| |
| // Merge B[eClassifiers delete] from right to left : EString [eStructuralFeatures move] |
| // will not be merge. |
| batchMerger.copyAllRightToLeft(Arrays.asList(diff), new BasicMonitor()); |
| |
| final String featureName = "eStructuralFeatures"; |
| final EObject leftEClassB = getNodeNamed(left, "B"); |
| assertNull(leftEClassB); |
| |
| final EObject leftEClassA = getNodeNamed(left, "A"); |
| assertNotNull(leftEClassA); |
| final EStructuralFeature featureA = leftEClassA.eClass().getEStructuralFeature(featureName); |
| assertNotNull(featureA); |
| final EStructuralFeature eStructuralFeatureNameA = ((EClass)leftEClassA) |
| .getEStructuralFeature("name"); |
| assertNull(eStructuralFeatureNameA); |
| |
| assertFalse(Iterators.any(differences.iterator(), not(hasState(MERGED, DISCARDED)))); |
| } |
| |
| @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 |
| batchMerger.copyAllLeftToRight(Arrays.asList(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(MERGED, DISCARDED)))); |
| } |
| |
| @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 |
| batchMerger.copyAllRightToLeft(Arrays.asList(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(MERGED, DISCARDED)))); |
| } |
| |
| private EObject getNodeNamed(Resource res, String name) { |
| final Iterator<EObject> iterator = EcoreUtil.getAllProperContents(res, false); |
| while (iterator.hasNext()) { |
| final EObject next = iterator.next(); |
| final EStructuralFeature nameFeature = next.eClass().getEStructuralFeature("name"); |
| if (nameFeature != null && name.equals(next.eGet(nameFeature))) { |
| return next; |
| } |
| } |
| return null; |
| } |
| } |
