path: root/org.eclipse.jgit.test/tst/org/eclipse/jgit/revplot/PlotCommitListTest.java

/*
 * Copyright (C) 2010, 2014 Christian Halstrick <christian.halstrick@sap.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.revplot;

import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertTrue;

import java.util.HashSet;
import java.util.Set;

import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevWalkTestCase;
import org.junit.Test;

public class PlotCommitListTest extends RevWalkTestCase {

	static class CommitListAssert {
		private PlotCommitList<PlotLane> pcl;
		private PlotCommit<PlotLane> current;
		private int nextIndex = 0;

		CommitListAssert(PlotCommitList<PlotLane> pcl) {
			this.pcl = pcl;
		}

		public CommitListAssert commit(RevCommit id) {
			assertTrue("Unexpected end of list at pos#"+nextIndex, pcl.size()>nextIndex);
			current = pcl.get(nextIndex++);
			assertEquals("Expected commit not found at pos#" + (nextIndex - 1),
					id.getId(), current.getId());
			return this;
		}

		public CommitListAssert lanePos(int pos) {
			PlotLane lane = current.getLane();
			assertEquals("Position of lane of commit #" + (nextIndex - 1)
					+ " not as expected.", pos, lane.getPosition());
			return this;
		}

		public int getLanePos() {
			return current.getLane().position;
		}

		/**
		 * Checks that the current position is valid and consumes this position.
		 *
		 * @param allowedPositions
		 * @return this
		 */
		public CommitListAssert lanePos(Set<Integer> allowedPositions) {
			PlotLane lane = current.getLane();
			@SuppressWarnings("boxing")
			boolean found = allowedPositions.remove(lane.getPosition());
			assertTrue("Position of lane of commit #" + (nextIndex - 1)
					+ " not as expected. Expecting one of: " + allowedPositions + " Actual: "+ lane.getPosition(), found);
			return this;
		}

		public CommitListAssert nrOfPassingLanes(int lanes) {
			assertEquals("Number of passing lanes of commit #"
					+ (nextIndex - 1)
					+ " not as expected.", lanes, current.passingLanes.length);
			return this;
		}

		public CommitListAssert parents(RevCommit... parents) {
			assertEquals("Number of parents of commit #" + (nextIndex - 1)
					+ " not as expected.", parents.length,
					current.getParentCount());
			for (int i = 0; i < parents.length; i++)
				assertEquals("Unexpected parent of commit #" + (nextIndex - 1),
						parents[i], current.getParent(i));
			return this;
		}

		public CommitListAssert noMoreCommits() {
			assertEquals("Unexpected size of list", nextIndex, pcl.size());
			return this;
		}
	}

	private static Set<Integer> asSet(int... numbers) {
		Set<Integer> result = new HashSet<>();
		for (int n : numbers)
			result.add(Integer.valueOf(n));
		return result;
	}

	@Test
	public void testLinear() throws Exception {
		final RevCommit a = commit();
		final RevCommit b = commit(a);
		final RevCommit c = commit(b);

		try (PlotWalk pw = new PlotWalk(db)) {
			pw.markStart(pw.lookupCommit(c.getId()));

			PlotCommitList<PlotLane> pcl = new PlotCommitList<>();
			pcl.source(pw);
			pcl.fillTo(Integer.MAX_VALUE);

			CommitListAssert test = new CommitListAssert(pcl);
			test.commit(c).lanePos(0).parents(b);
			test.commit(b).lanePos(0).parents(a);
			test.commit(a).lanePos(0).parents();
			test.noMoreCommits();
		}
	}

	@Test
	public void testMerged() throws Exception {
		final RevCommit a = commit();
		final RevCommit b = commit(a);
		final RevCommit c = commit(a);
		final RevCommit d = commit(b, c);

		try (PlotWalk pw = new PlotWalk(db)) {
			pw.markStart(pw.lookupCommit(d.getId()));

			PlotCommitList<PlotLane> pcl = new PlotCommitList<>();
			pcl.source(pw);
			pcl.fillTo(Integer.MAX_VALUE);

			CommitListAssert test = new CommitListAssert(pcl);
			test.commit(d).lanePos(0).parents(b, c);
			test.commit(c).lanePos(1).parents(a);
			test.commit(b).lanePos(0).parents(a);
			test.commit(a).lanePos(0).parents();
			test.noMoreCommits();
		}
	}

	@Test
	public void testSideBranch() throws Exception {
		final RevCommit a = commit();
		final RevCommit b = commit(a);
		final RevCommit c = commit(a);

		try (PlotWalk pw = new PlotWalk(db)) {
			pw.markStart(pw.lookupCommit(b.getId()));
			pw.markStart(pw.lookupCommit(c.getId()));

			PlotCommitList<PlotLane> pcl = new PlotCommitList<>();
			pcl.source(pw);
			pcl.fillTo(Integer.MAX_VALUE);

			Set<Integer> childPositions = asSet(0, 1);
			CommitListAssert test = new CommitListAssert(pcl);
			test.commit(c).lanePos(childPositions).parents(a);
			test.commit(b).lanePos(childPositions).parents(a);
			test.commit(a).lanePos(0).parents();
			test.noMoreCommits();
		}
	}

	@Test
	public void test2SideBranches() throws Exception {
		final RevCommit a = commit();
		final RevCommit b = commit(a);
		final RevCommit c = commit(a);
		final RevCommit d = commit(a);

		try (PlotWalk pw = new PlotWalk(db)) {
			pw.markStart(pw.lookupCommit(b.getId()));
			pw.markStart(pw.lookupCommit(c.getId()));
			pw.markStart(pw.lookupCommit(d.getId()));

			PlotCommitList<PlotLane> pcl = new PlotCommitList<>();
			pcl.source(pw);
			pcl.fillTo(Integer.MAX_VALUE);

			Set<Integer> childPositions = asSet(0, 1, 2);
			CommitListAssert test = new CommitListAssert(pcl);
			test.commit(d).lanePos(childPositions).parents(a);
			test.commit(c).lanePos(childPositions).parents(a);
			test.commit(b).lanePos(childPositions).parents(a);
			test.commit(a).lanePos(0).parents();
			test.noMoreCommits();
		}
	}

	@Test
	public void testBug300282_1() throws Exception {
		final RevCommit a = commit();
		final RevCommit b = commit(a);
		final RevCommit c = commit(a);
		final RevCommit d = commit(a);
		final RevCommit e = commit(a);
		final RevCommit f = commit(a);
		final RevCommit g = commit(f);

		try (PlotWalk pw = new PlotWalk(db)) {
			// TODO: when we add unnecessary commit's as tips (e.g. a commit
			// which is a parent of another tip) the walk will return those
			// commits twice. Find out why!
			// pw.markStart(pw.lookupCommit(a.getId()));
			pw.markStart(pw.lookupCommit(b.getId()));
			pw.markStart(pw.lookupCommit(c.getId()));
			pw.markStart(pw.lookupCommit(d.getId()));
			pw.markStart(pw.lookupCommit(e.getId()));
			// pw.markStart(pw.lookupCommit(f.getId()));
			pw.markStart(pw.lookupCommit(g.getId()));

			PlotCommitList<PlotLane> pcl = new PlotCommitList<>();
			pcl.source(pw);
			pcl.fillTo(Integer.MAX_VALUE);

			Set<Integer> childPositions = asSet(0, 1, 2, 3, 4);
			CommitListAssert test = new CommitListAssert(pcl);
			int posG = test.commit(g).lanePos(childPositions).parents(f)
					.getLanePos();
			test.commit(f).lanePos(posG).parents(a);

			test.commit(e).lanePos(childPositions).parents(a);
			test.commit(d).lanePos(childPositions).parents(a);
			test.commit(c).lanePos(childPositions).parents(a);
			test.commit(b).lanePos(childPositions).parents(a);
			test.commit(a).lanePos(0).parents();
			test.noMoreCommits();
		}
	}

	@Test
	public void testBug368927() throws Exception {
		final RevCommit a = commit();
		final RevCommit b = commit(a);
		final RevCommit c = commit(b);
		final RevCommit d = commit(b);
		final RevCommit e = commit(c);
		final RevCommit f = commit(e, d);
		final RevCommit g = commit(a);
		final RevCommit h = commit(f);
		final RevCommit i = commit(h);

		try (PlotWalk pw = new PlotWalk(db)) {
			pw.markStart(pw.lookupCommit(i.getId()));
			pw.markStart(pw.lookupCommit(g.getId()));

			PlotCommitList<PlotLane> pcl = new PlotCommitList<>();
			pcl.source(pw);
			pcl.fillTo(Integer.MAX_VALUE);
			Set<Integer> childPositions = asSet(0, 1);
			CommitListAssert test = new CommitListAssert(pcl);
			int posI = test.commit(i).lanePos(childPositions).parents(h)
					.getLanePos();
			test.commit(h).lanePos(posI).parents(f);
			test.commit(g).lanePos(childPositions).parents(a);
			test.commit(f).lanePos(posI).parents(e, d);
			test.commit(e).lanePos(posI).parents(c);
			test.commit(d).lanePos(2).parents(b);
			test.commit(c).lanePos(posI).parents(b);
			test.commit(b).lanePos(posI).parents(a);
			test.commit(a).lanePos(0).parents();
		}
	}

	// test the history of the egit project between 9fdaf3c1 and e76ad9170f
	@Test
	public void testEgitHistory() throws Exception {
		final RevCommit merge_fix = commit();
		final RevCommit add_simple = commit(merge_fix);
		final RevCommit remove_unused = commit(merge_fix);
		final RevCommit merge_remove = commit(add_simple, remove_unused);
		final RevCommit resolve_handler = commit(merge_fix);
		final RevCommit clear_repositorycache = commit(merge_remove);
		final RevCommit add_Maven = commit(clear_repositorycache);
		final RevCommit use_remote = commit(clear_repositorycache);
		final RevCommit findToolBar_layout = commit(clear_repositorycache);
		final RevCommit merge_add_Maven = commit(findToolBar_layout, add_Maven);
		final RevCommit update_eclipse_iplog = commit(merge_add_Maven);
		final RevCommit changeset_implementation = commit(clear_repositorycache);
		final RevCommit merge_use_remote = commit(update_eclipse_iplog,
				use_remote);
		final RevCommit disable_source = commit(merge_use_remote);
		final RevCommit update_eclipse_iplog2 = commit(merge_use_remote);
		final RevCommit merge_disable_source = commit(update_eclipse_iplog2,
				disable_source);
		final RevCommit merge_changeset_implementation = commit(
				merge_disable_source, changeset_implementation);
		final RevCommit clone_operation = commit(merge_changeset_implementation);
		final RevCommit update_eclipse = commit(add_Maven);
		final RevCommit merge_resolve_handler = commit(clone_operation,
				resolve_handler);
		final RevCommit disable_comment = commit(clone_operation);
		final RevCommit merge_disable_comment = commit(merge_resolve_handler,
				disable_comment);
		final RevCommit fix_broken = commit(merge_disable_comment);
		final RevCommit add_a_clear = commit(fix_broken);
		final RevCommit merge_update_eclipse = commit(add_a_clear,
				update_eclipse);
		final RevCommit sort_roots = commit(merge_update_eclipse);
		final RevCommit fix_logged_npe = commit(merge_changeset_implementation);
		final RevCommit merge_fixed_logged_npe = commit(sort_roots,
				fix_logged_npe);

		try (PlotWalk pw = new PlotWalk(db)) {
			pw.markStart(pw.lookupCommit(merge_fixed_logged_npe.getId()));

			PlotCommitList<PlotLane> pcl = new PlotCommitList<>();
			pcl.source(pw);
			pcl.fillTo(Integer.MAX_VALUE);

			CommitListAssert test = new CommitListAssert(pcl);

			// Note: all positions of side branches are rather arbitrary, but
			// some
			// may not overlap. Testing for the positions yielded by the current
			// implementation, which was manually checked to not overlap.
			final int mainPos = 0;
			test.commit(merge_fixed_logged_npe)
					.parents(sort_roots, fix_logged_npe).lanePos(mainPos);
			test.commit(fix_logged_npe).parents(merge_changeset_implementation)
					.lanePos(1);
			test.commit(sort_roots).parents(merge_update_eclipse)
					.lanePos(mainPos);
			test.commit(merge_update_eclipse)
					.parents(add_a_clear, update_eclipse).lanePos(mainPos);
			test.commit(add_a_clear).parents(fix_broken).lanePos(mainPos);
			test.commit(fix_broken).parents(merge_disable_comment)
					.lanePos(mainPos);
			test.commit(merge_disable_comment)
					.parents(merge_resolve_handler, disable_comment)
					.lanePos(mainPos);
			test.commit(disable_comment).parents(clone_operation).lanePos(2);
			test.commit(merge_resolve_handler)
					.parents(clone_operation, resolve_handler).lanePos(mainPos);
			test.commit(update_eclipse).parents(add_Maven).lanePos(3);
			test.commit(clone_operation).parents(merge_changeset_implementation)
					.lanePos(mainPos);
			test.commit(merge_changeset_implementation)
					.parents(merge_disable_source, changeset_implementation)
					.lanePos(mainPos);
			test.commit(merge_disable_source)
					.parents(update_eclipse_iplog2, disable_source)
					.lanePos(mainPos);
			test.commit(update_eclipse_iplog2).parents(merge_use_remote)
					.lanePos(mainPos);
			test.commit(disable_source).parents(merge_use_remote).lanePos(1);
			test.commit(merge_use_remote)
					.parents(update_eclipse_iplog, use_remote).lanePos(mainPos);
			test.commit(changeset_implementation).parents(clear_repositorycache)
					.lanePos(2);
			test.commit(update_eclipse_iplog).parents(merge_add_Maven)
					.lanePos(mainPos);
			test.commit(merge_add_Maven).parents(findToolBar_layout, add_Maven)
					.lanePos(mainPos);
			test.commit(findToolBar_layout).parents(clear_repositorycache)
					.lanePos(mainPos);
			test.commit(use_remote).parents(clear_repositorycache).lanePos(1);
			test.commit(add_Maven).parents(clear_repositorycache).lanePos(3);
			test.commit(clear_repositorycache).parents(merge_remove)
					.lanePos(mainPos);
			test.commit(resolve_handler).parents(merge_fix).lanePos(4);
			test.commit(merge_remove).parents(add_simple, remove_unused)
					.lanePos(mainPos);
			test.commit(remove_unused).parents(merge_fix).lanePos(1);
			test.commit(add_simple).parents(merge_fix).lanePos(mainPos);
			test.commit(merge_fix).parents().lanePos(mainPos);
			test.noMoreCommits();
		}
	}

	// test a history where a merge commit has two time the same parent
	@Test
	public void testDuplicateParents() throws Exception {
		final RevCommit m1 = commit();
		final RevCommit m2 = commit(m1);
		final RevCommit m3 = commit(m2, m2);

		final RevCommit s1 = commit(m2);
		final RevCommit s2 = commit(s1);

		try (PlotWalk pw = new PlotWalk(db)) {
			pw.markStart(pw.lookupCommit(m3));
			pw.markStart(pw.lookupCommit(s2));
			PlotCommitList<PlotLane> pcl = new PlotCommitList<>();
			pcl.source(pw);
			pcl.fillTo(Integer.MAX_VALUE);

			CommitListAssert test = new CommitListAssert(pcl);
			test.commit(s2).nrOfPassingLanes(0);
			test.commit(s1).nrOfPassingLanes(0);
			test.commit(m3).nrOfPassingLanes(1);
			test.commit(m2).nrOfPassingLanes(0);
			test.commit(m1).nrOfPassingLanes(0);
			test.noMoreCommits();
		}
	}

	/**
	 * The graph shows the problematic original positioning. Due to this some
	 * lanes are no straight lines here, but they are with the new layout code)
	 *
	 * <pre>
	 * a5
	 * | \
	 * |  a4
	 * | /
	 * a3
	 * |
	 * |  e
	 * |    \
	 * |     |
	 * |  b3 |
	 * |  |  d
	 * |  |/
	 * | /|
	 * |/ |
	 * a2 |
	 * |  b2
	 * |    \
	 * |  c |
	 * | /  /
	 * |/ b1
	 * a1
	 * </pre>
	 *
	 * @throws Exception
	 */
	@Test
	public void testBug419359() throws Exception {
		// this may not be the exact situation of bug 419359 but it shows
		// similar behavior
		final RevCommit a1 = commit();
		final RevCommit b1 = commit();
		final RevCommit c = commit(a1);
		final RevCommit b2 = commit(b1);
		final RevCommit a2 = commit(a1);
		final RevCommit d = commit(a2);
		final RevCommit b3 = commit(b2);
		final RevCommit e = commit(d);
		final RevCommit a3 = commit(a2);
		final RevCommit a4 = commit(a3);
		final RevCommit a5 = commit(a3, a4);

		try (PlotWalk pw = new PlotWalk(db)) {
			pw.markStart(pw.lookupCommit(b3.getId()));
			pw.markStart(pw.lookupCommit(c.getId()));
			pw.markStart(pw.lookupCommit(e.getId()));
			pw.markStart(pw.lookupCommit(a5.getId()));

			PlotCommitList<PlotLane> pcl = new PlotCommitList<>();
			pcl.source(pw);
			pcl.fillTo(Integer.MAX_VALUE);

			// test that the commits b1, b2 and b3 are on the same position
			int bPos = pcl.get(9).lane.position; // b1
			assertEquals("b2 is an a different position", bPos,
					pcl.get(7).lane.position);
			assertEquals("b3 is on a different position", bPos,
					pcl.get(4).lane.position);

			// test that nothing blocks the connections between b1, b2 and b3
			assertNotEquals("b lane is blocked by c", bPos,
					pcl.get(8).lane.position);
			assertNotEquals("b lane is blocked by a2", bPos,
					pcl.get(6).lane.position);
			assertNotEquals("b lane is blocked by d", bPos,
					pcl.get(5).lane.position);
		}
	}

	/**
	 * <pre>
	 *    b3
	 * a4 |
	 * | \|
	 * |  b2
	 * a3 |
	 * | \|
	 * a2 |
	 * |  b1
	 * | /
	 * a1
	 * </pre>
	 *
	 * @throws Exception
	 */
	@Test
	public void testMultipleMerges() throws Exception {
		final RevCommit a1 = commit();
		final RevCommit b1 = commit(a1);
		final RevCommit a2 = commit(a1);
		final RevCommit a3 = commit(a2, b1);
		final RevCommit b2 = commit(b1);
		final RevCommit a4 = commit(a3, b2);
		final RevCommit b3 = commit(b2);

		try (PlotWalk pw = new PlotWalk(db)) {
			pw.markStart(pw.lookupCommit(a4));
			pw.markStart(pw.lookupCommit(b3));
			PlotCommitList<PlotLane> pcl = new PlotCommitList<>();
			pcl.source(pw);
			pcl.fillTo(Integer.MAX_VALUE);

			Set<Integer> positions = asSet(0, 1);
			CommitListAssert test = new CommitListAssert(pcl);
			int posB = test.commit(b3).lanePos(positions).getLanePos();
			int posA = test.commit(a4).lanePos(positions).getLanePos();
			test.commit(b2).lanePos(posB);
			test.commit(a3).lanePos(posA);
			test.commit(a2).lanePos(posA);
			test.commit(b1).lanePos(posB);
			test.commit(a1).lanePos(posA);
			test.noMoreCommits();
		}
	}

	/**
	 * <pre>
	 * a4
	 * |   b3
	 * a3  |
	 * | \\|
	 * |   |\\
	 * |   b2||
	 * a2  | //
	 * |   b1
	 * | /
	 * a1
	 * </pre>
	 *
	 * @throws Exception
	 */
	@Test
	public void testMergeBlockedBySelf() throws Exception {
		final RevCommit a1 = commit();
		final RevCommit b1 = commit(a1);
		final RevCommit a2 = commit(a1);
		final RevCommit b2 = commit(b1); // blocks merging arc
		final RevCommit a3 = commit(a2, b1);
		final RevCommit b3 = commit(b2);
		final RevCommit a4 = commit(a3);

		try (PlotWalk pw = new PlotWalk(db)) {
			pw.markStart(pw.lookupCommit(a4));
			pw.markStart(pw.lookupCommit(b3));
			PlotCommitList<PlotLane> pcl = new PlotCommitList<>();
			pcl.source(pw);
			pcl.fillTo(Integer.MAX_VALUE);

			Set<Integer> positions = asSet(0, 1);
			CommitListAssert test = new CommitListAssert(pcl);
			int posA = test.commit(a4).lanePos(positions).getLanePos();
			int posB = test.commit(b3).lanePos(positions).getLanePos();
			test.commit(a3).lanePos(posA);
			test.commit(b2).lanePos(posB);
			test.commit(a2).lanePos(posA);
			// b1 is not repositioned, uses "detour lane"
			// (drawn as a double arc in the ascii graph above)
			test.commit(b1).lanePos(posB);
			test.commit(a1).lanePos(posA);
			test.noMoreCommits();
		}
	}

	/**
	 * <pre>
	 *      b2
	 * a4   |
	 * |  \ |
	 * a3  \|
	 * | \  |
	 * |  c |
	 * | /  |
	 * a2   |
	 * |    b1
	 *     /
	 * |  /
	 * a1
	 * </pre>
	 *
	 * @throws Exception
	 */
	@Test
	public void testMergeBlockedByOther() throws Exception {
		final RevCommit a1 = commit();
		final RevCommit b1 = commit(a1);
		final RevCommit a2 = commit(a1);
		final RevCommit c = commit(a2);// blocks merging arc
		final RevCommit a3 = commit(a2, c);
		final RevCommit a4 = commit(a3, b1);
		final RevCommit b2 = commit(b1);

		try (PlotWalk pw = new PlotWalk(db)) {
			pw.markStart(pw.lookupCommit(a4));
			pw.markStart(pw.lookupCommit(b2));
			pw.markStart(pw.lookupCommit(c));
			PlotCommitList<PlotLane> pcl = new PlotCommitList<>();
			pcl.source(pw);
			pcl.fillTo(Integer.MAX_VALUE);

			Set<Integer> positions = asSet(0, 1, 2);
			CommitListAssert test = new CommitListAssert(pcl);
			int posB = test.commit(b2).lanePos(positions).getLanePos();
			int posA = test.commit(a4).lanePos(positions).getLanePos();
			test.commit(a3).lanePos(posA);
			test.commit(c).lanePos(positions);
			test.commit(a2).lanePos(posA);
			test.commit(b1).lanePos(posB); // repositioned to go around c
			test.commit(a1).lanePos(posA);
			test.noMoreCommits();
		}
	}

	/**
	 * <pre>
	 *     b1
	 * a3  |
	 * |   |
	 * a2  |
	 * -- processing stops here --
	 * |  /
	 * a1
	 * </pre>
	 *
	 * @throws Exception
	 */
	@Test
	public void testDanglingCommitShouldContinueLane() throws Exception {
		final RevCommit a1 = commit();
		final RevCommit a2 = commit(a1);
		final RevCommit a3 = commit(a2);
		final RevCommit b1 = commit(a1);

		try (PlotWalk pw = new PlotWalk(db)) {
			pw.markStart(pw.lookupCommit(a3));
			pw.markStart(pw.lookupCommit(b1));
			PlotCommitList<PlotLane> pcl = new PlotCommitList<>();
			pcl.source(pw);
			pcl.fillTo(2); // don't process a1

			Set<Integer> positions = asSet(0, 1);
			CommitListAssert test = new CommitListAssert(pcl);
			PlotLane laneB = test.commit(b1).lanePos(positions).current
					.getLane();
			int posA = test.commit(a3).lanePos(positions).getLanePos();
			test.commit(a2).lanePos(posA);
			assertArrayEquals(
					"Although the parent of b1, a1, is not processed yet, the b lane should still be drawn",
					new PlotLane[] { laneB }, test.current.passingLanes);
			test.noMoreCommits();
		}
	}

	@Test
	public void testTwoRoots1() throws Exception {
		final RevCommit a = commit();
		final RevCommit b = commit();

		try (PlotWalk pw = new PlotWalk(db)) {
			pw.markStart(pw.lookupCommit(a));
			pw.markStart(pw.lookupCommit(b));
			PlotCommitList<PlotLane> pcl = new PlotCommitList<>();
			pcl.source(pw);
			pcl.fillTo(Integer.MAX_VALUE);

			CommitListAssert test = new CommitListAssert(pcl);
			test.commit(b).lanePos(0);
			test.commit(a).lanePos(0);
			test.noMoreCommits();
		}
	}

	@Test
	public void testTwoRoots2() throws Exception {
		final RevCommit a = commit();
		final RevCommit b1 = commit();
		final RevCommit b2 = commit(b1);

		try (PlotWalk pw = new PlotWalk(db)) {
			pw.markStart(pw.lookupCommit(a));
			pw.markStart(pw.lookupCommit(b2));
			PlotCommitList<PlotLane> pcl = new PlotCommitList<>();
			pcl.source(pw);
			pcl.fillTo(Integer.MAX_VALUE);

			CommitListAssert test = new CommitListAssert(pcl);
			test.commit(b2).lanePos(0);
			test.commit(b1).lanePos(0);
			test.commit(a).lanePos(0);
			test.noMoreCommits();
		}
	}
}