/*******************************************************************************
* 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.Arrays;
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.merge.BatchMerger;
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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllRightToLeft(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllRightToLeft(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllRightToLeft(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllRightToLeft(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllRightToLeft(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllRightToLeft(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllRightToLeft(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllRightToLeft(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllRightToLeft(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllRightToLeft(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllRightToLeft(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllRightToLeft(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllRightToLeft(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllRightToLeft(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllRightToLeft(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllRightToLeft(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllRightToLeft(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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);
new BatchMerger(getMergerRegistry()).copyAllLeftToRight(Arrays.asList(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));
}
}