blob: 3a8af7a00e9e6f5960dcb386f31a572460857f31 [file]
/*
* Copyright (C) 2024 Qualcomm Innovation Center, Inc.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Distribution License v. 1.0 which is available at
* https://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
package org.eclipse.jgit.merge;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.Assert.assertEquals;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import org.eclipse.jgit.diff.RawText;
import org.eclipse.jgit.diff.RawTextComparator;
import org.eclipse.jgit.lib.Constants;
import org.junit.Assume;
import org.junit.Test;
import org.junit.experimental.theories.DataPoints;
import org.junit.experimental.theories.Theories;
import org.junit.runner.RunWith;
@RunWith(Theories.class)
public class MergeAlgorithmUnionTest {
MergeFormatter fmt = new MergeFormatter();
private final boolean newlineAtEnd;
@DataPoints
public static boolean[] newlineAtEndDataPoints = { false, true };
public MergeAlgorithmUnionTest(boolean newlineAtEnd) {
this.newlineAtEnd = newlineAtEnd;
}
/**
* Check for a conflict where the second text was changed similar to the
* first one, but the second texts modification covers one more line.
*
* @throws java.io.IOException
*/
@Test
public void testTwoConflictingModifications() throws IOException {
assertEquals(t("abZZdefghij"),
merge("abcdefghij", "abZdefghij", "aZZdefghij"));
}
/**
* Test a case where we have three consecutive chunks. The first text
* modifies all three chunks. The second text modifies the first and the
* last chunk. This should be reported as one conflicting region.
*
* @throws java.io.IOException
*/
@Test
public void testOneAgainstTwoConflictingModifications() throws IOException {
assertEquals(t("aZZcZefghij"),
merge("abcdefghij", "aZZZefghij", "aZcZefghij"));
}
/**
* Test a merge where only the second text contains modifications. Expect as
* merge result the second text.
*
* @throws java.io.IOException
*/
@Test
public void testNoAgainstOneModification() throws IOException {
assertEquals(t("aZcZefghij"),
merge("abcdefghij", "abcdefghij", "aZcZefghij"));
}
/**
* Both texts contain modifications but not on the same chunks. Expect a
* non-conflict merge result.
*
* @throws java.io.IOException
*/
@Test
public void testTwoNonConflictingModifications() throws IOException {
assertEquals(t("YbZdefghij"),
merge("abcdefghij", "abZdefghij", "Ybcdefghij"));
}
/**
* Merge two complicated modifications. The merge algorithm has to extend
* and combine conflicting regions to get to the expected merge result.
*
* @throws java.io.IOException
*/
@Test
public void testTwoComplicatedModifications() throws IOException {
assertEquals(t("aZZZZfZhZjbYdYYYYiY"),
merge("abcdefghij", "aZZZZfZhZj", "abYdYYYYiY"));
}
/**
* Merge two modifications with a shared delete at the end. The underlying
* diff algorithm has to provide consistent edit results to get the expected
* merge result.
*
* @throws java.io.IOException
*/
@Test
public void testTwoModificationsWithSharedDelete() throws IOException {
assertEquals(t("Cb}n}"), merge("ab}n}n}", "ab}n}", "Cb}n}"));
}
/**
* Merge modifications with a shared insert in the middle. The underlying
* diff algorithm has to provide consistent edit results to get the expected
* merge result.
*
* @throws java.io.IOException
*/
@Test
public void testModificationsWithMiddleInsert() throws IOException {
assertEquals(t("aBcd123123uvwxPq"),
merge("abcd123uvwxpq", "aBcd123123uvwxPq", "abcd123123uvwxpq"));
}
/**
* Merge modifications with a shared delete in the middle. The underlying
* diff algorithm has to provide consistent edit results to get the expected
* merge result.
*
* @throws java.io.IOException
*/
@Test
public void testModificationsWithMiddleDelete() throws IOException {
assertEquals(t("Abz}z123Q"),
merge("abz}z}z123q", "Abz}z123Q", "abz}z123q"));
}
@Test
public void testInsertionAfterDeletion() throws IOException {
assertEquals(t("abcd"), merge("abd", "ad", "abcd"));
}
@Test
public void testInsertionBeforeDeletion() throws IOException {
assertEquals(t("acbd"), merge("abd", "ad", "acbd"));
}
/**
* Test a conflicting region at the very start of the text.
*
* @throws java.io.IOException
*/
@Test
public void testConflictAtStart() throws IOException {
assertEquals(t("ZYbcdefghij"),
merge("abcdefghij", "Zbcdefghij", "Ybcdefghij"));
}
/**
* Test a conflicting region at the very end of the text.
*
* @throws java.io.IOException
*/
@Test
public void testConflictAtEnd() throws IOException {
assertEquals(t("abcdefghiZY"),
merge("abcdefghij", "abcdefghiZ", "abcdefghiY"));
}
/**
* Check for a conflict where the second text was changed similar to the
* first one, but the second texts modification covers one more line.
*
* @throws java.io.IOException
*/
@Test
public void testSameModification() throws IOException {
assertEquals(t("abZdefghij"),
merge("abcdefghij", "abZdefghij", "abZdefghij"));
}
/**
* Check that a deleted vs. a modified line shows up as conflict (see Bug
* 328551)
*
* @throws java.io.IOException
*/
@Test
public void testDeleteVsModify() throws IOException {
assertEquals(t("abZdefghij"),
merge("abcdefghij", "abdefghij", "abZdefghij"));
}
@Test
public void testInsertVsModify() throws IOException {
assertEquals(t("abZXY"), merge("ab", "abZ", "aXY"));
}
@Test
public void testAdjacentModifications() throws IOException {
assertEquals(t("aZcbYd"), merge("abcd", "aZcd", "abYd"));
}
@Test
public void testSeparateModifications() throws IOException {
assertEquals(t("aZcYe"), merge("abcde", "aZcde", "abcYe"));
}
@Test
public void testBlankLines() throws IOException {
assertEquals(t("aZc\nYe"), merge("abc\nde", "aZc\nde", "abc\nYe"));
}
/**
* Test merging two contents which do one similar modification and one
* insertion is only done by one side, in the middle. Between modification
* and insertion is a block which is common between the two contents and the
* common base
*
* @throws java.io.IOException
*/
@Test
public void testTwoSimilarModsAndOneInsert() throws IOException {
assertEquals(t("aBcDde"), merge("abcde", "aBcde", "aBcDde"));
assertEquals(t("IAAAJCAB"), merge("iACAB", "IACAB", "IAAAJCAB"));
assertEquals(t("HIAAAJCAB"), merge("HiACAB", "HIACAB", "HIAAAJCAB"));
assertEquals(t("AGADEFHIAAAJCAB"),
merge("AGADEFHiACAB", "AGADEFHIACAB", "AGADEFHIAAAJCAB"));
}
/**
* Test merging two contents which do one similar modification and one
* insertion is only done by one side, at the end. Between modification and
* insertion is a block which is common between the two contents and the
* common base
*
* @throws java.io.IOException
*/
@Test
public void testTwoSimilarModsAndOneInsertAtEnd() throws IOException {
Assume.assumeTrue(newlineAtEnd);
assertEquals(t("IAAJ"), merge("iA", "IA", "IAAJ"));
assertEquals(t("IAJ"), merge("iA", "IA", "IAJ"));
assertEquals(t("IAAAJ"), merge("iA", "IA", "IAAAJ"));
}
@Test
public void testTwoSimilarModsAndOneInsertAtEndNoNewlineAtEnd()
throws IOException {
Assume.assumeFalse(newlineAtEnd);
assertEquals(t("IAAAJ"), merge("iA", "IA", "IAAJ"));
assertEquals(t("IAAJ"), merge("iA", "IA", "IAJ"));
assertEquals(t("IAAAAJ"), merge("iA", "IA", "IAAAJ"));
}
// Test situations where (at least) one input value is the empty text
@Test
public void testEmptyTextModifiedAgainstDeletion() throws IOException {
// NOTE: git.git merge-file appends a '\n' to the end of the file even
// when the input files do not have a newline at the end. That appears
// to be a bug in git.git.
assertEquals(t("AB"), merge("A", "AB", ""));
assertEquals(t("AB"), merge("A", "", "AB"));
}
@Test
public void testEmptyTextUnmodifiedAgainstDeletion() throws IOException {
assertEquals(t(""), merge("AB", "AB", ""));
assertEquals(t(""), merge("AB", "", "AB"));
}
@Test
public void testEmptyTextDeletionAgainstDeletion() throws IOException {
assertEquals(t(""), merge("AB", "", ""));
}
private String merge(String commonBase, String ours, String theirs)
throws IOException {
MergeAlgorithm ma = new MergeAlgorithm();
ma.setContentMergeStrategy(ContentMergeStrategy.UNION);
MergeResult<RawText> r = ma.merge(RawTextComparator.DEFAULT,
T(commonBase), T(ours), T(theirs));
ByteArrayOutputStream bo = new ByteArrayOutputStream(50);
fmt.formatMerge(bo, r, "B", "O", "T", UTF_8);
return bo.toString(UTF_8);
}
public String t(String text) {
StringBuilder r = new StringBuilder();
for (int i = 0; i < text.length(); i++) {
char c = text.charAt(i);
switch (c) {
case '<':
r.append("<<<<<<< O\n");
break;
case '=':
r.append("=======\n");
break;
case '|':
r.append("||||||| B\n");
break;
case '>':
r.append(">>>>>>> T\n");
break;
default:
r.append(c);
if (newlineAtEnd || i < text.length() - 1)
r.append('\n');
}
}
return r.toString();
}
public RawText T(String text) {
return new RawText(Constants.encode(t(text)));
}
}