/*******************************************************************************
* Copyright (c) 2014, 2015 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
* Philip Langer - extract super class AbstractGitLogicalModelTest
*******************************************************************************/
package org.eclipse.emf.compare.ide.ui.tests.unit;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.io.IOException;
import org.eclipse.core.resources.IFile;
import org.eclipse.emf.compare.Comparison;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.jgit.api.Status;
import org.junit.Test;
@SuppressWarnings("nls")
public class GitLogicalMergeTest extends AbstractGitLogicalModelTest {
/**
* Sets up the repository so that there are three commits affecting a single file.
* <ul>
* <li>initial commit : A single file "file1" contains a package P1 which contains the classes C1 and C2.
* </li>
* <li>master commit : delete C2</li>
* <li>branch commit : make C2 a super-class of C1</li>
* </ul>
* <p>
* This is both a textual and a logical conflict. We expect both kind of merges to mark the file as
* conflicting, but textual merging should corrupt the model with its conflict markers whereas logical
* merge will leave it untouched.
* </p>
*/
private void setUp001() throws Exception {
// We don't need the second resource here
file2.delete();
resource2 = null;
final EPackage root = createPackage(null, "P1");
createClass(root, "C1");
EClass class2 = createClass(root, "C2");
resource1.getContents().add(root);
save(resource1);
repository.addAllAndCommit("initial-commit");
// Branch, but stay on master
repository.createBranch(MASTER, BRANCH);
root.getEClassifiers().remove(class2);
save(resource1);
repository.addAndCommit(project, "master-commit", file1);
repository.checkoutBranch(BRANCH);
reload(resource1);
final EClass class1 = (EClass)findObject(resource1, "C1");
class2 = (EClass)findObject(resource1, "C2");
class1.getESuperTypes().add(class2);
save(resource1);
repository.addAndCommit(project, "branch-commit", file1);
repository.checkoutBranch(MASTER);
final Status status = repository.status();
assertFalse(status.hasUncommittedChanges());
// We expect one conflict, with one single diff on each side
compareBothDirectionsAndCheck(iFile1, MASTER, BRANCH, 1, 1, 1);
}
/**
* Sets up the repository so that there are three commits affecting a single file.
* <ul>
* <li>initial commit : A single file "file1" contains a package P1 which contains the classes C1 and C2.
* </li>
* <li>master commit : rename C1 into C10</li>
* <li>branch commit : make C2 a super-class of C1</li>
* </ul>
* <p>
* This is a textual conflict, but there are no logical conflict. We expect the textual merge to mark the
* file as conflicting, corrupting the model with its markers, but the logical merge should pass without
* issues.
* </p>
*
* @throws Exception
*/
private void setUp002() throws Exception {
// We don't need the second resource here
file2.delete();
resource2 = null;
final EPackage root = createPackage(null, "P1");
EClass class1 = createClass(root, "C1");
createClass(root, "C2");
resource1.getContents().add(root);
save(resource1);
repository.addAllAndCommit("initial-commit");
// Branch, but stay on master
repository.createBranch(MASTER, BRANCH);
class1.setName("C10");
save(resource1);
repository.addAndCommit(project, "master-commit", file1);
repository.checkoutBranch(BRANCH);
reload(resource1);
class1 = (EClass)findObject(resource1, "C1");
final EClass class2 = (EClass)findObject(resource1, "C2");
class1.getESuperTypes().add(class2);
save(resource1);
repository.addAndCommit(project, "branch-commit", file1);
repository.checkoutBranch(MASTER);
final Status status = repository.status();
assertFalse(status.hasUncommittedChanges());
// One diff on each side, no conflicts
compareBothDirectionsAndCheck(iFile1, MASTER, BRANCH, 0, 1, 1);
}
/**
* Sets up the repository so that there are three commits affecting a single file.
* <ul>
* <li>initial commit : A single file "file1" contains a package P1 which contains the classes C1 and C2.
* </li>
* <li>master commit : delete C2</li>
* <li>branch commit : delete C2</li>
* </ul>
* <p>
* This is a pseudo conflict at both logical and textual level, which can thus be automatically merged in
* both cases.
* </p>
*
* @throws Exception
*/
private void setUp003() throws Exception {
// We don't need the second resource here
file2.delete();
resource2 = null;
final EPackage root = createPackage(null, "P1");
createClass(root, "C1");
EClass class2 = createClass(root, "C2");
resource1.getContents().add(root);
save(resource1);
repository.addAllAndCommit("initial-commit");
// Branch, but stay on master
repository.createBranch(MASTER, BRANCH);
root.getEClassifiers().remove(class2);
save(resource1);
repository.addAndCommit(project, "master-commit", file1);
repository.checkoutBranch(BRANCH);
reload(resource1);
class2 = (EClass)findObject(resource1, "C2");
class2.getEPackage().getEClassifiers().remove(class2);
save(resource1);
repository.addAndCommit(project, "branch-commit", file1);
repository.checkoutBranch(MASTER);
final Status status = repository.status();
assertFalse(status.hasUncommittedChanges());
// One diff on each side, one pseudo conflict
compareBothDirectionsAndCheck(iFile1, MASTER, BRANCH, 1, 1, 1);
}
/**
* Sets up the repository so that there are three commits affecting two files with no links between them
* (not part of a single logical model).
* <ul>
* <li>initial commit : "file1" contains package P1 and classes C1 and C2. "file2" contains P2 containing
* C3 and C4.</li>
* <li>master commit : delete C2</li>
* <li>branch commit : make C2 a super-class of C1, delete C4</li>
* </ul>
* <p>
* This constitutes a conflict in file1, whereas the merge of file2 should end successfully.
* </p>
*
* @throws Exception
*/
private void setUp004() throws Exception {
final EPackage root1 = createPackage(null, "P1");
createClass(root1, "C1");
EClass class2 = createClass(root1, "C2");
resource1.getContents().add(root1);
final EPackage root2 = createPackage(null, "P2");
createClass(root2, "C3");
createClass(root2, "C4");
resource2.getContents().add(root2);
save(resource1, resource2);
repository.addAllAndCommit("initial-commit");
// Branch, but stay on master
repository.createBranch(MASTER, BRANCH);
root1.getEClassifiers().remove(class2);
save(resource1);
repository.addAndCommit(project, "master-commit", file1);
repository.checkoutBranch(BRANCH);
reload(resource1, resource2);
final EClass class1 = (EClass)findObject(resource1, "C1");
class2 = (EClass)findObject(resource1, "C2");
final EClass class4 = (EClass)findObject(resource2, "C4");
class1.getESuperTypes().add(class2);
class4.getEPackage().getEClassifiers().remove(class4);
save(resource1, resource2);
repository.addAndCommit(project, "branch-commit", file1, file2);
repository.checkoutBranch(MASTER);
final Status status = repository.status();
assertFalse(status.hasUncommittedChanges());
// One diff on each side, one conflict
compareBothDirectionsAndCheck(iFile1, MASTER, BRANCH, 1, 1, 1);
// one diff from the right
compareBothDirectionsAndCheck(iFile2, MASTER, BRANCH, 0, 0, 1);
}
/**
* Sets up the repository so that there are three commits affecting two files with no links between them
* (not part of a single logical model).
* <ul>
* <li>initial commit : "file1" contains package P1 and classes C1 and C2. "file2" contains P2 containing
* C3 and C4.</li>
* <li>master commit : delete C2, delete C4</li>
* <li>branch commit : make C2 a super-class of C1, make C4 a super-class of C3</li>
* </ul>
* <p>
* This constitutes a conflict in both files for both kind of merge (textual or logical).
* </p>
*
* @throws Exception
*/
private void setUp005() throws Exception {
final EPackage root1 = createPackage(null, "P1");
createClass(root1, "C1");
EClass class2 = createClass(root1, "C2");
resource1.getContents().add(root1);
final EPackage root2 = createPackage(null, "P2");
createClass(root2, "C3");
EClass class4 = createClass(root2, "C4");
resource2.getContents().add(root2);
save(resource1, resource2);
repository.addAllAndCommit("initial-commit");
// Branch, but stay on master
repository.createBranch(MASTER, BRANCH);
root1.getEClassifiers().remove(class2);
root2.getEClassifiers().remove(class4);
save(resource1, resource2);
repository.addAndCommit(project, "master-commit", file1, file2);
repository.checkoutBranch(BRANCH);
reload(resource1, resource2);
final EClass class1 = (EClass)findObject(resource1, "C1");
class2 = (EClass)findObject(resource1, "C2");
final EClass class3 = (EClass)findObject(resource2, "C3");
class4 = (EClass)findObject(resource2, "C4");
class1.getESuperTypes().add(class2);
class3.getESuperTypes().add(class4);
save(resource1, resource2);
repository.addAndCommit(project, "branch-commit", file1, file2);
repository.checkoutBranch(MASTER);
final Status status = repository.status();
assertFalse(status.hasUncommittedChanges());
// One diff on each side, one conflict
compareBothDirectionsAndCheck(iFile1, MASTER, BRANCH, 1, 1, 1);
// likewise
compareBothDirectionsAndCheck(iFile2, MASTER, BRANCH, 1, 1, 1);
}
/**
* Sets up the repository so that there are three commits affecting two files with no links between them
* (not part of a single logical model).
* <ul>
* <li>initial commit : "file1" contains package P1 and classes C1 and C2. "file2" contains P2 containing
* C3 and C4.</li>
* <li>master commit : renamed C1 into C10, rename C3 into C30</li>
* <li>branch commit : make C2 a super-class of C1, make C4 a super-class of C3</li>
* </ul>
* <p>
* This is a textual conflict in both files, but there are no logical conflicts. Textual merge will
* corrupt both models on top of being unable to finish the merge, logical merge will end successfully.
* </p>
*
* @throws Exception
*/
private void setUp006() throws Exception {
final EPackage root1 = createPackage(null, "P1");
EClass class1 = createClass(root1, "C1");
createClass(root1, "C2");
resource1.getContents().add(root1);
final EPackage root2 = createPackage(null, "P2");
EClass class3 = createClass(root2, "C3");
createClass(root2, "C4");
resource2.getContents().add(root2);
save(resource1, resource2);
repository.addAllAndCommit("initial-commit");
// Branch, but stay on master
repository.createBranch(MASTER, BRANCH);
class1.setName("C10");
class3.setName("C30");
save(resource1, resource2);
repository.addAndCommit(project, "master-commit", file1, file2);
repository.checkoutBranch(BRANCH);
reload(resource1, resource2);
class1 = (EClass)findObject(resource1, "C1");
final EClass class2 = (EClass)findObject(resource1, "C2");
class3 = (EClass)findObject(resource2, "C3");
final EClass class4 = (EClass)findObject(resource2, "C4");
class1.getESuperTypes().add(class2);
class3.getESuperTypes().add(class4);
save(resource1, resource2);
repository.addAndCommit(project, "branch-commit", file1, file2);
repository.checkoutBranch(MASTER);
final Status status = repository.status();
assertFalse(status.hasUncommittedChanges());
// One diff on each side, no conflict
compareBothDirectionsAndCheck(iFile1, MASTER, BRANCH, 0, 1, 1);
// likewise
compareBothDirectionsAndCheck(iFile2, MASTER, BRANCH, 0, 1, 1);
}
/**
* Sets up the repository so that there are three commits affecting two interlinked files (part of the
* same logical model). The files won't be part of the same logical model initially, the link will be
* created in one of the commits we'll merge.
* <ul>
* <li>initial commit : "file1" contains package P1 and classes C1 and C2. "file2" contains P2 containing
* C3 and C4.</li>
* <li>master commit : delete C3</li>
* <li>branch commit : make C3 a super-class of C1</li>
* </ul>
* <p>
* There is no textual conflict in these changes, so a textual merge will end successfully, corrupting the
* model by breaking the links between them. However, logical merging will see the conflict and should
* mark both files as conflicting, without touching either of them.
* </p>
* <p>
* This case also presents the particularity of having a "single file" locally (file1 is not linked to
* file2) whereas the model is comprised of two files in the right. This will allow us to make sure that
* we are able to resolve the logical model in such cases.
* </p>
*
* @throws Exception
*/
private void setUp007() throws Exception {
final EPackage root1 = createPackage(null, "P1");
createClass(root1, "C1");
createClass(root1, "C2");
resource1.getContents().add(root1);
final EPackage root2 = createPackage(null, "P2");
EClass class3 = createClass(root2, "C3");
createClass(root2, "C4");
resource2.getContents().add(root2);
save(resource1, resource2);
repository.addAllAndCommit("initial-commit");
// Branch, but stay on master
repository.createBranch(MASTER, BRANCH);
root2.getEClassifiers().remove(class3);
save(resource2);
repository.addAndCommit(project, "master-commit", file2);
repository.checkoutBranch(BRANCH);
reload(resource1, resource2);
final EClass class1 = (EClass)findObject(resource1, "C1");
class3 = (EClass)findObject(resource2, "C3");
class1.getESuperTypes().add(class3);
save(resource1);
repository.addAndCommit(project, "branch-commit", file1);
repository.checkoutBranch(MASTER);
final Status status = repository.status();
assertFalse(status.hasUncommittedChanges());
/*
* The files are unrelated locally, but they are part of the same logical model on the remote. We
* expect EMF Compare to detect that when starting from file1 (as the remote file1 references the
* remote file2), but not when starting from file2 (since in such a case, we have no way to discover
* the cross reference).
*/
compareBothDirectionsAndCheck(iFile1, MASTER, BRANCH, 1, 1, 1);
compareADirectionAndCheck(iFile2, MASTER, BRANCH, 0, 1, 0);
compareADirectionAndCheck(iFile2, BRANCH, MASTER, 1, 1, 1);
repository.checkoutBranch(MASTER);
}
/**
* See {@link #setUp007()} for the description of this use case, except that we reverse the changes made
* to file1 and file2 so that the "leaf" of the logical model is found before its root in the tree, making
* sure that this case will not fail to merge properly.
*
* @see #setUp007()
* @throws Exception
*/
private void setUp007_reverse() throws Exception {
final EPackage root1 = createPackage(null, "P1");
EClass class1 = createClass(root1, "C1");
createClass(root1, "C2");
resource1.getContents().add(root1);
final EPackage root2 = createPackage(null, "P2");
createClass(root2, "C3");
createClass(root2, "C4");
resource2.getContents().add(root2);
save(resource1, resource2);
repository.addAllAndCommit("initial-commit");
// Branch, but stay on master
repository.createBranch(MASTER, BRANCH);
root1.getEClassifiers().remove(class1);
save(resource1);
repository.addAndCommit(project, "master-commit", file1);
repository.checkoutBranch(BRANCH);
reload(resource1, resource2);
final EClass class3 = (EClass)findObject(resource2, "C3");
class1 = (EClass)findObject(resource1, "C1");
class3.getESuperTypes().add(class1);
save(resource2);
repository.addAndCommit(project, "branch-commit", file2);
repository.checkoutBranch(MASTER);
final Status status = repository.status();
assertFalse(status.hasUncommittedChanges());
/*
* The files are unrelated locally, but they are part of the same logical model on the remote. We
* expect EMF Compare to detect that when starting from file2 (as the remote file2 references the
* remote file1), but not when starting from file1 (since in such a case, we have no way to discover
* the cross reference).
*/
compareADirectionAndCheck(iFile1, MASTER, BRANCH, 0, 1, 0);
compareADirectionAndCheck(iFile1, BRANCH, MASTER, 1, 1, 1);
compareBothDirectionsAndCheck(iFile2, MASTER, BRANCH, 1, 1, 1);
}
/**
* Sets up the repository so that there are three commits affecting two interlinked files (part of the
* same logical model). The files will be linked together as a single logical model in all three sides of
* the comparison.
* <ul>
* <li>initial commit : "file1" contains package P1 and classes C1 and C2. "file2" contains P2 containing
* C3 and C4. C3 is a super-type of C1, linking the two files together.</li>
* <li>master commit : renamed C1 into C10</li>
* <li>branch commit : replace C3 by C4 as a super-class of C1, rename C4 into C40</li>
* </ul>
* <p>
* There is a textual conflict in the first file, none in the second. We expect the textual merge to
* corrupt the model with its textual conflict markers. There are no logical conflicts, so logical merging
* should end successfully.
* </p>
*
* @throws Exception
*/
private void setUp008() throws Exception {
final EPackage root1 = createPackage(null, "P1");
EClass class1 = createClass(root1, "C1");
createClass(root1, "C2");
resource1.getContents().add(root1);
final EPackage root2 = createPackage(null, "P2");
EClass class3 = createClass(root2, "C3");
createClass(root2, "C4");
resource2.getContents().add(root2);
class1.getESuperTypes().add(class3);
save(resource1, resource2);
repository.addAllAndCommit("initial-commit");
// Branch, but stay on master
repository.createBranch(MASTER, BRANCH);
class1.setName("C10");
save(resource1);
repository.addAndCommit(project, "master-commit", file1);
repository.checkoutBranch(BRANCH);
reload(resource1, resource2);
class1 = (EClass)findObject(resource1, "C1");
final EClass class4 = (EClass)findObject(resource2, "C4");
class1.getESuperTypes().clear();
class1.getESuperTypes().add(class4);
class4.setName("C40");
save(resource1, resource2);
repository.addAndCommit(project, "branch-commit", file1, file2);
repository.checkoutBranch(MASTER);
final Status status = repository.status();
assertFalse(status.hasUncommittedChanges());
compareBothDirectionsAndCheck(iFile1, MASTER, BRANCH, 0, 1, 3);
compareBothDirectionsAndCheck(iFile2, MASTER, BRANCH, 0, 1, 3);
}
/**
* Sets up the repository so that there are three commits affecting two interlinked files (part of the
* same logical model).
* <ul>
* <li>initial commit : "file1" contains package P1 and classes C1 and C2. "file2" contains P2 containing
* C3 and C4.</li>
* <li>master commit : renamed C1 into C10</li>
* <li>branch commit : renamed C4 into C40</li>
* </ul>
* <p>
* There is no conflict with these changes, neither textual nor logical.
* </p>
*
* @throws Exception
*/
private void setUp009() throws Exception {
final EPackage root1 = createPackage(null, "P1");
final EClass class1 = createClass(root1, "C1");
createClass(root1, "C2");
resource1.getContents().add(root1);
final EPackage root2 = createPackage(null, "P2");
final EClass class3 = createClass(root2, "C3");
createClass(root2, "C4");
resource2.getContents().add(root2);
class1.getESuperTypes().add(class3);
save(resource1, resource2);
repository.addAllAndCommit("initial-commit");
// Branch, but stay on master
repository.createBranch(MASTER, BRANCH);
class1.setName("C10");
save(resource1);
repository.addAndCommit(project, "master-commit", file1);
repository.checkoutBranch(BRANCH);
reload(resource1, resource2);
final EClass class4 = (EClass)findObject(resource2, "C4");
class4.setName("C40");
save(resource2);
repository.addAndCommit(project, "branch-commit", file2);
repository.checkoutBranch(MASTER);
final Status status = repository.status();
assertFalse(status.hasUncommittedChanges());
compareBothDirectionsAndCheck(iFile1, MASTER, BRANCH, 0, 1, 1);
compareBothDirectionsAndCheck(iFile2, MASTER, BRANCH, 0, 1, 1);
}
/*
* Try and merge textually. This has no relation with EMF Compare, but it does check that : A - the models
* were properly created by setUp001, and B - the textual merge ends up corrupting the models.
*/
@Test
public void merge001_text() throws Exception {
setUp001();
repository.mergeTextual(BRANCH);
final Status status = repository.status();
assertTrue(status.hasUncommittedChanges());
assertTrue(status.getConflicting().contains(repository.getRepoRelativePath(file1)));
try {
reload(resource1);
fail();
} catch (IOException e) {
// expected behavior : the file has been corrupted by the textual merge
}
}
/*
* Try and merge logically. There is a conflict, but contrarily to merge001_textual, we expect the model
* not to be corrupted by this attempt.
*/
@Test
public void merge001_logical() throws Exception {
setUp001();
repository.mergeLogical(BRANCH);
final Status status = repository.status();
assertTrue(status.hasUncommittedChanges());
assertTrue(status.getConflicting().contains(repository.getRepoRelativePath(file1)));
// Make sure we're still in the configuration we had on master
reload(resource1);
assertTrue(resource1.getErrors().isEmpty());
assertNotNull(findObject(resource1, "C1"));
assertNull(findObject(resource1, "C2"));
}
/*
* Try and merge textually. This has no relation with EMF Compare, but it does check that : A - the models
* were properly created by setUp002, and B - the textual merge ends up corrupting the model with a false
* conflict.
*/
@Test
public void merge002_text() throws Exception {
setUp002();
repository.mergeTextual(BRANCH);
final Status status = repository.status();
assertTrue(status.hasUncommittedChanges());
assertTrue(status.getConflicting().contains(repository.getRepoRelativePath(file1)));
try {
reload(resource1);
fail();
} catch (IOException e) {
// expected behavior : the file has been corrupted by the textual merge
}
}
/*
* Try and merge logically. The merge should end without issues, without being affected by the textual
* conflict.
*/
@Test
public void merge002_logical() throws Exception {
setUp002();
repository.mergeLogical(BRANCH);
final Status status = repository.status();
assertFalse(status.hasUncommittedChanges());
assertTrue(status.getConflicting().isEmpty());
// Make sure that the merge actually changed the model
reload(resource1);
assertTrue(resource1.getErrors().isEmpty());
final EPackage pack = (EPackage)findObject(resource1, "P1");
final EClass class1 = (EClass)findObject(resource1, "C10");
final EClass class2 = (EClass)findObject(resource1, "C2");
assertNotNull(pack);
assertNotNull(class1);
assertNotNull(class2);
assertTrue(class1.getESuperTypes().contains(class2));
assertEquals(2, pack.getEClassifiers().size());
}
/*
* Try and merge textually. This has no relation with EMF Compare, but it does check that : A - the models
* were properly created by setUp003, and B - the textual merge manages to auto-merge the pseudo-conflict
* without corrupting the model.
*/
@Test
public void merge003_text() throws Exception {
setUp003();
repository.mergeTextual(BRANCH);
final Status status = repository.status();
assertFalse(status.hasUncommittedChanges());
assertTrue(status.getConflicting().isEmpty());
reload(resource1);
assertTrue(resource1.getErrors().isEmpty());
final EPackage pack = (EPackage)findObject(resource1, "P1");
final EClass class1 = (EClass)findObject(resource1, "C1");
assertNotNull(pack);
assertNotNull(class1);
assertEquals(1, pack.getEClassifiers().size());
}
/*
* Try and merge logically. The merge should end successfully, auto-merging the pseudo-conflict as needed.
*/
@Test
public void merge003_logical() throws Exception {
setUp003();
repository.mergeLogical(BRANCH);
final Status status = repository.status();
assertFalse(status.hasUncommittedChanges());
assertTrue(status.getConflicting().isEmpty());
reload(resource1);
assertTrue(resource1.getErrors().isEmpty());
final EPackage pack = (EPackage)findObject(resource1, "P1");
final EClass class1 = (EClass)findObject(resource1, "C1");
assertNotNull(pack);
assertNotNull(class1);
assertEquals(1, pack.getEClassifiers().size());
}
/*
* Try and merge textually. This has no relation with EMF Compare, but it does check that : A - the models
* were properly created by setUp004, and B - the textual merge corrupts the model in which there was a
* conflict.
*/
@Test
public void merge004_text() throws Exception {
setUp004();
repository.mergeTextual(BRANCH);
final Status status = repository.status();
assertTrue(status.hasUncommittedChanges());
assertTrue(status.getConflicting().contains(repository.getRepoRelativePath(file1)));
assertFalse(status.getConflicting().contains(repository.getRepoRelativePath(file2)));
unload(resource1, resource2);
try {
reload(resource1);
fail();
} catch (IOException e) {
// expected behavior : the file has been corrupted by the textual merge
}
reload(resource2);
assertTrue(resource2.getErrors().isEmpty());
final EPackage pack = (EPackage)findObject(resource2, "P2");
final EClass class3 = (EClass)findObject(resource2, "C3");
assertNotNull(pack);
assertNotNull(class3);
assertEquals(1, pack.getEClassifiers().size());
}
/*
* Try and merge logically. The merge should leave file1 as conflicting, leaving it untouched as compared
* to master. file2 should be properly merged.
*/
@Test
public void merge004_logical() throws Exception {
setUp004();
repository.mergeLogical(BRANCH);
final Status status = repository.status();
assertTrue(status.hasUncommittedChanges());
assertTrue(status.getConflicting().contains(repository.getRepoRelativePath(file1)));
assertFalse(status.getConflicting().contains(repository.getRepoRelativePath(file2)));
unload(resource1, resource2);
reload(resource1);
assertTrue(resource1.getErrors().isEmpty());
assertNotNull(findObject(resource1, "C1"));
assertNull(findObject(resource1, "C2"));
reload(resource2);
assertTrue(resource2.getErrors().isEmpty());
final EPackage pack = (EPackage)findObject(resource2, "P2");
final EClass class3 = (EClass)findObject(resource2, "C3");
assertNotNull(pack);
assertNotNull(class3);
assertEquals(1, pack.getEClassifiers().size());
}
/*
* Try and merge textually. This has no relation with EMF Compare, but it does check that : A - the models
* were properly created by setUp005, and B - the textual merge corrupts the two models.
*/
@Test
public void merge005_text() throws Exception {
setUp005();
repository.mergeTextual(BRANCH);
final Status status = repository.status();
assertTrue(status.hasUncommittedChanges());
assertTrue(status.getConflicting().contains(repository.getRepoRelativePath(file1)));
assertTrue(status.getConflicting().contains(repository.getRepoRelativePath(file2)));
unload(resource1, resource2);
try {
reload(resource1);
fail();
} catch (IOException e) {
// expected behavior : the file has been corrupted by the textual merge
}
try {
reload(resource2);
fail();
} catch (IOException e) {
// expected behavior : the file has been corrupted by the textual merge
}
}
/*
* Try and merge logically. both files should be marked as conflicting, untouched as compared to master.
*/
@Test
public void merge005_logical() throws Exception {
setUp005();
repository.mergeLogical(BRANCH);
final Status status = repository.status();
assertTrue(status.hasUncommittedChanges());
assertTrue(status.getConflicting().contains(repository.getRepoRelativePath(file1)));
assertTrue(status.getConflicting().contains(repository.getRepoRelativePath(file2)));
unload(resource1, resource2);
reload(resource1);
assertTrue(resource1.getErrors().isEmpty());
assertNotNull(findObject(resource1, "C1"));
assertNull(findObject(resource1, "C2"));
reload(resource2);
assertTrue(resource2.getErrors().isEmpty());
assertNotNull(findObject(resource2, "C3"));
assertNull(findObject(resource2, "C4"));
}
/*
* Try and merge textually. This has no relation with EMF Compare, but it does check that : A - the models
* were properly created by setUp006, and B - the textual merge ends up corrupting the models with false
* conflicts.
*/
@Test
public void merge006_text() throws Exception {
setUp006();
repository.mergeTextual(BRANCH);
final Status status = repository.status();
assertTrue(status.hasUncommittedChanges());
assertTrue(status.getConflicting().contains(repository.getRepoRelativePath(file1)));
assertTrue(status.getConflicting().contains(repository.getRepoRelativePath(file2)));
unload(resource1, resource2);
try {
reload(resource1);
fail();
} catch (IOException e) {
// expected behavior : the file has been corrupted by the textual merge
}
try {
reload(resource2);
fail();
} catch (IOException e) {
// expected behavior : the file has been corrupted by the textual merge
}
}
/*
* Try and merge logically. The merge should end without issues, without being affected by the textual
* conflicts.
*/
@Test
public void merge006_logical() throws Exception {
setUp006();
repository.mergeLogical(BRANCH);
final Status status = repository.status();
assertFalse(status.hasUncommittedChanges());
assertTrue(status.getConflicting().isEmpty());
// Make sure that the merge actually changed the models
reload(resource1, resource2);
assertTrue(resource1.getErrors().isEmpty());
final EPackage pack1 = (EPackage)findObject(resource1, "P1");
final EClass class1 = (EClass)findObject(resource1, "C10");
final EClass class2 = (EClass)findObject(resource1, "C2");
assertNotNull(pack1);
assertNotNull(class1);
assertNotNull(class2);
assertTrue(class1.getESuperTypes().contains(class2));
assertEquals(2, pack1.getEClassifiers().size());
assertTrue(resource2.getErrors().isEmpty());
final EPackage pack2 = (EPackage)findObject(resource2, "P2");
final EClass class3 = (EClass)findObject(resource2, "C30");
final EClass class4 = (EClass)findObject(resource2, "C4");
assertNotNull(pack2);
assertNotNull(class3);
assertNotNull(class4);
assertTrue(class3.getESuperTypes().contains(class4));
assertEquals(2, pack2.getEClassifiers().size());
}
/*
* Try and merge textually. This has no relation with EMF Compare, but it does check that : A - the models
* were properly created by setUp007, and B - the textual merge ends up corrupting the logical model even
* though it says the merge ends successfully.
*/
@Test
public void merge007_text() throws Exception {
setUp007();
repository.mergeTextual(BRANCH);
final Status status = repository.status();
assertFalse(status.hasUncommittedChanges());
assertTrue(status.getConflicting().isEmpty());
unload(resource1, resource2);
// This one has a broken reference towards C3
reload(resource1);
assertTrue(resource1.getErrors().isEmpty());
final EClass class1 = (EClass)findObject(resource1, "C1");
final EClass superType = class1.getESuperTypes().get(0);
// the super type (what was "class C3") is a proxy
assertTrue(superType.eIsProxy());
// even though its resource has been loaded in the resource set
final Resource res2 = resource1.getResourceSet().getResource(resource2.getURI(), false);
assertNotNull(res2);
// and it is unresolveable
assertSame(superType, EcoreUtil.resolve(superType, resource1.getResourceSet()));
// But the second should be fine
reload(resource2);
final EPackage pack2 = (EPackage)findObject(resource2, "P2");
final EClass class4 = (EClass)findObject(resource2, "C4");
assertNotNull(pack2);
assertNotNull(class4);
assertEquals(1, pack2.getEClassifiers().size());
}
/*
* Try and merge logically. There is a logical conflict, so we expect both files to remain untouched and
* the conflict marked.
*/
@Test
public void merge007_logical() throws Exception {
setUp007();
repository.mergeLogical(BRANCH);
final Status status = repository.status();
assertTrue(status.hasUncommittedChanges());
assertTrue(status.getConflicting().contains(repository.getRepoRelativePath(file1)));
assertTrue(status.getConflicting().contains(repository.getRepoRelativePath(file2)));
unload(resource1, resource2);
reload(resource1);
assertTrue(resource1.getErrors().isEmpty());
final EClass class1 = (EClass)findObject(resource1, "C1");
assertNotNull(class1);
assertTrue(class1.getESuperTypes().isEmpty());
assertNotNull(findObject(resource1, "C2"));
reload(resource2);
assertTrue(resource2.getErrors().isEmpty());
assertNull(findObject(resource2, "C3"));
assertNotNull(findObject(resource2, "C4"));
}
/* This should have the reverse effect as merge007_textual. */
@Test
public void merge007_reverse_text() throws Exception {
setUp007_reverse();
repository.mergeTextual(BRANCH);
final Status status = repository.status();
assertFalse(status.hasUncommittedChanges());
assertTrue(status.getConflicting().isEmpty());
unload(resource1, resource2);
// This one should be fine
reload(resource1);
final EPackage pack1 = (EPackage)findObject(resource1, "P1");
final EClass class2 = (EClass)findObject(resource1, "C2");
assertNotNull(pack1);
assertNotNull(class2);
assertEquals(1, pack1.getEClassifiers().size());
// But the second one has a broken references towards C1
reload(resource2);
assertTrue(resource2.getErrors().isEmpty());
final EClass class3 = (EClass)findObject(resource2, "C3");
final EClass superType = class3.getESuperTypes().get(0);
// the super type (what was "class C1") is a proxy
assertTrue(superType.eIsProxy());
// even though its resource has been loaded in the resource set
final Resource res1 = resource2.getResourceSet().getResource(resource1.getURI(), false);
assertNotNull(res1);
// and it is unresolveable
assertSame(superType, EcoreUtil.resolve(superType, resource2.getResourceSet()));
}
/* This should have the exact same effect as merge007_logical. */
@Test
public void merge007_reverse_logical() throws Exception {
setUp007_reverse();
repository.mergeLogical(BRANCH);
final Status status = repository.status();
assertTrue(status.hasUncommittedChanges());
assertTrue(status.getConflicting().contains(repository.getRepoRelativePath(file1)));
assertTrue(status.getConflicting().contains(repository.getRepoRelativePath(file2)));
unload(resource1, resource2);
reload(resource1);
assertTrue(resource1.getErrors().isEmpty());
assertNull(findObject(resource1, "C1"));
assertNotNull(findObject(resource1, "C2"));
reload(resource2);
assertTrue(resource2.getErrors().isEmpty());
final EClass class3 = (EClass)findObject(resource2, "C3");
assertNotNull(class3);
assertTrue(class3.getESuperTypes().isEmpty());
assertNotNull(findObject(resource2, "C4"));
}
/*
* Try and merge textually. This has no relation with EMF Compare, but it does check that : A - the models
* were properly created by setUp008, and B - the textual merge ends up corrupting the logical model even
* though it says the merge ends successfully.
*/
@Test
public void merge008_text() throws Exception {
setUp008();
repository.mergeTextual(BRANCH);
final Status status = repository.status();
assertTrue(status.hasUncommittedChanges());
assertTrue(status.getConflicting().contains(repository.getRepoRelativePath(file1)));
unload(resource1, resource2);
try {
reload(resource1);
fail();
} catch (IOException e) {
// expected behavior : the file has been corrupted by the textual merge
}
// This file has been merged, so we should find C40 in it.
reload(resource2);
assertTrue(resource2.getErrors().isEmpty());
final EPackage pack2 = (EPackage)findObject(resource2, "P2");
assertNotNull(findObject(resource2, "C3"));
assertNotNull(findObject(resource2, "C40"));
assertEquals(2, pack2.getEClassifiers().size());
}
/*
* Try and merge logically. There is no logical conflict, so the merge should end successfully.
*/
@Test
public void merge008_logical() throws Exception {
setUp008();
repository.mergeLogical(BRANCH);
final Status status = repository.status();
assertFalse(status.hasUncommittedChanges());
assertTrue(status.getConflicting().isEmpty());
reload(resource1, resource2);
assertTrue(resource1.getErrors().isEmpty());
final EClass class1 = (EClass)findObject(resource1, "C10");
assertNotNull(class1);
assertNotNull(findObject(resource1, "C2"));
assertTrue(resource2.getErrors().isEmpty());
final EClass class4 = (EClass)findObject(resource2, "C40");
assertNotNull(findObject(resource2, "C3"));
assertNotNull(class4);
assertTrue(class1.getESuperTypes().contains(class4));
assertEquals(1, class1.getESuperTypes().size());
}
/*
* Try and merge textually. This has no relation with EMF Compare, but it does check that : A - the models
* were properly created by setUp009, and B - the textual merge wouldn't have corrupted the model in this
* case.
*/
@Test
public void merge009_text() throws Exception {
setUp009();
repository.mergeTextual(BRANCH);
final Status status = repository.status();
assertFalse(status.hasUncommittedChanges());
assertTrue(status.getConflicting().isEmpty());
reload(resource1, resource2);
assertTrue(resource1.getErrors().isEmpty());
final EPackage pack1 = (EPackage)findObject(resource1, "P1");
final EClass class1 = (EClass)findObject(resource1, "C10");
assertNotNull(class1);
assertNotNull(findObject(resource1, "C2"));
assertEquals(2, pack1.getEClassifiers().size());
assertTrue(resource2.getErrors().isEmpty());
final EPackage pack2 = (EPackage)findObject(resource2, "P2");
final EClass class3 = (EClass)findObject(resource2, "C3");
assertNotNull(class3);
assertNotNull(findObject(resource2, "C40"));
assertEquals(2, pack2.getEClassifiers().size());
assertTrue(class1.getESuperTypes().contains(class3));
assertEquals(1, class1.getESuperTypes().size());
}
/*
* Try and merge logically. There is no logical conflict, so the merge should end successfully.
*/
@Test
public void merge009_logical() throws Exception {
setUp009();
repository.mergeLogical(BRANCH);
final Status status = repository.status();
assertFalse(status.hasUncommittedChanges());
assertTrue(status.getConflicting().isEmpty());
reload(resource1, resource2);
assertTrue(resource1.getErrors().isEmpty());
final EPackage pack1 = (EPackage)findObject(resource1, "P1");
final EClass class1 = (EClass)findObject(resource1, "C10");
assertNotNull(class1);
assertNotNull(findObject(resource1, "C2"));
assertEquals(2, pack1.getEClassifiers().size());
assertTrue(resource2.getErrors().isEmpty());
final EPackage pack2 = (EPackage)findObject(resource2, "P2");
final EClass class3 = (EClass)findObject(resource2, "C3");
assertNotNull(class3);
assertNotNull(findObject(resource2, "C40"));
assertEquals(2, pack2.getEClassifiers().size());
assertTrue(class1.getESuperTypes().contains(class3));
assertEquals(1, class1.getESuperTypes().size());
}
private void compareADirectionAndCheck(IFile file, String source, String destination,
int expectedConflicts, int diffsInSource, int diffsInDestination) throws Exception {
repository.checkoutBranch(source);
Comparison compareResult = compare(source, destination, file);
assertEquals(expectedConflicts, compareResult.getConflicts().size());
assertDiffCount(compareResult.getDifferences(), diffsInSource, diffsInDestination);
}
}