org.eclipse.jgit.test/tst/org/eclipse/jgit/revwalk/RevWalkMergedIntoTest.java

/*
 * Copyright (C) 2014, Sven Selberg <sven.selberg@sonymobile.com> and others
 *
 * 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.revwalk;

import static org.junit.Assert.assertTrue;

import java.util.List;
import java.util.stream.Collectors;
import org.eclipse.jgit.lib.Ref;
import org.junit.Test;

public class RevWalkMergedIntoTest extends RevWalkTestCase {

	@Test
	public void testOldCommitWalk() throws Exception {
		/*
		 * Sometimes a merge is performed on a machine with faulty time.
		 * This makes the traversal of the graph, when trying to find out if B
		 * is merged into T, complex since the algorithm uses the time stamps
		 * of commits to find the best route.
		 * When for example O(ld) has a very old time stamp compared to one of the
		 * commits (N(ew)) on the upper route between T and F(alse base), the route
		 * to False is deemed the better option even though the alternate route leeds
		 * to B(ase) which was the commit we were after.
		 *
		 *             o---o---o---o---N
		 *            /                 \
		 *           /   o---o---o---O---T
		 *          /   /
		 *      ---F---B
		 *
		 * This test is asserting that isMergedInto(B, T) returns true even
		 * under those circumstances.
		 */
		final int threeDaysInSecs = 3 * 24 * 60 * 60;
		final RevCommit f = commit();
		final RevCommit b = commit(f);
		final RevCommit o = commit(-threeDaysInSecs, commit(commit(commit(b))));
		final RevCommit n = commit(commit(commit(commit(commit(f)))));
		final RevCommit t = commit(n, o);
		assertTrue(rw.isMergedInto(b, t));
	}

	@Test
	public void testGetMergedInto() throws Exception {
		/*
		 *          i
		 *         / \
		 *        A   o
		 *       / \   \
		 *      o1  o2  E
		 *     / \ / \
		 *    B   C   D
		 */
		String b = "refs/heads/b";
		String c = "refs/heads/c";
		String d = "refs/heads/d";
		String e = "refs/heads/e";
		final RevCommit i = commit();
		final RevCommit a = commit(i);
		final RevCommit o1 = commit(a);
		final RevCommit o2 = commit(a);
		createBranch(commit(o1), b);
		createBranch(commit(o1, o2), c);
		createBranch(commit(o2), d);
		createBranch(commit(commit(i)), e);

		List<String>  modifiedResult = rw.getMergedInto(a, getRefs())
				.stream().map(Ref::getName).collect(Collectors.toList());

		assertTrue(modifiedResult.size() == 3);
		assertTrue(modifiedResult.contains(b));
		assertTrue(modifiedResult.contains(c));
		assertTrue(modifiedResult.contains(d));
	}

	@Test
	public void testIsMergedIntoAny() throws Exception {
		/*
		 *          i
		 *         / \
		 *        A   o
		 *       /     \
		 *      o       C
		 *     /
		 *    B
		 */
		String b = "refs/heads/b";
		String c = "refs/heads/c";
		final RevCommit i = commit();
		final RevCommit a = commit(i);
		createBranch(commit(commit(a)), b);
		createBranch(commit(commit(i)), c);

		assertTrue(rw.isMergedIntoAny(a, getRefs()));
	}

	@Test
	public void testIsMergedIntoAll() throws Exception {
		/*
		 *
		 *        A
		 *       / \
		 *      o1  o2
		 *     / \ / \
		 *    B   C   D
		 */

		String b = "refs/heads/b";
		String c = "refs/heads/c";
		String d = "refs/heads/c";
		final RevCommit a = commit();
		final RevCommit o1 = commit(a);
		final RevCommit o2 = commit(a);
		createBranch(commit(o1), b);
		createBranch(commit(o1, o2), c);
		createBranch(commit(o2), d);

		assertTrue(rw.isMergedIntoAll(a, getRefs()));
	}

	@Test
	public void testMergeIntoAnnotatedTag() throws Exception {
		/*
		 *        a
		 *        |
		 *        b
		 *       / \
		 *      c  v1 (annotated tag)
		 */
		String c = "refs/heads/c";
		String v1 = "refs/tags/v1";
		final RevCommit a = commit();
		final RevCommit b = commit(a);
		createBranch(commit(b), c);
		createBranch(tag("v1", b), v1);

		assertTrue(rw.isMergedIntoAll(a, getRefs()));
	}
}