Fix a number of failing conflict situations

Adds further tests where the working tree is dirty (differs from
index) and where we have staged but uncommitted changes.

Fixed the test case 9 for file/directory conflicts.

Bug: 428819
Change-Id: Ie44a288b052abe936ebb74272d0fefef3b218a7a
Signed-off-by: Axel Richard <axel.richard@obeo.fr>
Signed-off-by: Robin Rosenberg <robin.rosenberg@dewire.com>
Signed-off-by: Christian Halstrick <christian.halstrick@sap.com>

org.eclipse.jgit.pgm.test/META-INF/MANIFEST.MF

@@ -8,6 +8,8 @@ Bundle-Localization: plugin
 Bundle-ActivationPolicy: lazy
 Bundle-RequiredExecutionEnvironment: J2SE-1.5
 Import-Package: org.eclipse.jgit.api;version="[3.4.0,3.5.0)",
+ org.eclipse.jgit.api.errors;version="[3.4.0,3.5.0)",
+ org.eclipse.jgit.diff;version="[3.4.0,3.5.0)",
  org.eclipse.jgit.dircache;version="[3.4.0,3.5.0)",
  org.eclipse.jgit.junit;version="[3.4.0,3.5.0)",
  org.eclipse.jgit.lib;version="[3.4.0,3.5.0)",

org.eclipse.jgit.pgm.test/tst/org/eclipse/jgit/pgm/CheckoutTest.java

@@ -43,15 +43,21 @@
 package org.eclipse.jgit.pgm;
 
 import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertNotNull;
 
 import java.io.File;
+import java.util.List;
 
 import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.errors.CheckoutConflictException;
+import org.eclipse.jgit.diff.DiffEntry;
 import org.eclipse.jgit.lib.CLIRepositoryTestCase;
 import org.eclipse.jgit.lib.FileMode;
 import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.revwalk.RevCommit;
 import org.eclipse.jgit.treewalk.FileTreeIterator;
 import org.eclipse.jgit.treewalk.FileTreeIterator.FileEntry;
+import org.eclipse.jgit.treewalk.TreeWalk;
 import org.eclipse.jgit.util.FileUtils;
 import org.junit.Assert;
 import org.junit.Test;
