| /******************************************************************************* |
| * Copyright (c) 2013, 2016 Obeo and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Obeo - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.emf.compare.diagram.papyrus.tests.merge; |
| |
| import static com.google.common.base.Predicates.and; |
| import static com.google.common.base.Predicates.instanceOf; |
| import static com.google.common.base.Predicates.not; |
| import static org.eclipse.emf.compare.utils.EMFComparePredicates.ofKind; |
| |
| import com.google.common.base.Predicate; |
| import com.google.common.collect.Iterables; |
| |
| import java.io.IOException; |
| import java.util.regex.Pattern; |
| |
| import org.eclipse.emf.common.util.BasicMonitor; |
| import org.eclipse.emf.compare.Comparison; |
| import org.eclipse.emf.compare.Diff; |
| import org.eclipse.emf.compare.DifferenceKind; |
| import org.eclipse.emf.compare.ReferenceChange; |
| import org.eclipse.emf.compare.diagram.internal.extensions.EdgeChange; |
| import org.eclipse.emf.compare.diagram.internal.extensions.NodeChange; |
| import org.eclipse.emf.compare.diagram.papyrus.tests.AbstractTest; |
| import org.eclipse.emf.compare.diagram.papyrus.tests.DiagramInputData; |
| import org.eclipse.emf.compare.diagram.papyrus.tests.merge.data.EdgeMergeInputData; |
| import org.eclipse.emf.compare.tests.postprocess.data.TestPostProcessor; |
| import org.eclipse.emf.compare.uml2.internal.AssociationChange; |
| import org.eclipse.emf.compare.uml2.internal.DirectedRelationshipChange; |
| import org.eclipse.emf.compare.uml2.internal.postprocessor.MultiplicityElementChangePostProcessor; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.gmf.runtime.notation.NotationPackage; |
| import org.eclipse.uml2.uml.UMLPackage; |
| import org.junit.Test; |
| |
| @SuppressWarnings("nls") |
| public class EdgeMergeTest extends AbstractTest { |
| private EdgeMergeInputData input = new EdgeMergeInputData(); |
| |
| private static final int A1_EDGECHANGE_NB = 19; |
| private static final int A1_ASSOCHANGE_NB = 18; |
| private static final int A1_DIFFS_NB = A1_EDGECHANGE_NB + A1_ASSOCHANGE_NB; |
| |
| private static final int A2_EDGECHANGE_NB = 19; |
| private static final int A2_NODECHANGE_NB = 26; |
| private static final int A2_ASSOCHANGE_NB = 18; |
| private static final int A2_CLASSCHANGE_NB = 1; |
| private static final int A2_DIFFS_NB = A2_EDGECHANGE_NB + A2_NODECHANGE_NB + A2_ASSOCHANGE_NB + A2_CLASSCHANGE_NB; |
| |
| private static final int A3_EDGECHANGE_NB = A2_EDGECHANGE_NB; |
| private static final int A3_NODECHANGE_NB = 2 * A2_NODECHANGE_NB; |
| private static final int A3_ASSOCHANGE_NB = A2_ASSOCHANGE_NB; |
| private static final int A3_CLASSCHANGE_NB = 2 * A2_CLASSCHANGE_NB; |
| private static final int A3_DIFFS_NB = A3_EDGECHANGE_NB + A3_NODECHANGE_NB + A3_ASSOCHANGE_NB + A3_CLASSCHANGE_NB; |
| |
| private static final int A4_EDGECHANGE1_NB = A3_EDGECHANGE_NB; |
| private static final int A4_EDGECHANGE_NB = 2 * A4_EDGECHANGE1_NB; |
| private static final int A4_NODECHANGE1_NB = A2_NODECHANGE_NB; |
| private static final int A4_NODECHANGE_NB = 2 * A4_NODECHANGE1_NB; |
| private static final int A4_SUBNODECHANGE_NB = 4; |
| private static final int A4_PROPNODECHANGE_NB = 4; |
| private static final int A4_PKGNODECHANGE_NB = 14; |
| |
| private static final int A4_ASSOCHANGE1_NB = A2_ASSOCHANGE_NB; |
| private static final int A4_ASSOCHANGE_NB = 2 * A4_ASSOCHANGE1_NB; |
| private static final int A4_CLASSCHANGE1_NB = A2_CLASSCHANGE_NB; |
| private static final int A4_CLASSCHANGE_NB = 3 * A4_CLASSCHANGE1_NB; |
| private static final int A4_PKGCHANGE_NB = 1; |
| private static final int A4_PROPCHANGE_NB = 1; |
| private static final int A4_DIFFS_NB = A4_EDGECHANGE_NB + A4_NODECHANGE_NB + A4_SUBNODECHANGE_NB + A4_PROPNODECHANGE_NB + A4_PKGNODECHANGE_NB + A4_ASSOCHANGE_NB + A4_CLASSCHANGE_NB + A4_PKGCHANGE_NB + A4_PROPCHANGE_NB; |
| |
| private static final int A5_NOTMANAGED_CONTAINMENT_LINK_NB = 15; |
| private static final int A5_NOTMANAGED_BRANCH1_NB = 13; |
| private static final int A5_NOTMANAGED_BRANCHES_NB = 3 * A5_NOTMANAGED_BRANCH1_NB; |
| private static final int A5_NOTMANAGED_BRANCH_COMMON_NB = 6; |
| private static final int A5_NOTMANAGED_MULTI_EDGES_NB = A5_NOTMANAGED_BRANCH_COMMON_NB + A5_NOTMANAGED_BRANCHES_NB; |
| private static final int A5_NODECHANGE1_NB = A2_NODECHANGE_NB; |
| private static final int A5_NODECHANGES_NB = 3 * A5_NODECHANGE1_NB; |
| private static final int A5_EDGECHANGE1_NB = 13; |
| private static final int A5_EDGECHANGES_NB = 7 * A5_EDGECHANGE1_NB; |
| private static final int A5_EDGECHANGE_ASSO1_NB = 21; |
| private static final int A5_EDGECHANGE_ASSOS_NB = 2 * A5_EDGECHANGE_ASSO1_NB; |
| private static final int A5_EDGECHANGE_GENE1_NB = 11; |
| private static final int A5_EDGECHANGE_IREAL_NB = 12; |
| private static final int A5_SEMANTIC_DIFFS_NB = 90; |
| private static final int A5_DIFFS_NB = A5_NOTMANAGED_CONTAINMENT_LINK_NB + A5_NOTMANAGED_MULTI_EDGES_NB + A5_NODECHANGES_NB + A5_EDGECHANGES_NB + A5_EDGECHANGE_ASSOS_NB + A5_EDGECHANGE_GENE1_NB + A5_EDGECHANGE_IREAL_NB + A5_SEMANTIC_DIFFS_NB; |
| |
| private static final int A6_NODECHANGE1_NB = 26; |
| private static final int A6_NODECHANGES_NB = 2 * A6_NODECHANGE1_NB; |
| private static final int A6_DEPENDENCY_EDGE_CHANGE1_NB = 12; |
| private static final int A6_DEPENDENCY_EDGE_CHANGES_NB = 11 * A6_DEPENDENCY_EDGE_CHANGE1_NB; |
| private static final int A6_ASSO_EDGE_CHANGE1_NB = 21; |
| private static final int A6_ASSO_EDGE_CHANGES_NB = 2 * A6_ASSO_EDGE_CHANGE1_NB; |
| private static final int A6_IMPORT_EDGE_CHANGE1_NB = 13; |
| private static final int A6_IMPORT_EDGE_CHANGES_NB = 2 * A6_IMPORT_EDGE_CHANGE1_NB; |
| private static final int A6_FLOW_EDGE_CHANGE1_NB = 13; |
| private static final int A6_FLOW_EDGE_CHANGES_NB = 2 * A6_FLOW_EDGE_CHANGE1_NB; |
| private static final int A6_GENERAL_EDGE_CHANGE1_NB = 11; |
| private static final int A6_GENERAL_EDGE_CHANGES_NB = 2 * A6_GENERAL_EDGE_CHANGE1_NB; |
| private static final int A6_CLASSCHANGE1_NB = 1; |
| private static final int A6_CLASSCHANGES_NB = 2 * A6_CLASSCHANGE1_NB; |
| private static final int A6_DEPENDENCY_CHANGE1_NB = 5; |
| private static final int A6_SUBSTITUTION_CHANGE1_NB = 6; |
| private static final int A6_IREAL_CHANGE1_NB = 6; |
| private static final int A6_DEPENDENCY_CHANGES_NB = 8 * A6_DEPENDENCY_CHANGE1_NB + 2 * A6_SUBSTITUTION_CHANGE1_NB + A6_IREAL_CHANGE1_NB; |
| private static final int A6_ASSO_CHANGE1_NB = 18; |
| private static final int A6_ASSO_CHANGES_NB = 2 * A6_ASSO_CHANGE1_NB; |
| private static final int A6_IMPORT_CHANGE1_NB = 3; |
| private static final int A6_IMPORT_CHANGES_NB = 2 * A6_IMPORT_CHANGE1_NB; |
| private static final int A6_FLOW_CHANGE1_NB = 4; |
| private static final int A6_FLOW_CHANGES_NB = 2 * A6_FLOW_CHANGE1_NB; |
| private static final int A6_GENERAL_CHANGE1_NB = 3; |
| private static final int A6_GENERAL_CHANGES_NB = 2 * A6_GENERAL_CHANGE1_NB; |
| private static final int A6_DIFFS_NB = A6_NODECHANGES_NB + A6_DEPENDENCY_EDGE_CHANGES_NB + A6_ASSO_EDGE_CHANGES_NB + A6_IMPORT_EDGE_CHANGES_NB + A6_FLOW_EDGE_CHANGES_NB + A6_GENERAL_EDGE_CHANGES_NB + A6_CLASSCHANGES_NB + A6_DEPENDENCY_CHANGES_NB + A6_ASSO_CHANGES_NB + A6_IMPORT_CHANGES_NB + A6_FLOW_CHANGES_NB + A6_GENERAL_CHANGES_NB; |
| |
| private static final int A7_EDGECHANGE1_NB = 2; |
| private static final int A7_EDGECHANGES_NB = 3 * A7_EDGECHANGE1_NB; |
| private static final int A7_EDGE_TARGET_CHANGE_NB = 1; |
| private static final int A7_ASSO_TARGET_CHANGE_NB = 1; |
| private static final int A7_DIFFS_NB = A7_EDGECHANGES_NB + A7_EDGE_TARGET_CHANGE_NB + A7_ASSO_TARGET_CHANGE_NB; |
| |
| @Test |
| // Merge left to right <ADD Edge> |
| public void testA1a() throws IOException { |
| final Resource left = input.getA1EdgeChangeLeft(); |
| final Resource right = input.getA1EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| diffsChecking(comparison, A1_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1)); |
| |
| // ** MERGE ** |
| Diff edgeChange = Iterables.find(comparison.getDifferences(), edge); |
| getMergerRegistry().getHighestRankingMerger(edgeChange).copyLeftToRight(edgeChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, 0); // all diffs merged |
| } |
| |
| @Test |
| // Merge right to left <ADD Edge> |
| public void testA1b() throws IOException { |
| final Resource left = input.getA1EdgeChangeLeft(); |
| final Resource right = input.getA1EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| diffsChecking(comparison, A1_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1)); |
| |
| // ** MERGE ** |
| Diff edgeChange = Iterables.find(comparison.getDifferences(), edge); |
| getMergerRegistry().getHighestRankingMerger(edgeChange).copyRightToLeft(edgeChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A1_DIFFS_NB - A1_EDGECHANGE_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 0)); // only graphical diffs merged |
| } |
| |
| @Test |
| // Merge left to right <DELETE Edge> |
| public void testA1c() throws IOException { |
| final Resource right = input.getA1EdgeChangeLeft(); |
| final Resource left = input.getA1EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.DELETE)); |
| diffsChecking(comparison, A1_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1)); |
| |
| // ** MERGE ** |
| Diff edgeChange = Iterables.find(comparison.getDifferences(), edge); |
| getMergerRegistry().getHighestRankingMerger(edgeChange).copyLeftToRight(edgeChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A1_DIFFS_NB - A1_EDGECHANGE_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 0)); // only graphical diffs merged |
| } |
| |
| @Test |
| // Merge right to left <DELETE Edge> |
| public void testA1d() throws IOException { |
| final Resource right = input.getA1EdgeChangeLeft(); |
| final Resource left = input.getA1EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.DELETE)); |
| diffsChecking(comparison, A1_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1)); |
| |
| // ** MERGE ** |
| Diff edgeChange = Iterables.find(comparison.getDifferences(), edge); |
| getMergerRegistry().getHighestRankingMerger(edgeChange).copyRightToLeft(edgeChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, 0); // all diffs merged |
| } |
| |
| @Test |
| // Merge left to right <ADD Association> |
| public void testA1e() throws IOException { |
| final Resource left = input.getA1EdgeChangeLeft(); |
| final Resource right = input.getA1EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| diffsChecking(comparison, A1_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1)); |
| |
| // ** MERGE ** |
| Diff associationChange = Iterables.find(comparison.getDifferences(), association); |
| getMergerRegistry().getHighestRankingMerger(associationChange).copyLeftToRight(associationChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A1_DIFFS_NB - A1_ASSOCHANGE_NB); // only 13 semantic diffs merged |
| } |
| |
| @Test |
| // Merge right to left <ADD Association> |
| public void testA1f() throws IOException { |
| final Resource left = input.getA1EdgeChangeLeft(); |
| final Resource right = input.getA1EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| diffsChecking(comparison, A1_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1)); |
| |
| // ** MERGE ** |
| Diff associationChange = Iterables.find(comparison.getDifferences(), association); |
| getMergerRegistry().getHighestRankingMerger(associationChange).copyRightToLeft(associationChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, 0); // all diffs merged |
| } |
| |
| @Test |
| // Merge left to right <DELETE Association> |
| public void testA1g() throws IOException { |
| final Resource right = input.getA1EdgeChangeLeft(); |
| final Resource left = input.getA1EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.DELETE)); |
| diffsChecking(comparison, A1_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1)); |
| |
| // ** MERGE ** |
| Diff associationChange = Iterables.find(comparison.getDifferences(), association); |
| getMergerRegistry().getHighestRankingMerger(associationChange).copyLeftToRight(associationChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, 0); // all diffs merged |
| } |
| |
| @Test |
| // Merge right to left <DELETE Association> |
| public void testA1h() throws IOException { |
| final Resource right = input.getA1EdgeChangeLeft(); |
| final Resource left = input.getA1EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.DELETE)); |
| diffsChecking(comparison, A1_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1)); |
| |
| // ** MERGE ** |
| Diff associationChange = Iterables.find(comparison.getDifferences(), association); |
| getMergerRegistry().getHighestRankingMerger(associationChange).copyRightToLeft(associationChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A1_DIFFS_NB - A1_ASSOCHANGE_NB); // only 13 semantic diffs merged |
| } |
| |
| @Test |
| // Merge left to right <ADD Edge> -> merge <ADD Node> (and merge <ADD Association>, merge <ADD Class>) |
| public void testA2a() throws IOException { |
| final Resource left = input.getA2EdgeChangeLeft(); |
| final Resource right = input.getA2EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| diffsChecking(comparison, A2_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1), new ExpectedStat(node, 1)); |
| |
| // ** MERGE ** |
| Diff edgeChange = Iterables.find(comparison.getDifferences(), edge); |
| getMergerRegistry().getHighestRankingMerger(edgeChange).copyLeftToRight(edgeChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, 0); // all diffs merged |
| } |
| |
| @Test |
| // Merge right to left <ADD Edge> |
| public void testA2b() throws IOException { |
| final Resource left = input.getA2EdgeChangeLeft(); |
| final Resource right = input.getA2EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| diffsChecking(comparison, A2_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1), new ExpectedStat(node, 1)); |
| |
| // ** MERGE ** |
| Diff edgeChange = Iterables.find(comparison.getDifferences(), edge); |
| getMergerRegistry().getHighestRankingMerger(edgeChange).copyRightToLeft(edgeChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A2_DIFFS_NB - A2_EDGECHANGE_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 0), new ExpectedStat(node, 1)); |
| } |
| |
| @Test |
| // Merge left to right <DELETE Edge> |
| public void testA2c() throws IOException { |
| final Resource right = input.getA2EdgeChangeLeft(); |
| final Resource left = input.getA2EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.DELETE)); |
| diffsChecking(comparison, A2_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1), new ExpectedStat(node, 1)); |
| |
| // ** MERGE ** |
| Diff edgeChange = Iterables.find(comparison.getDifferences(), edge); |
| getMergerRegistry().getHighestRankingMerger(edgeChange).copyLeftToRight(edgeChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A2_DIFFS_NB - A2_EDGECHANGE_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 0), new ExpectedStat(node, 1)); |
| } |
| |
| @Test |
| // Merge right to left <DELETE Edge> -> merge <ADD Node> (and merge <ADD Association>, merge <ADD Class>) |
| public void testA2d() throws IOException { |
| final Resource right = input.getA2EdgeChangeLeft(); |
| final Resource left = input.getA2EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.DELETE)); |
| diffsChecking(comparison, A2_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1), new ExpectedStat(node, 1)); |
| |
| // ** MERGE ** |
| Diff edgeChange = Iterables.find(comparison.getDifferences(), edge); |
| getMergerRegistry().getHighestRankingMerger(edgeChange).copyRightToLeft(edgeChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, 0); // all diffs merged |
| } |
| |
| @Test |
| // Merge left to right <ADD Association> -> merge <ADD Class> |
| public void testA2e() throws IOException { |
| final Resource left = input.getA2EdgeChangeLeft(); |
| final Resource right = input.getA2EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| diffsChecking(comparison, A2_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1), new ExpectedStat(node, 1)); |
| |
| // ** MERGE ** |
| Diff associationChange = Iterables.find(comparison.getDifferences(), association); |
| getMergerRegistry().getHighestRankingMerger(associationChange).copyLeftToRight(associationChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A2_DIFFS_NB - A2_ASSOCHANGE_NB - A2_CLASSCHANGE_NB, new ExpectedStat(association, 0), new ExpectedStat(edge, 1), new ExpectedStat(node, 1)); |
| } |
| |
| @Test |
| // Merge right to left <ADD Association> -> (merge <ADD Edge>) |
| public void testA2f() throws IOException { |
| final Resource left = input.getA2EdgeChangeLeft(); |
| final Resource right = input.getA2EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| diffsChecking(comparison, A2_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1), new ExpectedStat(node, 1)); |
| |
| // ** MERGE ** |
| Diff associationChange = Iterables.find(comparison.getDifferences(), association); |
| getMergerRegistry().getHighestRankingMerger(associationChange).copyRightToLeft(associationChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A2_DIFFS_NB - A2_ASSOCHANGE_NB - A2_EDGECHANGE_NB, new ExpectedStat(association, 0), new ExpectedStat(edge, 0), new ExpectedStat(node, 1)); |
| } |
| |
| @Test |
| // Merge left to right <DELETE Association> -> (merge <DELETE Edge>) |
| public void testA2g() throws IOException { |
| final Resource right = input.getA2EdgeChangeLeft(); |
| final Resource left = input.getA2EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.DELETE)); |
| diffsChecking(comparison, A2_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1), new ExpectedStat(node, 1)); |
| |
| // ** MERGE ** |
| Diff associationChange = Iterables.find(comparison.getDifferences(), association); |
| getMergerRegistry().getHighestRankingMerger(associationChange).copyLeftToRight(associationChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A2_DIFFS_NB - A2_ASSOCHANGE_NB - A2_EDGECHANGE_NB, new ExpectedStat(association, 0), new ExpectedStat(edge, 0), new ExpectedStat(node, 1)); |
| } |
| |
| @Test |
| // Merge right to left <DELETE Association> -> merge <DELETE Class> |
| public void testA2h() throws IOException { |
| final Resource right = input.getA2EdgeChangeLeft(); |
| final Resource left = input.getA2EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.DELETE)); |
| diffsChecking(comparison, A2_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1), new ExpectedStat(node, 1)); |
| |
| // ** MERGE ** |
| Diff associationChange = Iterables.find(comparison.getDifferences(), association); |
| getMergerRegistry().getHighestRankingMerger(associationChange).copyRightToLeft(associationChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A2_DIFFS_NB - A2_ASSOCHANGE_NB - A2_CLASSCHANGE_NB, new ExpectedStat(association, 0), new ExpectedStat(edge, 1), new ExpectedStat(node, 1)); |
| } |
| |
| @Test |
| // Merge left to right <ADD Edge> -> merge <ADD Nodes> (and merge <ADD Association>, merge <ADD Classes>) |
| public void testA3a() throws IOException { |
| final Resource left = input.getA3EdgeChangeLeft(); |
| final Resource right = input.getA3EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| diffsChecking(comparison, A3_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1), new ExpectedStat(node, 2)); |
| |
| // ** MERGE ** |
| Diff edgeChange = Iterables.find(comparison.getDifferences(), edge); |
| getMergerRegistry().getHighestRankingMerger(edgeChange).copyLeftToRight(edgeChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, 0); // all diffs merged |
| } |
| |
| @Test |
| // Merge right to left <ADD Edge> |
| public void testA3b() throws IOException { |
| final Resource left = input.getA3EdgeChangeLeft(); |
| final Resource right = input.getA3EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| diffsChecking(comparison, A3_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1), new ExpectedStat(node, 2)); |
| |
| // ** MERGE ** |
| Diff edgeChange = Iterables.find(comparison.getDifferences(), edge); |
| getMergerRegistry().getHighestRankingMerger(edgeChange).copyRightToLeft(edgeChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A3_DIFFS_NB - A3_EDGECHANGE_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 0), new ExpectedStat(node, 2)); |
| } |
| |
| @Test |
| // Merge left to right <DELETE Edge> |
| public void testA3c() throws IOException { |
| final Resource right = input.getA3EdgeChangeLeft(); |
| final Resource left = input.getA3EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.DELETE)); |
| diffsChecking(comparison, A3_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1), new ExpectedStat(node, 2)); |
| |
| // ** MERGE ** |
| Diff edgeChange = Iterables.find(comparison.getDifferences(), edge); |
| getMergerRegistry().getHighestRankingMerger(edgeChange).copyLeftToRight(edgeChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A3_DIFFS_NB - A3_EDGECHANGE_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 0), new ExpectedStat(node, 2)); |
| } |
| |
| @Test |
| // Merge right to left <DELETE Edge> -> merge <ADD Nodes> (and merge <ADD Association>, merge <ADD Classes>) |
| public void testA3d() throws IOException { |
| final Resource right = input.getA3EdgeChangeLeft(); |
| final Resource left = input.getA3EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.DELETE)); |
| diffsChecking(comparison, A3_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1), new ExpectedStat(node, 2)); |
| |
| // ** MERGE ** |
| Diff edgeChange = Iterables.find(comparison.getDifferences(), edge); |
| getMergerRegistry().getHighestRankingMerger(edgeChange).copyRightToLeft(edgeChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, 0); // all diffs merged |
| } |
| |
| @Test |
| // Merge left to right <ADD Association> -> merge <ADD Classes> |
| public void testA3e() throws IOException { |
| final Resource left = input.getA3EdgeChangeLeft(); |
| final Resource right = input.getA3EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| diffsChecking(comparison, A3_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1), new ExpectedStat(node, 2)); |
| |
| // ** MERGE ** |
| Diff associationChange = Iterables.find(comparison.getDifferences(), association); |
| getMergerRegistry().getHighestRankingMerger(associationChange).copyLeftToRight(associationChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A3_DIFFS_NB - A3_ASSOCHANGE_NB - A3_CLASSCHANGE_NB, new ExpectedStat(association, 0), new ExpectedStat(edge, 1), new ExpectedStat(node, 2)); |
| } |
| |
| @Test |
| // Merge right to left <ADD Association> -> (merge <ADD Edge>) |
| public void testA3f() throws IOException { |
| final Resource left = input.getA3EdgeChangeLeft(); |
| final Resource right = input.getA3EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| diffsChecking(comparison, A3_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1), new ExpectedStat(node, 2)); |
| |
| // ** MERGE ** |
| Diff associationChange = Iterables.find(comparison.getDifferences(), association); |
| getMergerRegistry().getHighestRankingMerger(associationChange).copyRightToLeft(associationChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A3_DIFFS_NB - A3_ASSOCHANGE_NB - A3_EDGECHANGE_NB, new ExpectedStat(association, 0), new ExpectedStat(edge, 0), new ExpectedStat(node, 2)); |
| } |
| |
| @Test |
| // Merge left to right <DELETE Association> -> (merge <DELETE Edge>) |
| public void testA3g() throws IOException { |
| final Resource right = input.getA3EdgeChangeLeft(); |
| final Resource left = input.getA3EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.DELETE)); |
| diffsChecking(comparison, A3_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1), new ExpectedStat(node, 2)); |
| |
| // ** MERGE ** |
| Diff associationChange = Iterables.find(comparison.getDifferences(), association); |
| getMergerRegistry().getHighestRankingMerger(associationChange).copyLeftToRight(associationChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A3_DIFFS_NB - A3_ASSOCHANGE_NB - A3_EDGECHANGE_NB, new ExpectedStat(association, 0), new ExpectedStat(edge, 0), new ExpectedStat(node, 2)); |
| } |
| |
| @Test |
| // Merge right to left <DELETE Association> -> merge <DELETE Classes> |
| public void testA3h() throws IOException { |
| final Resource right = input.getA3EdgeChangeLeft(); |
| final Resource left = input.getA3EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> edge = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.DELETE)); |
| diffsChecking(comparison, A3_DIFFS_NB, new ExpectedStat(association, 1), new ExpectedStat(edge, 1), new ExpectedStat(node, 2)); |
| |
| // ** MERGE ** |
| Diff associationChange = Iterables.find(comparison.getDifferences(), association); |
| getMergerRegistry().getHighestRankingMerger(associationChange).copyRightToLeft(associationChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A3_DIFFS_NB - A3_ASSOCHANGE_NB - A3_CLASSCHANGE_NB, new ExpectedStat(association, 0), new ExpectedStat(edge, 1), new ExpectedStat(node, 2)); |
| } |
| |
| @Test |
| // Merge left to right <ADD Edge> -> merge <ADD Node>, merge <ADD PkgNode> (and merge <ADD Association>, merge <ADD Class>, merge <ADD Package>) |
| public void testA4a() throws IOException { |
| final Resource left = input.getA4EdgeChangeLeft(); |
| final Resource right = input.getA4EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edge1 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementNameIs("a_b_1")); |
| Predicate<Diff> edge2 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementNameIs("c_b_1")); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| diffsChecking(comparison, A4_DIFFS_NB, new ExpectedStat(association, 2), new ExpectedStat(edge1, 1), new ExpectedStat(edge2, 1), new ExpectedStat(node, 5)); |
| |
| // ** MERGE ** |
| Diff edgeChange = Iterables.find(comparison.getDifferences(), edge1); |
| getMergerRegistry().getHighestRankingMerger(edgeChange).copyLeftToRight(edgeChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A4_DIFFS_NB - A4_EDGECHANGE1_NB - A4_NODECHANGE1_NB - A4_PKGNODECHANGE_NB - A4_ASSOCHANGE1_NB - A4_CLASSCHANGE1_NB - A4_PKGCHANGE_NB, new ExpectedStat(association, 1), new ExpectedStat(edge1, 0), new ExpectedStat(edge2, 1), new ExpectedStat(node, 3)); |
| } |
| |
| @Test |
| // Merge right to left <ADD Edge> |
| public void testA4b() throws IOException { |
| final Resource left = input.getA4EdgeChangeLeft(); |
| final Resource right = input.getA4EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edge1 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementNameIs("a_b_1")); |
| Predicate<Diff> edge2 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementNameIs("c_b_1")); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| diffsChecking(comparison, A4_DIFFS_NB, new ExpectedStat(association, 2), new ExpectedStat(edge1, 1), new ExpectedStat(edge2, 1), new ExpectedStat(node, 5)); |
| |
| // ** MERGE ** |
| Diff edgeChange = Iterables.find(comparison.getDifferences(), edge1); |
| getMergerRegistry().getHighestRankingMerger(edgeChange).copyRightToLeft(edgeChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A4_DIFFS_NB - A4_EDGECHANGE1_NB, new ExpectedStat(association, 2), new ExpectedStat(edge1, 0), new ExpectedStat(edge2, 1), new ExpectedStat(node, 5)); |
| } |
| |
| @Test |
| // Merge left to right <DELETE Edge> |
| public void testA4c() throws IOException { |
| final Resource right = input.getA4EdgeChangeLeft(); |
| final Resource left = input.getA4EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> edge1 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.DELETE), elementNameIs("a_b_1")); |
| Predicate<Diff> edge2 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.DELETE), elementNameIs("c_b_1")); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.DELETE)); |
| diffsChecking(comparison, A4_DIFFS_NB, new ExpectedStat(association, 2), new ExpectedStat(edge1, 1), new ExpectedStat(edge2, 1), new ExpectedStat(node, 5)); |
| |
| // ** MERGE ** |
| Diff edgeChange = Iterables.find(comparison.getDifferences(), edge1); |
| getMergerRegistry().getHighestRankingMerger(edgeChange).copyLeftToRight(edgeChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A4_DIFFS_NB - A4_EDGECHANGE1_NB, new ExpectedStat(association, 2), new ExpectedStat(edge1, 0), new ExpectedStat(edge2, 1), new ExpectedStat(node, 5)); |
| } |
| |
| @Test |
| // Merge right to left <DELETE Edge> -> merge <ADD Node>, merge <ADD PkgNode> (and merge <ADD Association>, merge <ADD Class>, merge <ADD Package>) |
| public void testA4d() throws IOException { |
| final Resource right = input.getA4EdgeChangeLeft(); |
| final Resource left = input.getA4EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> association = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.DELETE)); |
| Predicate<Diff> edge1 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.DELETE), elementNameIs("a_b_1")); |
| Predicate<Diff> edge2 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.DELETE), elementNameIs("c_b_1")); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.DELETE)); |
| diffsChecking(comparison, A4_DIFFS_NB, new ExpectedStat(association, 2), new ExpectedStat(edge1, 1), new ExpectedStat(edge2, 1), new ExpectedStat(node, 5)); |
| |
| // ** MERGE ** |
| Diff edgeChange = Iterables.find(comparison.getDifferences(), edge1); |
| getMergerRegistry().getHighestRankingMerger(edgeChange).copyRightToLeft(edgeChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A4_DIFFS_NB - A4_EDGECHANGE1_NB - A4_NODECHANGE1_NB - A4_PKGNODECHANGE_NB - A4_ASSOCHANGE1_NB - A4_CLASSCHANGE1_NB - A4_PKGCHANGE_NB, new ExpectedStat(association, 1), new ExpectedStat(edge1, 0), new ExpectedStat(edge2, 1), new ExpectedStat(node, 3)); |
| } |
| |
| @Test |
| // Merge left to right <ADD Association> -> merge <ADD Class>, merge <ADD Package> |
| public void testA4e() throws IOException { |
| final Resource left = input.getA4EdgeChangeLeft(); |
| final Resource right = input.getA4EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> asso1 = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD), nameIs("a_b_1")); |
| Predicate<Diff> asso2 = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD), nameIs("c_b_1")); |
| Predicate<Diff> edge1 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementNameIs("a_b_1")); |
| Predicate<Diff> edge2 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementNameIs("c_b_1")); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| diffsChecking(comparison, A4_DIFFS_NB, new ExpectedStat(asso1, 1), new ExpectedStat(asso2, 1), new ExpectedStat(edge1, 1), new ExpectedStat(edge2, 1), new ExpectedStat(node, 5)); |
| |
| // ** MERGE ** |
| Diff associationChange = Iterables.find(comparison.getDifferences(), asso1); |
| getMergerRegistry().getHighestRankingMerger(associationChange).copyLeftToRight(associationChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A4_DIFFS_NB - A4_ASSOCHANGE1_NB - A4_CLASSCHANGE1_NB - A4_PKGCHANGE_NB, new ExpectedStat(asso1, 0), new ExpectedStat(asso2, 1), new ExpectedStat(edge1, 1), new ExpectedStat(edge2, 1), new ExpectedStat(node, 5)); |
| } |
| |
| @Test |
| // Merge right to left <ADD Association> -> (merge <ADD Edge>) |
| public void testA4f() throws IOException { |
| final Resource left = input.getA4EdgeChangeLeft(); |
| final Resource right = input.getA4EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> asso1 = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD), nameIs("a_b_1")); |
| Predicate<Diff> asso2 = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD), nameIs("c_b_1")); |
| Predicate<Diff> edge1 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementNameIs("a_b_1")); |
| Predicate<Diff> edge2 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementNameIs("c_b_1")); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| diffsChecking(comparison, A4_DIFFS_NB, new ExpectedStat(asso1, 1), new ExpectedStat(asso2, 1), new ExpectedStat(edge1, 1), new ExpectedStat(edge2, 1), new ExpectedStat(node, 5)); |
| |
| // ** MERGE ** |
| Diff associationChange = Iterables.find(comparison.getDifferences(), asso1); |
| getMergerRegistry().getHighestRankingMerger(associationChange).copyRightToLeft(associationChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A4_DIFFS_NB - A4_ASSOCHANGE1_NB - A4_EDGECHANGE1_NB, new ExpectedStat(asso1, 0), new ExpectedStat(asso2, 1), new ExpectedStat(edge1, 0), new ExpectedStat(edge2, 1), new ExpectedStat(node, 5)); |
| } |
| |
| @Test |
| // Merge left to right <DELETE Association> -> (merge <DELETE Edge>) |
| public void testA4g() throws IOException { |
| final Resource right = input.getA4EdgeChangeLeft(); |
| final Resource left = input.getA4EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> asso1 = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.DELETE), nameIs("a_b_1")); |
| Predicate<Diff> asso2 = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.DELETE), nameIs("c_b_1")); |
| Predicate<Diff> edge1 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.DELETE), elementNameIs("a_b_1")); |
| Predicate<Diff> edge2 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.DELETE), elementNameIs("c_b_1")); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.DELETE)); |
| diffsChecking(comparison, A4_DIFFS_NB, new ExpectedStat(asso1, 1), new ExpectedStat(asso2, 1), new ExpectedStat(edge1, 1), new ExpectedStat(edge2, 1), new ExpectedStat(node, 5)); |
| |
| // ** MERGE ** |
| Diff associationChange = Iterables.find(comparison.getDifferences(), asso1); |
| getMergerRegistry().getHighestRankingMerger(associationChange).copyLeftToRight(associationChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A4_DIFFS_NB - A4_ASSOCHANGE1_NB - A4_EDGECHANGE1_NB, new ExpectedStat(asso1, 0), new ExpectedStat(asso2, 1), new ExpectedStat(edge1, 0), new ExpectedStat(edge2, 1), new ExpectedStat(node, 5)); |
| } |
| |
| @Test |
| // Merge right to left <DELETE Association> -> merge <DELETE Class>, merge <DELETE Package> |
| public void testA4h() throws IOException { |
| final Resource right = input.getA4EdgeChangeLeft(); |
| final Resource left = input.getA4EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> asso1 = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.DELETE), nameIs("a_b_1")); |
| Predicate<Diff> asso2 = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.DELETE), nameIs("c_b_1")); |
| Predicate<Diff> edge1 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.DELETE), elementNameIs("a_b_1")); |
| Predicate<Diff> edge2 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.DELETE), elementNameIs("c_b_1")); |
| Predicate<Diff> node = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.DELETE)); |
| diffsChecking(comparison, A4_DIFFS_NB, new ExpectedStat(asso1, 1), new ExpectedStat(asso2, 1), new ExpectedStat(edge1, 1), new ExpectedStat(edge2, 1), new ExpectedStat(node, 5)); |
| |
| // ** MERGE ** |
| Diff associationChange = Iterables.find(comparison.getDifferences(), asso1); |
| getMergerRegistry().getHighestRankingMerger(associationChange).copyRightToLeft(associationChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A4_DIFFS_NB - A4_ASSOCHANGE1_NB - A4_CLASSCHANGE1_NB - A4_PKGCHANGE_NB, new ExpectedStat(asso1, 0), new ExpectedStat(asso2, 1), new ExpectedStat(edge1, 1), new ExpectedStat(edge2, 1), new ExpectedStat(node, 5)); |
| } |
| |
| @Test |
| // Merge left to right <ADD NodeB> -> merge <ADD PkgNodeB> (and merge <ADD ClassB>, merge <ADD PackageB>) |
| public void testA4i() throws IOException { |
| final Resource left = input.getA4EdgeChangeLeft(); |
| final Resource right = input.getA4EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> asso1 = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD), nameIs("a_b_1")); |
| Predicate<Diff> asso2 = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD), nameIs("c_b_1")); |
| Predicate<Diff> edge1 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementNameIs("a_b_1")); |
| Predicate<Diff> edge2 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementNameIs("c_b_1")); |
| Predicate<Diff> nodeB = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD), elementNameIs("B")); |
| Predicate<Diff> nodeSubB = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD), elementNameIs("SubB")); |
| Predicate<Diff> nodePropB = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD), elementNameIs("propB")); |
| diffsChecking(comparison, A4_DIFFS_NB, new ExpectedStat(asso1, 1), new ExpectedStat(asso2, 1), new ExpectedStat(edge1, 1), new ExpectedStat(edge2, 1), new ExpectedStat(nodeB, 1), new ExpectedStat(nodeSubB, 1), new ExpectedStat(nodePropB, 1)); |
| |
| // ** MERGE ** |
| Diff nodeBChange = Iterables.find(comparison.getDifferences(), nodeB); |
| getMergerRegistry().getHighestRankingMerger(nodeBChange).copyLeftToRight(nodeBChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A4_DIFFS_NB - A4_NODECHANGE1_NB - A4_PKGNODECHANGE_NB - A4_CLASSCHANGE1_NB - A4_PKGCHANGE_NB, new ExpectedStat(asso1, 1), new ExpectedStat(asso2, 1), new ExpectedStat(edge1, 1), new ExpectedStat(edge2, 1), new ExpectedStat(nodeB, 0), new ExpectedStat(nodeSubB, 1), new ExpectedStat(nodePropB, 1)); |
| } |
| |
| @Test |
| // Merge right to left <ADD NodeB> -> merge <ADD edge1>, merge <ADD edge2>, merge <ADD nodePropB>, merge <ADD nodeSubB> |
| public void testA4j() throws IOException { |
| final Resource left = input.getA4EdgeChangeLeft(); |
| final Resource right = input.getA4EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> asso1 = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD), nameIs("a_b_1")); |
| Predicate<Diff> asso2 = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD), nameIs("c_b_1")); |
| Predicate<Diff> edge1 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementNameIs("a_b_1")); |
| Predicate<Diff> edge2 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementNameIs("c_b_1")); |
| Predicate<Diff> nodeB = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD), elementNameIs("B")); |
| Predicate<Diff> nodeSubB = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD), elementNameIs("SubB")); |
| Predicate<Diff> nodePropB = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD), elementNameIs("propB")); |
| diffsChecking(comparison, A4_DIFFS_NB, new ExpectedStat(asso1, 1), new ExpectedStat(asso2, 1), new ExpectedStat(edge1, 1), new ExpectedStat(edge2, 1), new ExpectedStat(nodeB, 1), new ExpectedStat(nodeSubB, 1), new ExpectedStat(nodePropB, 1)); |
| |
| // ** MERGE ** |
| Diff nodeBChange = Iterables.find(comparison.getDifferences(), nodeB); |
| getMergerRegistry().getHighestRankingMerger(nodeBChange).copyRightToLeft(nodeBChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A4_DIFFS_NB - A4_NODECHANGE1_NB - 2 * A4_EDGECHANGE1_NB - A4_PROPNODECHANGE_NB - A4_SUBNODECHANGE_NB, new ExpectedStat(asso1, 1), new ExpectedStat(asso2, 1), new ExpectedStat(edge1, 0), new ExpectedStat(edge2, 0), new ExpectedStat(nodeB, 0), new ExpectedStat(nodeSubB, 0), new ExpectedStat(nodePropB, 0)); |
| } |
| |
| @Test |
| // Merge Left to Right <ADD Abstraction Edge> |
| public void testA6a() throws IOException { |
| final Resource left = input.getA6EdgeChangeLeft(); |
| final Resource right = input.getA6EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> substitutions = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.SUBSTITUTION), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> interfaceRealizations = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.INTERFACE_REALIZATION), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> associations = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> dependencies = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.DEPENDENCY), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> nodes = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edges = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edgeAbstraction = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ABSTRACTION)); |
| Predicate<Diff> edgeAssociation = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ASSOCIATION)); |
| Predicate<Diff> edgeDependency = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.DEPENDENCY)); |
| Predicate<Diff> edgeImport = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ELEMENT_IMPORT)); |
| Predicate<Diff> edgeGeneralization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.GENERALIZATION)); |
| Predicate<Diff> edgeFlow = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.INFORMATION_FLOW)); |
| Predicate<Diff> edgeInterfaceRealization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.INTERFACE_REALIZATION)); |
| Predicate<Diff> edgeRealization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.REALIZATION)); |
| Predicate<Diff> edgeSubstitution = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.SUBSTITUTION)); |
| Predicate<Diff> edgeUsage = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.USAGE)); |
| |
| diffsChecking(comparison, A6_DIFFS_NB, |
| new ExpectedStat(substitutions, 2), |
| new ExpectedStat(interfaceRealizations, 1), |
| new ExpectedStat(associations, 2), |
| new ExpectedStat(and(dependencies, not(substitutions), not(interfaceRealizations)), 8), // 2 abstractions + 2 dependencies + 2 realizations + 2 usages. Details below: |
| new ExpectedStat(nodes, 2), |
| new ExpectedStat(edges, 19), // 13 + 2 imports + 2 generalizations + 2 information flows (no UMLDiff for them). Details below: |
| new ExpectedStat(edgeAbstraction, 2), |
| new ExpectedStat(edgeAssociation, 2), |
| new ExpectedStat(edgeDependency, 2), |
| new ExpectedStat(edgeImport, 2), |
| new ExpectedStat(edgeGeneralization, 2), |
| new ExpectedStat(edgeFlow, 2), |
| new ExpectedStat(edgeInterfaceRealization, 1), |
| new ExpectedStat(edgeRealization, 2), |
| new ExpectedStat(edgeSubstitution, 2), |
| new ExpectedStat(edgeUsage, 2)); |
| |
| // ** MERGE ** |
| Diff edgeAbstractionChange = Iterables.find(comparison.getDifferences(), edgeAbstraction); |
| getMergerRegistry().getHighestRankingMerger(edgeAbstractionChange).copyLeftToRight(edgeAbstractionChange, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A6_DIFFS_NB - A6_DEPENDENCY_EDGE_CHANGE1_NB - A6_DEPENDENCY_CHANGE1_NB - A6_NODECHANGE1_NB - A6_CLASSCHANGE1_NB, |
| new ExpectedStat(substitutions, 2), |
| new ExpectedStat(interfaceRealizations, 1), |
| new ExpectedStat(associations, 2), |
| new ExpectedStat(and(dependencies, not(substitutions), not(interfaceRealizations)), 7), // ** -1 |
| new ExpectedStat(nodes, 1), // ** -1 |
| new ExpectedStat(edgeAbstraction, 1), // ** -1 |
| new ExpectedStat(edgeAssociation, 2), |
| new ExpectedStat(edgeDependency, 2), |
| new ExpectedStat(edgeImport, 2), |
| new ExpectedStat(edgeGeneralization, 2), |
| new ExpectedStat(edgeFlow, 2), |
| new ExpectedStat(edgeInterfaceRealization, 1), |
| new ExpectedStat(edgeRealization, 2), |
| new ExpectedStat(edgeSubstitution, 2), |
| new ExpectedStat(edgeUsage, 2)); |
| } |
| |
| @Test |
| // Merge Left to Right <ADD Association Edge> |
| public void testA6b() throws IOException { |
| final Resource left = input.getA6EdgeChangeLeft(); |
| final Resource right = input.getA6EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> substitutions = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.SUBSTITUTION), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> interfaceRealizations = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.INTERFACE_REALIZATION), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> associations = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> dependencies = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.DEPENDENCY), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> nodes = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edges = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edgeAbstraction = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ABSTRACTION)); |
| Predicate<Diff> edgeAssociation = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ASSOCIATION)); |
| Predicate<Diff> edgeDependency = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.DEPENDENCY)); |
| Predicate<Diff> edgeImport = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ELEMENT_IMPORT)); |
| Predicate<Diff> edgeGeneralization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.GENERALIZATION)); |
| Predicate<Diff> edgeFlow = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.INFORMATION_FLOW)); |
| Predicate<Diff> edgeInterfaceRealization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.INTERFACE_REALIZATION)); |
| Predicate<Diff> edgeRealization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.REALIZATION)); |
| Predicate<Diff> edgeSubstitution = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.SUBSTITUTION)); |
| Predicate<Diff> edgeUsage = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.USAGE)); |
| |
| diffsChecking(comparison, A6_DIFFS_NB, |
| new ExpectedStat(substitutions, 2), |
| new ExpectedStat(interfaceRealizations, 1), |
| new ExpectedStat(associations, 2), |
| new ExpectedStat(and(dependencies, not(substitutions), not(interfaceRealizations)), 8), // 2 abstractions + 2 dependencies + 2 realizations + 2 usages. |
| new ExpectedStat(nodes, 2), |
| new ExpectedStat(edges, 19), // 13 + 2 imports + 2 generalizations + 2 information flows. Details below: |
| new ExpectedStat(edgeAbstraction, 2), |
| new ExpectedStat(edgeAssociation, 2), |
| new ExpectedStat(edgeDependency, 2), |
| new ExpectedStat(edgeImport, 2), |
| new ExpectedStat(edgeGeneralization, 2), |
| new ExpectedStat(edgeFlow, 2), |
| new ExpectedStat(edgeInterfaceRealization, 1), |
| new ExpectedStat(edgeRealization, 2), |
| new ExpectedStat(edgeSubstitution, 2), |
| new ExpectedStat(edgeUsage, 2)); |
| |
| // ** MERGE ** |
| Diff edge = Iterables.find(comparison.getDifferences(), edgeAssociation); |
| getMergerRegistry().getHighestRankingMerger(edge).copyLeftToRight(edge, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A6_DIFFS_NB - A6_ASSO_EDGE_CHANGE1_NB - A6_ASSO_CHANGE1_NB - A6_NODECHANGE1_NB - A6_CLASSCHANGE1_NB, |
| new ExpectedStat(substitutions, 2), |
| new ExpectedStat(interfaceRealizations, 1), |
| new ExpectedStat(associations, 1), // ** -1 |
| new ExpectedStat(and(dependencies, not(substitutions), not(interfaceRealizations)), 8), |
| new ExpectedStat(nodes, 1), // ** -1 |
| new ExpectedStat(edgeAbstraction, 2), |
| new ExpectedStat(edgeAssociation, 1), // ** -1 |
| new ExpectedStat(edgeDependency, 2), |
| new ExpectedStat(edgeImport, 2), |
| new ExpectedStat(edgeGeneralization, 2), |
| new ExpectedStat(edgeFlow, 2), |
| new ExpectedStat(edgeInterfaceRealization, 1), |
| new ExpectedStat(edgeRealization, 2), |
| new ExpectedStat(edgeSubstitution, 2), |
| new ExpectedStat(edgeUsage, 2)); |
| } |
| |
| @Test |
| // Merge Left to Right <ADD Dependency Edge> |
| public void testA6c() throws IOException { |
| final Resource left = input.getA6EdgeChangeLeft(); |
| final Resource right = input.getA6EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> substitutions = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.SUBSTITUTION), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> interfaceRealizations = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.INTERFACE_REALIZATION), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> associations = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> dependencies = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.DEPENDENCY), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> nodes = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edges = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edgeAbstraction = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ABSTRACTION)); |
| Predicate<Diff> edgeAssociation = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ASSOCIATION)); |
| Predicate<Diff> edgeDependency = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.DEPENDENCY)); |
| Predicate<Diff> edgeImport = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ELEMENT_IMPORT)); |
| Predicate<Diff> edgeGeneralization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.GENERALIZATION)); |
| Predicate<Diff> edgeFlow = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.INFORMATION_FLOW)); |
| Predicate<Diff> edgeInterfaceRealization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.INTERFACE_REALIZATION)); |
| Predicate<Diff> edgeRealization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.REALIZATION)); |
| Predicate<Diff> edgeSubstitution = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.SUBSTITUTION)); |
| Predicate<Diff> edgeUsage = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.USAGE)); |
| |
| diffsChecking(comparison, A6_DIFFS_NB, |
| new ExpectedStat(substitutions, 2), |
| new ExpectedStat(interfaceRealizations, 1), |
| new ExpectedStat(associations, 2), |
| new ExpectedStat(and(dependencies, not(substitutions), not(interfaceRealizations)), 8), // 2 abstractions + 2 dependencies + 2 realizations + 2 usages. |
| new ExpectedStat(nodes, 2), |
| new ExpectedStat(edges, 19), // 13 + 2 imports + 2 generalizations + 2 information flows (no UMLDiff for them). Details below: |
| new ExpectedStat(edgeAbstraction, 2), |
| new ExpectedStat(edgeAssociation, 2), |
| new ExpectedStat(edgeDependency, 2), |
| new ExpectedStat(edgeImport, 2), |
| new ExpectedStat(edgeGeneralization, 2), |
| new ExpectedStat(edgeFlow, 2), |
| new ExpectedStat(edgeInterfaceRealization, 1), |
| new ExpectedStat(edgeRealization, 2), |
| new ExpectedStat(edgeSubstitution, 2), |
| new ExpectedStat(edgeUsage, 2)); |
| |
| // ** MERGE ** |
| Diff edge = Iterables.find(comparison.getDifferences(), edgeDependency); |
| getMergerRegistry().getHighestRankingMerger(edge).copyLeftToRight(edge, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A6_DIFFS_NB - A6_DEPENDENCY_EDGE_CHANGE1_NB - A6_DEPENDENCY_CHANGE1_NB - A6_NODECHANGE1_NB - A6_CLASSCHANGE1_NB, |
| new ExpectedStat(substitutions, 2), |
| new ExpectedStat(interfaceRealizations, 1), |
| new ExpectedStat(associations, 2), |
| new ExpectedStat(and(dependencies, not(substitutions), not(interfaceRealizations)), 7), // ** -1 |
| new ExpectedStat(nodes, 1), // ** -1 |
| new ExpectedStat(edgeAbstraction, 2), |
| new ExpectedStat(edgeAssociation, 2), |
| new ExpectedStat(edgeDependency, 1), // ** -1 |
| new ExpectedStat(edgeImport, 2), |
| new ExpectedStat(edgeGeneralization, 2), |
| new ExpectedStat(edgeFlow, 2), |
| new ExpectedStat(edgeInterfaceRealization, 1), |
| new ExpectedStat(edgeRealization, 2), |
| new ExpectedStat(edgeSubstitution, 2), |
| new ExpectedStat(edgeUsage, 2)); |
| } |
| |
| @Test |
| // Merge Left to Right <ADD Import Edge> |
| public void testA6d() throws IOException { |
| final Resource left = input.getA6EdgeChangeLeft(); |
| final Resource right = input.getA6EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> substitutions = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.SUBSTITUTION), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> interfaceRealizations = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.INTERFACE_REALIZATION), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> associations = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> dependencies = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.DEPENDENCY), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> nodes = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edges = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edgeAbstraction = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ABSTRACTION)); |
| Predicate<Diff> edgeAssociation = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ASSOCIATION)); |
| Predicate<Diff> edgeDependency = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.DEPENDENCY)); |
| Predicate<Diff> edgeImport = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ELEMENT_IMPORT)); |
| Predicate<Diff> edgeGeneralization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.GENERALIZATION)); |
| Predicate<Diff> edgeFlow = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.INFORMATION_FLOW)); |
| Predicate<Diff> edgeInterfaceRealization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.INTERFACE_REALIZATION)); |
| Predicate<Diff> edgeRealization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.REALIZATION)); |
| Predicate<Diff> edgeSubstitution = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.SUBSTITUTION)); |
| Predicate<Diff> edgeUsage = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.USAGE)); |
| |
| diffsChecking(comparison, A6_DIFFS_NB, |
| new ExpectedStat(substitutions, 2), |
| new ExpectedStat(interfaceRealizations, 1), |
| new ExpectedStat(associations, 2), |
| new ExpectedStat(and(dependencies, not(substitutions), not(interfaceRealizations)), 8), // 2 abstractions + 2 dependencies + 2 realizations + 2 usages. |
| new ExpectedStat(nodes, 2), |
| new ExpectedStat(edges, 19), // 13 + 2 imports + 2 generalizations + 2 information flows. Details below: |
| new ExpectedStat(edgeAbstraction, 2), |
| new ExpectedStat(edgeAssociation, 2), |
| new ExpectedStat(edgeDependency, 2), |
| new ExpectedStat(edgeImport, 2), |
| new ExpectedStat(edgeGeneralization, 2), |
| new ExpectedStat(edgeFlow, 2), |
| new ExpectedStat(edgeInterfaceRealization, 1), |
| new ExpectedStat(edgeRealization, 2), |
| new ExpectedStat(edgeSubstitution, 2), |
| new ExpectedStat(edgeUsage, 2)); |
| |
| // ** MERGE ** |
| Diff edge = Iterables.find(comparison.getDifferences(), edgeImport); |
| getMergerRegistry().getHighestRankingMerger(edge).copyLeftToRight(edge, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| //FIXME: ElementImport.importedElement is not merged => should create a UMLDiff for this DirectedRelationship (A6_IMPORT_CHANGE1_NB += 1) |
| // See Bug 406405 |
| diffsChecking(comparison, A6_DIFFS_NB - A6_IMPORT_EDGE_CHANGE1_NB - A6_IMPORT_CHANGE1_NB - A6_NODECHANGE1_NB - A6_CLASSCHANGE1_NB, |
| new ExpectedStat(substitutions, 2), |
| new ExpectedStat(interfaceRealizations, 1), |
| new ExpectedStat(associations, 2), |
| new ExpectedStat(and(dependencies, not(substitutions), not(interfaceRealizations)), 8), |
| new ExpectedStat(nodes, 1), // ** -1 |
| new ExpectedStat(edgeAbstraction, 2), |
| new ExpectedStat(edgeAssociation, 2), |
| new ExpectedStat(edgeDependency, 2), |
| new ExpectedStat(edgeImport, 1), // ** -1 |
| new ExpectedStat(edgeGeneralization, 2), |
| new ExpectedStat(edgeFlow, 2), |
| new ExpectedStat(edgeInterfaceRealization, 1), |
| new ExpectedStat(edgeRealization, 2), |
| new ExpectedStat(edgeSubstitution, 2), |
| new ExpectedStat(edgeUsage, 2)); |
| } |
| |
| @Test |
| // Merge Left to Right <ADD Generalization Edge> |
| public void testA6e() throws IOException { |
| final Resource left = input.getA6EdgeChangeLeft(); |
| final Resource right = input.getA6EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> substitutions = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.SUBSTITUTION), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> interfaceRealizations = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.INTERFACE_REALIZATION), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> associations = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> dependencies = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.DEPENDENCY), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> nodes = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edges = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edgeAbstraction = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ABSTRACTION)); |
| Predicate<Diff> edgeAssociation = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ASSOCIATION)); |
| Predicate<Diff> edgeDependency = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.DEPENDENCY)); |
| Predicate<Diff> edgeImport = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ELEMENT_IMPORT)); |
| Predicate<Diff> edgeGeneralization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.GENERALIZATION)); |
| Predicate<Diff> edgeFlow = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.INFORMATION_FLOW)); |
| Predicate<Diff> edgeInterfaceRealization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.INTERFACE_REALIZATION)); |
| Predicate<Diff> edgeRealization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.REALIZATION)); |
| Predicate<Diff> edgeSubstitution = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.SUBSTITUTION)); |
| Predicate<Diff> edgeUsage = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.USAGE)); |
| |
| diffsChecking(comparison, A6_DIFFS_NB, |
| new ExpectedStat(substitutions, 2), |
| new ExpectedStat(interfaceRealizations, 1), |
| new ExpectedStat(associations, 2), |
| new ExpectedStat(and(dependencies, not(substitutions), not(interfaceRealizations)), 8), // 2 abstractions + 2 dependencies + 2 realizations + 2 usages. |
| new ExpectedStat(nodes, 2), |
| new ExpectedStat(edges, 19), // 13 + 2 imports + 2 generalizations + 2 information flows (no UMLDiff for them). Details below: |
| new ExpectedStat(edgeAbstraction, 2), |
| new ExpectedStat(edgeAssociation, 2), |
| new ExpectedStat(edgeDependency, 2), |
| new ExpectedStat(edgeImport, 2), |
| new ExpectedStat(edgeGeneralization, 2), |
| new ExpectedStat(edgeFlow, 2), |
| new ExpectedStat(edgeInterfaceRealization, 1), |
| new ExpectedStat(edgeRealization, 2), |
| new ExpectedStat(edgeSubstitution, 2), |
| new ExpectedStat(edgeUsage, 2)); |
| |
| // ** MERGE ** |
| Diff edge = Iterables.find(comparison.getDifferences(), edgeGeneralization); |
| getMergerRegistry().getHighestRankingMerger(edge).copyLeftToRight(edge, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| //FIXME: Generalization.general is not merged => should create a UMLDiff for this DirectedRelationship (A6_GENERAL_CHANGE1_NB += 1) |
| // See Bug 406405 |
| diffsChecking(comparison, A6_DIFFS_NB - A6_GENERAL_EDGE_CHANGE1_NB - A6_GENERAL_CHANGE1_NB - A6_NODECHANGE1_NB - A6_CLASSCHANGE1_NB, |
| new ExpectedStat(substitutions, 2), |
| new ExpectedStat(interfaceRealizations, 1), |
| new ExpectedStat(associations, 2), |
| new ExpectedStat(and(dependencies, not(substitutions), not(interfaceRealizations)), 8), |
| new ExpectedStat(nodes, 1), // ** -1 |
| new ExpectedStat(edgeAbstraction, 2), |
| new ExpectedStat(edgeAssociation, 2), |
| new ExpectedStat(edgeDependency, 2), |
| new ExpectedStat(edgeImport, 2), |
| new ExpectedStat(edgeGeneralization, 1), // ** -1 |
| new ExpectedStat(edgeFlow, 2), |
| new ExpectedStat(edgeInterfaceRealization, 1), |
| new ExpectedStat(edgeRealization, 2), |
| new ExpectedStat(edgeSubstitution, 2), |
| new ExpectedStat(edgeUsage, 2)); |
| } |
| |
| @Test |
| // Merge Left to Right <ADD Flow Edge> |
| public void testA6f() throws IOException { |
| final Resource left = input.getA6EdgeChangeLeft(); |
| final Resource right = input.getA6EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> substitutions = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.SUBSTITUTION), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> interfaceRealizations = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.INTERFACE_REALIZATION), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> associations = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> dependencies = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.DEPENDENCY), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> nodes = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edges = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edgeAbstraction = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ABSTRACTION)); |
| Predicate<Diff> edgeAssociation = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ASSOCIATION)); |
| Predicate<Diff> edgeDependency = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.DEPENDENCY)); |
| Predicate<Diff> edgeImport = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ELEMENT_IMPORT)); |
| Predicate<Diff> edgeGeneralization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.GENERALIZATION)); |
| Predicate<Diff> edgeFlow = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.INFORMATION_FLOW)); |
| Predicate<Diff> edgeInterfaceRealization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.INTERFACE_REALIZATION)); |
| Predicate<Diff> edgeRealization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.REALIZATION)); |
| Predicate<Diff> edgeSubstitution = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.SUBSTITUTION)); |
| Predicate<Diff> edgeUsage = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.USAGE)); |
| |
| diffsChecking(comparison, A6_DIFFS_NB, |
| new ExpectedStat(substitutions, 2), |
| new ExpectedStat(interfaceRealizations, 1), |
| new ExpectedStat(associations, 2), |
| new ExpectedStat(and(dependencies, not(substitutions), not(interfaceRealizations)), 8), // 2 abstractions + 2 dependencies + 2 realizations + 2 usages. |
| new ExpectedStat(nodes, 2), |
| new ExpectedStat(edges, 19), // 13 + 2 imports + 2 generalizations + 2 information flows (no UMLDiff for them). Details below: |
| new ExpectedStat(edgeAbstraction, 2), |
| new ExpectedStat(edgeAssociation, 2), |
| new ExpectedStat(edgeDependency, 2), |
| new ExpectedStat(edgeImport, 2), |
| new ExpectedStat(edgeGeneralization, 2), |
| new ExpectedStat(edgeFlow, 2), |
| new ExpectedStat(edgeInterfaceRealization, 1), |
| new ExpectedStat(edgeRealization, 2), |
| new ExpectedStat(edgeSubstitution, 2), |
| new ExpectedStat(edgeUsage, 2)); |
| |
| // ** MERGE ** |
| Diff edge = Iterables.find(comparison.getDifferences(), edgeFlow); |
| getMergerRegistry().getHighestRankingMerger(edge).copyLeftToRight(edge, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| //FIXME: InformationFlow.informationSource and InformationFlow.informationTarget are not merged => should create a UMLDiff for this DirectedRelationship (A6_FLOW_CHANGE1_NB += 2) |
| // See Bug 406405 |
| diffsChecking(comparison, A6_DIFFS_NB - A6_FLOW_EDGE_CHANGE1_NB - A6_FLOW_CHANGE1_NB - A6_NODECHANGE1_NB - A6_CLASSCHANGE1_NB, |
| new ExpectedStat(substitutions, 2), |
| new ExpectedStat(interfaceRealizations, 1), |
| new ExpectedStat(associations, 2), |
| new ExpectedStat(and(dependencies, not(substitutions), not(interfaceRealizations)), 8), |
| new ExpectedStat(nodes, 1), // ** -1 |
| new ExpectedStat(edgeAbstraction, 2), |
| new ExpectedStat(edgeAssociation, 2), |
| new ExpectedStat(edgeDependency, 2), |
| new ExpectedStat(edgeImport, 2), |
| new ExpectedStat(edgeGeneralization, 2), |
| new ExpectedStat(edgeFlow, 1), // ** -1 |
| new ExpectedStat(edgeInterfaceRealization, 1), |
| new ExpectedStat(edgeRealization, 2), |
| new ExpectedStat(edgeSubstitution, 2), |
| new ExpectedStat(edgeUsage, 2)); |
| } |
| |
| @Test |
| // Merge Left to Right <ADD InterfaceRealization Edge> |
| public void testA6g() throws IOException { |
| final Resource left = input.getA6EdgeChangeLeft(); |
| final Resource right = input.getA6EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> substitutions = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.SUBSTITUTION), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> interfaceRealizations = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.INTERFACE_REALIZATION), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> associations = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> dependencies = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.DEPENDENCY), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> nodes = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edges = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edgeAbstraction = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ABSTRACTION)); |
| Predicate<Diff> edgeAssociation = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ASSOCIATION)); |
| Predicate<Diff> edgeDependency = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.DEPENDENCY)); |
| Predicate<Diff> edgeImport = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ELEMENT_IMPORT)); |
| Predicate<Diff> edgeGeneralization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.GENERALIZATION)); |
| Predicate<Diff> edgeFlow = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.INFORMATION_FLOW)); |
| Predicate<Diff> edgeInterfaceRealization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.INTERFACE_REALIZATION)); |
| Predicate<Diff> edgeRealization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.REALIZATION)); |
| Predicate<Diff> edgeSubstitution = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.SUBSTITUTION)); |
| Predicate<Diff> edgeUsage = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.USAGE)); |
| |
| diffsChecking(comparison, A6_DIFFS_NB, |
| new ExpectedStat(substitutions, 2), |
| new ExpectedStat(interfaceRealizations, 1), |
| new ExpectedStat(associations, 2), |
| new ExpectedStat(and(dependencies, not(substitutions), not(interfaceRealizations)), 8), // 2 abstractions + 2 dependencies + 2 realizations + 2 usages. |
| new ExpectedStat(nodes, 2), |
| new ExpectedStat(edges, 19), // 13 + 2 imports + 2 generalizations + 2 information flows (no UMLDiff for them). Details below: |
| new ExpectedStat(edgeAbstraction, 2), |
| new ExpectedStat(edgeAssociation, 2), |
| new ExpectedStat(edgeDependency, 2), |
| new ExpectedStat(edgeImport, 2), |
| new ExpectedStat(edgeGeneralization, 2), |
| new ExpectedStat(edgeFlow, 2), |
| new ExpectedStat(edgeInterfaceRealization, 1), |
| new ExpectedStat(edgeRealization, 2), |
| new ExpectedStat(edgeSubstitution, 2), |
| new ExpectedStat(edgeUsage, 2)); |
| |
| // ** MERGE ** |
| Diff edge = Iterables.find(comparison.getDifferences(), edgeInterfaceRealization); |
| getMergerRegistry().getHighestRankingMerger(edge).copyLeftToRight(edge, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A6_DIFFS_NB - A6_DEPENDENCY_EDGE_CHANGE1_NB - A6_IREAL_CHANGE1_NB - A6_NODECHANGE1_NB - A6_CLASSCHANGE1_NB, |
| new ExpectedStat(substitutions, 2), |
| new ExpectedStat(interfaceRealizations, 0), // ** -1 |
| new ExpectedStat(associations, 2), |
| new ExpectedStat(and(dependencies, not(substitutions), not(interfaceRealizations)), 8), |
| new ExpectedStat(nodes, 1), // ** -1 |
| new ExpectedStat(edgeAbstraction, 2), |
| new ExpectedStat(edgeAssociation, 2), |
| new ExpectedStat(edgeDependency, 2), |
| new ExpectedStat(edgeImport, 2), |
| new ExpectedStat(edgeGeneralization, 2), |
| new ExpectedStat(edgeFlow, 2), |
| new ExpectedStat(edgeInterfaceRealization, 0),// ** -1 |
| new ExpectedStat(edgeRealization, 2), |
| new ExpectedStat(edgeSubstitution, 2), |
| new ExpectedStat(edgeUsage, 2)); |
| } |
| |
| @Test |
| // Merge Left to Right <ADD Realization Edge> |
| public void testA6h() throws IOException { |
| final Resource left = input.getA6EdgeChangeLeft(); |
| final Resource right = input.getA6EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> substitutions = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.SUBSTITUTION), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> interfaceRealizations = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.INTERFACE_REALIZATION), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> associations = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> dependencies = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.DEPENDENCY), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> nodes = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edges = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edgeAbstraction = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ABSTRACTION)); |
| Predicate<Diff> edgeAssociation = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ASSOCIATION)); |
| Predicate<Diff> edgeDependency = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.DEPENDENCY)); |
| Predicate<Diff> edgeImport = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ELEMENT_IMPORT)); |
| Predicate<Diff> edgeGeneralization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.GENERALIZATION)); |
| Predicate<Diff> edgeFlow = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.INFORMATION_FLOW)); |
| Predicate<Diff> edgeInterfaceRealization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.INTERFACE_REALIZATION)); |
| Predicate<Diff> edgeRealization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.REALIZATION)); |
| Predicate<Diff> edgeSubstitution = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.SUBSTITUTION)); |
| Predicate<Diff> edgeUsage = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.USAGE)); |
| |
| diffsChecking(comparison, A6_DIFFS_NB, |
| new ExpectedStat(substitutions, 2), |
| new ExpectedStat(interfaceRealizations, 1), |
| new ExpectedStat(associations, 2), |
| new ExpectedStat(and(dependencies, not(substitutions), not(interfaceRealizations)), 8), // 2 abstractions + 2 dependencies + 2 realizations + 2 usages. |
| new ExpectedStat(nodes, 2), |
| new ExpectedStat(edges, 19), // 13 + 2 imports + 2 generalizations + 2 information flows (no UMLDiff for them). Details below: |
| new ExpectedStat(edgeAbstraction, 2), |
| new ExpectedStat(edgeAssociation, 2), |
| new ExpectedStat(edgeDependency, 2), |
| new ExpectedStat(edgeImport, 2), |
| new ExpectedStat(edgeGeneralization, 2), |
| new ExpectedStat(edgeFlow, 2), |
| new ExpectedStat(edgeInterfaceRealization, 1), |
| new ExpectedStat(edgeRealization, 2), |
| new ExpectedStat(edgeSubstitution, 2), |
| new ExpectedStat(edgeUsage, 2)); |
| |
| // ** MERGE ** |
| Diff edge = Iterables.find(comparison.getDifferences(), edgeRealization); |
| getMergerRegistry().getHighestRankingMerger(edge).copyLeftToRight(edge, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A6_DIFFS_NB - A6_DEPENDENCY_EDGE_CHANGE1_NB - A6_DEPENDENCY_CHANGE1_NB - A6_NODECHANGE1_NB - A6_CLASSCHANGE1_NB, |
| new ExpectedStat(substitutions, 2), |
| new ExpectedStat(interfaceRealizations, 1), |
| new ExpectedStat(associations, 2), |
| new ExpectedStat(and(dependencies, not(substitutions), not(interfaceRealizations)), 7), // ** -1 |
| new ExpectedStat(nodes, 1), // ** -1 |
| new ExpectedStat(edgeAbstraction, 2), |
| new ExpectedStat(edgeAssociation, 2), |
| new ExpectedStat(edgeDependency, 2), |
| new ExpectedStat(edgeImport, 2), |
| new ExpectedStat(edgeGeneralization, 2), |
| new ExpectedStat(edgeFlow, 2), |
| new ExpectedStat(edgeInterfaceRealization, 1), |
| new ExpectedStat(edgeRealization, 1), // ** -1 |
| new ExpectedStat(edgeSubstitution, 2), |
| new ExpectedStat(edgeUsage, 2)); |
| } |
| |
| @Test |
| // Merge Left to Right <ADD Substitution Edge> |
| public void testA6i() throws IOException { |
| final Resource left = input.getA6EdgeChangeLeft(); |
| final Resource right = input.getA6EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> substitutions = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.SUBSTITUTION), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> interfaceRealizations = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.INTERFACE_REALIZATION), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> associations = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> dependencies = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.DEPENDENCY), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> nodes = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edges = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edgeAbstraction = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ABSTRACTION)); |
| Predicate<Diff> edgeAssociation = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ASSOCIATION)); |
| Predicate<Diff> edgeDependency = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.DEPENDENCY)); |
| Predicate<Diff> edgeImport = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ELEMENT_IMPORT)); |
| Predicate<Diff> edgeGeneralization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.GENERALIZATION)); |
| Predicate<Diff> edgeFlow = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.INFORMATION_FLOW)); |
| Predicate<Diff> edgeInterfaceRealization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.INTERFACE_REALIZATION)); |
| Predicate<Diff> edgeRealization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.REALIZATION)); |
| Predicate<Diff> edgeSubstitution = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.SUBSTITUTION)); |
| Predicate<Diff> edgeUsage = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.USAGE)); |
| |
| diffsChecking(comparison, A6_DIFFS_NB, |
| new ExpectedStat(substitutions, 2), |
| new ExpectedStat(interfaceRealizations, 1), |
| new ExpectedStat(associations, 2), |
| new ExpectedStat(and(dependencies, not(substitutions), not(interfaceRealizations)), 8), // 2 abstractions + 2 dependencies + 2 realizations + 2 usages. |
| new ExpectedStat(nodes, 2), |
| new ExpectedStat(edges, 19), // 13 + 2 imports + 2 generalizations + 2 information flows (no UMLDiff for them). Details below: |
| new ExpectedStat(edgeAbstraction, 2), |
| new ExpectedStat(edgeAssociation, 2), |
| new ExpectedStat(edgeDependency, 2), |
| new ExpectedStat(edgeImport, 2), |
| new ExpectedStat(edgeGeneralization, 2), |
| new ExpectedStat(edgeFlow, 2), |
| new ExpectedStat(edgeInterfaceRealization, 1), |
| new ExpectedStat(edgeRealization, 2), |
| new ExpectedStat(edgeSubstitution, 2), |
| new ExpectedStat(edgeUsage, 2)); |
| |
| // ** MERGE ** |
| Diff edge = Iterables.find(comparison.getDifferences(), edgeSubstitution); |
| getMergerRegistry().getHighestRankingMerger(edge).copyLeftToRight(edge, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A6_DIFFS_NB - A6_DEPENDENCY_EDGE_CHANGE1_NB - A6_SUBSTITUTION_CHANGE1_NB - A6_NODECHANGE1_NB - A6_CLASSCHANGE1_NB, |
| new ExpectedStat(substitutions, 1), // ** -1 |
| new ExpectedStat(interfaceRealizations, 1), |
| new ExpectedStat(associations, 2), |
| new ExpectedStat(and(dependencies, not(substitutions), not(interfaceRealizations)), 8), |
| new ExpectedStat(nodes, 1), // ** -1 |
| new ExpectedStat(edgeAbstraction, 2), |
| new ExpectedStat(edgeAssociation, 2), |
| new ExpectedStat(edgeDependency, 2), |
| new ExpectedStat(edgeImport, 2), |
| new ExpectedStat(edgeGeneralization, 2), |
| new ExpectedStat(edgeFlow, 2), |
| new ExpectedStat(edgeInterfaceRealization, 1), |
| new ExpectedStat(edgeRealization, 2), |
| new ExpectedStat(edgeSubstitution, 1), // ** -1 |
| new ExpectedStat(edgeUsage, 2)); |
| } |
| |
| @Test |
| // Merge Left to Right <ADD Usage Edge> |
| public void testA6j() throws IOException { |
| final Resource left = input.getA6EdgeChangeLeft(); |
| final Resource right = input.getA6EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> substitutions = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.SUBSTITUTION), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> interfaceRealizations = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.INTERFACE_REALIZATION), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> associations = and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> dependencies = and(instanceOf(DirectedRelationshipChange.class), discriminantInstanceOf(UMLPackage.Literals.DEPENDENCY), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> nodes = and(instanceOf(NodeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edges = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD)); |
| Predicate<Diff> edgeAbstraction = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ABSTRACTION)); |
| Predicate<Diff> edgeAssociation = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ASSOCIATION)); |
| Predicate<Diff> edgeDependency = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.DEPENDENCY)); |
| Predicate<Diff> edgeImport = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.ELEMENT_IMPORT)); |
| Predicate<Diff> edgeGeneralization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.GENERALIZATION)); |
| Predicate<Diff> edgeFlow = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.INFORMATION_FLOW)); |
| Predicate<Diff> edgeInterfaceRealization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.INTERFACE_REALIZATION)); |
| Predicate<Diff> edgeRealization = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.REALIZATION)); |
| Predicate<Diff> edgeSubstitution = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.SUBSTITUTION)); |
| Predicate<Diff> edgeUsage = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.ADD), elementClassIs(UMLPackage.Literals.USAGE)); |
| |
| diffsChecking(comparison, A6_DIFFS_NB, |
| new ExpectedStat(substitutions, 2), |
| new ExpectedStat(interfaceRealizations, 1), |
| new ExpectedStat(associations, 2), |
| new ExpectedStat(and(dependencies, not(substitutions), not(interfaceRealizations)), 8), // 2 abstractions + 2 dependencies + 2 realizations + 2 usages. |
| new ExpectedStat(nodes, 2), |
| new ExpectedStat(edges, 19), // 13 + 2 imports + 2 generalizations + 2 information flows (no UMLDiff for them). Details below: |
| new ExpectedStat(edgeAbstraction, 2), |
| new ExpectedStat(edgeAssociation, 2), |
| new ExpectedStat(edgeDependency, 2), |
| new ExpectedStat(edgeImport, 2), |
| new ExpectedStat(edgeGeneralization, 2), |
| new ExpectedStat(edgeFlow, 2), |
| new ExpectedStat(edgeInterfaceRealization, 1), |
| new ExpectedStat(edgeRealization, 2), |
| new ExpectedStat(edgeSubstitution, 2), |
| new ExpectedStat(edgeUsage, 2)); |
| |
| // ** MERGE ** |
| Diff edge = Iterables.find(comparison.getDifferences(), edgeUsage); |
| getMergerRegistry().getHighestRankingMerger(edge).copyLeftToRight(edge, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A6_DIFFS_NB - A6_DEPENDENCY_EDGE_CHANGE1_NB - A6_DEPENDENCY_CHANGE1_NB - A6_NODECHANGE1_NB - A6_CLASSCHANGE1_NB, |
| new ExpectedStat(substitutions, 2), |
| new ExpectedStat(interfaceRealizations, 1), |
| new ExpectedStat(associations, 2), |
| new ExpectedStat(and(dependencies, not(substitutions), not(interfaceRealizations)), 7), // ** -1 |
| new ExpectedStat(nodes, 1), // ** -1 |
| new ExpectedStat(edgeAbstraction, 2), |
| new ExpectedStat(edgeAssociation, 2), |
| new ExpectedStat(edgeDependency, 2), |
| new ExpectedStat(edgeImport, 2), |
| new ExpectedStat(edgeGeneralization, 2), |
| new ExpectedStat(edgeFlow, 2), |
| new ExpectedStat(edgeInterfaceRealization, 1), |
| new ExpectedStat(edgeRealization, 2), |
| new ExpectedStat(edgeSubstitution, 2), |
| new ExpectedStat(edgeUsage, 1)); // ** -1 |
| } |
| |
| @Test |
| // Merge Left to Right <CHANGE Edge1> |
| public void testA7a() throws IOException { |
| final Resource left = input.getA7EdgeChangeLeft(); |
| final Resource right = input.getA7EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> edges = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.CHANGE)); |
| Predicate<Diff> edge1 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.CHANGE), elementNameIs("a_b_1")); |
| Predicate<Diff> edge2 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.CHANGE), elementNameIs("a_b_2")); |
| Predicate<Diff> edge3 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.CHANGE), elementNameIs("a_b_3")); |
| Predicate<Diff> edgeTarget = and(instanceOf(ReferenceChange.class), ofKind(DifferenceKind.CHANGE), valueIs(NotationPackage.Literals.SHAPE)); |
| Predicate<Diff> assoTarget = and(instanceOf(ReferenceChange.class), ofKind(DifferenceKind.CHANGE), valueIs(UMLPackage.Literals.CLASS)); |
| |
| diffsChecking(comparison, A7_DIFFS_NB, |
| new ExpectedStat(edges, 3), |
| new ExpectedStat(edgeTarget, 1), |
| new ExpectedStat(assoTarget, 1)); |
| |
| // ** MERGE ** |
| Diff edge = Iterables.find(comparison.getDifferences(), edge1); |
| getMergerRegistry().getHighestRankingMerger(edge).copyLeftToRight(edge, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A7_DIFFS_NB - A7_EDGECHANGE1_NB, |
| new ExpectedStat(edges, 2), // ** -1 |
| new ExpectedStat(edgeTarget, 1), |
| new ExpectedStat(assoTarget, 1)); |
| } |
| |
| @Test |
| // Merge Left to Right <CHANGE Edge2> |
| public void testA7b() throws IOException { |
| final Resource left = input.getA7EdgeChangeLeft(); |
| final Resource right = input.getA7EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> edges = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.CHANGE)); |
| Predicate<Diff> edge1 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.CHANGE), elementNameIs("a_b_1")); |
| Predicate<Diff> edge2 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.CHANGE), elementNameIs("a_b_2")); |
| Predicate<Diff> edge3 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.CHANGE), elementNameIs("a_b_3")); |
| Predicate<Diff> edgeTarget = and(instanceOf(ReferenceChange.class), ofKind(DifferenceKind.CHANGE), valueIs(NotationPackage.Literals.SHAPE)); |
| Predicate<Diff> assoTarget = and(instanceOf(ReferenceChange.class), ofKind(DifferenceKind.CHANGE), valueIs(UMLPackage.Literals.CLASS)); |
| |
| diffsChecking(comparison, A7_DIFFS_NB, |
| new ExpectedStat(edges, 3), |
| new ExpectedStat(edgeTarget, 1), |
| new ExpectedStat(assoTarget, 1)); |
| |
| // ** MERGE ** |
| Diff edge = Iterables.find(comparison.getDifferences(), edge2); |
| getMergerRegistry().getHighestRankingMerger(edge).copyLeftToRight(edge, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A7_DIFFS_NB - A7_EDGECHANGE1_NB, |
| new ExpectedStat(edges, 2), // ** -1 |
| new ExpectedStat(edgeTarget, 1), |
| new ExpectedStat(assoTarget, 1)); |
| } |
| |
| @Test |
| // Merge Left to Right <CHANGE Edge3> |
| public void testA7c() throws IOException { |
| final Resource left = input.getA7EdgeChangeLeft(); |
| final Resource right = input.getA7EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> edges = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.CHANGE)); |
| Predicate<Diff> edge1 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.CHANGE), elementNameIs("a_b_1")); |
| Predicate<Diff> edge2 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.CHANGE), elementNameIs("a_b_2")); |
| Predicate<Diff> edge3 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.CHANGE), elementNameIs("a_b_3")); |
| Predicate<Diff> edgeTarget = and(instanceOf(ReferenceChange.class), ofKind(DifferenceKind.CHANGE), valueIs(NotationPackage.Literals.SHAPE)); |
| Predicate<Diff> assoTarget = and(instanceOf(ReferenceChange.class), ofKind(DifferenceKind.CHANGE), valueIs(UMLPackage.Literals.CLASS)); |
| |
| diffsChecking(comparison, A7_DIFFS_NB, |
| new ExpectedStat(edges, 3), |
| new ExpectedStat(edgeTarget, 1), |
| new ExpectedStat(assoTarget, 1)); |
| |
| // ** MERGE ** |
| Diff edge = Iterables.find(comparison.getDifferences(), edge3); |
| getMergerRegistry().getHighestRankingMerger(edge).copyLeftToRight(edge, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A7_DIFFS_NB - A7_EDGECHANGE1_NB, |
| new ExpectedStat(edges, 2), // ** -1 |
| new ExpectedStat(edgeTarget, 1), |
| new ExpectedStat(assoTarget, 1)); |
| } |
| |
| @Test |
| // Merge Left to Right <CHANGE EdgeTarget> |
| public void testA7d() throws IOException { |
| final Resource left = input.getA7EdgeChangeLeft(); |
| final Resource right = input.getA7EdgeChangeRight(); |
| |
| Comparison comparison = buildComparison(left, right); |
| |
| // ** DIFF CHECKING ** |
| Predicate<Diff> edges = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.CHANGE)); |
| Predicate<Diff> edge1 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.CHANGE), elementNameIs("a_b_1")); |
| Predicate<Diff> edge2 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.CHANGE), elementNameIs("a_b_2")); |
| Predicate<Diff> edge3 = and(instanceOf(EdgeChange.class), ofKind(DifferenceKind.CHANGE), elementNameIs("a_b_3")); |
| Predicate<Diff> edgeTarget = and(instanceOf(ReferenceChange.class), ofKind(DifferenceKind.CHANGE), valueIs(NotationPackage.Literals.SHAPE)); |
| Predicate<Diff> assoTarget = and(instanceOf(ReferenceChange.class), ofKind(DifferenceKind.CHANGE), valueIs(UMLPackage.Literals.CLASS)); |
| |
| diffsChecking(comparison, A7_DIFFS_NB, |
| new ExpectedStat(edges, 3), |
| new ExpectedStat(edgeTarget, 1), |
| new ExpectedStat(assoTarget, 1)); |
| |
| // ** MERGE ** |
| Diff edge = Iterables.find(comparison.getDifferences(), edgeTarget); |
| getMergerRegistry().getHighestRankingMerger(edge).copyLeftToRight(edge, new BasicMonitor()); |
| |
| // ** MERGE CHECKING ** |
| comparison = buildComparison(left, right); |
| diffsChecking(comparison, A7_DIFFS_NB - A7_EDGE_TARGET_CHANGE_NB, |
| new ExpectedStat(edges, 3), |
| new ExpectedStat(edgeTarget, 0), // ** -1 |
| new ExpectedStat(assoTarget, 1)); |
| } |
| |
| @Override |
| protected DiagramInputData getInput() { |
| return input; |
| } |
| |
| @Override |
| protected void registerPostProcessors() { |
| super.registerPostProcessors(); |
| getPostProcessorRegistry() |
| .put(MultiplicityElementChangePostProcessor.class.getName(), |
| new TestPostProcessor.TestPostProcessorDescriptor( |
| Pattern.compile("http://www.eclipse.org/uml2/\\d\\.0\\.0/UML"), |
| null, |
| new MultiplicityElementChangePostProcessor(), |
| 25)); |
| } |
| |
| } |
