/*
    * Copyright (C) 2012, Robin Stocker <robin@nibor.org>
    * and other copyright owners as documented in the project's IP log.
    *
    * This program and the accompanying materials are made available
    * under the terms of the Eclipse Distribution License v1.0 which
    * accompanies this distribution, is reproduced below, and is
    * available at http://www.eclipse.org/org/documents/edl-v10.php
    *
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or
   * without modification, are permitted provided that the following
   * conditions are met:
   *
   * - Redistributions of source code must retain the above copyright
   *   notice, this list of conditions and the following disclaimer.
   *
   * - Redistributions in binary form must reproduce the above
   *   copyright notice, this list of conditions and the following
   *   disclaimer in the documentation and/or other materials provided
   *   with the distribution.
   *
   * - Neither the name of the Eclipse Foundation, Inc. nor the
   *   names of its contributors may be used to endorse or promote
   *   products derived from this software without specific prior
   *   written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
   * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
   * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
   * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  package org.eclipse.jgit.merge;
  
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertTrue;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
  
  import org.eclipse.jgit.api.Git;
  import org.eclipse.jgit.api.MergeResult;
  import org.eclipse.jgit.api.MergeResult.MergeStatus;
  import org.eclipse.jgit.api.errors.CheckoutConflictException;
  import org.eclipse.jgit.api.errors.GitAPIException;
  import org.eclipse.jgit.api.errors.JGitInternalException;
  import org.eclipse.jgit.dircache.DirCache;
  import org.eclipse.jgit.errors.NoMergeBaseException;
  import org.eclipse.jgit.errors.NoMergeBaseException.MergeBaseFailureReason;
  import org.eclipse.jgit.junit.RepositoryTestCase;
  import org.eclipse.jgit.merge.ResolveMerger.MergeFailureReason;
  import org.eclipse.jgit.revwalk.RevCommit;
  import org.eclipse.jgit.treewalk.FileTreeIterator;
  import org.eclipse.jgit.util.FS;
  import org.eclipse.jgit.util.FileUtils;
  import org.junit.Assert;
  import org.junit.experimental.theories.DataPoint;
  import org.junit.experimental.theories.Theories;
  import org.junit.experimental.theories.Theory;
  import org.junit.runner.RunWith;
  
  @RunWith(Theories.class)
  public class ResolveMergerTest extends RepositoryTestCase {
  
  	@DataPoint
  	public static MergeStrategy resolve = MergeStrategy.RESOLVE;
  
  	@DataPoint
  	public static MergeStrategy recursive = MergeStrategy.RECURSIVE;
  
  	@Theory
  	public void failingDeleteOfDirectoryWithUntrackedContent(
  			MergeStrategy strategy) throws Exception {
  		File folder1 = new File(db.getWorkTree(), "folder1");
  		FileUtils.mkdir(folder1);
  		File file = new File(folder1, "file1.txt");
  		write(file, "folder1--file1.txt");
  		file = new File(folder1, "file2.txt");
  		write(file, "folder1--file2.txt");
  
  		try (Git git = new Git(db)) {
  			git.add().addFilepattern(folder1.getName()).call();
  			RevCommit base = git.commit().setMessage("adding folder").call();
  
  			recursiveDelete(folder1);
  			git.rm().addFilepattern("folder1/file1.txt")
  					.addFilepattern("folder1/file2.txt").call();
  			RevCommit other = git.commit()
 					.setMessage("removing folders on 'other'").call();
 
 			git.checkout().setName(base.name()).call();
 
 			file = new File(db.getWorkTree(), "unrelated.txt");
 			write(file, "unrelated");
 
 			git.add().addFilepattern("unrelated.txt").call();
 			RevCommit head = git.commit().setMessage("Adding another file").call();
 
 			// Untracked file to cause failing path for delete() of folder1
 			// but that's ok.
 			file = new File(folder1, "file3.txt");
 			write(file, "folder1--file3.txt");
 
 			ResolveMerger merger = (ResolveMerger) strategy.newMerger(db, false);
 			merger.setCommitNames(new String[] { "BASE", "HEAD", "other" });
 			merger.setWorkingTreeIterator(new FileTreeIterator(db));
 			boolean ok = merger.merge(head.getId(), other.getId());
 			assertTrue(ok);
 			assertTrue(file.exists());
 		}
 	}
 
 	/**
 	 * Merging two conflicting subtrees when the index does not contain any file
 	 * in that subtree should lead to a conflicting state.
 	 *
 	 * @param strategy
 	 * @throws Exception
 	 */
 	@Theory
 	public void checkMergeConflictingTreesWithoutIndex(MergeStrategy strategy)
 			throws Exception {
 		Git git = Git.wrap(db);
 
 		writeTrashFile("d/1", "orig");
 		git.add().addFilepattern("d/1").call();
 		RevCommit first = git.commit().setMessage("added d/1").call();
 
 		writeTrashFile("d/1", "master");
 		RevCommit masterCommit = git.commit().setAll(true)
 				.setMessage("modified d/1 on master").call();
 
 		git.checkout().setCreateBranch(true).setStartPoint(first)
 				.setName("side").call();
 		writeTrashFile("d/1", "side");
 		git.commit().setAll(true).setMessage("modified d/1 on side").call();
 
 		git.rm().addFilepattern("d/1").call();
 		git.rm().addFilepattern("d").call();
 		MergeResult mergeRes = git.merge().setStrategy(strategy)
 				.include(masterCommit).call();
 		assertEquals(MergeStatus.CONFLICTING, mergeRes.getMergeStatus());
 		assertEquals(
 				"[d/1, mode:100644, stage:1, content:orig][d/1, mode:100644, stage:2, content:side][d/1, mode:100644, stage:3, content:master]",
 				indexState(CONTENT));
 	}
 
 	/**
 	 * Merging two different but mergeable subtrees when the index does not
 	 * contain any file in that subtree should lead to a merged state.
 	 *
 	 * @param strategy
 	 * @throws Exception
 	 */
 	@Theory
 	public void checkMergeMergeableTreesWithoutIndex(MergeStrategy strategy)
 			throws Exception {
 		Git git = Git.wrap(db);
 
 		writeTrashFile("d/1", "1\n2\n3");
 		git.add().addFilepattern("d/1").call();
 		RevCommit first = git.commit().setMessage("added d/1").call();
 
 		writeTrashFile("d/1", "1master\n2\n3");
 		RevCommit masterCommit = git.commit().setAll(true)
 				.setMessage("modified d/1 on master").call();
 
 		git.checkout().setCreateBranch(true).setStartPoint(first)
 				.setName("side").call();
 		writeTrashFile("d/1", "1\n2\n3side");
 		git.commit().setAll(true).setMessage("modified d/1 on side").call();
 
 		git.rm().addFilepattern("d/1").call();
 		git.rm().addFilepattern("d").call();
 		MergeResult mergeRes = git.merge().setStrategy(strategy)
 				.include(masterCommit).call();
 		assertEquals(MergeStatus.MERGED, mergeRes.getMergeStatus());
 		assertEquals("[d/1, mode:100644, content:1master\n2\n3side]",
 				indexState(CONTENT));
 	}
 
 	/**
 	 * An existing directory without tracked content should not prevent merging
 	 * a tree where that directory exists.
 	 *
 	 * @param strategy
 	 * @throws Exception
 	 */
 	@Theory
 	public void checkUntrackedFolderIsNotAConflict(
 			MergeStrategy strategy) throws Exception {
 		Git git = Git.wrap(db);
 
 		writeTrashFile("d/1", "1");
 		git.add().addFilepattern("d/1").call();
 		RevCommit first = git.commit().setMessage("added d/1").call();
 
 		writeTrashFile("e/1", "4");
 		git.add().addFilepattern("e/1").call();
 		RevCommit masterCommit = git.commit().setMessage("added e/1").call();
 
 		git.checkout().setCreateBranch(true).setStartPoint(first)
 				.setName("side").call();
 		writeTrashFile("f/1", "5");
 		git.add().addFilepattern("f/1").call();
 		git.commit().setAll(true).setMessage("added f/1")
 				.call();
 
 		// Untracked directory e shall not conflict with merged e/1
 		writeTrashFile("e/2", "d two");
 
 		MergeResult mergeRes = git.merge().setStrategy(strategy)
 				.include(masterCommit).call();
 		assertEquals(MergeStatus.MERGED, mergeRes.getMergeStatus());
 		assertEquals(
 				"[d/1, mode:100644, content:1][e/1, mode:100644, content:4][f/1, mode:100644, content:5]",
 				indexState(CONTENT));
 	}
 
 	/**
 	 * A tracked file is replaced by a folder in THEIRS.
 	 *
 	 * @param strategy
 	 * @throws Exception
 	 */
 	@Theory
 	public void checkFileReplacedByFolderInTheirs(MergeStrategy strategy)
 			throws Exception {
 		Git git = Git.wrap(db);
 
 		writeTrashFile("sub", "file");
 		git.add().addFilepattern("sub").call();
 		RevCommit first = git.commit().setMessage("initial").call();
 
 		git.checkout().setCreateBranch(true).setStartPoint(first)
 				.setName("side").call();
 
 		git.rm().addFilepattern("sub").call();
 		writeTrashFile("sub/file", "subfile");
 		git.add().addFilepattern("sub/file").call();
 		RevCommit masterCommit = git.commit().setMessage("file -> folder")
 				.call();
 
 		git.checkout().setName("master").call();
 		writeTrashFile("noop", "other");
 		git.add().addFilepattern("noop").call();
 		git.commit().setAll(true).setMessage("noop").call();
 
 		MergeResult mergeRes = git.merge().setStrategy(strategy)
 				.include(masterCommit).call();
 		assertEquals(MergeStatus.MERGED, mergeRes.getMergeStatus());
 		assertEquals(
 				"[noop, mode:100644, content:other][sub/file, mode:100644, content:subfile]",
 				indexState(CONTENT));
 	}
 
 	/**
 	 * A tracked file is replaced by a folder in OURS.
 	 *
 	 * @param strategy
 	 * @throws Exception
 	 */
 	@Theory
 	public void checkFileReplacedByFolderInOurs(MergeStrategy strategy)
 			throws Exception {
 		Git git = Git.wrap(db);
 
 		writeTrashFile("sub", "file");
 		git.add().addFilepattern("sub").call();
 		RevCommit first = git.commit().setMessage("initial").call();
 
 		git.checkout().setCreateBranch(true).setStartPoint(first)
 				.setName("side").call();
 		writeTrashFile("noop", "other");
 		git.add().addFilepattern("noop").call();
 		RevCommit sideCommit = git.commit().setAll(true).setMessage("noop")
 				.call();
 
 		git.checkout().setName("master").call();
 		git.rm().addFilepattern("sub").call();
 		writeTrashFile("sub/file", "subfile");
 		git.add().addFilepattern("sub/file").call();
 		git.commit().setMessage("file -> folder")
 				.call();
 
 		MergeResult mergeRes = git.merge().setStrategy(strategy)
 				.include(sideCommit).call();
 		assertEquals(MergeStatus.MERGED, mergeRes.getMergeStatus());
 		assertEquals(
 				"[noop, mode:100644, content:other][sub/file, mode:100644, content:subfile]",
 				indexState(CONTENT));
 	}
 
 	/**
 	 * An existing directory without tracked content should not prevent merging
 	 * a file with that name.
 	 *
 	 * @param strategy
 	 * @throws Exception
 	 */
 	@Theory
 	public void checkUntrackedEmpytFolderIsNotAConflictWithFile(
 			MergeStrategy strategy)
 			throws Exception {
 		Git git = Git.wrap(db);
 
 		writeTrashFile("d/1", "1");
 		git.add().addFilepattern("d/1").call();
 		RevCommit first = git.commit().setMessage("added d/1").call();
 
 		writeTrashFile("e", "4");
 		git.add().addFilepattern("e").call();
 		RevCommit masterCommit = git.commit().setMessage("added e").call();
 
 		git.checkout().setCreateBranch(true).setStartPoint(first)
 				.setName("side").call();
 		writeTrashFile("f/1", "5");
 		git.add().addFilepattern("f/1").call();
 		git.commit().setAll(true).setMessage("added f/1").call();
 
 		// Untracked empty directory hierarcy e/1 shall not conflict with merged
 		// e/1
 		FileUtils.mkdirs(new File(trash, "e/1"), true);
 
 		MergeResult mergeRes = git.merge().setStrategy(strategy)
 				.include(masterCommit).call();
 		assertEquals(MergeStatus.MERGED, mergeRes.getMergeStatus());
 		assertEquals(
 				"[d/1, mode:100644, content:1][e, mode:100644, content:4][f/1, mode:100644, content:5]",
 				indexState(CONTENT));
 	}
 
 	@Theory
 	public void mergeWithCrlfInWT(MergeStrategy strategy) throws IOException,
 			GitAPIException {
 		Git git = Git.wrap(db);
 		db.getConfig().setString("core", null, "autocrlf", "false");
 		db.getConfig().save();
 		writeTrashFile("crlf.txt", "some\r\ndata\r\n");
 		git.add().addFilepattern("crlf.txt").call();
 		git.commit().setMessage("base").call();
 
 		git.branchCreate().setName("brancha").call();
 
 		writeTrashFile("crlf.txt", "some\r\nmore\r\ndata\r\n");
 		git.add().addFilepattern("crlf.txt").call();
 		git.commit().setMessage("on master").call();
 
 		git.checkout().setName("brancha").call();
 		writeTrashFile("crlf.txt", "some\r\ndata\r\ntoo\r\n");
 		git.add().addFilepattern("crlf.txt").call();
 		git.commit().setMessage("on brancha").call();
 
 		db.getConfig().setString("core", null, "autocrlf", "input");
 		db.getConfig().save();
 
 		MergeResult mergeResult = git.merge().setStrategy(strategy)
 				.include(db.resolve("master"))
 				.call();
 		assertEquals(MergeResult.MergeStatus.MERGED,
 				mergeResult.getMergeStatus());
 	}
 
 	/**
 	 * Merging two equal subtrees when the index does not contain any file in
 	 * that subtree should lead to a merged state.
 	 *
 	 * @param strategy
 	 * @throws Exception
 	 */
 	@Theory
 	public void checkMergeEqualTreesWithoutIndex(MergeStrategy strategy)
 			throws Exception {
 		Git git = Git.wrap(db);
 
 		writeTrashFile("d/1", "orig");
 		git.add().addFilepattern("d/1").call();
 		RevCommit first = git.commit().setMessage("added d/1").call();
 
 		writeTrashFile("d/1", "modified");
 		RevCommit masterCommit = git.commit().setAll(true)
 				.setMessage("modified d/1 on master").call();
 
 		git.checkout().setCreateBranch(true).setStartPoint(first)
 				.setName("side").call();
 		writeTrashFile("d/1", "modified");
 		git.commit().setAll(true).setMessage("modified d/1 on side").call();
 
 		git.rm().addFilepattern("d/1").call();
 		git.rm().addFilepattern("d").call();
 		MergeResult mergeRes = git.merge().setStrategy(strategy)
 				.include(masterCommit).call();
 		assertEquals(MergeStatus.MERGED, mergeRes.getMergeStatus());
 		assertEquals("[d/1, mode:100644, content:modified]",
 				indexState(CONTENT));
 	}
 
 	/**
 	 * Merging two equal subtrees with an incore merger should lead to a merged
 	 * state (The 'Gerrit' use case).
 	 *
 	 * @param strategy
 	 * @throws Exception
 	 */
 	@Theory
 	public void checkMergeEqualTreesInCore(MergeStrategy strategy)
 			throws Exception {
 		Git git = Git.wrap(db);
 
 		writeTrashFile("d/1", "orig");
 		git.add().addFilepattern("d/1").call();
 		RevCommit first = git.commit().setMessage("added d/1").call();
 
 		writeTrashFile("d/1", "modified");
 		RevCommit masterCommit = git.commit().setAll(true)
 				.setMessage("modified d/1 on master").call();
 
 		git.checkout().setCreateBranch(true).setStartPoint(first)
 				.setName("side").call();
 		writeTrashFile("d/1", "modified");
 		RevCommit sideCommit = git.commit().setAll(true)
 				.setMessage("modified d/1 on side").call();
 
 		git.rm().addFilepattern("d/1").call();
 		git.rm().addFilepattern("d").call();
 
 		ThreeWayMerger resolveMerger = (ThreeWayMerger) strategy.newMerger(db,
 				true);
 		boolean noProblems = resolveMerger.merge(masterCommit, sideCommit);
 		assertTrue(noProblems);
 	}
 
 	/**
 	 * Merging two equal subtrees when the index and HEAD does not contain any
 	 * file in that subtree should lead to a merged state.
 	 *
 	 * @param strategy
 	 * @throws Exception
 	 */
 	@Theory
 	public void checkMergeEqualNewTrees(MergeStrategy strategy)
 			throws Exception {
 		Git git = Git.wrap(db);
 
 		writeTrashFile("2", "orig");
 		git.add().addFilepattern("2").call();
 		RevCommit first = git.commit().setMessage("added 2").call();
 
 		writeTrashFile("d/1", "orig");
 		git.add().addFilepattern("d/1").call();
 		RevCommit masterCommit = git.commit().setAll(true)
 				.setMessage("added d/1 on master").call();
 
 		git.checkout().setCreateBranch(true).setStartPoint(first)
 				.setName("side").call();
 		writeTrashFile("d/1", "orig");
 		git.add().addFilepattern("d/1").call();
 		git.commit().setAll(true).setMessage("added d/1 on side").call();
 
 		git.rm().addFilepattern("d/1").call();
 		git.rm().addFilepattern("d").call();
 		MergeResult mergeRes = git.merge().setStrategy(strategy)
 				.include(masterCommit).call();
 		assertEquals(MergeStatus.MERGED, mergeRes.getMergeStatus());
 		assertEquals(
 				"[2, mode:100644, content:orig][d/1, mode:100644, content:orig]",
 				indexState(CONTENT));
 	}
 
 	/**
 	 * Merging two conflicting subtrees when the index and HEAD does not contain
 	 * any file in that subtree should lead to a conflicting state.
 	 *
 	 * @param strategy
 	 * @throws Exception
 	 */
 	@Theory
 	public void checkMergeConflictingNewTrees(MergeStrategy strategy)
 			throws Exception {
 		Git git = Git.wrap(db);
 
 		writeTrashFile("2", "orig");
 		git.add().addFilepattern("2").call();
 		RevCommit first = git.commit().setMessage("added 2").call();
 
 		writeTrashFile("d/1", "master");
 		git.add().addFilepattern("d/1").call();
 		RevCommit masterCommit = git.commit().setAll(true)
 				.setMessage("added d/1 on master").call();
 
 		git.checkout().setCreateBranch(true).setStartPoint(first)
 				.setName("side").call();
 		writeTrashFile("d/1", "side");
 		git.add().addFilepattern("d/1").call();
 		git.commit().setAll(true).setMessage("added d/1 on side").call();
 
 		git.rm().addFilepattern("d/1").call();
 		git.rm().addFilepattern("d").call();
 		MergeResult mergeRes = git.merge().setStrategy(strategy)
 				.include(masterCommit).call();
 		assertEquals(MergeStatus.CONFLICTING, mergeRes.getMergeStatus());
 		assertEquals(
 				"[2, mode:100644, content:orig][d/1, mode:100644, stage:2, content:side][d/1, mode:100644, stage:3, content:master]",
 				indexState(CONTENT));
 	}
 
 	/**
 	 * Merging two conflicting files when the index contains a tree for that
 	 * path should lead to a failed state.
 	 *
 	 * @param strategy
 	 * @throws Exception
 	 */
 	@Theory
 	public void checkMergeConflictingFilesWithTreeInIndex(MergeStrategy strategy)
 			throws Exception {
 		Git git = Git.wrap(db);
 
 		writeTrashFile("0", "orig");
 		git.add().addFilepattern("0").call();
 		RevCommit first = git.commit().setMessage("added 0").call();
 
 		writeTrashFile("0", "master");
 		RevCommit masterCommit = git.commit().setAll(true)
 				.setMessage("modified 0 on master").call();
 
 		git.checkout().setCreateBranch(true).setStartPoint(first)
 				.setName("side").call();
 		writeTrashFile("0", "side");
 		git.commit().setAll(true).setMessage("modified 0 on side").call();
 
 		git.rm().addFilepattern("0").call();
 		writeTrashFile("0/0", "side");
 		git.add().addFilepattern("0/0").call();
 		MergeResult mergeRes = git.merge().setStrategy(strategy)
 				.include(masterCommit).call();
 		assertEquals(MergeStatus.FAILED, mergeRes.getMergeStatus());
 	}
 
 	/**
 	 * Merging two equal files when the index contains a tree for that path
 	 * should lead to a failed state.
 	 *
 	 * @param strategy
 	 * @throws Exception
 	 */
 	@Theory
 	public void checkMergeMergeableFilesWithTreeInIndex(MergeStrategy strategy)
 			throws Exception {
 		Git git = Git.wrap(db);
 
 		writeTrashFile("0", "orig");
 		writeTrashFile("1", "1\n2\n3");
 		git.add().addFilepattern("0").addFilepattern("1").call();
 		RevCommit first = git.commit().setMessage("added 0, 1").call();
 
 		writeTrashFile("1", "1master\n2\n3");
 		RevCommit masterCommit = git.commit().setAll(true)
 				.setMessage("modified 1 on master").call();
 
 		git.checkout().setCreateBranch(true).setStartPoint(first)
 				.setName("side").call();
 		writeTrashFile("1", "1\n2\n3side");
 		git.commit().setAll(true).setMessage("modified 1 on side").call();
 
 		git.rm().addFilepattern("0").call();
 		writeTrashFile("0/0", "modified");
 		git.add().addFilepattern("0/0").call();
 		try {
 			git.merge().setStrategy(strategy).include(masterCommit).call();
 			Assert.fail("Didn't get the expected exception");
 		} catch (CheckoutConflictException e) {
 			assertEquals(1, e.getConflictingPaths().size());
 			assertEquals("0/0", e.getConflictingPaths().get(0));
 		}
 	}
 
 	/**
 	 * Merging after criss-cross merges. In this case we merge together two
 	 * commits which have two equally good common ancestors
 	 *
 	 * @param strategy
 	 * @throws Exception
 	 */
 	@Theory
 	public void checkMergeCrissCross(MergeStrategy strategy) throws Exception {
 		Git git = Git.wrap(db);
 
 		writeTrashFile("1", "1\n2\n3");
 		git.add().addFilepattern("1").call();
 		RevCommit first = git.commit().setMessage("added 1").call();
 
 		writeTrashFile("1", "1master\n2\n3");
 		RevCommit masterCommit = git.commit().setAll(true)
 				.setMessage("modified 1 on master").call();
 
 		writeTrashFile("1", "1master2\n2\n3");
 		git.commit().setAll(true)
 				.setMessage("modified 1 on master again").call();
 
 		git.checkout().setCreateBranch(true).setStartPoint(first)
 				.setName("side").call();
 		writeTrashFile("1", "1\n2\na\nb\nc\n3side");
 		RevCommit sideCommit = git.commit().setAll(true)
 				.setMessage("modified 1 on side").call();
 
 		writeTrashFile("1", "1\n2\n3side2");
 		git.commit().setAll(true)
 				.setMessage("modified 1 on side again").call();
 
 		MergeResult result = git.merge().setStrategy(strategy)
 				.include(masterCommit).call();
 		assertEquals(MergeStatus.MERGED, result.getMergeStatus());
 		result.getNewHead();
 		git.checkout().setName("master").call();
 		result = git.merge().setStrategy(strategy).include(sideCommit).call();
 		assertEquals(MergeStatus.MERGED, result.getMergeStatus());
 
 		// we have two branches which are criss-cross merged. Try to merge the
 		// tips. This should succeed with RecursiveMerge and fail with
 		// ResolveMerge
 		try {
 			MergeResult mergeResult = git.merge().setStrategy(strategy)
 					.include(git.getRepository().exactRef("refs/heads/side"))
 					.call();
 			assertEquals(MergeStrategy.RECURSIVE, strategy);
 			assertEquals(MergeResult.MergeStatus.MERGED,
 					mergeResult.getMergeStatus());
 			assertEquals("1master2\n2\n3side2", read("1"));
 		} catch (JGitInternalException e) {
 			assertEquals(MergeStrategy.RESOLVE, strategy);
 			assertTrue(e.getCause() instanceof NoMergeBaseException);
 			assertEquals(((NoMergeBaseException) e.getCause()).getReason(),
 					MergeBaseFailureReason.MULTIPLE_MERGE_BASES_NOT_SUPPORTED);
 		}
 	}
 
 	@Theory
 	public void checkLockedFilesToBeDeleted(MergeStrategy strategy)
 			throws Exception {
 		Git git = Git.wrap(db);
 
 		writeTrashFile("a.txt", "orig");
 		writeTrashFile("b.txt", "orig");
 		git.add().addFilepattern("a.txt").addFilepattern("b.txt").call();
 		RevCommit first = git.commit().setMessage("added a.txt, b.txt").call();
 
 		// modify and delete files on the master branch
 		writeTrashFile("a.txt", "master");
 		git.rm().addFilepattern("b.txt").call();
 		RevCommit masterCommit = git.commit()
 				.setMessage("modified a.txt, deleted b.txt").setAll(true)
 				.call();
 
 		// switch back to a side branch
 		git.checkout().setCreateBranch(true).setStartPoint(first)
 				.setName("side").call();
 		writeTrashFile("c.txt", "side");
 		git.add().addFilepattern("c.txt").call();
 		git.commit().setMessage("added c.txt").call();
 
 		// Get a handle to the the file so on windows it can't be deleted.
 		FileInputStream fis = new FileInputStream(new File(db.getWorkTree(),
 				"b.txt"));
 		MergeResult mergeRes = git.merge().setStrategy(strategy)
 				.include(masterCommit).call();
 		if (mergeRes.getMergeStatus().equals(MergeStatus.FAILED)) {
 			// probably windows
 			assertEquals(1, mergeRes.getFailingPaths().size());
 			assertEquals(MergeFailureReason.COULD_NOT_DELETE, mergeRes
 					.getFailingPaths().get("b.txt"));
 		}
 		assertEquals("[a.txt, mode:100644, content:master]"
 				+ "[c.txt, mode:100644, content:side]", indexState(CONTENT));
 		fis.close();
 	}
 
 	@Theory
 	public void checkForCorrectIndex(MergeStrategy strategy) throws Exception {
 		File f;
 		long lastTs4, lastTsIndex;
 		Git git = Git.wrap(db);
 		File indexFile = db.getIndexFile();
 
 		// Create initial content and remember when the last file was written.
 		f = writeTrashFiles(false, "orig", "orig", "1\n2\n3", "orig", "orig");
 		lastTs4 = FS.DETECTED.lastModified(f);
 
 		// add all files, commit and check this doesn't update any working tree
 		// files and that the index is in a new file system timer tick. Make
 		// sure to wait long enough before adding so the index doesn't contain
 		// racily clean entries
 		fsTick(f);
 		git.add().addFilepattern(".").call();
 		RevCommit firstCommit = git.commit().setMessage("initial commit")
 				.call();
 		checkConsistentLastModified("0", "1", "2", "3", "4");
 		checkModificationTimeStampOrder("1", "2", "3", "4", "<.git/index");
 		assertEquals("Commit should not touch working tree file 4", lastTs4,
 				FS.DETECTED.lastModified(new File(db.getWorkTree(), "4")));
 		lastTsIndex = FS.DETECTED.lastModified(indexFile);
 
 		// Do modifications on the master branch. Then add and commit. This
 		// should touch only "0", "2 and "3"
 		fsTick(indexFile);
 		f = writeTrashFiles(false, "master", null, "1master\n2\n3", "master",
 				null);
 		fsTick(f);
 		git.add().addFilepattern(".").call();
 		RevCommit masterCommit = git.commit().setMessage("master commit")
 				.call();
 		checkConsistentLastModified("0", "1", "2", "3", "4");
 		checkModificationTimeStampOrder("1", "4", "*" + lastTs4, "<*"
 				+ lastTsIndex, "<0", "2", "3", "<.git/index");
 		lastTsIndex = FS.DETECTED.lastModified(indexFile);
 
 		// Checkout a side branch. This should touch only "0", "2 and "3"
 		fsTick(indexFile);
 		git.checkout().setCreateBranch(true).setStartPoint(firstCommit)
 				.setName("side").call();
 		checkConsistentLastModified("0", "1", "2", "3", "4");
 		checkModificationTimeStampOrder("1", "4", "*" + lastTs4, "<*"
 				+ lastTsIndex, "<0", "2", "3", ".git/index");
 		lastTsIndex = FS.DETECTED.lastModified(indexFile);
 
 		// This checkout may have populated worktree and index so fast that we
 		// may have smudged entries now. Check that we have the right content
 		// and then rewrite the index to get rid of smudged state
 		assertEquals("[0, mode:100644, content:orig]" //
 				+ "[1, mode:100644, content:orig]" //
 				+ "[2, mode:100644, content:1\n2\n3]" //
 				+ "[3, mode:100644, content:orig]" //
 				+ "[4, mode:100644, content:orig]", //
 				indexState(CONTENT));
 		fsTick(indexFile);
 		f = writeTrashFiles(false, "orig", "orig", "1\n2\n3", "orig", "orig");
 		lastTs4 = FS.DETECTED.lastModified(f);
 		fsTick(f);
 		git.add().addFilepattern(".").call();
 		checkConsistentLastModified("0", "1", "2", "3", "4");
 		checkModificationTimeStampOrder("*" + lastTsIndex, "<0", "1", "2", "3",
 				"4", "<.git/index");
 		lastTsIndex = FS.DETECTED.lastModified(indexFile);
 
 		// Do modifications on the side branch. Touch only "1", "2 and "3"
 		fsTick(indexFile);
 		f = writeTrashFiles(false, null, "side", "1\n2\n3side", "side", null);
 		fsTick(f);
 		git.add().addFilepattern(".").call();
 		git.commit().setMessage("side commit").call();
 		checkConsistentLastModified("0", "1", "2", "3", "4");
 		checkModificationTimeStampOrder("0", "4", "*" + lastTs4, "<*"
 				+ lastTsIndex, "<1", "2", "3", "<.git/index");
 		lastTsIndex = FS.DETECTED.lastModified(indexFile);
 
 		// merge master and side. Should only touch "0," "2" and "3"
 		fsTick(indexFile);
 		git.merge().setStrategy(strategy).include(masterCommit).call();
 		checkConsistentLastModified("0", "1", "2", "4");
 		checkModificationTimeStampOrder("4", "*" + lastTs4, "<1", "<*"
 				+ lastTsIndex, "<0", "2", "3", ".git/index");
 		assertEquals(
 				"[0, mode:100644, content:master]" //
 						+ "[1, mode:100644, content:side]" //
 						+ "[2, mode:100644, content:1master\n2\n3side]" //
 						+ "[3, mode:100644, stage:1, content:orig][3, mode:100644, stage:2, content:side][3, mode:100644, stage:3, content:master]" //
 						+ "[4, mode:100644, content:orig]", //
 				indexState(CONTENT));
 	}
 
 	// Assert that every specified index entry has the same last modification
 	// timestamp as the associated file
 	private void checkConsistentLastModified(String... pathes)
 			throws IOException {
 		DirCache dc = db.readDirCache();
 		File workTree = db.getWorkTree();
 		for (String path : pathes)
 			assertEquals(
 					"IndexEntry with path "
 							+ path
 							+ " has lastmodified with is different from the worktree file",
 					FS.DETECTED.lastModified(new File(workTree, path)), dc.getEntry(path)
 							.getLastModified());
 	}
 
 	// Assert that modification timestamps of working tree files are as
 	// expected. You may specify n files. It is asserted that every file
 	// i+1 is not older than file i. If a path of file i+1 is prefixed with "<"
 	// then this file must be younger then file i. A path "*<modtime>"
 	// represents a file with a modification time of <modtime>
 	// E.g. ("a", "b", "<c", "f/a.txt") means: a<=b<c<=f/a.txt
 	private void checkModificationTimeStampOrder(String... pathes)
 			throws IOException {
 		long lastMod = Long.MIN_VALUE;
 		for (String p : pathes) {
 			boolean strong = p.startsWith("<");
 			boolean fixed = p.charAt(strong ? 1 : 0) == '*';
 			p = p.substring((strong ? 1 : 0) + (fixed ? 1 : 0));
 			long curMod = fixed ? Long.valueOf(p).longValue()
 					: FS.DETECTED.lastModified(new File(db.getWorkTree(), p));
 			if (strong)
 				assertTrue("path " + p + " is not younger than predecesssor",
 						curMod > lastMod);
 			else
 				assertTrue("path " + p + " is older than predecesssor",
 						curMod >= lastMod);
 		}
 	}
 }