@@ -150,6 +156,7 @@ public class CheckoutTest extends CLIRepositoryTestCase {
 	 * <li>Delete file 'a' in the working tree
 	 * <li>Checkout branch '1'
 	 * </ol>
+	 * <p>
 	 * The working tree should contain 'a' with FileMode.REGULAR_FILE after the
 	 * checkout.
 	 *
@@ -181,6 +188,359 @@ public class CheckoutTest extends CLIRepositoryTestCase {
 		assertEquals("Hello world a", read(fileA));
 	}
 
+	/**
+	 * Steps:
+	 * <ol>
+	 * <li>Add file 'b'
+	 * <li>Commit
+	 * <li>Create branch '1'
+	 * <li>Add folder 'a'
+	 * <li>Commit
+	 * <li>Replace folder 'a' by file 'a' in the working tree
+	 * <li>Checkout branch '1'
+	 * </ol>
+	 * <p>
+	 * The working tree should contain 'a' with FileMode.REGULAR_FILE after the
+	 * checkout.
+	 *
+	 * @throws Exception
+	 */
+	@Test
+	public void fileModeTestMissingThenFolderWithFileInWorkingTree()
+			throws Exception {
+		Git git = new Git(db);
+		writeTrashFile("b", "Hello world b");
+		git.add().addFilepattern(".").call();
+		git.commit().setMessage("add file b").call();
+		Ref branch_1 = git.branchCreate().setName("branch_1").call();
+		File folderA = new File(db.getWorkTree(), "a");
+		FileUtils.mkdirs(folderA);
+		writeTrashFile("a/c", "Hello world c");
+		git.add().addFilepattern(".").call();
+		git.commit().setMessage("add folder a").call();
+
+		FileEntry entry = new FileTreeIterator.FileEntry(new File(
+				db.getWorkTree(), "a"), db.getFS());
+		assertEquals(FileMode.TREE, entry.getMode());
+
+		FileUtils.delete(folderA, FileUtils.RECURSIVE);
+		writeTrashFile("a", "b");
+
+		entry = new FileTreeIterator.FileEntry(new File(db.getWorkTree(), "a"),
+				db.getFS());
+		assertEquals(FileMode.REGULAR_FILE, entry.getMode());
+
+		git.checkout().setName(branch_1.getName()).call();
+
+		entry = new FileTreeIterator.FileEntry(new File(db.getWorkTree(), "a"),
+				db.getFS());
+		assertEquals(FileMode.REGULAR_FILE, entry.getMode());
+	}
+
+	/**
+	 * Steps:
+	 * <ol>
+	 * <li>Add file 'a'
+	 * <li>Commit
+	 * <li>Create branch '1'
+	 * <li>Replace file 'a' by folder 'a'
+	 * <li>Commit
+	 * <li>Delete folder 'a' in the working tree
+	 * <li>Checkout branch '1'
+	 * </ol>
+	 * <p>
+	 * The working tree should contain 'a' with FileMode.REGULAR_FILE after the
+	 * checkout.
+	 *
+	 * @throws Exception
+	 */
+	@Test
+	public void fileModeTestFolderWithMissingInWorkingTree() throws Exception {
+		Git git = new Git(db);
+		writeTrashFile("b", "Hello world b");
+		writeTrashFile("a", "b");
+		git.add().addFilepattern(".").call();
+		git.commit().setMessage("add file b & file a").call();
+		Ref branch_1 = git.branchCreate().setName("branch_1").call();
+		git.rm().addFilepattern("a").call();
+		File folderA = new File(db.getWorkTree(), "a");
+		FileUtils.mkdirs(folderA);
+		writeTrashFile("a/c", "Hello world c");
+		git.add().addFilepattern(".").call();
+		git.commit().setMessage("add folder a").call();
+
+		FileEntry entry = new FileTreeIterator.FileEntry(new File(
+				db.getWorkTree(), "a"), db.getFS());
+		assertEquals(FileMode.TREE, entry.getMode());
+
+		FileUtils.delete(folderA, FileUtils.RECURSIVE);
+
+		git.checkout().setName(branch_1.getName()).call();
+
+		entry = new FileTreeIterator.FileEntry(new File(db.getWorkTree(), "a"),
+				db.getFS());
+		assertEquals(FileMode.REGULAR_FILE, entry.getMode());
+	}
+
+	/**
+	 * Steps:
+	 * <ol>
+	 * <li>Add file 'a'
+	 * <li>Commit
+	 * <li>Create branch '1'
+	 * <li>Delete file 'a'
+	 * <li>Commit
+	 * <li>Add folder 'a' in the working tree
+	 * <li>Checkout branch '1'
+	 * </ol>
+	 * <p>
+	 * The checkout command should raise an error. The conflicting paths are 'a'
+	 * and 'a/c'.
+	 *
+	 * @throws Exception
+	 */
+	@Test
+	public void fileModeTestMissingWithFolderInWorkingTree() throws Exception {
+		Git git = new Git(db);
+		writeTrashFile("b", "Hello world b");
+		writeTrashFile("a", "b");
+		git.add().addFilepattern(".").call();
+		git.commit().setMessage("add file b & file a").call();
+		Ref branch_1 = git.branchCreate().setName("branch_1").call();
+		git.rm().addFilepattern("a").call();
+		git.commit().setMessage("delete file a").call();
+
+		FileUtils.mkdirs(new File(db.getWorkTree(), "a"));
+		writeTrashFile("a/c", "Hello world c");
+
+		FileEntry entry = new FileTreeIterator.FileEntry(new File(
+				db.getWorkTree(), "a"), db.getFS());
+		assertEquals(FileMode.TREE, entry.getMode());
+
+		CheckoutConflictException exception = null;
+		try {
+			git.checkout().setName(branch_1.getName()).call();
+		} catch (CheckoutConflictException e) {
+			exception = e;
+		}
+		assertNotNull(exception);
+		assertEquals(2, exception.getConflictingPaths().size());
+		assertEquals("a", exception.getConflictingPaths().get(0));
+		assertEquals("a/c", exception.getConflictingPaths().get(1));
+	}
+
+	/**
+	 * Steps:
+	 * <ol>
+	 * <li>Add folder 'a'
+	 * <li>Commit
+	 * <li>Create branch '1'
+	 * <li>Delete folder 'a'
+	 * <li>Commit
+	 * <li>Add file 'a' in the working tree
+	 * <li>Checkout branch '1'
+	 * </ol>
+	 * <p>
+	 * The checkout command should raise an error. The conflicting path is 'a'.
+	 *
+	 * @throws Exception
+	 */
+	@Test
+	public void fileModeTestFolderThenMissingWithFileInWorkingTree()
+			throws Exception {
+		Git git = new Git(db);
+		FileUtils.mkdirs(new File(db.getWorkTree(), "a"));
+		writeTrashFile("a/c", "Hello world c");
+		writeTrashFile("b", "Hello world b");
+		git.add().addFilepattern(".").call();
+		RevCommit commit1 = git.commit().setMessage("add folder a & file b")
+				.call();
+		Ref branch_1 = git.branchCreate().setName("branch_1").call();
+		git.rm().addFilepattern("a").call();
+		RevCommit commit2 = git.commit().setMessage("delete folder a").call();
+
+		TreeWalk tw = new TreeWalk(db);
+		tw.addTree(commit1.getTree());
+		tw.addTree(commit2.getTree());
+		List<DiffEntry> scan = DiffEntry.scan(tw);
+		assertEquals(1, scan.size());
+		assertEquals(FileMode.MISSING, scan.get(0).getNewMode());
+		assertEquals(FileMode.TREE, scan.get(0).getOldMode());
+
+		writeTrashFile("a", "b");
+
+		FileEntry entry = new FileTreeIterator.FileEntry(new File(
+				db.getWorkTree(), "a"), db.getFS());
+		assertEquals(FileMode.REGULAR_FILE, entry.getMode());
+
+		CheckoutConflictException exception = null;
+		try {
+			git.checkout().setName(branch_1.getName()).call();
+		} catch (CheckoutConflictException e) {
+			exception = e;
+		}
+		assertNotNull(exception);
+		assertEquals(1, exception.getConflictingPaths().size());
+		assertEquals("a", exception.getConflictingPaths().get(0));
+	}
+
+	/**
+	 * Steps:
+	 * <ol>
+	 * <li>Add folder 'a'
+	 * <li>Commit
+	 * <li>Create branch '1'
+	 * <li>Replace folder 'a'by file 'a'
+	 * <li>Commit
+	 * <li>Delete file 'a' in the working tree
+	 * <li>Checkout branch '1'
+	 * </ol>
+	 * <p>
+	 * The working tree should contain 'a' with FileMode.TREE after the
+	 * checkout.
+	 *
+	 * @throws Exception
+	 */
+	@Test
+	public void fileModeTestFolderThenFileWithMissingInWorkingTree()
+			throws Exception {
+		Git git = new Git(db);
+		FileUtils.mkdirs(new File(db.getWorkTree(), "a"));
+		writeTrashFile("a/c", "Hello world c");
+		writeTrashFile("b", "Hello world b");
+		git.add().addFilepattern(".").call();
+		git.commit().setMessage("add folder a & file b").call();
+		Ref branch_1 = git.branchCreate().setName("branch_1").call();
+		git.rm().addFilepattern("a").call();
+		File fileA = new File(db.getWorkTree(), "a");
+		writeTrashFile("a", "b");
+		git.add().addFilepattern("a").call();
+		git.commit().setMessage("add file a").call();
+
+		FileEntry entry = new FileTreeIterator.FileEntry(new File(
+				db.getWorkTree(), "a"), db.getFS());
+		assertEquals(FileMode.REGULAR_FILE, entry.getMode());
+
+		FileUtils.delete(fileA);
+
+		git.checkout().setName(branch_1.getName()).call();
+
+		entry = new FileTreeIterator.FileEntry(new File(db.getWorkTree(), "a"),
+				db.getFS());
+		assertEquals(FileMode.TREE, entry.getMode());
+	}
+
+	/**
+	 * Steps:
+	 * <ol>
+	 * <li>Add file 'a'
+	 * <li>Commit
+	 * <li>Create branch '1'
+	 * <li>Modify file 'a'
+	 * <li>Commit
+	 * <li>Delete file 'a' & replace by folder 'a' in the working tree & index
+	 * <li>Checkout branch '1'
+	 * </ol>
+	 * <p>
+	 * The checkout command should raise an error. The conflicting path is 'a'.
+	 *
+	 * @throws Exception
+	 */
+	@Test
+	public void fileModeTestFileThenFileWithFolderInIndex() throws Exception {
+		Git git = new Git(db);
+		writeTrashFile("a", "Hello world a");
+		writeTrashFile("b", "Hello world b");
+		git.add().addFilepattern(".").call();
+		git.commit().setMessage("add files a & b").call();
+		Ref branch_1 = git.branchCreate().setName("branch_1").call();
+		writeTrashFile("a", "b");
+		git.add().addFilepattern("a").call();
+		git.commit().setMessage("add file a").call();
+
+		FileEntry entry = new FileTreeIterator.FileEntry(new File(
+				db.getWorkTree(), "a"), db.getFS());
+		assertEquals(FileMode.REGULAR_FILE, entry.getMode());
+
+		git.rm().addFilepattern("a").call();
+		FileUtils.mkdirs(new File(db.getWorkTree(), "a"));
+		writeTrashFile("a/c", "Hello world c");
+		git.add().addFilepattern(".").call();
+
+		entry = new FileTreeIterator.FileEntry(new File(db.getWorkTree(), "a"),
+				db.getFS());
+		assertEquals(FileMode.TREE, entry.getMode());
+
+		CheckoutConflictException exception = null;
+		try {
+			git.checkout().setName(branch_1.getName()).call();
+		} catch (CheckoutConflictException e) {
+			exception = e;
+		}
+		assertNotNull(exception);
+		assertEquals(1, exception.getConflictingPaths().size());
+		assertEquals("a", exception.getConflictingPaths().get(0));
+	}
+
+	/**
+	 * Steps:
+	 * <ol>
+	 * <li>Add file 'a'
+	 * <li>Commit
+	 * <li>Create branch '1'
+	 * <li>Modify file 'a'
+	 * <li>Commit
+	 * <li>Delete file 'a' & replace by folder 'a' in the working tree & index
+	 * <li>Checkout branch '1'
+	 * </ol>
+	 * <p>
+	 * The checkout command should raise an error. The conflicting paths are 'a'
+	 * and 'a/c'.
+	 *
+	 * @throws Exception
+	 */
+	@Test
+	public void fileModeTestFileWithFolderInIndex() throws Exception {
+		Git git = new Git(db);
+		writeTrashFile("b", "Hello world b");
+		writeTrashFile("a", "b");
+		git.add().addFilepattern(".").call();
+		git.commit().setMessage("add file b & file a").call();
+		Ref branch_1 = git.branchCreate().setName("branch_1").call();
+		git.rm().addFilepattern("a").call();
+		writeTrashFile("a", "Hello world a");
+		git.add().addFilepattern("a").call();
+		git.commit().setMessage("add file a").call();
+
+		FileEntry entry = new FileTreeIterator.FileEntry(new File(
+				db.getWorkTree(), "a"), db.getFS());
+		assertEquals(FileMode.REGULAR_FILE, entry.getMode());
+
+		git.rm().addFilepattern("a").call();
+		FileUtils.mkdirs(new File(db.getWorkTree(), "a"));
+		writeTrashFile("a/c", "Hello world c");
+		git.add().addFilepattern(".").call();
+
+		entry = new FileTreeIterator.FileEntry(new File(db.getWorkTree(), "a"),
+				db.getFS());
+		assertEquals(FileMode.TREE, entry.getMode());
+
+		CheckoutConflictException exception = null;
+		try {
+			git.checkout().setName(branch_1.getName()).call();
+		} catch (CheckoutConflictException e) {
+			exception = e;
+		}
+		assertNotNull(exception);
+		assertEquals(1, exception.getConflictingPaths().size());
+		assertEquals("a", exception.getConflictingPaths().get(0));
+
+		// TODO: ideally we'd like to get two paths from this exception
+		// assertEquals(2, exception.getConflictingPaths().size());
+		// assertEquals("a", exception.getConflictingPaths().get(0));
+		// assertEquals("a/c", exception.getConflictingPaths().get(1));
+	}
+
 	static private void assertEquals(Object expected, Object actual) {
 		Assert.assertEquals(expected, actual);
 	}

org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/DirCacheCheckoutTest.java

@@ -619,7 +619,7 @@ public class DirCacheCheckoutTest extends RepositoryTestCase {
 	@Test
 	public void testDirectoryFileConflicts_9() throws Exception {
 		// 9
-		doit(mk("DF"), mkmap("DF", "QP"), mk("DF/DF"));
+		doit(mkmap("DF", "QP"), mkmap("DF", "QP"), mkmap("DF/DF", "DF/DF"));
 		assertRemoved("DF/DF");
 		assertUpdated("DF");
 	}

org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheCheckout.java

@@ -562,7 +562,7 @@ public class DirCacheCheckout {
 		 * 6b   D        F       F       N         N       N       N           Conflict
 		 * 7    F        D       F       Y         Y       N       N           Update
 		 * 8    F        D       F       N         Y       N       N           Conflict
-		 * 9    F        D       F       Y         N       N       N           Update
+		 * 9    F        D       F                 N       N       N           Conflict
 		 * 10   F        D       D                 N       N       Y           Keep
 		 * 11   F        D       D                 N       N       N           Conflict
 		 * 12   F        F       D       Y         N       Y       N           Update
@@ -610,7 +610,7 @@ public class DirCacheCheckout {
 			// switch processes all relevant cases.
 			switch (ffMask) {
 			case 0xDDF: // 1 2
-				if (isModified(name)) {
+				if (f != null && isModifiedSubtree_IndexWorkingtree(name)) {
 					conflict(name, dce, h, m); // 1
 				} else {
 					update(name, mId, mMode); // 2
@@ -647,32 +647,29 @@ public class DirCacheCheckout {
 				break;
 			case 0xFDF: // 7 8 9
 				if (equalIdAndMode(hId, hMode, mId, mMode)) {
-					if (isModified(name))
+					if (isModifiedSubtree_IndexWorkingtree(name))
 						conflict(name, dce, h, m); // 8
 					else
 						update(name, mId, mMode); // 7
-				} else if (!isModified(name))
+				} else
-					update(name, mId, mMode); // 9
+					conflict(name, dce, h, m); // 9
-				else
-					// To be confirmed - this case is not in the table.
-					conflict(name, dce, h, m);
 				break;
 			case 0xFD0: // keep without a rule
 				keep(dce);
 				break;
 			case 0xFFD: // 12 13 14
 				if (equalIdAndMode(hId, hMode, iId, iMode))
-					if (f == null
+					if (f != null
-							|| f.isModified(dce, true,
+							&& f.isModified(dce, true,
 									this.walk.getObjectReader()))
-						conflict(name, dce, h, m);
+						conflict(name, dce, h, m); // 13
 					else
-						remove(name);
+						remove(name); // 12
 				else
-					conflict(name, dce, h, m);
+					conflict(name, dce, h, m); // 14
 				break;
 			case 0x0DF: // 16 17
-				if (!isModified(name))
+				if (!isModifiedSubtree_IndexWorkingtree(name))
 					update(name, mId, mMode);
 				else
 					conflict(name, dce, h, m);
@@ -684,12 +681,14 @@ public class DirCacheCheckout {
 		}
 
 		// if we have no file at all then there is nothing to do
-		if ((ffMask & 0x222) == 0)
+		if ((ffMask & 0x222) == 0
+				&& (f == null || FileMode.TREE.equals(f.getEntryFileMode())))
 			return;
 
 		if ((ffMask == 0x00F) && f != null && FileMode.TREE.equals(f.getEntryFileMode())) {
 			// File/Directory conflict case #20
 			conflict(name, null, h, m);
+			return;
 		}
 
 		if (i == null) {
@@ -768,7 +767,9 @@ public class DirCacheCheckout {
 				 * </pre>
 				 */
 
-				if (m == null || equalIdAndMode(mId, mMode, iId, iMode)) {
+				if (m == null
+						|| !isModified_IndexTree(name, iId, iMode, mId, mMode,
+								mergeCommitTree)) {
 					// Merge contains nothing or the same as Index
 					// Nothing in Head
 					// Something in Index
@@ -824,7 +825,7 @@ public class DirCacheCheckout {
 				 * 	           clean I==H  I==M       H        M        Result
 				 * 	         -----------------------------------------------------
 				 * 	        10 yes   yes   N/A     exists   nothing  remove path from index
-				 * 	        11 no    yes   N/A     exists   nothing  fail
+				 * 	        11 no    yes   N/A     exists   nothing  keep file
 				 * 	        12 yes   no    N/A     exists   nothing  fail
 				 * 	        13 no    no    N/A     exists   nothing  fail
 				 * </pre>
@@ -841,23 +842,31 @@ public class DirCacheCheckout {
 					// Something different from a submodule in Index
 					// Nothing in Merge
 					// Something in Head
-					if (equalIdAndMode(hId, hMode, iId, iMode)) {
+					if (!isModified_IndexTree(name, iId, iMode, hId, hMode,
+							headCommitTree)) {
 						// Index contains the same as Head
 						// Something different from a submodule in Index
 						// Nothing in Merge
 						// Something in Head
-						if (f == null
+						if (f != null
-								|| f.isModified(dce, true,
+								&& f.isModified(dce, true,
-										this.walk.getObjectReader()))
+										this.walk.getObjectReader())) {
 							// file is dirty
 							// Index contains the same as Head
 							// Something different from a submodule in Index
 							// Nothing in Merge
 							// Something in Head
-							// -> file is dirty but is should be removed. That's
+
-							// a conflict
+							if (!FileMode.TREE.equals(f.getEntryFileMode())
-							conflict(name, dce, h, m);
+									&& FileMode.TREE.equals(iMode))
+								// The workingtree contains a file and the index semantically contains a folder.
+								// Git considers the workingtree file as untracked. Just keep the untracked file.
+								return;
 							else
+								// -> file is dirty and tracked but is should be
+								// removed. That's a conflict
+								conflict(name, dce, h, m);
+						} else
 							// file doesn't exist or is clean
 							// Index contains the same as Head
 							// Something different from a submodule in Index
@@ -880,8 +889,10 @@ public class DirCacheCheckout {
 				// Something in Head
 				// Something in Index
 				if (!equalIdAndMode(hId, hMode, mId, mMode)
-						&& !equalIdAndMode(hId, hMode, iId, iMode)
+						&& isModified_IndexTree(name, iId, iMode, hId, hMode,
-						&& !equalIdAndMode(mId, mMode, iId, iMode))
+								headCommitTree)
+						&& isModified_IndexTree(name, iId, iMode, mId, mMode,
+								mergeCommitTree))
 					// All three contents in Head, Merge, Index differ from each
 					// other
 					// -> All contents differ. Report a conflict.
@@ -893,8 +904,10 @@ public class DirCacheCheckout {
 					// Something in Head
 					// Something in Index
 
-					if (equalIdAndMode(hId, hMode, iId, iMode)
+				if (!isModified_IndexTree(name, iId, iMode, hId, hMode,
-						&& !equalIdAndMode(mId, mMode, iId, iMode)) {
+						headCommitTree)
+						&& isModified_IndexTree(name, iId, iMode, mId, mMode,
+								mergeCommitTree)) {
 						// Head contains the same as Index. Merge differs
 						// Something in Merge
 
@@ -1036,8 +1049,19 @@ public class DirCacheCheckout {
 		}
 	}
 
-	private boolean isModified(String path) throws CorruptObjectException, IOException {
+	/**
+	 * Checks whether the subtree starting at a given path differs between Index and
+	 * workingtree.
+	 *
+	 * @param path
+	 * @return true if the subtrees differ
+	 * @throws CorruptObjectException
+	 * @throws IOException
+	 */
+	private boolean isModifiedSubtree_IndexWorkingtree(String path)
+			throws CorruptObjectException, IOException {
 		NameConflictTreeWalk tw = new NameConflictTreeWalk(repo);
+		try {
 			tw.addTree(new DirCacheIterator(dc));
 			tw.addTree(new FileTreeIterator(repo));
 			tw.setRecursive(true);
@@ -1055,6 +1079,58 @@ public class DirCacheCheckout {
 				}
 			}
 			return false;
+		} finally {
+			tw.release();
+		}
+	}
+
+	private boolean isModified_IndexTree(String path, ObjectId iId,
+			FileMode iMode, ObjectId tId, FileMode tMode, ObjectId rootTree)
+			throws CorruptObjectException, IOException {
+		if (iMode != tMode)
+			return true;
+		if (FileMode.TREE.equals(iMode)
+				&& (iId == null || ObjectId.zeroId().equals(iId)))
+			return isModifiedSubtree_IndexTree(path, rootTree);
+		else
+			return !equalIdAndMode(iId, iMode, tId, tMode);
+	}
+
+	/**
+	 * Checks whether the subtree starting at a given path differs between Index and
+	 * some tree.
+	 *
+	 * @param path
+	 * @param tree
+	 *            the tree to compare
+	 * @return true if the subtrees differ
+	 * @throws CorruptObjectException
+	 * @throws IOException
+	 */
+	private boolean isModifiedSubtree_IndexTree(String path, ObjectId tree)
+			throws CorruptObjectException, IOException {
+		NameConflictTreeWalk tw = new NameConflictTreeWalk(repo);
+		try {
+			tw.addTree(new DirCacheIterator(dc));
+			tw.addTree(tree);
+			tw.setRecursive(true);
+			tw.setFilter(PathFilter.create(path));
+			while (tw.next()) {
+				AbstractTreeIterator dcIt = tw.getTree(0,
+						DirCacheIterator.class);
+				AbstractTreeIterator treeIt = tw.getTree(1,
+						AbstractTreeIterator.class);
+				if (dcIt == null || treeIt == null)
+					return true;
+				if (dcIt.getEntryRawMode() != treeIt.getEntryRawMode())
+					return true;
+				if (!dcIt.getEntryObjectId().equals(treeIt.getEntryObjectId()))
+					return true;
+			}
+			return false;
+		} finally {
+			tw.release();
+		}
 	}
 
 	/**

org.eclipse.jgit/src/org/eclipse/jgit/treewalk/WorkingTreeIterator.java

@@ -832,6 +832,8 @@ public abstract class WorkingTreeIterator extends AbstractTreeIterator {
 	 */
 	public boolean isModified(DirCacheEntry entry, boolean forceContentCheck,
 			ObjectReader reader) throws IOException {
+		if (entry == null)
+			return !FileMode.MISSING.equals(getEntryFileMode());
 		MetadataDiff diff = compareMetadata(entry);
 		switch (diff) {
 		case DIFFER_BY_TIMESTAMP: