Java Diff类代码示例

import org.eclipse.emf.compare.Diff; //导入依赖的package包/类
/**
 * Tells if there is a difference in the given {@link Match} for the given {@link EStructuralFeature}.
 * 
 * @param match
 *            the {@link Match}
 * @param feature
 *            the {@link EStructuralFeature}
 * @return <code>true</code> if there is a difference in the given {@link Match} for the given
 *         {@link EStructuralFeature}, <code>false</code> otherwise
 */
protected boolean hasDiffForFeature(Match match, EStructuralFeature feature) {
	boolean res = false;

	for (Diff diff : match.getDifferences()) {
		if (diff instanceof AttributeChange) {
			if (((AttributeChange)diff).getAttribute() == feature) {
				res = true;
				break;
			}
		} else if (diff instanceof ReferenceChange) {
			if (((ReferenceChange)diff).getReference() == feature) {
				res = true;
				break;
			}
		}
	}

	return res;
}
 

import org.eclipse.emf.compare.Diff; //导入依赖的package包/类
@Override
public void postComparison(Comparison comparison, Monitor monitor) {
	for (Diff diff : comparison.getDifferences()) {
		if (diff instanceof EdgeChange) {
			EdgeChange edgeChange = (EdgeChange) diff;
			switch (edgeChange.getKind()) {
			case ADD:
				postProcessEdgeAddition(edgeChange);
				break;
			case DELETE:
				postProcessEdgeDeletion(edgeChange);
				break;
			default: // do nothing
			}

		}
	}
}
 

import org.eclipse.emf.compare.Diff; //导入依赖的package包/类
/**
 * In this case by default following dependencies are created:<br>
 * <br>
 * EdgeDeletion --requires-> OutgoingTransitionDeletion <-requires--
 * IncomingTransitionDeletion<br>
 * <br>
 * Needs to be changed into:<br>
 * <br>
 * EdgeDeletion --requires-> IncomingTransitionDeletion --requires->
 * OutgoingTransitionDeletion<br>
 * 
 * @param edgeChange
 */
private void postProcessEdgeAddition(EdgeChange edgeChange) {
	Set<Diff> requiredIncomingTransitionAdditions = new HashSet<Diff>();
	for (Diff requireds : edgeChange.getRequires()) {
		if (requireds instanceof ReferenceChange) {
			ReferenceChange requiredRefChange = (ReferenceChange) requireds;
			// for required changes in outgoing transition refs we also need
			// to add the corresponding change in incoming transition refs
			if (requiredRefChange.getReference() == SGraphPackage.Literals.VERTEX__OUTGOING_TRANSITIONS
					&& requiredRefChange.getKind() == DifferenceKind.ADD) {
				requiredIncomingTransitionAdditions
						.addAll(findRequiredIncomingTransitionRefChange(
								requiredRefChange, DifferenceKind.ADD));
			}
		}
	}
	edgeChange.getRequires().addAll(requiredIncomingTransitionAdditions);
}
 

import org.eclipse.emf.compare.Diff; //导入依赖的package包/类
/**
 * In this case by default following dependencies are created:<br>
 * <br>
 * EdgeDeletion <-requires-- OutgoingTransitionDeletion --requires->
 * IncomingTransitionDeletion<br>
 * <br>
 * Needs to be changed into:<br>
 * <br>
 * EdgeDeletion --requires-> OutgoingTransitionDeletion --requires->
 * IncomingTransitionDeletion<br>
 * 
 * @param edgeChange
 */
private void postProcessEdgeDeletion(EdgeChange edgeChange) {
	Set<Diff> requiredOutgoingTransitionDeletions = new HashSet<Diff>();
	for (Diff requireds : edgeChange.getRequiredBy()) {
		if (requireds instanceof ReferenceChange) {
			ReferenceChange requiredRefChange = (ReferenceChange) requireds;
			// for required changes in outgoing transition refs we also need
			// to add the corresponding change in incoming transition refs
			if (requiredRefChange.getReference() == SGraphPackage.Literals.VERTEX__OUTGOING_TRANSITIONS
					&& requiredRefChange.getKind() == DifferenceKind.DELETE) {
				requiredOutgoingTransitionDeletions.add(requiredRefChange);
			}
		}
	}
	edgeChange.getRequires().addAll(requiredOutgoingTransitionDeletions);
}
 

import org.eclipse.emf.compare.Diff; //导入依赖的package包/类
private static String prettyPrintCustom(Diff diff) {
    CompareSwitch<String> printer = new CompareSwitch<String>() {

        @Override
        public String caseReferenceChange(ReferenceChange object) {
            EObject actual = object.getMatch().getRight();
            EObject expected = object.getMatch().getLeft();
            EReference reference = object.getReference();

            if (actual != null && expected != null) {
                EObject parent = actual;
                String referenceName = String.format("%s::%s", reference.getEContainingClass().getName(),
                        object.getReference().getName());
                Object actualValue = actual.eGet(reference);
                Object expectedValue = expected.eGet(reference);

                return String.format(
                        "ReferenceChange%n\tParent: %s%n\tReference: %s%n\tExpected Value: %s%n\tActual Value: %s",
                        parent, referenceName, expectedValue, actualValue);
            }
            return defaultCase(object);
        }

    };
    return printer.doSwitch(diff);
}
 

import org.eclipse.emf.compare.Diff; //导入依赖的package包/类
protected void testRegular(String modelName, Function<Collection<Diff>, Collection<Diff>> diffProcessor)
        throws Exception {
    URI sourceModelURI = createResourceModelURI(resourcePluginId, modelName + "." + sourceFileExtension);
    URI umlModelURI = createResourceModelURI(resourcePluginId, modelName + ".uml");
    URI resultModelURI = createResourceModelURI(resourcePluginId, modelName + "." + targetFileExtension);

    ModelExtent transformationResult = runTransformation(transformationURI, sourceModelURI, umlModelURI);

    EObject expected = getRootElement(resultModelURI);
    assertEquals(1, transformationResult.getContents().size());
    EObject actual = transformationResult.getContents().get(0);
    EcoreUtil.resolveAll(getResourceSet());

    debugSerialize(expected, actual);

    assertModelEquals(expected, actual, diffProcessor);
}
 

import org.eclipse.emf.compare.Diff; //导入依赖的package包/类
/**
 * Test diffing of changed array field declarations.
 *
 * @throws Exception
 *             Identifies a failed diffing.
 */
@Test
public void testArrayFieldDeclarationDiff() throws Exception {

    TestUtil.setUp();
    File testFileA = new File(basePathA + "ArrayFieldDeclarationChange.java");
    File testFileB = new File(basePathB + "ArrayFieldDeclarationChange.java");
    ResourceSet rsA = TestUtil.loadResourceSet(Sets.newHashSet(testFileA));
    ResourceSet rsB = TestUtil.loadResourceSet(Sets.newHashSet(testFileB));

    JaMoPPDiffer differ = new JaMoPPDiffer();
    Comparison comparison = differ.doDiff(rsA, rsB, TestUtil.getDiffOptions());

    EList<Diff> differences = comparison.getDifferences();

    assertThat("1 difference should be detected", differences.size(), is(1));
    FieldChange change = (FieldChange) differences.get(0);
    assertThat("Wrong diff kind", change.getKind(), is(DifferenceKind.CHANGE));
    assertThat("Diff should be FieldChange", change, is(instanceOf(FieldChange.class)));
    Field field = change.getChangedField();
    assertThat("Wrong field name", field.getName(), is("newValueArray"));
}
 

import org.eclipse.emf.compare.Diff; //导入依赖的package包/类
/**
 * Test new field declarations to ignore field order.
 *
 * @throws Exception
 *             Identifies a failed diffing.
 */
@Test
public void testNewInTheMiddleDiff() throws Exception {

    TestUtil.setUp();
    File testFileA = new File(basePathA + "NewInTheMiddle.java");
    File testFileB = new File(basePathB + "NewInTheMiddle.java");
    ResourceSet rsLeading = TestUtil.loadResourceSet(Sets.newHashSet(testFileA));
    ResourceSet rsIntegration = TestUtil.loadResourceSet(Sets.newHashSet(testFileB));

    JaMoPPDiffer differ = new JaMoPPDiffer();
    Comparison comparison = differ.doDiff(rsLeading, rsIntegration, TestUtil.getDiffOptions());

    EList<Diff> differences = comparison.getDifferences();

    assertThat("1 difference should be detected", differences.size(), is(1));
    FieldChange change = (FieldChange) differences.get(0);
    assertThat("Diff should be FieldChange", change, is(instanceOf(FieldChange.class)));
    assertThat("Wrong diff kind", change.getKind(), is(DifferenceKind.ADD));
    Field field = change.getChangedField();
    assertThat("Wrong field name", field.getName(), is("newField"));
}
 

import org.eclipse.emf.compare.Diff; //导入依赖的package包/类
/**
 * Test new field declarations to ignore field order.
 *
 * @throws Exception
 *             Identifies a failed diffing.
 */
@Test
public void testRemovedFromTheMiddleDiff() throws Exception {

    TestUtil.setUp();
    File testFileA = new File(basePathA + "RemovedFromTheMiddle.java");
    File testFileB = new File(basePathB + "RemovedFromTheMiddle.java");
    ResourceSet rsLeading = TestUtil.loadResourceSet(Sets.newHashSet(testFileA));
    ResourceSet rsIntegration = TestUtil.loadResourceSet(Sets.newHashSet(testFileB));

    JaMoPPDiffer differ = new JaMoPPDiffer();
    Comparison comparison = differ.doDiff(rsLeading, rsIntegration, TestUtil.getDiffOptions());

    EList<Diff> differences = comparison.getDifferences();

    assertThat("1 difference should be detected", differences.size(), is(1));
    FieldChange change = (FieldChange) differences.get(0);
    assertThat("Diff should be FieldChange", change, is(instanceOf(FieldChange.class)));
    assertThat("Wrong diff kind", change.getKind(), is(DifferenceKind.DELETE));
    Field field = change.getChangedField();
    assertThat("Wrong field name", field.getName(), is("removeField"));
}
 

import org.eclipse.emf.compare.Diff; //导入依赖的package包/类
/**
 * Test primitive declarations
 *
 * @throws Exception
 *             Identifies a failed diffing.
 */
@Test
public void testPrimitivesDiff() throws Exception {

    File testFileA = new File(basePath + "a/Primitives.java");
    File testFileB = new File(basePath + "b/Primitives.java");
    ResourceSet rsA = TestUtil.loadResourceSet(Sets.newHashSet(testFileA));
    ResourceSet rsB = TestUtil.loadResourceSet(Sets.newHashSet(testFileB));

    JaMoPPDiffer differ = new JaMoPPDiffer();
    Comparison comparison = differ.doDiff(rsA, rsB, TestUtil.getDiffOptions());

    EList<Diff> differences = comparison.getDifferences();

    assertThat("Wrong number of differences", differences.size(), is(2));
}
 

import org.eclipse.emf.compare.Diff; //导入依赖的package包/类
/**
 * Test method to detect changes in the class and package declarations.
 *
 * @throws Exception
 *             Identifies a failed diffing.
 */
@Test
public void testDerivedCopyWithIgnoreImports() throws Exception {

    String basePath = "testmodels/implementation/derivedcopyimport/";
    ResourceSet setA = TestUtil.extractModel(basePath + "a");
    ResourceSet setB = TestUtil.extractModel(basePath + "b");

    StringBuilder packageMapping = new StringBuilder();

    StringBuilder classifierNormalization = new StringBuilder();
    classifierNormalization.append("*Custom");

    JaMoPPDiffer differ = new JaMoPPDiffer();

    Map<String, String> diffOptions = TestUtil.getDiffOptions();
    diffOptions.put(JaMoPPDiffer.OPTION_JAVA_PACKAGE_NORMALIZATION, packageMapping.toString());
    diffOptions.put(JaMoPPDiffer.OPTION_JAVA_CLASSIFIER_NORMALIZATION, classifierNormalization.toString());
    diffOptions.put(JaMoPPPostProcessor.OPTION_DIFF_CLEANUP_DERIVED_COPIES, "true");

    Comparison comparison = differ.doDiff(setA, setB, diffOptions);

    EList<Diff> differences = comparison.getDifferences();
    assertThat("No diff because not present imports must not be detected as deleted", differences.size(), is(0));
}
 

import org.eclipse.emf.compare.Diff; //导入依赖的package包/类
/**
 * Test that the derived method delete is not filtered if anyway.
 *
 * @throws Exception
 *             Identifies a failed diffing.
 */
