| /******************************************************************************* |
| * 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); |
| } |
| } |
