/*
    * Copyright (C) 2010, Stefan Lay <stefan.lay@sap.com>
    * Copyright (C) 2010-2014, Christian Halstrick <christian.halstrick@sap.com>
    * 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.api;
  
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertFalse;
  import static org.junit.Assert.assertNull;
  import static org.junit.Assert.assertTrue;
  import static org.junit.Assert.fail;
  
  import java.io.File;
  import java.util.Iterator;
  
  import org.eclipse.jgit.api.MergeCommand.FastForwardMode;
  import org.eclipse.jgit.api.MergeResult.MergeStatus;
  import org.eclipse.jgit.api.errors.InvalidMergeHeadsException;
  import org.eclipse.jgit.junit.RepositoryTestCase;
  import org.eclipse.jgit.junit.TestRepository;
  import org.eclipse.jgit.junit.TestRepository.BranchBuilder;
  import org.eclipse.jgit.lib.Constants;
  import org.eclipse.jgit.lib.Ref;
  import org.eclipse.jgit.lib.Repository;
  import org.eclipse.jgit.lib.RepositoryState;
  import org.eclipse.jgit.lib.Sets;
  import org.eclipse.jgit.merge.MergeStrategy;
  import org.eclipse.jgit.merge.ResolveMerger.MergeFailureReason;
  import org.eclipse.jgit.revwalk.RevCommit;
  import org.eclipse.jgit.util.FS;
  import org.eclipse.jgit.util.FileUtils;
  import org.eclipse.jgit.util.GitDateFormatter;
  import org.eclipse.jgit.util.GitDateFormatter.Format;
  import org.junit.Before;
  import org.junit.Test;
  import org.junit.experimental.theories.DataPoints;
  import org.junit.experimental.theories.Theories;
  import org.junit.experimental.theories.Theory;
  import org.junit.runner.RunWith;
  
  @RunWith(Theories.class)
  public class MergeCommandTest extends RepositoryTestCase {
  
  	public static @DataPoints
  	MergeStrategy[] mergeStrategies = MergeStrategy.get();
  
  	private GitDateFormatter dateFormatter;
  
  	@Override
  	@Before
  	public void setUp() throws Exception {
  		super.setUp();
  		dateFormatter = new GitDateFormatter(Format.DEFAULT);
  	}
  
  	@Test
  	public void testMergeInItself() throws Exception {
  		Git git = new Git(db);
  		git.commit().setMessage("initial commit").call();
  
 		MergeResult result = git.merge().include(db.getRef(Constants.HEAD)).call();
 		assertEquals(MergeResult.MergeStatus.ALREADY_UP_TO_DATE, result.getMergeStatus());
 		// no reflog entry written by merge
 		assertEquals("commit (initial): initial commit",
 				db
 				.getReflogReader(Constants.HEAD).getLastEntry().getComment());
 		assertEquals("commit (initial): initial commit",
 				db
 				.getReflogReader(db.getBranch()).getLastEntry().getComment());
 	}
 
 	@Test
 	public void testAlreadyUpToDate() throws Exception {
 		Git git = new Git(db);
 		RevCommit first = git.commit().setMessage("initial commit").call();
 		createBranch(first, "refs/heads/branch1");
 
 		RevCommit second = git.commit().setMessage("second commit").call();
 		MergeResult result = git.merge().include(db.getRef("refs/heads/branch1")).call();
 		assertEquals(MergeResult.MergeStatus.ALREADY_UP_TO_DATE, result.getMergeStatus());
 		assertEquals(second, result.getNewHead());
 		// no reflog entry written by merge
 		assertEquals("commit: second commit", db
 				.getReflogReader(Constants.HEAD).getLastEntry().getComment());
 		assertEquals("commit: second commit", db
 				.getReflogReader(db.getBranch()).getLastEntry().getComment());
 	}
 
 	@Test
 	public void testFastForward() throws Exception {
 		Git git = new Git(db);
 		RevCommit first = git.commit().setMessage("initial commit").call();
 		createBranch(first, "refs/heads/branch1");
 
 		RevCommit second = git.commit().setMessage("second commit").call();
 
 		checkoutBranch("refs/heads/branch1");
 
 		MergeResult result = git.merge().include(db.getRef(Constants.MASTER)).call();
 
 		assertEquals(MergeResult.MergeStatus.FAST_FORWARD, result.getMergeStatus());
 		assertEquals(second, result.getNewHead());
 		assertEquals("merge refs/heads/master: Fast-forward",
 				db.getReflogReader(Constants.HEAD).getLastEntry().getComment());
 		assertEquals("merge refs/heads/master: Fast-forward",
 				db.getReflogReader(db.getBranch()).getLastEntry().getComment());
 	}
 
 	@Test
 	public void testFastForwardNoCommit() throws Exception {
 		Git git = new Git(db);
 		RevCommit first = git.commit().setMessage("initial commit").call();
 		createBranch(first, "refs/heads/branch1");
 
 		RevCommit second = git.commit().setMessage("second commit").call();
 
 		checkoutBranch("refs/heads/branch1");
 
 		MergeResult result = git.merge().include(db.getRef(Constants.MASTER))
 				.setCommit(false).call();
 
 		assertEquals(MergeResult.MergeStatus.FAST_FORWARD,
 				result.getMergeStatus());
 		assertEquals(second, result.getNewHead());
 		assertEquals("merge refs/heads/master: Fast-forward", db
 				.getReflogReader(Constants.HEAD).getLastEntry().getComment());
 		assertEquals("merge refs/heads/master: Fast-forward", db
 				.getReflogReader(db.getBranch()).getLastEntry().getComment());
 	}
 
 	@Test
 	public void testFastForwardWithFiles() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("file1", "file1");
 		git.add().addFilepattern("file1").call();
 		RevCommit first = git.commit().setMessage("initial commit").call();
 
 		assertTrue(new File(db.getWorkTree(), "file1").exists());
 		createBranch(first, "refs/heads/branch1");
 
 		writeTrashFile("file2", "file2");
 		git.add().addFilepattern("file2").call();
 		RevCommit second = git.commit().setMessage("second commit").call();
 		assertTrue(new File(db.getWorkTree(), "file2").exists());
 
 		checkoutBranch("refs/heads/branch1");
 		assertFalse(new File(db.getWorkTree(), "file2").exists());
 
 		MergeResult result = git.merge().include(db.getRef(Constants.MASTER)).call();
 
 		assertTrue(new File(db.getWorkTree(), "file1").exists());
 		assertTrue(new File(db.getWorkTree(), "file2").exists());
 		assertEquals(MergeResult.MergeStatus.FAST_FORWARD, result.getMergeStatus());
 		assertEquals(second, result.getNewHead());
 		assertEquals("merge refs/heads/master: Fast-forward",
 				db.getReflogReader(Constants.HEAD).getLastEntry().getComment());
 		assertEquals("merge refs/heads/master: Fast-forward",
 				db.getReflogReader(db.getBranch()).getLastEntry().getComment());
 	}
 
 	@Test
 	public void testMultipleHeads() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("file1", "file1");
 		git.add().addFilepattern("file1").call();
 		RevCommit first = git.commit().setMessage("initial commit").call();
 		createBranch(first, "refs/heads/branch1");
 
 		writeTrashFile("file2", "file2");
 		git.add().addFilepattern("file2").call();
 		RevCommit second = git.commit().setMessage("second commit").call();
 
 		writeTrashFile("file3", "file3");
 		git.add().addFilepattern("file3").call();
 		git.commit().setMessage("third commit").call();
 
 		checkoutBranch("refs/heads/branch1");
 		assertFalse(new File(db.getWorkTree(), "file2").exists());
 		assertFalse(new File(db.getWorkTree(), "file3").exists());
 
 		MergeCommand merge = git.merge();
 		merge.include(second.getId());
 		merge.include(db.getRef(Constants.MASTER));
 		try {
 			merge.call();
 			fail("Expected exception not thrown when merging multiple heads");
 		} catch (InvalidMergeHeadsException e) {
 			// expected this exception
 		}
 	}
 
 	@Theory
 	public void testMergeSuccessAllStrategies(MergeStrategy mergeStrategy)
 			throws Exception {
 		Git git = new Git(db);
 
 		RevCommit first = git.commit().setMessage("first").call();
 		createBranch(first, "refs/heads/side");
 
 		writeTrashFile("a", "a");
 		git.add().addFilepattern("a").call();
 		git.commit().setMessage("second").call();
 
 		checkoutBranch("refs/heads/side");
 		writeTrashFile("b", "b");
 		git.add().addFilepattern("b").call();
 		git.commit().setMessage("third").call();
 
 		MergeResult result = git.merge().setStrategy(mergeStrategy)
 				.include(db.getRef(Constants.MASTER)).call();
 		assertEquals(MergeStatus.MERGED, result.getMergeStatus());
 		assertEquals(
 				"merge refs/heads/master: Merge made by "
 						+ mergeStrategy.getName() + ".",
 				db.getReflogReader(Constants.HEAD).getLastEntry().getComment());
 		assertEquals(
 				"merge refs/heads/master: Merge made by "
 						+ mergeStrategy.getName() + ".",
 				db.getReflogReader(db.getBranch()).getLastEntry().getComment());
 	}
 
 	@Theory
 	public void testMergeSuccessAllStrategiesNoCommit(
 			MergeStrategy mergeStrategy) throws Exception {
 		Git git = new Git(db);
 
 		RevCommit first = git.commit().setMessage("first").call();
 		createBranch(first, "refs/heads/side");
 
 		writeTrashFile("a", "a");
 		git.add().addFilepattern("a").call();
 		git.commit().setMessage("second").call();
 
 		checkoutBranch("refs/heads/side");
 		writeTrashFile("b", "b");
 		git.add().addFilepattern("b").call();
 		RevCommit thirdCommit = git.commit().setMessage("third").call();
 
 		MergeResult result = git.merge().setStrategy(mergeStrategy)
 				.setCommit(false)
 				.include(db.getRef(Constants.MASTER)).call();
 		assertEquals(MergeStatus.MERGED_NOT_COMMITTED, result.getMergeStatus());
 		assertEquals(db.getRef(Constants.HEAD).getTarget().getObjectId(),
 				thirdCommit.getId());
 	}
 
 	@Test
 	public void testContentMerge() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("a", "1\na\n3\n");
 		writeTrashFile("b", "1\nb\n3\n");
 		writeTrashFile("c/c/c", "1\nc\n3\n");
 		git.add().addFilepattern("a").addFilepattern("b")
 				.addFilepattern("c/c/c").call();
 		RevCommit initialCommit = git.commit().setMessage("initial").call();
 
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 
 		writeTrashFile("a", "1\na(side)\n3\n");
 		writeTrashFile("b", "1\nb(side)\n3\n");
 		git.add().addFilepattern("a").addFilepattern("b").call();
 		RevCommit secondCommit = git.commit().setMessage("side").call();
 
 		assertEquals("1\nb(side)\n3\n", read(new File(db.getWorkTree(), "b")));
 		checkoutBranch("refs/heads/master");
 		assertEquals("1\nb\n3\n", read(new File(db.getWorkTree(), "b")));
 
 		writeTrashFile("a", "1\na(main)\n3\n");
 		writeTrashFile("c/c/c", "1\nc(main)\n3\n");
 		git.add().addFilepattern("a").addFilepattern("c/c/c").call();
 		git.commit().setMessage("main").call();
 
 		MergeResult result = git.merge().include(secondCommit.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 		assertEquals(MergeStatus.CONFLICTING, result.getMergeStatus());
 
 		assertEquals(
 				"1\n<<<<<<< HEAD\na(main)\n=======\na(side)\n>>>>>>> 86503e7e397465588cc267b65d778538bffccb83\n3\n",
 				read(new File(db.getWorkTree(), "a")));
 		assertEquals("1\nb(side)\n3\n", read(new File(db.getWorkTree(), "b")));
 		assertEquals("1\nc(main)\n3\n",
 				read(new File(db.getWorkTree(), "c/c/c")));
 
 		assertEquals(1, result.getConflicts().size());
 		assertEquals(3, result.getConflicts().get("a")[0].length);
 
 		assertEquals(RepositoryState.MERGING, db.getRepositoryState());
 	}
 
 	@Test
 	public void testMergeTag() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("a", "a");
 		git.add().addFilepattern("a").call();
 		RevCommit initialCommit = git.commit().setMessage("initial").call();
 
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 
 		writeTrashFile("b", "b");
 		git.add().addFilepattern("b").call();
 		RevCommit secondCommit = git.commit().setMessage("side").call();
 		Ref tag = git.tag().setAnnotated(true).setMessage("my tag 01")
 				.setName("tag01").setObjectId(secondCommit).call();
 
 		checkoutBranch("refs/heads/master");
 
 		writeTrashFile("a", "a2");
 		git.add().addFilepattern("a").call();
 		git.commit().setMessage("main").call();
 
 		MergeResult result = git.merge().include(tag).setStrategy(MergeStrategy.RESOLVE).call();
 		assertEquals(MergeStatus.MERGED, result.getMergeStatus());
 	}
 
 	@Test
 	public void testMergeMessage() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("a", "1\na\n3\n");
 		git.add().addFilepattern("a").call();
 		RevCommit initialCommit = git.commit().setMessage("initial").call();
 
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 
 		writeTrashFile("a", "1\na(side)\n3\n");
 		git.add().addFilepattern("a").call();
 		git.commit().setMessage("side").call();
 
 		checkoutBranch("refs/heads/master");
 
 		writeTrashFile("a", "1\na(main)\n3\n");
 		git.add().addFilepattern("a").call();
 		git.commit().setMessage("main").call();
 
 		Ref sideBranch = db.getRef("side");
 
 		git.merge().include(sideBranch)
 				.setStrategy(MergeStrategy.RESOLVE).call();
 
 		assertEquals("Merge branch 'side'\n\nConflicts:\n\ta\n",
 				db.readMergeCommitMsg());
 
 	}
 
 	@Test
 	public void testMergeNonVersionedPaths() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("a", "1\na\n3\n");
 		writeTrashFile("b", "1\nb\n3\n");
 		writeTrashFile("c/c/c", "1\nc\n3\n");
 		git.add().addFilepattern("a").addFilepattern("b")
 				.addFilepattern("c/c/c").call();
 		RevCommit initialCommit = git.commit().setMessage("initial").call();
 
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 
 		writeTrashFile("a", "1\na(side)\n3\n");
 		writeTrashFile("b", "1\nb(side)\n3\n");
 		git.add().addFilepattern("a").addFilepattern("b").call();
 		RevCommit secondCommit = git.commit().setMessage("side").call();
 
 		assertEquals("1\nb(side)\n3\n", read(new File(db.getWorkTree(), "b")));
 		checkoutBranch("refs/heads/master");
 		assertEquals("1\nb\n3\n", read(new File(db.getWorkTree(), "b")));
 
 		writeTrashFile("a", "1\na(main)\n3\n");
 		writeTrashFile("c/c/c", "1\nc(main)\n3\n");
 		git.add().addFilepattern("a").addFilepattern("c/c/c").call();
 		git.commit().setMessage("main").call();
 
 		writeTrashFile("d", "1\nd\n3\n");
 		assertTrue(new File(db.getWorkTree(), "e").mkdir());
 
 		MergeResult result = git.merge().include(secondCommit.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 		assertEquals(MergeStatus.CONFLICTING, result.getMergeStatus());
 
 		assertEquals(
 				"1\n<<<<<<< HEAD\na(main)\n=======\na(side)\n>>>>>>> 86503e7e397465588cc267b65d778538bffccb83\n3\n",
 				read(new File(db.getWorkTree(), "a")));
 		assertEquals("1\nb(side)\n3\n", read(new File(db.getWorkTree(), "b")));
 		assertEquals("1\nc(main)\n3\n",
 				read(new File(db.getWorkTree(), "c/c/c")));
 		assertEquals("1\nd\n3\n", read(new File(db.getWorkTree(), "d")));
 		File dir = new File(db.getWorkTree(), "e");
 		assertTrue(dir.isDirectory());
 
 		assertEquals(1, result.getConflicts().size());
 		assertEquals(3, result.getConflicts().get("a")[0].length);
 
 		assertEquals(RepositoryState.MERGING, db.getRepositoryState());
 	}
 
 	@Test
 	public void testMultipleCreations() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("a", "1\na\n3\n");
 		git.add().addFilepattern("a").call();
 		RevCommit initialCommit = git.commit().setMessage("initial").call();
 
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 
 		writeTrashFile("b", "1\nb(side)\n3\n");
 		git.add().addFilepattern("b").call();
 		RevCommit secondCommit = git.commit().setMessage("side").call();
 
 		checkoutBranch("refs/heads/master");
 
 		writeTrashFile("b", "1\nb(main)\n3\n");
 		git.add().addFilepattern("b").call();
 		git.commit().setMessage("main").call();
 
 		MergeResult result = git.merge().include(secondCommit.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 		assertEquals(MergeStatus.CONFLICTING, result.getMergeStatus());
 	}
 
 	@Test
 	public void testMultipleCreationsSameContent() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("a", "1\na\n3\n");
 		git.add().addFilepattern("a").call();
 		RevCommit initialCommit = git.commit().setMessage("initial").call();
 
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 
 		writeTrashFile("b", "1\nb(1)\n3\n");
 		git.add().addFilepattern("b").call();
 		RevCommit secondCommit = git.commit().setMessage("side").call();
 
 		checkoutBranch("refs/heads/master");
 
 		writeTrashFile("b", "1\nb(1)\n3\n");
 		git.add().addFilepattern("b").call();
 		git.commit().setMessage("main").call();
 
 		MergeResult result = git.merge().include(secondCommit.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 		assertEquals(MergeStatus.MERGED, result.getMergeStatus());
 		assertEquals("1\nb(1)\n3\n", read(new File(db.getWorkTree(), "b")));
 		assertEquals("merge " + secondCommit.getId().getName()
 				+ ": Merge made by resolve.", db
 				.getReflogReader(Constants.HEAD)
 				.getLastEntry().getComment());
 		assertEquals("merge " + secondCommit.getId().getName()
 				+ ": Merge made by resolve.", db
 				.getReflogReader(db.getBranch())
 				.getLastEntry().getComment());
 	}
 
 	@Test
 	public void testSuccessfulContentMerge() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("a", "1\na\n3\n");
 		writeTrashFile("b", "1\nb\n3\n");
 		writeTrashFile("c/c/c", "1\nc\n3\n");
 		git.add().addFilepattern("a").addFilepattern("b")
 				.addFilepattern("c/c/c").call();
 		RevCommit initialCommit = git.commit().setMessage("initial").call();
 
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 
 		writeTrashFile("a", "1(side)\na\n3\n");
 		writeTrashFile("b", "1\nb(side)\n3\n");
 		git.add().addFilepattern("a").addFilepattern("b").call();
 		RevCommit secondCommit = git.commit().setMessage("side").call();
 
 		assertEquals("1\nb(side)\n3\n", read(new File(db.getWorkTree(), "b")));
 		checkoutBranch("refs/heads/master");
 		assertEquals("1\nb\n3\n", read(new File(db.getWorkTree(), "b")));
 
 		writeTrashFile("a", "1\na\n3(main)\n");
 		writeTrashFile("c/c/c", "1\nc(main)\n3\n");
 		git.add().addFilepattern("a").addFilepattern("c/c/c").call();
 		RevCommit thirdCommit = git.commit().setMessage("main").call();
 
 		MergeResult result = git.merge().include(secondCommit.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 		assertEquals(MergeStatus.MERGED, result.getMergeStatus());
 
 		assertEquals("1(side)\na\n3(main)\n", read(new File(db.getWorkTree(),
 				"a")));
 		assertEquals("1\nb(side)\n3\n", read(new File(db.getWorkTree(), "b")));
 		assertEquals("1\nc(main)\n3\n", read(new File(db.getWorkTree(),
 				"c/c/c")));
 
 		assertEquals(null, result.getConflicts());
 
 		assertEquals(2, result.getMergedCommits().length);
 		assertEquals(thirdCommit, result.getMergedCommits()[0]);
 		assertEquals(secondCommit, result.getMergedCommits()[1]);
 
 		Iterator<RevCommit> it = git.log().call().iterator();
 		RevCommit newHead = it.next();
 		assertEquals(newHead, result.getNewHead());
 		assertEquals(2, newHead.getParentCount());
 		assertEquals(thirdCommit, newHead.getParent(0));
 		assertEquals(secondCommit, newHead.getParent(1));
 		assertEquals(
 				"Merge commit '3fa334456d236a92db020289fe0bf481d91777b4'",
 				newHead.getFullMessage());
 		// @TODO fix me
 		assertEquals(RepositoryState.SAFE, db.getRepositoryState());
 		// test index state
 	}
 
 	@Test
 	public void testSuccessfulContentMergeNoCommit() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("a", "1\na\n3\n");
 		writeTrashFile("b", "1\nb\n3\n");
 		writeTrashFile("c/c/c", "1\nc\n3\n");
 		git.add().addFilepattern("a").addFilepattern("b")
 				.addFilepattern("c/c/c").call();
 		RevCommit initialCommit = git.commit().setMessage("initial").call();
 
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 
 		writeTrashFile("a", "1(side)\na\n3\n");
 		writeTrashFile("b", "1\nb(side)\n3\n");
 		git.add().addFilepattern("a").addFilepattern("b").call();
 		RevCommit secondCommit = git.commit().setMessage("side").call();
 
 		assertEquals("1\nb(side)\n3\n", read(new File(db.getWorkTree(), "b")));
 		checkoutBranch("refs/heads/master");
 		assertEquals("1\nb\n3\n", read(new File(db.getWorkTree(), "b")));
 
 		writeTrashFile("a", "1\na\n3(main)\n");
 		writeTrashFile("c/c/c", "1\nc(main)\n3\n");
 		git.add().addFilepattern("a").addFilepattern("c/c/c").call();
 		RevCommit thirdCommit = git.commit().setMessage("main").call();
 
 		MergeResult result = git.merge().include(secondCommit.getId())
 				.setCommit(false)
 				.setStrategy(MergeStrategy.RESOLVE).call();
 		assertEquals(MergeStatus.MERGED_NOT_COMMITTED, result.getMergeStatus());
 		assertEquals(db.getRef(Constants.HEAD).getTarget().getObjectId(),
 				thirdCommit.getId());
 
 		assertEquals("1(side)\na\n3(main)\n", read(new File(db.getWorkTree(),
 				"a")));
 		assertEquals("1\nb(side)\n3\n", read(new File(db.getWorkTree(), "b")));
 		assertEquals("1\nc(main)\n3\n",
 				read(new File(db.getWorkTree(), "c/c/c")));
 
 		assertEquals(null, result.getConflicts());
 
 		assertEquals(2, result.getMergedCommits().length);
 		assertEquals(thirdCommit, result.getMergedCommits()[0]);
 		assertEquals(secondCommit, result.getMergedCommits()[1]);
 		assertNull(result.getNewHead());
 		assertEquals(RepositoryState.MERGING_RESOLVED, db.getRepositoryState());
 	}
 
 	@Test
 	public void testSuccessfulContentMergeAndDirtyworkingTree()
 			throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("a", "1\na\n3\n");
 		writeTrashFile("b", "1\nb\n3\n");
 		writeTrashFile("d", "1\nd\n3\n");
 		writeTrashFile("c/c/c", "1\nc\n3\n");
 		git.add().addFilepattern("a").addFilepattern("b")
 				.addFilepattern("c/c/c").addFilepattern("d").call();
 		RevCommit initialCommit = git.commit().setMessage("initial").call();
 
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 
 		writeTrashFile("a", "1(side)\na\n3\n");
 		writeTrashFile("b", "1\nb(side)\n3\n");
 		git.add().addFilepattern("a").addFilepattern("b").call();
 		RevCommit secondCommit = git.commit().setMessage("side").call();
 
 		assertEquals("1\nb(side)\n3\n", read(new File(db.getWorkTree(), "b")));
 		checkoutBranch("refs/heads/master");
 		assertEquals("1\nb\n3\n", read(new File(db.getWorkTree(), "b")));
 
 		writeTrashFile("a", "1\na\n3(main)\n");
 		writeTrashFile("c/c/c", "1\nc(main)\n3\n");
 		git.add().addFilepattern("a").addFilepattern("c/c/c").call();
 		RevCommit thirdCommit = git.commit().setMessage("main").call();
 
 		writeTrashFile("d", "--- dirty ---");
 		MergeResult result = git.merge().include(secondCommit.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 		assertEquals(MergeStatus.MERGED, result.getMergeStatus());
 
 		assertEquals("1(side)\na\n3(main)\n", read(new File(db.getWorkTree(),
 				"a")));
 		assertEquals("1\nb(side)\n3\n", read(new File(db.getWorkTree(), "b")));
 		assertEquals("1\nc(main)\n3\n", read(new File(db.getWorkTree(),
 				"c/c/c")));
 		assertEquals("--- dirty ---", read(new File(db.getWorkTree(), "d")));
 
 		assertEquals(null, result.getConflicts());
 
 		assertEquals(2, result.getMergedCommits().length);
 		assertEquals(thirdCommit, result.getMergedCommits()[0]);
 		assertEquals(secondCommit, result.getMergedCommits()[1]);
 
 		Iterator<RevCommit> it = git.log().call().iterator();
 		RevCommit newHead = it.next();
 		assertEquals(newHead, result.getNewHead());
 		assertEquals(2, newHead.getParentCount());
 		assertEquals(thirdCommit, newHead.getParent(0));
 		assertEquals(secondCommit, newHead.getParent(1));
 		assertEquals(
 				"Merge commit '064d54d98a4cdb0fed1802a21c656bfda67fe879'",
 				newHead.getFullMessage());
 
 		assertEquals(RepositoryState.SAFE, db.getRepositoryState());
 	}
 
 	@Test
 	public void testSingleDeletion() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("a", "1\na\n3\n");
 		writeTrashFile("b", "1\nb\n3\n");
 		writeTrashFile("d", "1\nd\n3\n");
 		writeTrashFile("c/c/c", "1\nc\n3\n");
 		git.add().addFilepattern("a").addFilepattern("b")
 				.addFilepattern("c/c/c").addFilepattern("d").call();
 		RevCommit initialCommit = git.commit().setMessage("initial").call();
 
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 
 		assertTrue(new File(db.getWorkTree(), "b").delete());
 		git.add().addFilepattern("b").setUpdate(true).call();
 		RevCommit secondCommit = git.commit().setMessage("side").call();
 
 		assertFalse(new File(db.getWorkTree(), "b").exists());
 		checkoutBranch("refs/heads/master");
 		assertTrue(new File(db.getWorkTree(), "b").exists());
 
 		writeTrashFile("a", "1\na\n3(main)\n");
 		writeTrashFile("c/c/c", "1\nc(main)\n3\n");
 		git.add().addFilepattern("a").addFilepattern("c/c/c").call();
 		RevCommit thirdCommit = git.commit().setMessage("main").call();
 
 		// We are merging a deletion into our branch
 		MergeResult result = git.merge().include(secondCommit.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 		assertEquals(MergeStatus.MERGED, result.getMergeStatus());
 
 		assertEquals("1\na\n3(main)\n", read(new File(db.getWorkTree(), "a")));
 		assertFalse(new File(db.getWorkTree(), "b").exists());
 		assertEquals("1\nc(main)\n3\n",
 				read(new File(db.getWorkTree(), "c/c/c")));
 		assertEquals("1\nd\n3\n", read(new File(db.getWorkTree(), "d")));
 
 		// Do the opposite, be on a branch where we have deleted a file and
 		// merge in a old commit where this file was not deleted
 		checkoutBranch("refs/heads/side");
 		assertFalse(new File(db.getWorkTree(), "b").exists());
 
 		result = git.merge().include(thirdCommit.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 		assertEquals(MergeStatus.MERGED, result.getMergeStatus());
 
 		assertEquals("1\na\n3(main)\n", read(new File(db.getWorkTree(), "a")));
 		assertFalse(new File(db.getWorkTree(), "b").exists());
 		assertEquals("1\nc(main)\n3\n",
 				read(new File(db.getWorkTree(), "c/c/c")));
 		assertEquals("1\nd\n3\n", read(new File(db.getWorkTree(), "d")));
 	}
 
 	@Test
 	public void testMultipleDeletions() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("a", "1\na\n3\n");
 		git.add().addFilepattern("a").call();
 		RevCommit initialCommit = git.commit().setMessage("initial").call();
 
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 
 		assertTrue(new File(db.getWorkTree(), "a").delete());
 		git.add().addFilepattern("a").setUpdate(true).call();
 		RevCommit secondCommit = git.commit().setMessage("side").call();
 
 		assertFalse(new File(db.getWorkTree(), "a").exists());
 		checkoutBranch("refs/heads/master");
 		assertTrue(new File(db.getWorkTree(), "a").exists());
 
 		assertTrue(new File(db.getWorkTree(), "a").delete());
 		git.add().addFilepattern("a").setUpdate(true).call();
 		git.commit().setMessage("main").call();
 
 		// We are merging a deletion into our branch
 		MergeResult result = git.merge().include(secondCommit.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 		assertEquals(MergeStatus.MERGED, result.getMergeStatus());
 	}
 
 	@Test
 	public void testDeletionAndConflict() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("a", "1\na\n3\n");
 		writeTrashFile("b", "1\nb\n3\n");
 		writeTrashFile("d", "1\nd\n3\n");
 		writeTrashFile("c/c/c", "1\nc\n3\n");
 		git.add().addFilepattern("a").addFilepattern("b")
 				.addFilepattern("c/c/c").addFilepattern("d").call();
 		RevCommit initialCommit = git.commit().setMessage("initial").call();
 
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 
 		assertTrue(new File(db.getWorkTree(), "b").delete());
 		writeTrashFile("a", "1\na\n3(side)\n");
 		git.add().addFilepattern("b").setUpdate(true).call();
 		git.add().addFilepattern("a").setUpdate(true).call();
 		RevCommit secondCommit = git.commit().setMessage("side").call();
 
 		assertFalse(new File(db.getWorkTree(), "b").exists());
 		checkoutBranch("refs/heads/master");
 		assertTrue(new File(db.getWorkTree(), "b").exists());
 
 		writeTrashFile("a", "1\na\n3(main)\n");
 		writeTrashFile("c/c/c", "1\nc(main)\n3\n");
 		git.add().addFilepattern("a").addFilepattern("c/c/c").call();
 		git.commit().setMessage("main").call();
 
 		// We are merging a deletion into our branch
 		MergeResult result = git.merge().include(secondCommit.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 		assertEquals(MergeStatus.CONFLICTING, result.getMergeStatus());
 
 		assertEquals(
 				"1\na\n<<<<<<< HEAD\n3(main)\n=======\n3(side)\n>>>>>>> 54ffed45d62d252715fc20e41da92d44c48fb0ff\n",
 				read(new File(db.getWorkTree(), "a")));
 		assertFalse(new File(db.getWorkTree(), "b").exists());
 		assertEquals("1\nc(main)\n3\n",
 				read(new File(db.getWorkTree(), "c/c/c")));
 		assertEquals("1\nd\n3\n", read(new File(db.getWorkTree(), "d")));
 	}
 
 	@Test
 	public void testDeletionOnMasterConflict() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("a", "1\na\n3\n");
 		writeTrashFile("b", "1\nb\n3\n");
 		git.add().addFilepattern("a").addFilepattern("b").call();
 		RevCommit initialCommit = git.commit().setMessage("initial").call();
 
 		// create side branch and modify "a"
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 		writeTrashFile("a", "1\na(side)\n3\n");
 		git.add().addFilepattern("a").call();
 		RevCommit secondCommit = git.commit().setMessage("side").call();
 
 		// delete a on master to generate conflict
 		checkoutBranch("refs/heads/master");
 		git.rm().addFilepattern("a").call();
 		git.commit().setMessage("main").call();
 
 		// merge side with master
 		MergeResult result = git.merge().include(secondCommit.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 		assertEquals(MergeStatus.CONFLICTING, result.getMergeStatus());
 
 		// result should be 'a' conflicting with workspace content from side
 		assertTrue(new File(db.getWorkTree(), "a").exists());
 		assertEquals("1\na(side)\n3\n", read(new File(db.getWorkTree(), "a")));
 		assertEquals("1\nb\n3\n", read(new File(db.getWorkTree(), "b")));
 	}
 
 	@Test
 	public void testDeletionOnSideConflict() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("a", "1\na\n3\n");
 		writeTrashFile("b", "1\nb\n3\n");
 		git.add().addFilepattern("a").addFilepattern("b").call();
 		RevCommit initialCommit = git.commit().setMessage("initial").call();
 
 		// create side branch and delete "a"
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 		git.rm().addFilepattern("a").call();
 		RevCommit secondCommit = git.commit().setMessage("side").call();
 
 		// update a on master to generate conflict
 		checkoutBranch("refs/heads/master");
 		writeTrashFile("a", "1\na(main)\n3\n");
 		git.add().addFilepattern("a").call();
 		git.commit().setMessage("main").call();
 
 		// merge side with master
 		MergeResult result = git.merge().include(secondCommit.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 		assertEquals(MergeStatus.CONFLICTING, result.getMergeStatus());
 
 		assertTrue(new File(db.getWorkTree(), "a").exists());
 		assertEquals("1\na(main)\n3\n", read(new File(db.getWorkTree(), "a")));
 		assertEquals("1\nb\n3\n", read(new File(db.getWorkTree(), "b")));
 
 		assertEquals(1, result.getConflicts().size());
 		assertEquals(3, result.getConflicts().get("a")[0].length);
 	}
 
 	@Test
 	public void testModifiedAndRenamed() throws Exception {
 		// this test is essentially the same as testDeletionOnSideConflict,
 		// however if once rename support is added this test should result in a
 		// successful merge instead of a conflict
 		Git git = new Git(db);
 
 		writeTrashFile("x", "add x");
 		git.add().addFilepattern("x").call();
 		RevCommit initial = git.commit().setMessage("add x").call();
 
 		createBranch(initial, "refs/heads/d1");
 		createBranch(initial, "refs/heads/d2");
 
 		// rename x to y on d1
 		checkoutBranch("refs/heads/d1");
 		new File(db.getWorkTree(), "x")
 				.renameTo(new File(db.getWorkTree(), "y"));
 		git.rm().addFilepattern("x").call();
 		git.add().addFilepattern("y").call();
 		RevCommit d1Commit = git.commit().setMessage("d1 rename x -> y").call();
 
 		checkoutBranch("refs/heads/d2");
 		writeTrashFile("x", "d2 change");
 		git.add().addFilepattern("x").call();
 		RevCommit d2Commit = git.commit().setMessage("d2 change in x").call();
 
 		checkoutBranch("refs/heads/master");
 		MergeResult d1Merge = git.merge().include(d1Commit).call();
 		assertEquals(MergeResult.MergeStatus.FAST_FORWARD,
 				d1Merge.getMergeStatus());
 
 		MergeResult d2Merge = git.merge().include(d2Commit).call();
 		assertEquals(MergeResult.MergeStatus.CONFLICTING,
 				d2Merge.getMergeStatus());
 		assertEquals(1, d2Merge.getConflicts().size());
 		assertEquals(3, d2Merge.getConflicts().get("x")[0].length);
 	}
 
 	@Test
 	public void testMergeFailingWithDirtyWorkingTree() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("a", "1\na\n3\n");
 		writeTrashFile("b", "1\nb\n3\n");
 		git.add().addFilepattern("a").addFilepattern("b").call();
 		RevCommit initialCommit = git.commit().setMessage("initial").call();
 
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 
 		writeTrashFile("a", "1(side)\na\n3\n");
 		writeTrashFile("b", "1\nb(side)\n3\n");
 		git.add().addFilepattern("a").addFilepattern("b").call();
 		RevCommit secondCommit = git.commit().setMessage("side").call();
 
 		assertEquals("1\nb(side)\n3\n", read(new File(db.getWorkTree(), "b")));
 		checkoutBranch("refs/heads/master");
 		assertEquals("1\nb\n3\n", read(new File(db.getWorkTree(), "b")));
 
 		writeTrashFile("a", "1\na\n3(main)\n");
 		git.add().addFilepattern("a").call();
 		git.commit().setMessage("main").call();
 
 		writeTrashFile("a", "--- dirty ---");
 		MergeResult result = git.merge().include(secondCommit.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 
 		assertEquals(MergeStatus.FAILED, result.getMergeStatus());
 
 		assertEquals("--- dirty ---", read(new File(db.getWorkTree(), "a")));
 		assertEquals("1\nb\n3\n", read(new File(db.getWorkTree(), "b")));
 
 		assertEquals(null, result.getConflicts());
 
 		assertEquals(RepositoryState.SAFE, db.getRepositoryState());
 	}
 
 	@Test
 	public void testMergeConflictFileFolder() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("a", "1\na\n3\n");
 		writeTrashFile("b", "1\nb\n3\n");
 		git.add().addFilepattern("a").addFilepattern("b").call();
 		RevCommit initialCommit = git.commit().setMessage("initial").call();
 
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 
 		writeTrashFile("c/c/c", "1\nc(side)\n3\n");
 		writeTrashFile("d", "1\nd(side)\n3\n");
 		git.add().addFilepattern("c/c/c").addFilepattern("d").call();
 		RevCommit secondCommit = git.commit().setMessage("side").call();
 
 		checkoutBranch("refs/heads/master");
 
 		writeTrashFile("c", "1\nc(main)\n3\n");
 		writeTrashFile("d/d/d", "1\nd(main)\n3\n");
 		git.add().addFilepattern("c").addFilepattern("d/d/d").call();
 		git.commit().setMessage("main").call();
 
 		MergeResult result = git.merge().include(secondCommit.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 
 		assertEquals(MergeStatus.CONFLICTING, result.getMergeStatus());
 
 		assertEquals("1\na\n3\n", read(new File(db.getWorkTree(), "a")));
 		assertEquals("1\nb\n3\n", read(new File(db.getWorkTree(), "b")));
 		assertEquals("1\nc(main)\n3\n", read(new File(db.getWorkTree(), "c")));
 		assertEquals("1\nd(main)\n3\n", read(new File(db.getWorkTree(), "d/d/d")));
 
 		assertEquals(null, result.getConflicts());
 
 		assertEquals(RepositoryState.MERGING, db.getRepositoryState());
 	}
 
 	@Test
 	public void testSuccessfulMergeFailsDueToDirtyIndex() throws Exception {
 		Git git = new Git(db);
 
 		File fileA = writeTrashFile("a", "a");
 		RevCommit initialCommit = addAllAndCommit(git);
 
 		// switch branch
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 		// modify file a
 		write(fileA, "a(side)");
 		writeTrashFile("b", "b");
 		RevCommit sideCommit = addAllAndCommit(git);
 
 		// switch branch
 		checkoutBranch("refs/heads/master");
 		writeTrashFile("c", "c");
 		addAllAndCommit(git);
 
 		// modify and add file a
 		write(fileA, "a(modified)");
 		git.add().addFilepattern("a").call();
 		// do not commit
 
 		// get current index state
 		String indexState = indexState(CONTENT);
 
 		// merge
 		MergeResult result = git.merge().include(sideCommit.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 
 		checkMergeFailedResult(result, MergeFailureReason.DIRTY_INDEX,
 				indexState, fileA);
 	}
 
 	@Test
 	public void testConflictingMergeFailsDueToDirtyIndex() throws Exception {
 		Git git = new Git(db);
 
 		File fileA = writeTrashFile("a", "a");
 		RevCommit initialCommit = addAllAndCommit(git);
 
 		// switch branch
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 		// modify file a
 		write(fileA, "a(side)");
 		writeTrashFile("b", "b");
 		RevCommit sideCommit = addAllAndCommit(git);
 
 		// switch branch
 		checkoutBranch("refs/heads/master");
 		// modify file a - this will cause a conflict during merge
 		write(fileA, "a(master)");
 		writeTrashFile("c", "c");
 		addAllAndCommit(git);
 
 		// modify and add file a
 		write(fileA, "a(modified)");
 		git.add().addFilepattern("a").call();
 		// do not commit
 
 		// get current index state
 		String indexState = indexState(CONTENT);
 
 		// merge
 		MergeResult result = git.merge().include(sideCommit.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 
 		checkMergeFailedResult(result, MergeFailureReason.DIRTY_INDEX,
 				indexState, fileA);
 	}
 
 	@Test
 	public void testSuccessfulMergeFailsDueToDirtyWorktree() throws Exception {
 		Git git = new Git(db);
 
 		File fileA = writeTrashFile("a", "a");
 		RevCommit initialCommit = addAllAndCommit(git);
 
 		// switch branch
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 		// modify file a
 		write(fileA, "a(side)");
 		writeTrashFile("b", "b");
 		RevCommit sideCommit = addAllAndCommit(git);
 
 		// switch branch
 		checkoutBranch("refs/heads/master");
 		writeTrashFile("c", "c");
 		addAllAndCommit(git);
 
 		// modify file a
 		write(fileA, "a(modified)");
 		// do not add and commit
 
 		// get current index state
 		String indexState = indexState(CONTENT);
 
 		// merge
 		MergeResult result = git.merge().include(sideCommit.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 
 		checkMergeFailedResult(result, MergeFailureReason.DIRTY_WORKTREE,
 				indexState, fileA);
 	}
 
 	@Test
 	public void testConflictingMergeFailsDueToDirtyWorktree() throws Exception {
 		Git git = new Git(db);
 
 		File fileA = writeTrashFile("a", "a");
 		RevCommit initialCommit = addAllAndCommit(git);
 
 		// switch branch
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 		// modify file a
 		write(fileA, "a(side)");
 		writeTrashFile("b", "b");
 		RevCommit sideCommit = addAllAndCommit(git);
 
 		// switch branch
 		checkoutBranch("refs/heads/master");
 		// modify file a - this will cause a conflict during merge
 		write(fileA, "a(master)");
 		writeTrashFile("c", "c");
 		addAllAndCommit(git);
 
 		// modify file a
 		write(fileA, "a(modified)");
 		// do not add and commit
 
 		// get current index state
 		String indexState = indexState(CONTENT);
 
 		// merge
 		MergeResult result = git.merge().include(sideCommit.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 
 		checkMergeFailedResult(result, MergeFailureReason.DIRTY_WORKTREE,
 				indexState, fileA);
 	}
 
 	@Test
 	public void testMergeRemovingFolders() throws Exception {
 		File folder1 = new File(db.getWorkTree(), "folder1");
 		File folder2 = new File(db.getWorkTree(), "folder2");
 		FileUtils.mkdir(folder1);
 		FileUtils.mkdir(folder2);
 		File file = new File(folder1, "file1.txt");
 		write(file, "folder1--file1.txt");
 		file = new File(folder1, "file2.txt");
 		write(file, "folder1--file2.txt");
 		file = new File(folder2, "file1.txt");
 		write(file, "folder--file1.txt");
 		file = new File(folder2, "file2.txt");
 		write(file, "folder2--file2.txt");
 
 		Git git = new Git(db);
 		git.add().addFilepattern(folder1.getName())
 				.addFilepattern(folder2.getName()).call();
 		RevCommit commit1 = git.commit().setMessage("adding folders").call();
 
 		recursiveDelete(folder1);
 		recursiveDelete(folder2);
 		git.rm().addFilepattern("folder1/file1.txt")
 				.addFilepattern("folder1/file2.txt")
 				.addFilepattern("folder2/file1.txt")
 				.addFilepattern("folder2/file2.txt").call();
 		RevCommit commit2 = git.commit()
 				.setMessage("removing folders on 'branch'").call();
 
 		git.checkout().setName(commit1.name()).call();
 
 		MergeResult result = git.merge().include(commit2.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 		assertEquals(MergeResult.MergeStatus.FAST_FORWARD,
 				result.getMergeStatus());
 		assertEquals(commit2, result.getNewHead());
 		assertFalse(folder1.exists());
 		assertFalse(folder2.exists());
 	}
 
 	@Test
 	public void testMergeRemovingFoldersWithoutFastForward() throws Exception {
 		File folder1 = new File(db.getWorkTree(), "folder1");
 		File folder2 = new File(db.getWorkTree(), "folder2");
 		FileUtils.mkdir(folder1);
 		FileUtils.mkdir(folder2);
 		File file = new File(folder1, "file1.txt");
 		write(file, "folder1--file1.txt");
 		file = new File(folder1, "file2.txt");
 		write(file, "folder1--file2.txt");
 		file = new File(folder2, "file1.txt");
 		write(file, "folder--file1.txt");
 		file = new File(folder2, "file2.txt");
 		write(file, "folder2--file2.txt");
 
 		Git git = new Git(db);
 		git.add().addFilepattern(folder1.getName())
 				.addFilepattern(folder2.getName()).call();
 		RevCommit base = git.commit().setMessage("adding folders").call();
 
 		recursiveDelete(folder1);
 		recursiveDelete(folder2);
 		git.rm().addFilepattern("folder1/file1.txt")
 				.addFilepattern("folder1/file2.txt")
 				.addFilepattern("folder2/file1.txt")
 				.addFilepattern("folder2/file2.txt").call();
 		RevCommit other = git.commit()
 				.setMessage("removing folders on 'branch'").call();
 
 		git.checkout().setName(base.name()).call();
 
 		file = new File(folder2, "file3.txt");
 		write(file, "folder2--file3.txt");
 
 		git.add().addFilepattern(folder2.getName()).call();
 		git.commit().setMessage("adding another file").call();
 
 		MergeResult result = git.merge().include(other.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 
 		assertEquals(MergeResult.MergeStatus.MERGED,
 				result.getMergeStatus());
 		assertFalse(folder1.exists());
 	}
 
 	@Test
 	public void testFileModeMerge() throws Exception {
 		if (!FS.DETECTED.supportsExecute())
 			return;
 		// Only Java6
 		Git git = new Git(db);
 
 		writeTrashFile("mergeableMode", "a");
 		setExecutable(git, "mergeableMode", false);
 		writeTrashFile("conflictingModeWithBase", "a");
 		setExecutable(git, "conflictingModeWithBase", false);
 		RevCommit initialCommit = addAllAndCommit(git);
 
 		// switch branch
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 		setExecutable(git, "mergeableMode", true);
 		writeTrashFile("conflictingModeNoBase", "b");
 		setExecutable(git, "conflictingModeNoBase", true);
 		RevCommit sideCommit = addAllAndCommit(git);
 
 		// switch branch
 		createBranch(initialCommit, "refs/heads/side2");
 		checkoutBranch("refs/heads/side2");
 		setExecutable(git, "mergeableMode", false);
 		assertFalse(new File(git.getRepository().getWorkTree(),
 				"conflictingModeNoBase").exists());
 		writeTrashFile("conflictingModeNoBase", "b");
 		setExecutable(git, "conflictingModeNoBase", false);
 		addAllAndCommit(git);
 
 		// merge
 		MergeResult result = git.merge().include(sideCommit.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 		assertEquals(MergeStatus.CONFLICTING, result.getMergeStatus());
 		assertTrue(canExecute(git, "mergeableMode"));
 		assertFalse(canExecute(git, "conflictingModeNoBase"));
 	}
 
 	@Test
 	public void testFileModeMergeWithDirtyWorkTree() throws Exception {
 		if (!FS.DETECTED.supportsExecute())
 			return;
 		// Only Java6 (or set x bit in index)
 
 		Git git = new Git(db);
 
 		writeTrashFile("mergeableButDirty", "a");
 		setExecutable(git, "mergeableButDirty", false);
 		RevCommit initialCommit = addAllAndCommit(git);
 
 		// switch branch
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 		setExecutable(git, "mergeableButDirty", true);
 		RevCommit sideCommit = addAllAndCommit(git);
 
 		// switch branch
 		createBranch(initialCommit, "refs/heads/side2");
 		checkoutBranch("refs/heads/side2");
 		setExecutable(git, "mergeableButDirty", false);
 		addAllAndCommit(git);
 
 		writeTrashFile("mergeableButDirty", "b");
 
 		// merge
 		MergeResult result = git.merge().include(sideCommit.getId())
 				.setStrategy(MergeStrategy.RESOLVE).call();
 		assertEquals(MergeStatus.FAILED, result.getMergeStatus());
 		assertFalse(canExecute(git, "mergeableButDirty"));
 	}
 
 	@Test
 	public void testSquashFastForward() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("file1", "file1");
 		git.add().addFilepattern("file1").call();
 		RevCommit first = git.commit().setMessage("initial commit").call();
 
 		assertTrue(new File(db.getWorkTree(), "file1").exists());
 		createBranch(first, "refs/heads/branch1");
 		checkoutBranch("refs/heads/branch1");
 
 		writeTrashFile("file2", "file2");
 		git.add().addFilepattern("file2").call();
 		RevCommit second = git.commit().setMessage("second commit").call();
 		assertTrue(new File(db.getWorkTree(), "file2").exists());
 
 		writeTrashFile("file3", "file3");
 		git.add().addFilepattern("file3").call();
 		RevCommit third = git.commit().setMessage("third commit").call();
 		assertTrue(new File(db.getWorkTree(), "file3").exists());
 
 		checkoutBranch("refs/heads/master");
 		assertTrue(new File(db.getWorkTree(), "file1").exists());
 		assertFalse(new File(db.getWorkTree(), "file2").exists());
 		assertFalse(new File(db.getWorkTree(), "file3").exists());
 
 		MergeResult result = git.merge().include(db.getRef("branch1"))
 				.setSquash(true).call();
 
 		assertTrue(new File(db.getWorkTree(), "file1").exists());
 		assertTrue(new File(db.getWorkTree(), "file2").exists());
 		assertTrue(new File(db.getWorkTree(), "file3").exists());
 		assertEquals(MergeResult.MergeStatus.FAST_FORWARD_SQUASHED,
 				result.getMergeStatus());
 		assertEquals(first, result.getNewHead()); // HEAD didn't move
 		assertEquals(first, db.resolve(Constants.HEAD + "^{commit}"));
 
 		assertEquals(
 				"Squashed commit of the following:\n\ncommit "
 						+ third.getName()
 						+ "\nAuthor: "
 						+ third.getAuthorIdent().getName()
 						+ " <"
 						+ third.getAuthorIdent().getEmailAddress()
 						+ ">\nDate:   "
 						+ dateFormatter.formatDate(third
 								.getAuthorIdent())
 						+ "\n\n\tthird commit\n\ncommit "
 						+ second.getName()
 						+ "\nAuthor: "
 						+ second.getAuthorIdent().getName()
 						+ " <"
 						+ second.getAuthorIdent().getEmailAddress()
 						+ ">\nDate:   "
 						+ dateFormatter.formatDate(second
 								.getAuthorIdent()) + "\n\n\tsecond commit\n",
 				db.readSquashCommitMsg());
 		assertNull(db.readMergeCommitMsg());
 
 		Status stat = git.status().call();
 		assertEquals(Sets.of("file2", "file3"), stat.getAdded());
 	}
 
 	@Test
 	public void testSquashMerge() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("file1", "file1");
 		git.add().addFilepattern("file1").call();
 		RevCommit first = git.commit().setMessage("initial commit").call();
 
 		assertTrue(new File(db.getWorkTree(), "file1").exists());
 		createBranch(first, "refs/heads/branch1");
 
 		writeTrashFile("file2", "file2");
 		git.add().addFilepattern("file2").call();
 		RevCommit second = git.commit().setMessage("second commit").call();
 		assertTrue(new File(db.getWorkTree(), "file2").exists());
 
 		checkoutBranch("refs/heads/branch1");
 
 		writeTrashFile("file3", "file3");
 		git.add().addFilepattern("file3").call();
 		RevCommit third = git.commit().setMessage("third commit").call();
 		assertTrue(new File(db.getWorkTree(), "file3").exists());
 
 		checkoutBranch("refs/heads/master");
 		assertTrue(new File(db.getWorkTree(), "file1").exists());
 		assertTrue(new File(db.getWorkTree(), "file2").exists());
 		assertFalse(new File(db.getWorkTree(), "file3").exists());
 
 		MergeResult result = git.merge().include(db.getRef("branch1"))
 				.setSquash(true).call();
 
 		assertTrue(new File(db.getWorkTree(), "file1").exists());
 		assertTrue(new File(db.getWorkTree(), "file2").exists());
 		assertTrue(new File(db.getWorkTree(), "file3").exists());
 		assertEquals(MergeResult.MergeStatus.MERGED_SQUASHED,
 				result.getMergeStatus());
 		assertEquals(second, result.getNewHead()); // HEAD didn't move
 		assertEquals(second, db.resolve(Constants.HEAD + "^{commit}"));
 
 		assertEquals(
 				"Squashed commit of the following:\n\ncommit "
 						+ third.getName()
 						+ "\nAuthor: "
 						+ third.getAuthorIdent().getName()
 						+ " <"
 						+ third.getAuthorIdent().getEmailAddress()
 						+ ">\nDate:   "
 						+ dateFormatter.formatDate(third
 								.getAuthorIdent()) + "\n\n\tthird commit\n",
 				db.readSquashCommitMsg());
 		assertNull(db.readMergeCommitMsg());
 
 		Status stat = git.status().call();
 		assertEquals(Sets.of("file3"), stat.getAdded());
 	}
 
 	@Test
 	public void testSquashMergeConflict() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("file1", "file1");
 		git.add().addFilepattern("file1").call();
 		RevCommit first = git.commit().setMessage("initial commit").call();
 
 		assertTrue(new File(db.getWorkTree(), "file1").exists());
 		createBranch(first, "refs/heads/branch1");
 
 		writeTrashFile("file2", "master");
 		git.add().addFilepattern("file2").call();
 		RevCommit second = git.commit().setMessage("second commit").call();
 		assertTrue(new File(db.getWorkTree(), "file2").exists());
 
 		checkoutBranch("refs/heads/branch1");
 
 		writeTrashFile("file2", "branch");
 		git.add().addFilepattern("file2").call();
 		RevCommit third = git.commit().setMessage("third commit").call();
 		assertTrue(new File(db.getWorkTree(), "file2").exists());
 
 		checkoutBranch("refs/heads/master");
 		assertTrue(new File(db.getWorkTree(), "file1").exists());
 		assertTrue(new File(db.getWorkTree(), "file2").exists());
 
 		MergeResult result = git.merge().include(db.getRef("branch1"))
 				.setSquash(true).call();
 
 		assertTrue(new File(db.getWorkTree(), "file1").exists());
 		assertTrue(new File(db.getWorkTree(), "file2").exists());
 		assertEquals(MergeResult.MergeStatus.CONFLICTING,
 				result.getMergeStatus());
 		assertNull(result.getNewHead());
 		assertEquals(second, db.resolve(Constants.HEAD + "^{commit}"));
 
 		assertEquals(
 				"Squashed commit of the following:\n\ncommit "
 						+ third.getName()
 						+ "\nAuthor: "
 						+ third.getAuthorIdent().getName()
 						+ " <"
 						+ third.getAuthorIdent().getEmailAddress()
 						+ ">\nDate:   "
 						+ dateFormatter.formatDate(third
 								.getAuthorIdent()) + "\n\n\tthird commit\n",
 				db.readSquashCommitMsg());
 		assertEquals("\nConflicts:\n\tfile2\n", db.readMergeCommitMsg());
 
 		Status stat = git.status().call();
 		assertEquals(Sets.of("file2"), stat.getConflicting());
 	}
 
 	@Test
 	public void testFastForwardOnly() throws Exception {
 		Git git = new Git(db);
 		RevCommit initialCommit = git.commit().setMessage("initial commit")
 				.call();
 		createBranch(initialCommit, "refs/heads/branch1");
 		git.commit().setMessage("second commit").call();
 		checkoutBranch("refs/heads/branch1");
 
 		MergeCommand merge = git.merge();
 		merge.setFastForward(FastForwardMode.FF_ONLY);
 		merge.include(db.getRef(Constants.MASTER));
 		MergeResult result = merge.call();
 
 		assertEquals(MergeStatus.FAST_FORWARD, result.getMergeStatus());
 	}
 
 	@Test
 	public void testNoFastForward() throws Exception {
 		Git git = new Git(db);
 		RevCommit initialCommit = git.commit().setMessage("initial commit")
 				.call();
 		createBranch(initialCommit, "refs/heads/branch1");
 		git.commit().setMessage("second commit").call();
 		checkoutBranch("refs/heads/branch1");
 
 		MergeCommand merge = git.merge();
 		merge.setFastForward(FastForwardMode.NO_FF);
 		merge.include(db.getRef(Constants.MASTER));
 		MergeResult result = merge.call();
 
 		assertEquals(MergeStatus.MERGED, result.getMergeStatus());
 	}
 
 	@Test
 	public void testNoFastForwardNoCommit() throws Exception {
 		// given
 		Git git = new Git(db);
 		RevCommit initialCommit = git.commit().setMessage("initial commit")
 				.call();
 		createBranch(initialCommit, "refs/heads/branch1");
 		RevCommit secondCommit = git.commit().setMessage("second commit")
 				.call();
 		checkoutBranch("refs/heads/branch1");
 
 		// when
 		MergeCommand merge = git.merge();
 		merge.setFastForward(FastForwardMode.NO_FF);
 		merge.include(db.getRef(Constants.MASTER));
 		merge.setCommit(false);
 		MergeResult result = merge.call();
 
 		// then
 		assertEquals(MergeStatus.MERGED_NOT_COMMITTED, result.getMergeStatus());
 		assertEquals(2, result.getMergedCommits().length);
 		assertEquals(initialCommit, result.getMergedCommits()[0]);
 		assertEquals(secondCommit, result.getMergedCommits()[1]);
 		assertNull(result.getNewHead());
 		assertEquals(RepositoryState.MERGING_RESOLVED, db.getRepositoryState());
 	}
 
 	@Test
 	public void testFastForwardOnlyNotPossible() throws Exception {
 		Git git = new Git(db);
 		RevCommit initialCommit = git.commit().setMessage("initial commit")
 				.call();
 		createBranch(initialCommit, "refs/heads/branch1");
 		git.commit().setMessage("second commit").call();
 		checkoutBranch("refs/heads/branch1");
 		writeTrashFile("file1", "branch1");
 		git.add().addFilepattern("file").call();
 		git.commit().setMessage("second commit on branch1").call();
 		MergeCommand merge = git.merge();
 		merge.setFastForward(FastForwardMode.FF_ONLY);
 		merge.include(db.getRef(Constants.MASTER));
 		MergeResult result = merge.call();
 
 		assertEquals(MergeStatus.ABORTED, result.getMergeStatus());
 	}
 
 	@Test
 	public void testRecursiveMergeWithConflict() throws Exception {
 		TestRepository<Repository> db_t = new TestRepository<Repository>(db);
 		BranchBuilder master = db_t.branch("master");
 		RevCommit m0 = master.commit().add("f", "1\n2\n3\n4\n5\n6\n7\n8\n9\n")
 				.message("m0").create();
 		RevCommit m1 = master.commit()
 				.add("f", "1-master\n2\n3\n4\n5\n6\n7\n8\n9\n").message("m1")
 				.create();
 		db_t.getRevWalk().parseCommit(m1);
 
 		BranchBuilder side = db_t.branch("side");
 		RevCommit s1 = side.commit().parent(m0)
 				.add("f", "1\n2\n3\n4\n5\n6\n7\n8\n9-side\n").message("s1")
 				.create();
 		RevCommit s2 = side.commit().parent(m1)
 				.add("f", "1-master\n2\n3\n4\n5\n6\n7-res(side)\n8\n9-side\n")
 				.message("s2(merge)").create();
 		master.commit().parent(s1)
 				.add("f", "1-master\n2\n3\n4\n5\n6\n7-conflict\n8\n9-side\n")
 				.message("m2(merge)").create();
 
 		Git git = Git.wrap(db);
 		git.checkout().setName("master").call();
 
 		MergeResult result = git.merge().setStrategy(MergeStrategy.RECURSIVE)
 				.include("side", s2).call();
 		assertEquals(MergeStatus.CONFLICTING, result.getMergeStatus());
 	}
 
 	@Test
 	public void testMergeWithMessageOption() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("a", "1\na\n3\n");
 		git.add().addFilepattern("a").call();
 		RevCommit initialCommit = git.commit().setMessage("initial").call();
 
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 
 		writeTrashFile("b", "1\nb\n3\n");
 		git.add().addFilepattern("b").call();
 		git.commit().setMessage("side").call();
 
 		checkoutBranch("refs/heads/master");
 
 		writeTrashFile("c", "1\nc\n3\n");
 		git.add().addFilepattern("c").call();
 		git.commit().setMessage("main").call();
 
 		Ref sideBranch = db.getRef("side");
 
 		git.merge().include(sideBranch).setStrategy(MergeStrategy.RESOLVE)
 				.setMessage("user message").call();
 
 		assertNull(db.readMergeCommitMsg());
 
 		Iterator<RevCommit> it = git.log().call().iterator();
 		RevCommit newHead = it.next();
 		assertEquals("user message", newHead.getFullMessage());
 	}
 
 	@Test
 	public void testMergeConflictWithMessageOption() throws Exception {
 		Git git = new Git(db);
 
 		writeTrashFile("a", "1\na\n3\n");
 		git.add().addFilepattern("a").call();
 		RevCommit initialCommit = git.commit().setMessage("initial").call();
 
 		createBranch(initialCommit, "refs/heads/side");
 		checkoutBranch("refs/heads/side");
 
 		writeTrashFile("a", "1\na(side)\n3\n");
 		git.add().addFilepattern("a").call();
 		git.commit().setMessage("side").call();
 
 		checkoutBranch("refs/heads/master");
 
 		writeTrashFile("a", "1\na(main)\n3\n");
 		git.add().addFilepattern("a").call();
 		git.commit().setMessage("main").call();
 
 		Ref sideBranch = db.getRef("side");
 
 		git.merge().include(sideBranch).setStrategy(MergeStrategy.RESOLVE)
 				.setMessage("user message").call();
 
 		assertEquals("user message\n\nConflicts:\n\ta\n",
 				db.readMergeCommitMsg());
 	}
 
 	private static void setExecutable(Git git, String path, boolean executable) {
 		FS.DETECTED.setExecute(
 				new File(git.getRepository().getWorkTree(), path), executable);
 	}
 
 	private static boolean canExecute(Git git, String path) {
 		return FS.DETECTED.canExecute(new File(git.getRepository()
 				.getWorkTree(), path));
 	}
 
 	private static RevCommit addAllAndCommit(final Git git) throws Exception {
 		git.add().addFilepattern(".").call();
 		return git.commit().setMessage("message").call();
 	}
 
 	private void checkMergeFailedResult(final MergeResult result,
 			final MergeFailureReason reason,
 			final String indexState, final File fileA) throws Exception {
 		assertEquals(MergeStatus.FAILED, result.getMergeStatus());
 		assertEquals(reason, result.getFailingPaths().get("a"));
 		assertEquals("a(modified)", read(fileA));
 		assertFalse(new File(db.getWorkTree(), "b").exists());
 		assertEquals("c", read(new File(db.getWorkTree(), "c")));
 		assertEquals(indexState, indexState(CONTENT));
 		assertEquals(null, result.getConflicts());
 		assertEquals(RepositoryState.SAFE, db.getRepositoryState());
 	}
 }