@Test
public void testDerivedCopyWithChangedMethodCounterpart() throws Exception {

    String basePath = "testmodels/implementation/derivedcopymethod/";
    ResourceSet setA = TestUtil.extractModel(basePath + "a");
    ResourceSet setB = TestUtil.extractModel(basePath + "b");

    StringBuilder packageMapping = new StringBuilder();

    StringBuilder classifierNormalization = new StringBuilder();
    classifierNormalization.append("*Custom");

    JaMoPPDiffer differ = new JaMoPPDiffer();

    Map<String, String> diffOptions = TestUtil.getDiffOptions();
    diffOptions.put(JaMoPPDiffer.OPTION_JAVA_PACKAGE_NORMALIZATION, packageMapping.toString());
    diffOptions.put(JaMoPPDiffer.OPTION_JAVA_CLASSIFIER_NORMALIZATION, classifierNormalization.toString());
    diffOptions.put(JaMoPPPostProcessor.OPTION_DIFF_CLEANUP_DERIVED_COPIES, "true");
    diffOptions.put(JaMoPPPostProcessor.OPTION_DIFF_CLEANUP_DERIVED_COPIES_CLEAN_METHODS, null);

    Comparison comparison = differ.doDiff(setA, setB, diffOptions);

    EList<Diff> differences = comparison.getDifferences();
    assertThat("Wrong number of differences", differences.size(), is(3));
}
 

import org.eclipse.emf.compare.Diff; //导入依赖的package包/类
/**
 * Test that the derived method delete is not filtered if anyway.
 *
 * @throws Exception
 *             Identifies a failed diffing.
 */
@Test
public void testDerivedCopyWithIgnoreConstructor() throws Exception {

    String basePath = "testmodels/implementation/derivedcopyconstructor/";
    ResourceSet setA = TestUtil.extractModel(basePath + "a");
    ResourceSet setB = TestUtil.extractModel(basePath + "b");

    StringBuilder packageMapping = new StringBuilder();

    StringBuilder classifierNormalization = new StringBuilder();
    classifierNormalization.append("*Custom");

    JaMoPPDiffer differ = new JaMoPPDiffer();

    Map<String, String> diffOptions = TestUtil.getDiffOptions();
    diffOptions.put(JaMoPPDiffer.OPTION_JAVA_PACKAGE_NORMALIZATION, packageMapping.toString());
    diffOptions.put(JaMoPPDiffer.OPTION_JAVA_CLASSIFIER_NORMALIZATION, classifierNormalization.toString());
    diffOptions.put(JaMoPPPostProcessor.OPTION_DIFF_CLEANUP_DERIVED_COPIES, "true");

    Comparison comparison = differ.doDiff(setA, setB, diffOptions);

    EList<Diff> differences = comparison.getDifferences();
    assertThat("There should be no differences", differences.size(), is(0));
}
 

import org.eclipse.emf.compare.Diff; //导入依赖的package包/类
/**
 * Test diffing of changed array field declarations.
 * 
 * @throws Exception
 *             Identifies a failed diffing.
 */
@Test
public void testArrayAccessesDiff() throws Exception {

    File testFileA = new File(basePath + "a/ArrayAccesses.java");
    File testFileB = new File(basePath + "b/ArrayAccesses.java");
    ResourceSet rsA = TestUtil.loadResourceSet(Sets.newHashSet(testFileA));
    ResourceSet rsB = TestUtil.loadResourceSet(Sets.newHashSet(testFileB));

    JaMoPPDiffer differ = new JaMoPPDiffer();
    Comparison comparison = differ.doDiff(rsA, rsB, TestUtil.getDiffOptions());

    EList<Diff> differences = comparison.getDifferences();

    assertThat("Wrong number of differences", differences.size(), is(0));
}
 

import org.eclipse.emf.compare.Diff; //导入依赖的package包/类
/**
 * Test diffing of changed array field declarations.
 * 
 * @throws Exception
 *             Identifies a failed diffing.
 */
@Test
public void testArrayItemAccessesDiff() throws Exception {

    File testFileA = new File(basePath + "a/ArrayItemAccess.java");
    File testFileB = new File(basePath + "b/ArrayItemAccess.java");
    ResourceSet rsA = TestUtil.loadResourceSet(Sets.newHashSet(testFileA));
    ResourceSet rsB = TestUtil.loadResourceSet(Sets.newHashSet(testFileB));

    JaMoPPDiffer differ = new JaMoPPDiffer();
    Comparison comparison = differ.doDiff(rsA, rsB, TestUtil.getDiffOptions());

    EList<Diff> differences = comparison.getDifferences();

    assertThat("Wrong number of differences", differences.size(), is(1));

    StatementChange change = (StatementChange) differences.get(0);
    ExpressionStatement statement = (ExpressionStatement) change.getChangedStatement();
    AssignmentExpression exp = (AssignmentExpression) statement.getExpression();
    NewConstructorCall call = (NewConstructorCall) exp.getValue();
    StringReference stringRef = (StringReference) call.getArguments().get(0);
    assertThat(stringRef.getValue(), equalTo("3"));

}