diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CommitCommandTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CommitCommandTest.java
index b39a68a22..9d87f0c29 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CommitCommandTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CommitCommandTest.java
@@ -186,297 +186,302 @@ public class CommitCommandTest extends RepositoryTestCase {
 
 	@Test
 	public void commitNewSubmodule() throws Exception {
-		Git git = new Git(db);
-		writeTrashFile("file.txt", "content");
-		git.add().addFilepattern("file.txt").call();
-		RevCommit commit = git.commit().setMessage("create file").call();
-
-		SubmoduleAddCommand command = new SubmoduleAddCommand(db);
-		String path = "sub";
-		command.setPath(path);
-		String uri = db.getDirectory().toURI().toString();
-		command.setURI(uri);
-		Repository repo = command.call();
-		assertNotNull(repo);
-		addRepoToClose(repo);
-
-		SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
-		assertTrue(generator.next());
-		assertEquals(path, generator.getPath());
-		assertEquals(commit, generator.getObjectId());
-		assertEquals(uri, generator.getModulesUrl());
-		assertEquals(path, generator.getModulesPath());
-		assertEquals(uri, generator.getConfigUrl());
-		Repository subModRepo = generator.getRepository();
-		assertNotNull(subModRepo);
-		subModRepo.close();
-		assertEquals(commit, repo.resolve(Constants.HEAD));
-
-		RevCommit submoduleCommit = git.commit().setMessage("submodule add")
-				.setOnly(path).call();
-		assertNotNull(submoduleCommit);
-		TreeWalk walk = new TreeWalk(db);
-		walk.addTree(commit.getTree());
-		walk.addTree(submoduleCommit.getTree());
-		walk.setFilter(TreeFilter.ANY_DIFF);
-		List<DiffEntry> diffs = DiffEntry.scan(walk);
-		assertEquals(1, diffs.size());
-		DiffEntry subDiff = diffs.get(0);
-		assertEquals(FileMode.MISSING, subDiff.getOldMode());
-		assertEquals(FileMode.GITLINK, subDiff.getNewMode());
-		assertEquals(ObjectId.zeroId(), subDiff.getOldId().toObjectId());
-		assertEquals(commit, subDiff.getNewId().toObjectId());
-		assertEquals(path, subDiff.getNewPath());
+		try (Git git = new Git(db)) {
+			writeTrashFile("file.txt", "content");
+			git.add().addFilepattern("file.txt").call();
+			RevCommit commit = git.commit().setMessage("create file").call();
+
+			SubmoduleAddCommand command = new SubmoduleAddCommand(db);
+			String path = "sub";
+			command.setPath(path);
+			String uri = db.getDirectory().toURI().toString();
+			command.setURI(uri);
+			Repository repo = command.call();
+			assertNotNull(repo);
+			addRepoToClose(repo);
+
+			SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
+			assertTrue(generator.next());
+			assertEquals(path, generator.getPath());
+			assertEquals(commit, generator.getObjectId());
+			assertEquals(uri, generator.getModulesUrl());
+			assertEquals(path, generator.getModulesPath());
+			assertEquals(uri, generator.getConfigUrl());
+			Repository subModRepo = generator.getRepository();
+			assertNotNull(subModRepo);
+			subModRepo.close();
+			assertEquals(commit, repo.resolve(Constants.HEAD));
+
+			RevCommit submoduleCommit = git.commit().setMessage("submodule add")
+					.setOnly(path).call();
+			assertNotNull(submoduleCommit);
+			try (TreeWalk walk = new TreeWalk(db)) {
+				walk.addTree(commit.getTree());
+				walk.addTree(submoduleCommit.getTree());
+				walk.setFilter(TreeFilter.ANY_DIFF);
+				List<DiffEntry> diffs = DiffEntry.scan(walk);
+				assertEquals(1, diffs.size());
+				DiffEntry subDiff = diffs.get(0);
+				assertEquals(FileMode.MISSING, subDiff.getOldMode());
+				assertEquals(FileMode.GITLINK, subDiff.getNewMode());
+				assertEquals(ObjectId.zeroId(), subDiff.getOldId().toObjectId());
+				assertEquals(commit, subDiff.getNewId().toObjectId());
+				assertEquals(path, subDiff.getNewPath());
+			}
+		}
 	}
 
 	@Test
 	public void commitSubmoduleUpdate() throws Exception {
-		Git git = new Git(db);
-		writeTrashFile("file.txt", "content");
-		git.add().addFilepattern("file.txt").call();
-		RevCommit commit = git.commit().setMessage("create file").call();
-		writeTrashFile("file.txt", "content2");
-		git.add().addFilepattern("file.txt").call();
-		RevCommit commit2 = git.commit().setMessage("edit file").call();
-
-		SubmoduleAddCommand command = new SubmoduleAddCommand(db);
-		String path = "sub";
-		command.setPath(path);
-		String uri = db.getDirectory().toURI().toString();
-		command.setURI(uri);
-		Repository repo = command.call();
-		assertNotNull(repo);
-		addRepoToClose(repo);
-
-		SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
-		assertTrue(generator.next());
-		assertEquals(path, generator.getPath());
-		assertEquals(commit2, generator.getObjectId());
-		assertEquals(uri, generator.getModulesUrl());
-		assertEquals(path, generator.getModulesPath());
-		assertEquals(uri, generator.getConfigUrl());
-		Repository subModRepo = generator.getRepository();
-		assertNotNull(subModRepo);
-		subModRepo.close();
-		assertEquals(commit2, repo.resolve(Constants.HEAD));
-
-		RevCommit submoduleAddCommit = git.commit().setMessage("submodule add")
-				.setOnly(path).call();
-		assertNotNull(submoduleAddCommit);
-
-		RefUpdate update = repo.updateRef(Constants.HEAD);
-		update.setNewObjectId(commit);
-		assertEquals(Result.FORCED, update.forceUpdate());
-
-		RevCommit submoduleEditCommit = git.commit()
-				.setMessage("submodule add").setOnly(path).call();
-		assertNotNull(submoduleEditCommit);
-		TreeWalk walk = new TreeWalk(db);
-		walk.addTree(submoduleAddCommit.getTree());
-		walk.addTree(submoduleEditCommit.getTree());
-		walk.setFilter(TreeFilter.ANY_DIFF);
-		List<DiffEntry> diffs = DiffEntry.scan(walk);
-		assertEquals(1, diffs.size());
-		DiffEntry subDiff = diffs.get(0);
-		assertEquals(FileMode.GITLINK, subDiff.getOldMode());
-		assertEquals(FileMode.GITLINK, subDiff.getNewMode());
-		assertEquals(commit2, subDiff.getOldId().toObjectId());
-		assertEquals(commit, subDiff.getNewId().toObjectId());
-		assertEquals(path, subDiff.getNewPath());
-		assertEquals(path, subDiff.getOldPath());
+		try (Git git = new Git(db)) {
+			writeTrashFile("file.txt", "content");
+			git.add().addFilepattern("file.txt").call();
+			RevCommit commit = git.commit().setMessage("create file").call();
+			writeTrashFile("file.txt", "content2");
+			git.add().addFilepattern("file.txt").call();
+			RevCommit commit2 = git.commit().setMessage("edit file").call();
+
+			SubmoduleAddCommand command = new SubmoduleAddCommand(db);
+			String path = "sub";
+			command.setPath(path);
+			String uri = db.getDirectory().toURI().toString();
+			command.setURI(uri);
+			Repository repo = command.call();
+			assertNotNull(repo);
+			addRepoToClose(repo);
+
+			SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
+			assertTrue(generator.next());
+			assertEquals(path, generator.getPath());
+			assertEquals(commit2, generator.getObjectId());
+			assertEquals(uri, generator.getModulesUrl());
+			assertEquals(path, generator.getModulesPath());
+			assertEquals(uri, generator.getConfigUrl());
+			Repository subModRepo = generator.getRepository();
+			assertNotNull(subModRepo);
+			subModRepo.close();
+			assertEquals(commit2, repo.resolve(Constants.HEAD));
+
+			RevCommit submoduleAddCommit = git.commit().setMessage("submodule add")
+					.setOnly(path).call();
+			assertNotNull(submoduleAddCommit);
+
+			RefUpdate update = repo.updateRef(Constants.HEAD);
+			update.setNewObjectId(commit);
+			assertEquals(Result.FORCED, update.forceUpdate());
+
+			RevCommit submoduleEditCommit = git.commit()
+					.setMessage("submodule add").setOnly(path).call();
+			assertNotNull(submoduleEditCommit);
+			try (TreeWalk walk = new TreeWalk(db)) {
+				walk.addTree(submoduleAddCommit.getTree());
+				walk.addTree(submoduleEditCommit.getTree());
+				walk.setFilter(TreeFilter.ANY_DIFF);
+				List<DiffEntry> diffs = DiffEntry.scan(walk);
+				assertEquals(1, diffs.size());
+				DiffEntry subDiff = diffs.get(0);
+				assertEquals(FileMode.GITLINK, subDiff.getOldMode());
+				assertEquals(FileMode.GITLINK, subDiff.getNewMode());
+				assertEquals(commit2, subDiff.getOldId().toObjectId());
+				assertEquals(commit, subDiff.getNewId().toObjectId());
+				assertEquals(path, subDiff.getNewPath());
+				assertEquals(path, subDiff.getOldPath());
+			}
+		}
 	}
 
 	@Test
 	public void commitUpdatesSmudgedEntries() throws Exception {
-		Git git = new Git(db);
-
-		File file1 = writeTrashFile("file1.txt", "content1");
-		assertTrue(file1.setLastModified(file1.lastModified() - 5000));
-		File file2 = writeTrashFile("file2.txt", "content2");
-		assertTrue(file2.setLastModified(file2.lastModified() - 5000));
-		File file3 = writeTrashFile("file3.txt", "content3");
-		assertTrue(file3.setLastModified(file3.lastModified() - 5000));
-
-		assertNotNull(git.add().addFilepattern("file1.txt")
-				.addFilepattern("file2.txt").addFilepattern("file3.txt").call());
-		RevCommit commit = git.commit().setMessage("add files").call();
-		assertNotNull(commit);
-
-		DirCache cache = DirCache.read(db.getIndexFile(), db.getFS());
-		int file1Size = cache.getEntry("file1.txt").getLength();
-		int file2Size = cache.getEntry("file2.txt").getLength();
-		int file3Size = cache.getEntry("file3.txt").getLength();
-		ObjectId file2Id = cache.getEntry("file2.txt").getObjectId();
-		ObjectId file3Id = cache.getEntry("file3.txt").getObjectId();
-		assertTrue(file1Size > 0);
-		assertTrue(file2Size > 0);
-		assertTrue(file3Size > 0);
-
-		// Smudge entries
-		cache = DirCache.lock(db.getIndexFile(), db.getFS());
-		cache.getEntry("file1.txt").setLength(0);
-		cache.getEntry("file2.txt").setLength(0);
-		cache.getEntry("file3.txt").setLength(0);
-		cache.write();
-		assertTrue(cache.commit());
-
-		// Verify entries smudged
-		cache = DirCache.read(db.getIndexFile(), db.getFS());
-		assertEquals(0, cache.getEntry("file1.txt").getLength());
-		assertEquals(0, cache.getEntry("file2.txt").getLength());
-		assertEquals(0, cache.getEntry("file3.txt").getLength());
-
-		long indexTime = db.getIndexFile().lastModified();
-		db.getIndexFile().setLastModified(indexTime - 5000);
-
-		write(file1, "content4");
-		assertTrue(file1.setLastModified(file1.lastModified() + 2500));
-		assertNotNull(git.commit().setMessage("edit file").setOnly("file1.txt")
-				.call());
-
-		cache = db.readDirCache();
-		assertEquals(file1Size, cache.getEntry("file1.txt").getLength());
-		assertEquals(file2Size, cache.getEntry("file2.txt").getLength());
-		assertEquals(file3Size, cache.getEntry("file3.txt").getLength());
-		assertEquals(file2Id, cache.getEntry("file2.txt").getObjectId());
-		assertEquals(file3Id, cache.getEntry("file3.txt").getObjectId());
+		try (Git git = new Git(db)) {
+			File file1 = writeTrashFile("file1.txt", "content1");
+			assertTrue(file1.setLastModified(file1.lastModified() - 5000));
+			File file2 = writeTrashFile("file2.txt", "content2");
+			assertTrue(file2.setLastModified(file2.lastModified() - 5000));
+			File file3 = writeTrashFile("file3.txt", "content3");
+			assertTrue(file3.setLastModified(file3.lastModified() - 5000));
+
+			assertNotNull(git.add().addFilepattern("file1.txt")
+					.addFilepattern("file2.txt").addFilepattern("file3.txt").call());
+			RevCommit commit = git.commit().setMessage("add files").call();
+			assertNotNull(commit);
+
+			DirCache cache = DirCache.read(db.getIndexFile(), db.getFS());
+			int file1Size = cache.getEntry("file1.txt").getLength();
+			int file2Size = cache.getEntry("file2.txt").getLength();
+			int file3Size = cache.getEntry("file3.txt").getLength();
+			ObjectId file2Id = cache.getEntry("file2.txt").getObjectId();
+			ObjectId file3Id = cache.getEntry("file3.txt").getObjectId();
+			assertTrue(file1Size > 0);
+			assertTrue(file2Size > 0);
+			assertTrue(file3Size > 0);
+
+			// Smudge entries
+			cache = DirCache.lock(db.getIndexFile(), db.getFS());
+			cache.getEntry("file1.txt").setLength(0);
+			cache.getEntry("file2.txt").setLength(0);
+			cache.getEntry("file3.txt").setLength(0);
+			cache.write();
+			assertTrue(cache.commit());
+
+			// Verify entries smudged
+			cache = DirCache.read(db.getIndexFile(), db.getFS());
+			assertEquals(0, cache.getEntry("file1.txt").getLength());
+			assertEquals(0, cache.getEntry("file2.txt").getLength());
+			assertEquals(0, cache.getEntry("file3.txt").getLength());
+
+			long indexTime = db.getIndexFile().lastModified();
+			db.getIndexFile().setLastModified(indexTime - 5000);
+
+			write(file1, "content4");
+			assertTrue(file1.setLastModified(file1.lastModified() + 2500));
+			assertNotNull(git.commit().setMessage("edit file").setOnly("file1.txt")
+					.call());
+
+			cache = db.readDirCache();
+			assertEquals(file1Size, cache.getEntry("file1.txt").getLength());
+			assertEquals(file2Size, cache.getEntry("file2.txt").getLength());
+			assertEquals(file3Size, cache.getEntry("file3.txt").getLength());
+			assertEquals(file2Id, cache.getEntry("file2.txt").getObjectId());
+			assertEquals(file3Id, cache.getEntry("file3.txt").getObjectId());
+		}
 	}
 
 	@Test
 	public void commitIgnoresSmudgedEntryWithDifferentId() throws Exception {
-		Git git = new Git(db);
-
-		File file1 = writeTrashFile("file1.txt", "content1");
-		assertTrue(file1.setLastModified(file1.lastModified() - 5000));
-		File file2 = writeTrashFile("file2.txt", "content2");
-		assertTrue(file2.setLastModified(file2.lastModified() - 5000));
-
-		assertNotNull(git.add().addFilepattern("file1.txt")
-				.addFilepattern("file2.txt").call());
-		RevCommit commit = git.commit().setMessage("add files").call();
-		assertNotNull(commit);
-
-		DirCache cache = DirCache.read(db.getIndexFile(), db.getFS());
-		int file1Size = cache.getEntry("file1.txt").getLength();
-		int file2Size = cache.getEntry("file2.txt").getLength();
-		assertTrue(file1Size > 0);
-		assertTrue(file2Size > 0);
-
-		writeTrashFile("file2.txt", "content3");
-		assertNotNull(git.add().addFilepattern("file2.txt").call());
-		writeTrashFile("file2.txt", "content4");
-
-		// Smudge entries
-		cache = DirCache.lock(db.getIndexFile(), db.getFS());
-		cache.getEntry("file1.txt").setLength(0);
-		cache.getEntry("file2.txt").setLength(0);
-		cache.write();
-		assertTrue(cache.commit());
-
-		// Verify entries smudged
-		cache = db.readDirCache();
-		assertEquals(0, cache.getEntry("file1.txt").getLength());
-		assertEquals(0, cache.getEntry("file2.txt").getLength());
-
-		long indexTime = db.getIndexFile().lastModified();
-		db.getIndexFile().setLastModified(indexTime - 5000);
-
-		write(file1, "content5");
-		assertTrue(file1.setLastModified(file1.lastModified() + 1000));
-
-		assertNotNull(git.commit().setMessage("edit file").setOnly("file1.txt")
-				.call());
-
-		cache = db.readDirCache();
-		assertEquals(file1Size, cache.getEntry("file1.txt").getLength());
-		assertEquals(0, cache.getEntry("file2.txt").getLength());
+		try (Git git = new Git(db)) {
+			File file1 = writeTrashFile("file1.txt", "content1");
+			assertTrue(file1.setLastModified(file1.lastModified() - 5000));
+			File file2 = writeTrashFile("file2.txt", "content2");
+			assertTrue(file2.setLastModified(file2.lastModified() - 5000));
+
+			assertNotNull(git.add().addFilepattern("file1.txt")
+					.addFilepattern("file2.txt").call());
+			RevCommit commit = git.commit().setMessage("add files").call();
+			assertNotNull(commit);
+
+			DirCache cache = DirCache.read(db.getIndexFile(), db.getFS());
+			int file1Size = cache.getEntry("file1.txt").getLength();
+			int file2Size = cache.getEntry("file2.txt").getLength();
+			assertTrue(file1Size > 0);
+			assertTrue(file2Size > 0);
+
+			writeTrashFile("file2.txt", "content3");
+			assertNotNull(git.add().addFilepattern("file2.txt").call());
+			writeTrashFile("file2.txt", "content4");
+
+			// Smudge entries
+			cache = DirCache.lock(db.getIndexFile(), db.getFS());
+			cache.getEntry("file1.txt").setLength(0);
+			cache.getEntry("file2.txt").setLength(0);
+			cache.write();
+			assertTrue(cache.commit());
+
+			// Verify entries smudged
+			cache = db.readDirCache();
+			assertEquals(0, cache.getEntry("file1.txt").getLength());
+			assertEquals(0, cache.getEntry("file2.txt").getLength());
+
+			long indexTime = db.getIndexFile().lastModified();
+			db.getIndexFile().setLastModified(indexTime - 5000);
+
+			write(file1, "content5");
+			assertTrue(file1.setLastModified(file1.lastModified() + 1000));
+
+			assertNotNull(git.commit().setMessage("edit file").setOnly("file1.txt")
+					.call());
+
+			cache = db.readDirCache();
+			assertEquals(file1Size, cache.getEntry("file1.txt").getLength());
+			assertEquals(0, cache.getEntry("file2.txt").getLength());
+		}
 	}
 
 	@Test
 	public void commitAfterSquashMerge() throws Exception {
-		Git git = new Git(db);
-
-		writeTrashFile("file1", "file1");
-		git.add().addFilepattern("file1").call();
-		RevCommit first = git.commit().setMessage("initial commit").call();
+		try (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");
+			assertTrue(new File(db.getWorkTree(), "file1").exists());
+			createBranch(first, "refs/heads/branch1");
+			checkoutBranch("refs/heads/branch1");
 
-		writeTrashFile("file2", "file2");
-		git.add().addFilepattern("file2").call();
-		git.commit().setMessage("second commit").call();
-		assertTrue(new File(db.getWorkTree(), "file2").exists());
+			writeTrashFile("file2", "file2");
+			git.add().addFilepattern("file2").call();
+			git.commit().setMessage("second commit").call();
+			assertTrue(new File(db.getWorkTree(), "file2").exists());
 
-		checkoutBranch("refs/heads/master");
+			checkoutBranch("refs/heads/master");
 
-		MergeResult result = git.merge()
-				.include(db.exactRef("refs/heads/branch1"))
-				.setSquash(true)
-				.call();
+			MergeResult result = git.merge()
+					.include(db.exactRef("refs/heads/branch1"))
+					.setSquash(true)
+					.call();
 
-		assertTrue(new File(db.getWorkTree(), "file1").exists());
-		assertTrue(new File(db.getWorkTree(), "file2").exists());
-		assertEquals(MergeResult.MergeStatus.FAST_FORWARD_SQUASHED,
-				result.getMergeStatus());
+			assertTrue(new File(db.getWorkTree(), "file1").exists());
+			assertTrue(new File(db.getWorkTree(), "file2").exists());
+			assertEquals(MergeResult.MergeStatus.FAST_FORWARD_SQUASHED,
+					result.getMergeStatus());
 
-		// comment not set, should be inferred from SQUASH_MSG
-		RevCommit squashedCommit = git.commit().call();
+			// comment not set, should be inferred from SQUASH_MSG
+			RevCommit squashedCommit = git.commit().call();
 
-		assertEquals(1, squashedCommit.getParentCount());
-		assertNull(db.readSquashCommitMsg());
-		assertEquals("commit: Squashed commit of the following:", db
-				.getReflogReader(Constants.HEAD).getLastEntry().getComment());
-		assertEquals("commit: Squashed commit of the following:", db
-				.getReflogReader(db.getBranch()).getLastEntry().getComment());
+			assertEquals(1, squashedCommit.getParentCount());
+			assertNull(db.readSquashCommitMsg());
+			assertEquals("commit: Squashed commit of the following:", db
+					.getReflogReader(Constants.HEAD).getLastEntry().getComment());
+			assertEquals("commit: Squashed commit of the following:", db
+					.getReflogReader(db.getBranch()).getLastEntry().getComment());
+		}
 	}
 
 	@Test(expected = WrongRepositoryStateException.class)
 	public void commitAmendOnInitialShouldFail() throws Exception {
-		Git git = new Git(db);
-		git.commit().setAmend(true).setMessage("initial commit").call();
+		try (Git git = new Git(db)) {
+			git.commit().setAmend(true).setMessage("initial commit").call();
+		}
 	}
 
 	@Test
 	public void commitAmendWithoutAuthorShouldSetOriginalAuthorAndAuthorTime()
 			throws Exception {
-		Git git = new Git(db);
-
-		writeTrashFile("file1", "file1");
-		git.add().addFilepattern("file1").call();
+		try (Git git = new Git(db)) {
+			writeTrashFile("file1", "file1");
+			git.add().addFilepattern("file1").call();
 
-		final String authorName = "First Author";
-		final String authorEmail = "author@example.org";
-		final Date authorDate = new Date(1349621117000L);
-		PersonIdent firstAuthor = new PersonIdent(authorName, authorEmail,
-				authorDate, TimeZone.getTimeZone("UTC"));
-		git.commit().setMessage("initial commit").setAuthor(firstAuthor).call();
+			final String authorName = "First Author";
+			final String authorEmail = "author@example.org";
+			final Date authorDate = new Date(1349621117000L);
+			PersonIdent firstAuthor = new PersonIdent(authorName, authorEmail,
+					authorDate, TimeZone.getTimeZone("UTC"));
+			git.commit().setMessage("initial commit").setAuthor(firstAuthor).call();
 
-		RevCommit amended = git.commit().setAmend(true)
-				.setMessage("amend commit").call();
+			RevCommit amended = git.commit().setAmend(true)
+					.setMessage("amend commit").call();
 
-		PersonIdent amendedAuthor = amended.getAuthorIdent();
-		assertEquals(authorName, amendedAuthor.getName());
-		assertEquals(authorEmail, amendedAuthor.getEmailAddress());
-		assertEquals(authorDate.getTime(), amendedAuthor.getWhen().getTime());
+			PersonIdent amendedAuthor = amended.getAuthorIdent();
+			assertEquals(authorName, amendedAuthor.getName());
+			assertEquals(authorEmail, amendedAuthor.getEmailAddress());
+			assertEquals(authorDate.getTime(), amendedAuthor.getWhen().getTime());
+		}
 	}
 
 	@Test
 	public void commitAmendWithAuthorShouldUseIt() throws Exception {
-		Git git = new Git(db);
-
-		writeTrashFile("file1", "file1");
-		git.add().addFilepattern("file1").call();
-		git.commit().setMessage("initial commit").call();
+		try (Git git = new Git(db)) {
+			writeTrashFile("file1", "file1");
+			git.add().addFilepattern("file1").call();
+			git.commit().setMessage("initial commit").call();
 
-		RevCommit amended = git.commit().setAmend(true)
-				.setAuthor("New Author", "newauthor@example.org")
-				.setMessage("amend commit").call();
+			RevCommit amended = git.commit().setAmend(true)
+					.setAuthor("New Author", "newauthor@example.org")
+					.setMessage("amend commit").call();
 
-		PersonIdent amendedAuthor = amended.getAuthorIdent();
-		assertEquals("New Author", amendedAuthor.getName());
-		assertEquals("newauthor@example.org", amendedAuthor.getEmailAddress());
+			PersonIdent amendedAuthor = amended.getAuthorIdent();
+			assertEquals("New Author", amendedAuthor.getName());
+			assertEquals("newauthor@example.org", amendedAuthor.getEmailAddress());
+		}
 	}
 
 	@Test
@@ -532,18 +537,19 @@ public class CommitCommandTest extends RepositoryTestCase {
 				+ "[unmerged2, mode:100644, stage:3]",
 				indexState(0));
 
-		Git git = new Git(db);
-		RevCommit commit = git.commit().setOnly("unmerged1")
-				.setMessage("Only one file").call();
+		try (Git git = new Git(db)) {
+			RevCommit commit = git.commit().setOnly("unmerged1")
+					.setMessage("Only one file").call();
 
-		assertEquals("[other, mode:100644]" + "[unmerged1, mode:100644]"
-				+ "[unmerged2, mode:100644, stage:1]"
-				+ "[unmerged2, mode:100644, stage:2]"
-				+ "[unmerged2, mode:100644, stage:3]",
-				indexState(0));
+			assertEquals("[other, mode:100644]" + "[unmerged1, mode:100644]"
+					+ "[unmerged2, mode:100644, stage:1]"
+					+ "[unmerged2, mode:100644, stage:2]"
+					+ "[unmerged2, mode:100644, stage:3]",
+					indexState(0));
 
-		try (TreeWalk walk = TreeWalk.forPath(db, "unmerged1", commit.getTree())) {
-			assertEquals(FileMode.REGULAR_FILE, walk.getFileMode(0));
+			try (TreeWalk walk = TreeWalk.forPath(db, "unmerged1", commit.getTree())) {
+				assertEquals(FileMode.REGULAR_FILE, walk.getFileMode(0));
+			}
 		}
 	}
 
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/DiffCommandTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/DiffCommandTest.java
index 4ad01cf6f..4f5b50dcc 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/DiffCommandTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/DiffCommandTest.java
@@ -70,32 +70,33 @@ public class DiffCommandTest extends RepositoryTestCase {
 		File folder = new File(db.getWorkTree(), "folder");
 		folder.mkdir();
 		write(new File(folder, "folder.txt"), "folder");
-		Git git = new Git(db);
-		git.add().addFilepattern(".").call();
-		git.commit().setMessage("Initial commit").call();
-		write(new File(folder, "folder.txt"), "folder change");
-
-		OutputStream out = new ByteArrayOutputStream();
-		List<DiffEntry> entries = git.diff().setOutputStream(out).call();
-		assertEquals(1, entries.size());
-		assertEquals(ChangeType.MODIFY, entries.get(0)
-				.getChangeType());
-		assertEquals("folder/folder.txt", entries.get(0)
-				.getOldPath());
-		assertEquals("folder/folder.txt", entries.get(0)
-				.getNewPath());
-
-		String actual = out.toString();
-		String expected = "diff --git a/folder/folder.txt b/folder/folder.txt\n"
-				+ "index 0119635..95c4c65 100644\n"
-				+ "--- a/folder/folder.txt\n"
-				+ "+++ b/folder/folder.txt\n"
-				+ "@@ -1 +1 @@\n"
-				+ "-folder\n"
-				+ "\\ No newline at end of file\n"
-				+ "+folder change\n"
-				+ "\\ No newline at end of file\n";
-		assertEquals(expected.toString(), actual);
+		try (Git git = new Git(db)) {
+			git.add().addFilepattern(".").call();
+			git.commit().setMessage("Initial commit").call();
+			write(new File(folder, "folder.txt"), "folder change");
+
+			OutputStream out = new ByteArrayOutputStream();
+			List<DiffEntry> entries = git.diff().setOutputStream(out).call();
+			assertEquals(1, entries.size());
+			assertEquals(ChangeType.MODIFY, entries.get(0)
+					.getChangeType());
+			assertEquals("folder/folder.txt", entries.get(0)
+					.getOldPath());
+			assertEquals("folder/folder.txt", entries.get(0)
+					.getNewPath());
+
+			String actual = out.toString();
+			String expected = "diff --git a/folder/folder.txt b/folder/folder.txt\n"
+					+ "index 0119635..95c4c65 100644\n"
+					+ "--- a/folder/folder.txt\n"
+					+ "+++ b/folder/folder.txt\n"
+					+ "@@ -1 +1 @@\n"
+					+ "-folder\n"
+					+ "\\ No newline at end of file\n"
+					+ "+folder change\n"
+					+ "\\ No newline at end of file\n";
+			assertEquals(expected.toString(), actual);
+		}
 	}
 
 	@Test
@@ -103,33 +104,34 @@ public class DiffCommandTest extends RepositoryTestCase {
 		write(new File(db.getWorkTree(), "test.txt"), "test");
 		File folder = new File(db.getWorkTree(), "folder");
 		folder.mkdir();
-		Git git = new Git(db);
-		git.add().addFilepattern(".").call();
-		git.commit().setMessage("Initial commit").call();
-		write(new File(folder, "folder.txt"), "folder");
-		git.add().addFilepattern(".").call();
-
-		OutputStream out = new ByteArrayOutputStream();
-		List<DiffEntry> entries = git.diff().setOutputStream(out)
-				.setCached(true).call();
-		assertEquals(1, entries.size());
-		assertEquals(ChangeType.ADD, entries.get(0)
-				.getChangeType());
-		assertEquals("/dev/null", entries.get(0)
-				.getOldPath());
-		assertEquals("folder/folder.txt", entries.get(0)
-				.getNewPath());
-
-		String actual = out.toString();
-		String expected = "diff --git a/folder/folder.txt b/folder/folder.txt\n"
-				+ "new file mode 100644\n"
-				+ "index 0000000..0119635\n"
-				+ "--- /dev/null\n"
-				+ "+++ b/folder/folder.txt\n"
-				+ "@@ -0,0 +1 @@\n"
-				+ "+folder\n"
-				+ "\\ No newline at end of file\n";
-		assertEquals(expected.toString(), actual);
+		try (Git git = new Git(db)) {
+			git.add().addFilepattern(".").call();
+			git.commit().setMessage("Initial commit").call();
+			write(new File(folder, "folder.txt"), "folder");
+			git.add().addFilepattern(".").call();
+
+			OutputStream out = new ByteArrayOutputStream();
+			List<DiffEntry> entries = git.diff().setOutputStream(out)
+					.setCached(true).call();
+			assertEquals(1, entries.size());
+			assertEquals(ChangeType.ADD, entries.get(0)
+					.getChangeType());
+			assertEquals("/dev/null", entries.get(0)
+					.getOldPath());
+			assertEquals("folder/folder.txt", entries.get(0)
+					.getNewPath());
+
+			String actual = out.toString();
+			String expected = "diff --git a/folder/folder.txt b/folder/folder.txt\n"
+					+ "new file mode 100644\n"
+					+ "index 0000000..0119635\n"
+					+ "--- /dev/null\n"
+					+ "+++ b/folder/folder.txt\n"
+					+ "@@ -0,0 +1 @@\n"
+					+ "+folder\n"
+					+ "\\ No newline at end of file\n";
+			assertEquals(expected.toString(), actual);
+		}
 	}
 
 	@Test
@@ -138,107 +140,109 @@ public class DiffCommandTest extends RepositoryTestCase {
 		File folder = new File(db.getWorkTree(), "folder");
 		folder.mkdir();
 		write(new File(folder, "folder.txt"), "folder");
-		Git git = new Git(db);
-		git.add().addFilepattern(".").call();
-		git.commit().setMessage("Initial commit").call();
-		write(new File(folder, "folder.txt"), "folder change");
-		git.add().addFilepattern(".").call();
-		git.commit().setMessage("second commit").call();
-		write(new File(folder, "folder.txt"), "second folder change");
-		git.add().addFilepattern(".").call();
-		git.commit().setMessage("third commit").call();
-
-		// bad filter
-		DiffCommand diff = git.diff().setShowNameAndStatusOnly(true)
-				.setPathFilter(PathFilter.create("test.txt"))
-				.setOldTree(getTreeIterator("HEAD^^"))
-				.setNewTree(getTreeIterator("HEAD^"));
-		List<DiffEntry> entries = diff.call();
-		assertEquals(0, entries.size());
-
-		// no filter, two commits
-		OutputStream out = new ByteArrayOutputStream();
-		diff = git.diff().setOutputStream(out)
-				.setOldTree(getTreeIterator("HEAD^^"))
-				.setNewTree(getTreeIterator("HEAD^"));
-		entries = diff.call();
-		assertEquals(1, entries.size());
-		assertEquals(ChangeType.MODIFY, entries.get(0).getChangeType());
-		assertEquals("folder/folder.txt", entries.get(0).getOldPath());
-		assertEquals("folder/folder.txt", entries.get(0).getNewPath());
-
-		String actual = out.toString();
-		String expected = "diff --git a/folder/folder.txt b/folder/folder.txt\n"
-				+ "index 0119635..95c4c65 100644\n"
-				+ "--- a/folder/folder.txt\n"
-				+ "+++ b/folder/folder.txt\n"
-				+ "@@ -1 +1 @@\n"
-				+ "-folder\n"
-				+ "\\ No newline at end of file\n"
-				+ "+folder change\n"
-				+ "\\ No newline at end of file\n";
-		assertEquals(expected.toString(), actual);
+		try (Git git = new Git(db)) {
+			git.add().addFilepattern(".").call();
+			git.commit().setMessage("Initial commit").call();
+			write(new File(folder, "folder.txt"), "folder change");
+			git.add().addFilepattern(".").call();
+			git.commit().setMessage("second commit").call();
+			write(new File(folder, "folder.txt"), "second folder change");
+			git.add().addFilepattern(".").call();
+			git.commit().setMessage("third commit").call();
+
+			// bad filter
+			DiffCommand diff = git.diff().setShowNameAndStatusOnly(true)
+					.setPathFilter(PathFilter.create("test.txt"))
+					.setOldTree(getTreeIterator("HEAD^^"))
+					.setNewTree(getTreeIterator("HEAD^"));
+			List<DiffEntry> entries = diff.call();
+			assertEquals(0, entries.size());
+
+			// no filter, two commits
+			OutputStream out = new ByteArrayOutputStream();
+			diff = git.diff().setOutputStream(out)
+					.setOldTree(getTreeIterator("HEAD^^"))
+					.setNewTree(getTreeIterator("HEAD^"));
+			entries = diff.call();
+			assertEquals(1, entries.size());
+			assertEquals(ChangeType.MODIFY, entries.get(0).getChangeType());
+			assertEquals("folder/folder.txt", entries.get(0).getOldPath());
+			assertEquals("folder/folder.txt", entries.get(0).getNewPath());
+
+			String actual = out.toString();
+			String expected = "diff --git a/folder/folder.txt b/folder/folder.txt\n"
+					+ "index 0119635..95c4c65 100644\n"
+					+ "--- a/folder/folder.txt\n"
+					+ "+++ b/folder/folder.txt\n"
+					+ "@@ -1 +1 @@\n"
+					+ "-folder\n"
+					+ "\\ No newline at end of file\n"
+					+ "+folder change\n"
+					+ "\\ No newline at end of file\n";
+			assertEquals(expected.toString(), actual);
+		}
 	}
 
 	@Test
 	public void testDiffWithPrefixes() throws Exception {
 		write(new File(db.getWorkTree(), "test.txt"), "test");
-		Git git = new Git(db);
-		git.add().addFilepattern(".").call();
-		git.commit().setMessage("Initial commit").call();
-		write(new File(db.getWorkTree(), "test.txt"), "test change");
-
-		OutputStream out = new ByteArrayOutputStream();
-		git.diff().setOutputStream(out).setSourcePrefix("old/")
-				.setDestinationPrefix("new/")
-				.call();
-
-		String actual = out.toString();
-		String expected = "diff --git old/test.txt new/test.txt\n"
-				+ "index 30d74d2..4dba797 100644\n" + "--- old/test.txt\n"
-				+ "+++ new/test.txt\n" + "@@ -1 +1 @@\n" + "-test\n"
-				+ "\\ No newline at end of file\n" + "+test change\n"
-				+ "\\ No newline at end of file\n";
-		assertEquals(expected.toString(), actual);
+		try (Git git = new Git(db)) {
+			git.add().addFilepattern(".").call();
+			git.commit().setMessage("Initial commit").call();
+			write(new File(db.getWorkTree(), "test.txt"), "test change");
+
+			OutputStream out = new ByteArrayOutputStream();
+			git.diff().setOutputStream(out).setSourcePrefix("old/")
+					.setDestinationPrefix("new/").call();
+
+			String actual = out.toString();
+			String expected = "diff --git old/test.txt new/test.txt\n"
+					+ "index 30d74d2..4dba797 100644\n" + "--- old/test.txt\n"
+					+ "+++ new/test.txt\n" + "@@ -1 +1 @@\n" + "-test\n"
+					+ "\\ No newline at end of file\n" + "+test change\n"
+					+ "\\ No newline at end of file\n";
+			assertEquals(expected.toString(), actual);
+		}
 	}
 
 	@Test
 	public void testDiffWithNegativeLineCount() throws Exception {
 		write(new File(db.getWorkTree(), "test.txt"),
 				"0\n1\n2\n3\n4\n5\n6\n7\n8\n9");
-		Git git = new Git(db);
-		git.add().addFilepattern(".").call();
-		git.commit().setMessage("Initial commit").call();
-		write(new File(db.getWorkTree(), "test.txt"),
-				"0\n1\n2\n3\n4a\n5\n6\n7\n8\n9");
-
-		OutputStream out = new ByteArrayOutputStream();
-		git.diff().setOutputStream(out).setContextLines(1)
-				.call();
-
-		String actual = out.toString();
-		String expected = "diff --git a/test.txt b/test.txt\n"
-				+ "index f55b5c9..c5ec8fd 100644\n" + "--- a/test.txt\n"
-				+ "+++ b/test.txt\n" + "@@ -4,3 +4,3 @@\n" + " 3\n" + "-4\n"
-				+ "+4a\n" + " 5\n";
-		assertEquals(expected.toString(), actual);
+		try (Git git = new Git(db)) {
+			git.add().addFilepattern(".").call();
+			git.commit().setMessage("Initial commit").call();
+			write(new File(db.getWorkTree(), "test.txt"),
+					"0\n1\n2\n3\n4a\n5\n6\n7\n8\n9");
+
+			OutputStream out = new ByteArrayOutputStream();
+			git.diff().setOutputStream(out).setContextLines(1).call();
+
+			String actual = out.toString();
+			String expected = "diff --git a/test.txt b/test.txt\n"
+					+ "index f55b5c9..c5ec8fd 100644\n" + "--- a/test.txt\n"
+					+ "+++ b/test.txt\n" + "@@ -4,3 +4,3 @@\n" + " 3\n" + "-4\n"
+					+ "+4a\n" + " 5\n";
+			assertEquals(expected.toString(), actual);
+		}
 	}
 
 	@Test
 	public void testNoOutputStreamSet() throws Exception {
 		File file = writeTrashFile("test.txt", "a");
 		assertTrue(file.setLastModified(file.lastModified() - 5000));
-		Git git = new Git(db);
-		git.add().addFilepattern(".").call();
-		write(file, "b");
-
-		List<DiffEntry> diffs = git.diff().call();
-		assertNotNull(diffs);
-		assertEquals(1, diffs.size());
-		DiffEntry diff = diffs.get(0);
-		assertEquals(ChangeType.MODIFY, diff.getChangeType());
-		assertEquals("test.txt", diff.getOldPath());
-		assertEquals("test.txt", diff.getNewPath());
+		try (Git git = new Git(db)) {
+			git.add().addFilepattern(".").call();
+			write(file, "b");
+
+			List<DiffEntry> diffs = git.diff().call();
+			assertNotNull(diffs);
+			assertEquals(1, diffs.size());
+			DiffEntry diff = diffs.get(0);
+			assertEquals(ChangeType.MODIFY, diff.getChangeType());
+			assertEquals("test.txt", diff.getOldPath());
+			assertEquals("test.txt", diff.getNewPath());
+		}
 	}
 
 	private AbstractTreeIterator getTreeIterator(String name)
@@ -247,8 +251,9 @@ public class DiffCommandTest extends RepositoryTestCase {
 		if (id == null)
 			throw new IllegalArgumentException(name);
 		final CanonicalTreeParser p = new CanonicalTreeParser();
-		try (ObjectReader or = db.newObjectReader()) {
-			p.reset(or, new RevWalk(db).parseTree(id));
+		try (ObjectReader or = db.newObjectReader();
+				RevWalk rw = new RevWalk(db)) {
+			p.reset(or, rw.parseTree(id));
 			return p;
 		}
 	}
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/PullCommandTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/PullCommandTest.java
index 57888e70a..ff7066e8b 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/PullCommandTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/PullCommandTest.java
@@ -140,11 +140,12 @@ public class PullCommandTest extends RepositoryTestCase {
 		ObjectId[] mergedCommits = mergeResult.getMergedCommits();
 		assertEquals(targetCommit.getId(), mergedCommits[0]);
 		assertEquals(sourceCommit.getId(), mergedCommits[1]);
-		RevCommit mergeCommit = new RevWalk(dbTarget).parseCommit(mergeResult
-				.getNewHead());
-		String message = "Merge branch 'master' of "
-				+ db.getWorkTree().getAbsolutePath();
-		assertEquals(message, mergeCommit.getShortMessage());
+		try (RevWalk rw = new RevWalk(dbTarget)) {
+			RevCommit mergeCommit = rw.parseCommit(mergeResult.getNewHead());
+			String message = "Merge branch 'master' of "
+					+ db.getWorkTree().getAbsolutePath();
+			assertEquals(message, mergeCommit.getShortMessage());
+		}
 	}
 
 	@Test
@@ -259,11 +260,12 @@ public class PullCommandTest extends RepositoryTestCase {
 		ObjectId[] mergedCommits = mergeResult.getMergedCommits();
 		assertEquals(targetCommit.getId(), mergedCommits[0]);
 		assertEquals(sourceCommit.getId(), mergedCommits[1]);
-		RevCommit mergeCommit = new RevWalk(dbTarget).parseCommit(mergeResult
-				.getNewHead());
-		String message = "Merge branch 'other' of "
-				+ db.getWorkTree().getAbsolutePath();
-		assertEquals(message, mergeCommit.getShortMessage());
+		try (RevWalk rw = new RevWalk(dbTarget)) {
+			RevCommit mergeCommit = rw.parseCommit(mergeResult.getNewHead());
+			String message = "Merge branch 'other' of "
+					+ db.getWorkTree().getAbsolutePath();
+			assertEquals(message, mergeCommit.getShortMessage());
+		}
 	}
 
 	@Test
@@ -293,11 +295,12 @@ public class PullCommandTest extends RepositoryTestCase {
 		ObjectId[] mergedCommits = mergeResult.getMergedCommits();
 		assertEquals(targetCommit.getId(), mergedCommits[0]);
 		assertEquals(sourceCommit.getId(), mergedCommits[1]);
-		RevCommit mergeCommit = new RevWalk(dbTarget).parseCommit(mergeResult
-				.getNewHead());
-		String message = "Merge branch 'other' of "
-				+ db.getWorkTree().getAbsolutePath() + " into other";
-		assertEquals(message, mergeCommit.getShortMessage());
+		try (RevWalk rw = new RevWalk(dbTarget)) {
+			RevCommit mergeCommit = rw.parseCommit(mergeResult.getNewHead());
+			String message = "Merge branch 'other' of "
+					+ db.getWorkTree().getAbsolutePath() + " into other";
+			assertEquals(message, mergeCommit.getShortMessage());
+		}
 	}
 
 	private enum TestPullMode {
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/RebaseCommandTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/RebaseCommandTest.java
index 8b0ed5f39..24cb522a0 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/RebaseCommandTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/RebaseCommandTest.java
@@ -288,13 +288,14 @@ public class RebaseCommandTest extends RepositoryTestCase {
 		RebaseResult res = git.rebase().setUpstream("refs/heads/master").call();
 		assertEquals(Status.OK, res.getStatus());
 
-		RevWalk rw = new RevWalk(db);
-		rw.markStart(rw.parseCommit(db.resolve("refs/heads/topic")));
-		assertDerivedFrom(rw.next(), e);
-		assertDerivedFrom(rw.next(), d);
-		assertDerivedFrom(rw.next(), c);
-		assertEquals(b, rw.next());
-		assertEquals(a, rw.next());
+		try (RevWalk rw = new RevWalk(db)) {
+			rw.markStart(rw.parseCommit(db.resolve("refs/heads/topic")));
+			assertDerivedFrom(rw.next(), e);
+			assertDerivedFrom(rw.next(), d);
+			assertDerivedFrom(rw.next(), c);
+			assertEquals(b, rw.next());
+			assertEquals(a, rw.next());
+		}
 
 		List<ReflogEntry> headLog = db.getReflogReader(Constants.HEAD)
 				.getReverseEntries();
@@ -354,8 +355,6 @@ public class RebaseCommandTest extends RepositoryTestCase {
 	 */
 	private void doTestRebasePreservingMerges(boolean testConflict)
 			throws Exception {
-		RevWalk rw = new RevWalk(db);
-
 		// create file1 on master
 		writeTrashFile(FILE1, FILE1);
 		git.add().addFilepattern(FILE1).call();
@@ -409,7 +408,9 @@ public class RebaseCommandTest extends RepositoryTestCase {
 			f = git.commit().setMessage("commit f").call();
 		} else {
 			assertEquals(MergeStatus.MERGED, result.getMergeStatus());
-			f = rw.parseCommit(result.getNewHead());
+			try (RevWalk rw = new RevWalk(db)) {
+				f = rw.parseCommit(result.getNewHead());
+			}
 		}
 
 		RebaseResult res = git.rebase().setUpstream("refs/heads/master")
@@ -453,23 +454,25 @@ public class RebaseCommandTest extends RepositoryTestCase {
 		assertEquals("file2", read("file2"));
 		assertEquals("more change", read("file3"));
 
-		rw.markStart(rw.parseCommit(db.resolve("refs/heads/topic")));
-		RevCommit newF = rw.next();
-		assertDerivedFrom(newF, f);
-		assertEquals(2, newF.getParentCount());
-		RevCommit newD = rw.next();
-		assertDerivedFrom(newD, d);
-		if (testConflict)
-			assertEquals("d new", readFile("conflict", newD));
-		RevCommit newE = rw.next();
-		assertDerivedFrom(newE, e);
-		if (testConflict)
-			assertEquals("e new", readFile("conflict", newE));
-		assertEquals(newD, newF.getParent(0));
-		assertEquals(newE, newF.getParent(1));
-		assertDerivedFrom(rw.next(), c);
-		assertEquals(b, rw.next());
-		assertEquals(a, rw.next());
+		try (RevWalk rw = new RevWalk(db)) {
+			rw.markStart(rw.parseCommit(db.resolve("refs/heads/topic")));
+			RevCommit newF = rw.next();
+			assertDerivedFrom(newF, f);
+			assertEquals(2, newF.getParentCount());
+			RevCommit newD = rw.next();
+			assertDerivedFrom(newD, d);
+			if (testConflict)
+				assertEquals("d new", readFile("conflict", newD));
+			RevCommit newE = rw.next();
+			assertDerivedFrom(newE, e);
+			if (testConflict)
+				assertEquals("e new", readFile("conflict", newE));
+			assertEquals(newD, newF.getParent(0));
+			assertEquals(newE, newF.getParent(1));
+			assertDerivedFrom(rw.next(), c);
+			assertEquals(b, rw.next());
+			assertEquals(a, rw.next());
+		}
 	}
 
 	private String readFile(String path, RevCommit commit) throws IOException {
@@ -517,88 +520,89 @@ public class RebaseCommandTest extends RepositoryTestCase {
 	 */
 	private void doTestRebasePreservingMergesWithUnrelatedSide(
 			boolean testConflict) throws Exception {
-		RevWalk rw = new RevWalk(db);
-		rw.sort(RevSort.TOPO);
+		try (RevWalk rw = new RevWalk(db)) {
+			rw.sort(RevSort.TOPO);
 
-		writeTrashFile(FILE1, FILE1);
-		git.add().addFilepattern(FILE1).call();
-		RevCommit a = git.commit().setMessage("commit a").call();
+			writeTrashFile(FILE1, FILE1);
+			git.add().addFilepattern(FILE1).call();
+			RevCommit a = git.commit().setMessage("commit a").call();
 
-		writeTrashFile("file2", "blah");
-		git.add().addFilepattern("file2").call();
-		RevCommit b = git.commit().setMessage("commit b").call();
-
-		// create a topic branch
-		createBranch(b, "refs/heads/topic");
-		checkoutBranch("refs/heads/topic");
-
-		writeTrashFile("file3", "more changess");
-		writeTrashFile(FILE1, "preparing conflict");
-		git.add().addFilepattern("file3").addFilepattern(FILE1).call();
-		RevCommit c = git.commit().setMessage("commit c").call();
-
-		createBranch(a, "refs/heads/side");
-		checkoutBranch("refs/heads/side");
-		writeTrashFile("conflict", "e");
-		writeTrashFile(FILE1, FILE1 + "\n" + "line 2");
-		git.add().addFilepattern(".").call();
-		RevCommit e = git.commit().setMessage("commit e").call();
+			writeTrashFile("file2", "blah");
+			git.add().addFilepattern("file2").call();
+			RevCommit b = git.commit().setMessage("commit b").call();
 
-		// switch back to topic and merge in side, creating d
-		checkoutBranch("refs/heads/topic");
-		MergeResult result = git.merge().include(e)
-				.setStrategy(MergeStrategy.RESOLVE).call();
+			// create a topic branch
+			createBranch(b, "refs/heads/topic");
+			checkoutBranch("refs/heads/topic");
 
-		assertEquals(MergeStatus.CONFLICTING, result.getMergeStatus());
-		assertEquals(result.getConflicts().keySet(),
-				Collections.singleton(FILE1));
-		writeTrashFile(FILE1, "merge resolution");
-		git.add().addFilepattern(FILE1).call();
-		RevCommit d = git.commit().setMessage("commit d").call();
+			writeTrashFile("file3", "more changess");
+			writeTrashFile(FILE1, "preparing conflict");
+			git.add().addFilepattern("file3").addFilepattern(FILE1).call();
+			RevCommit c = git.commit().setMessage("commit c").call();
 
-		RevCommit f = commitFile("file2", "new content two", "topic");
+			createBranch(a, "refs/heads/side");
+			checkoutBranch("refs/heads/side");
+			writeTrashFile("conflict", "e");
+			writeTrashFile(FILE1, FILE1 + "\n" + "line 2");
+			git.add().addFilepattern(".").call();
+			RevCommit e = git.commit().setMessage("commit e").call();
 
-		checkoutBranch("refs/heads/master");
-		writeTrashFile("fileg", "fileg");
-		if (testConflict)
-			writeTrashFile("conflict", "g");
-		git.add().addFilepattern(".").call();
-		RevCommit g = git.commit().setMessage("commit g").call();
+			// switch back to topic and merge in side, creating d
+			checkoutBranch("refs/heads/topic");
+			MergeResult result = git.merge().include(e)
+					.setStrategy(MergeStrategy.RESOLVE).call();
 
-		checkoutBranch("refs/heads/topic");
-		RebaseResult res = git.rebase().setUpstream("refs/heads/master")
-				.setPreserveMerges(true).call();
-		if (testConflict) {
-			assertEquals(Status.STOPPED, res.getStatus());
-			assertEquals(Collections.singleton("conflict"), git.status().call()
-					.getConflicting());
-			// resolve
-			writeTrashFile("conflict", "e");
-			git.add().addFilepattern("conflict").call();
-			res = git.rebase().setOperation(Operation.CONTINUE).call();
+			assertEquals(MergeStatus.CONFLICTING, result.getMergeStatus());
+			assertEquals(result.getConflicts().keySet(),
+					Collections.singleton(FILE1));
+			writeTrashFile(FILE1, "merge resolution");
+			git.add().addFilepattern(FILE1).call();
+			RevCommit d = git.commit().setMessage("commit d").call();
+
+			RevCommit f = commitFile("file2", "new content two", "topic");
+
+			checkoutBranch("refs/heads/master");
+			writeTrashFile("fileg", "fileg");
+			if (testConflict)
+				writeTrashFile("conflict", "g");
+			git.add().addFilepattern(".").call();
+			RevCommit g = git.commit().setMessage("commit g").call();
+
+			checkoutBranch("refs/heads/topic");
+			RebaseResult res = git.rebase().setUpstream("refs/heads/master")
+					.setPreserveMerges(true).call();
+			if (testConflict) {
+				assertEquals(Status.STOPPED, res.getStatus());
+				assertEquals(Collections.singleton("conflict"), git.status().call()
+						.getConflicting());
+				// resolve
+				writeTrashFile("conflict", "e");
+				git.add().addFilepattern("conflict").call();
+				res = git.rebase().setOperation(Operation.CONTINUE).call();
+			}
+			assertEquals(Status.OK, res.getStatus());
+
+			assertEquals("merge resolution", read(FILE1));
+			assertEquals("new content two", read("file2"));
+			assertEquals("more changess", read("file3"));
+			assertEquals("fileg", read("fileg"));
+
+			rw.markStart(rw.parseCommit(db.resolve("refs/heads/topic")));
+			RevCommit newF = rw.next();
+			assertDerivedFrom(newF, f);
+			RevCommit newD = rw.next();
+			assertDerivedFrom(newD, d);
+			assertEquals(2, newD.getParentCount());
+			RevCommit newC = rw.next();
+			assertDerivedFrom(newC, c);
+			RevCommit newE = rw.next();
+			assertEquals(e, newE);
+			assertEquals(newC, newD.getParent(0));
+			assertEquals(e, newD.getParent(1));
+			assertEquals(g, rw.next());
+			assertEquals(b, rw.next());
+			assertEquals(a, rw.next());
 		}
-		assertEquals(Status.OK, res.getStatus());
-
-		assertEquals("merge resolution", read(FILE1));
-		assertEquals("new content two", read("file2"));
-		assertEquals("more changess", read("file3"));
-		assertEquals("fileg", read("fileg"));
-
-		rw.markStart(rw.parseCommit(db.resolve("refs/heads/topic")));
-		RevCommit newF = rw.next();
-		assertDerivedFrom(newF, f);
-		RevCommit newD = rw.next();
-		assertDerivedFrom(newD, d);
-		assertEquals(2, newD.getParentCount());
-		RevCommit newC = rw.next();
-		assertDerivedFrom(newC, c);
-		RevCommit newE = rw.next();
-		assertEquals(e, newE);
-		assertEquals(newC, newD.getParent(0));
-		assertEquals(e, newD.getParent(1));
-		assertEquals(g, rw.next());
-		assertEquals(b, rw.next());
-		assertEquals(a, rw.next());
 	}
 
 	@Test
@@ -687,8 +691,10 @@ public class RebaseCommandTest extends RepositoryTestCase {
 		checkFile(theFile, "1master\n2\n3\ntopic\n");
 		// our old branch should be checked out again
 		assertEquals("refs/heads/topic", db.getFullBranch());
-		assertEquals(lastMasterChange, new RevWalk(db).parseCommit(
-				db.resolve(Constants.HEAD)).getParent(0));
+		try (RevWalk rw = new RevWalk(db)) {
+			assertEquals(lastMasterChange, rw.parseCommit(
+					db.resolve(Constants.HEAD)).getParent(0));
+		}
 		assertEquals(origHead, db.readOrigHead());
 		List<ReflogEntry> headLog = db.getReflogReader(Constants.HEAD)
 				.getReverseEntries();
@@ -737,8 +743,10 @@ public class RebaseCommandTest extends RepositoryTestCase {
 		RebaseResult res = git.rebase().setUpstream("refs/heads/master").call();
 		assertEquals(Status.OK, res.getStatus());
 		checkFile(theFile, "1master\n2\n3\ntopic\n");
-		assertEquals(lastMasterChange, new RevWalk(db).parseCommit(
-				db.resolve(Constants.HEAD)).getParent(0));
+		try (RevWalk rw = new RevWalk(db)) {
+			assertEquals(lastMasterChange, rw.parseCommit(
+					db.resolve(Constants.HEAD)).getParent(0));
+		}
 
 		List<ReflogEntry> headLog = db.getReflogReader(Constants.HEAD)
 				.getReverseEntries();
@@ -785,8 +793,10 @@ public class RebaseCommandTest extends RepositoryTestCase {
 
 		// our old branch should be checked out again
 		assertEquals("refs/heads/file3", db.getFullBranch());
-		assertEquals(addFile2, new RevWalk(db).parseCommit(
-				db.resolve(Constants.HEAD)).getParent(0));
+		try (RevWalk rw = new RevWalk(db)) {
+			assertEquals(addFile2, rw.parseCommit(
+					db.resolve(Constants.HEAD)).getParent(0));
+		}
 
 		checkoutBranch("refs/heads/file2");
 		assertTrue(new File(db.getWorkTree(), FILE1).exists());
@@ -846,9 +856,10 @@ public class RebaseCommandTest extends RepositoryTestCase {
 		assertEquals(res.getStatus(), Status.ABORTED);
 		assertEquals("refs/heads/topic", db.getFullBranch());
 		checkFile(FILE1, "1topic", "2", "3", "topic4");
-		RevWalk rw = new RevWalk(db);
-		assertEquals(lastTopicCommit, rw
-				.parseCommit(db.resolve(Constants.HEAD)));
+		try (RevWalk rw = new RevWalk(db)) {
+			assertEquals(lastTopicCommit,
+					rw.parseCommit(db.resolve(Constants.HEAD)));
+		}
 		assertEquals(RepositoryState.SAFE, db.getRepositoryState());
 
 		// rebase- dir in .git must be deleted
@@ -909,9 +920,10 @@ public class RebaseCommandTest extends RepositoryTestCase {
 		assertEquals(res.getStatus(), Status.ABORTED);
 		assertEquals(lastTopicCommit.getName(), db.getFullBranch());
 		checkFile(FILE1, "1topic", "2", "3", "topic4");
-		RevWalk rw = new RevWalk(db);
-		assertEquals(lastTopicCommit,
-				rw.parseCommit(db.resolve(Constants.HEAD)));
+		try (RevWalk rw = new RevWalk(db)) {
+			assertEquals(lastTopicCommit,
+					rw.parseCommit(db.resolve(Constants.HEAD)));
+		}
 		assertEquals(RepositoryState.SAFE, db.getRepositoryState());
 
 		// rebase- dir in .git must be deleted
@@ -966,11 +978,12 @@ public class RebaseCommandTest extends RepositoryTestCase {
 		assertEquals(RepositoryState.SAFE, db.getRepositoryState());
 
 		ObjectId headId = db.resolve(Constants.HEAD);
-		RevWalk rw = new RevWalk(db);
-		RevCommit rc = rw.parseCommit(headId);
-		RevCommit parent = rw.parseCommit(rc.getParent(0));
-		assertEquals("change file1 in topic\n\nThis is conflicting", parent
-				.getFullMessage());
+		try (RevWalk rw = new RevWalk(db)) {
+			RevCommit rc = rw.parseCommit(headId);
+			RevCommit parent = rw.parseCommit(rc.getParent(0));
+			assertEquals("change file1 in topic\n\nThis is conflicting", parent
+					.getFullMessage());
+		}
 	}
 
 	@Test
@@ -1017,9 +1030,10 @@ public class RebaseCommandTest extends RepositoryTestCase {
 		git.rebase().setOperation(Operation.SKIP).call();
 
 		ObjectId headId = db.resolve(Constants.HEAD);
-		RevWalk rw = new RevWalk(db);
-		RevCommit rc = rw.parseCommit(headId);
-		assertEquals("change file1 in master", rc.getFullMessage());
+		try (RevWalk rw = new RevWalk(db)) {
+			RevCommit rc = rw.parseCommit(headId);
+			assertEquals("change file1 in master", rc.getFullMessage());
+		}
 	}
 
 	@Test
@@ -1308,10 +1322,11 @@ public class RebaseCommandTest extends RepositoryTestCase {
 		git.rebase().setOperation(Operation.SKIP).call();
 
 		ObjectId headId = db.resolve(Constants.HEAD);
-		RevWalk rw = new RevWalk(db);
-		RevCommit rc = rw.parseCommit(headId);
-		RevCommit parent = rw.parseCommit(rc.getParent(0));
-		assertEquals("A different commit message", parent.getFullMessage());
+		try (RevWalk rw = new RevWalk(db)) {
+			RevCommit rc = rw.parseCommit(headId);
+			RevCommit parent = rw.parseCommit(rc.getParent(0));
+			assertEquals("A different commit message", parent.getFullMessage());
+		}
 	}
 
 	private RevCommit writeFileAndCommit(String fileName, String commitMessage,
@@ -1420,9 +1435,10 @@ public class RebaseCommandTest extends RepositoryTestCase {
 		res = git.rebase().setOperation(Operation.ABORT).call();
 		assertEquals(res.getStatus(), Status.ABORTED);
 		assertEquals("refs/heads/topic", db.getFullBranch());
-		RevWalk rw = new RevWalk(db);
-		assertEquals(conflicting, rw.parseCommit(db.resolve(Constants.HEAD)));
-		assertEquals(RepositoryState.SAFE, db.getRepositoryState());
+		try (RevWalk rw = new RevWalk(db)) {
+			assertEquals(conflicting, rw.parseCommit(db.resolve(Constants.HEAD)));
+			assertEquals(RepositoryState.SAFE, db.getRepositoryState());
+		}
 
 		// rebase- dir in .git must be deleted
 		assertFalse(new File(db.getDirectory(), "rebase-merge").exists());
@@ -2286,14 +2302,15 @@ public class RebaseCommandTest extends RepositoryTestCase {
 		assertEquals(RebaseResult.Status.OK, res2.getStatus());
 
 		ObjectId headId = db.resolve(Constants.HEAD);
-		RevWalk rw = new RevWalk(db);
-		RevCommit rc = rw.parseCommit(headId);
+		try (RevWalk rw = new RevWalk(db)) {
+			RevCommit rc = rw.parseCommit(headId);
 
-		ObjectId head1Id = db.resolve(Constants.HEAD + "~1");
-		RevCommit rc1 = rw.parseCommit(head1Id);
+			ObjectId head1Id = db.resolve(Constants.HEAD + "~1");
+			RevCommit rc1 = rw.parseCommit(head1Id);
 
-		assertEquals(rc.getFullMessage(), c4.getFullMessage());
-		assertEquals(rc1.getFullMessage(), c2.getFullMessage());
+			assertEquals(rc.getFullMessage(), c4.getFullMessage());
+			assertEquals(rc1.getFullMessage(), c2.getFullMessage());
+		}
 	}
 
 	@Test
@@ -2643,15 +2660,16 @@ public class RebaseCommandTest extends RepositoryTestCase {
 					}
 				}).call();
 
-		RevWalk walk = new RevWalk(db);
-		ObjectId headId = db.resolve(Constants.HEAD);
-		RevCommit headCommit = walk.parseCommit(headId);
-		assertEquals(headCommit.getFullMessage(),
-				"update file2 on master\nnew line");
-
-		ObjectId head2Id = db.resolve(Constants.HEAD + "^1");
-		RevCommit head1Commit = walk.parseCommit(head2Id);
-		assertEquals("changed", head1Commit.getFullMessage());
+		try (RevWalk walk = new RevWalk(db)) {
+			ObjectId headId = db.resolve(Constants.HEAD);
+			RevCommit headCommit = walk.parseCommit(headId);
+			assertEquals(headCommit.getFullMessage(),
+					"update file2 on master\nnew line");
+
+			ObjectId head2Id = db.resolve(Constants.HEAD + "^1");
+			RevCommit head1Commit = walk.parseCommit(head2Id);
+			assertEquals("changed", head1Commit.getFullMessage());
+		}
 	}
 
 	@Test
@@ -2722,17 +2740,18 @@ public class RebaseCommandTest extends RepositoryTestCase {
 					}
 				}).call();
 
-		RevWalk walk = new RevWalk(db);
-		ObjectId headId = db.resolve(Constants.HEAD);
-		RevCommit headCommit = walk.parseCommit(headId);
-		assertEquals(headCommit.getFullMessage(),
-				"update file2 on master\nnew line");
-
-		ObjectId head2Id = db.resolve(Constants.HEAD + "^1");
-		RevCommit head1Commit = walk.parseCommit(head2Id);
-		assertEquals(
-				"Add file1\nnew line\nAdd file2\nnew line\nupdated file1 on master\nnew line",
-				head1Commit.getFullMessage());
+		try (RevWalk walk = new RevWalk(db)) {
+			ObjectId headId = db.resolve(Constants.HEAD);
+			RevCommit headCommit = walk.parseCommit(headId);
+			assertEquals(headCommit.getFullMessage(),
+					"update file2 on master\nnew line");
+
+			ObjectId head2Id = db.resolve(Constants.HEAD + "^1");
+			RevCommit head1Commit = walk.parseCommit(head2Id);
+			assertEquals(
+					"Add file1\nnew line\nAdd file2\nnew line\nupdated file1 on master\nnew line",
+					head1Commit.getFullMessage());
+		}
 	}
 
 	@Test
@@ -2804,15 +2823,16 @@ public class RebaseCommandTest extends RepositoryTestCase {
 					}
 				}).call();
 
-		RevWalk walk = new RevWalk(db);
-		ObjectId headId = db.resolve(Constants.HEAD);
-		RevCommit headCommit = walk.parseCommit(headId);
-		assertEquals(headCommit.getFullMessage(),
-				"update file2 on master\nnew line");
-
-		ObjectId head2Id = db.resolve(Constants.HEAD + "^1");
-		RevCommit head1Commit = walk.parseCommit(head2Id);
-		assertEquals("changed", head1Commit.getFullMessage());
+		try (RevWalk walk = new RevWalk(db)) {
+			ObjectId headId = db.resolve(Constants.HEAD);
+			RevCommit headCommit = walk.parseCommit(headId);
+			assertEquals(headCommit.getFullMessage(),
+					"update file2 on master\nnew line");
+
+			ObjectId head2Id = db.resolve(Constants.HEAD + "^1");
+			RevCommit head1Commit = walk.parseCommit(head2Id);
+			assertEquals("changed", head1Commit.getFullMessage());
+		}
 	}
 
 	@Test
@@ -2855,16 +2875,17 @@ public class RebaseCommandTest extends RepositoryTestCase {
 					}
 				}).call();
 
-		RevWalk walk = new RevWalk(db);
-		ObjectId headId = db.resolve(Constants.HEAD);
-		RevCommit headCommit = walk.parseCommit(headId);
-		assertEquals("update file2 on master\nnew line",
-				headCommit.getFullMessage());
-
-		ObjectId head1Id = db.resolve(Constants.HEAD + "^1");
-		RevCommit head1Commit = walk.parseCommit(head1Id);
-		assertEquals("Add file2\nnew line",
-				head1Commit.getFullMessage());
+		try (RevWalk walk = new RevWalk(db)) {
+			ObjectId headId = db.resolve(Constants.HEAD);
+			RevCommit headCommit = walk.parseCommit(headId);
+			assertEquals("update file2 on master\nnew line",
+					headCommit.getFullMessage());
+
+			ObjectId head1Id = db.resolve(Constants.HEAD + "^1");
+			RevCommit head1Commit = walk.parseCommit(head1Id);
+			assertEquals("Add file2\nnew line",
+					head1Commit.getFullMessage());
+		}
 	}
 
 	@Test
@@ -2903,11 +2924,12 @@ public class RebaseCommandTest extends RepositoryTestCase {
 					}
 				}).call();
 
-		RevWalk walk = new RevWalk(db);
-		ObjectId headId = db.resolve(Constants.HEAD);
-		RevCommit headCommit = walk.parseCommit(headId);
-		assertEquals("Add file2",
-				headCommit.getFullMessage());
+		try (RevWalk walk = new RevWalk(db)) {
+			ObjectId headId = db.resolve(Constants.HEAD);
+			RevCommit headCommit = walk.parseCommit(headId);
+			assertEquals("Add file2",
+					headCommit.getFullMessage());
+		}
 	}
 
 	@Test(expected = InvalidRebaseStepException.class)
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/blame/BlameGeneratorTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/blame/BlameGeneratorTest.java
index 42909f0d7..fa9848bab 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/blame/BlameGeneratorTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/blame/BlameGeneratorTest.java
@@ -58,141 +58,142 @@ import org.junit.Test;
 public class BlameGeneratorTest extends RepositoryTestCase {
 	@Test
 	public void testBoundLineDelete() throws Exception {
-		Git git = new Git(db);
-
-		String[] content1 = new String[] { "first", "second" };
-		writeTrashFile("file.txt", join(content1));
-		git.add().addFilepattern("file.txt").call();
-		RevCommit c1 = git.commit().setMessage("create file").call();
-
-		String[] content2 = new String[] { "third", "first", "second" };
-		writeTrashFile("file.txt", join(content2));
-		git.add().addFilepattern("file.txt").call();
-		RevCommit c2 = git.commit().setMessage("create file").call();
-
-		try (BlameGenerator generator = new BlameGenerator(db, "file.txt")) {
-			generator.push(null, db.resolve(Constants.HEAD));
-			assertEquals(3, generator.getResultContents().size());
-
-			assertTrue(generator.next());
-			assertEquals(c2, generator.getSourceCommit());
-			assertEquals(1, generator.getRegionLength());
-			assertEquals(0, generator.getResultStart());
-			assertEquals(1, generator.getResultEnd());
-			assertEquals(0, generator.getSourceStart());
-			assertEquals(1, generator.getSourceEnd());
-			assertEquals("file.txt", generator.getSourcePath());
-
-			assertTrue(generator.next());
-			assertEquals(c1, generator.getSourceCommit());
-			assertEquals(2, generator.getRegionLength());
-			assertEquals(1, generator.getResultStart());
-			assertEquals(3, generator.getResultEnd());
-			assertEquals(0, generator.getSourceStart());
-			assertEquals(2, generator.getSourceEnd());
-			assertEquals("file.txt", generator.getSourcePath());
-
-			assertFalse(generator.next());
+		try (Git git = new Git(db)) {
+			String[] content1 = new String[] { "first", "second" };
+			writeTrashFile("file.txt", join(content1));
+			git.add().addFilepattern("file.txt").call();
+			RevCommit c1 = git.commit().setMessage("create file").call();
+
+			String[] content2 = new String[] { "third", "first", "second" };
+			writeTrashFile("file.txt", join(content2));
+			git.add().addFilepattern("file.txt").call();
+			RevCommit c2 = git.commit().setMessage("create file").call();
+
+			try (BlameGenerator generator = new BlameGenerator(db, "file.txt")) {
+				generator.push(null, db.resolve(Constants.HEAD));
+				assertEquals(3, generator.getResultContents().size());
+
+				assertTrue(generator.next());
+				assertEquals(c2, generator.getSourceCommit());
+				assertEquals(1, generator.getRegionLength());
+				assertEquals(0, generator.getResultStart());
+				assertEquals(1, generator.getResultEnd());
+				assertEquals(0, generator.getSourceStart());
+				assertEquals(1, generator.getSourceEnd());
+				assertEquals("file.txt", generator.getSourcePath());
+
+				assertTrue(generator.next());
+				assertEquals(c1, generator.getSourceCommit());
+				assertEquals(2, generator.getRegionLength());
+				assertEquals(1, generator.getResultStart());
+				assertEquals(3, generator.getResultEnd());
+				assertEquals(0, generator.getSourceStart());
+				assertEquals(2, generator.getSourceEnd());
+				assertEquals("file.txt", generator.getSourcePath());
+
+				assertFalse(generator.next());
+			}
 		}
 	}
 
 	@Test
 	public void testRenamedBoundLineDelete() throws Exception {
-		Git git = new Git(db);
-		final String FILENAME_1 = "subdir/file1.txt";
-		final String FILENAME_2 = "subdir/file2.txt";
-
-		String[] content1 = new String[] { "first", "second" };
-		writeTrashFile(FILENAME_1, join(content1));
-		git.add().addFilepattern(FILENAME_1).call();
-		RevCommit c1 = git.commit().setMessage("create file1").call();
-
-		// rename it
-		writeTrashFile(FILENAME_2, join(content1));
-		git.add().addFilepattern(FILENAME_2).call();
-		deleteTrashFile(FILENAME_1);
-		git.rm().addFilepattern(FILENAME_1).call();
-		git.commit().setMessage("rename file1.txt to file2.txt").call();
-
-		// and change the new file
-		String[] content2 = new String[] { "third", "first", "second" };
-		writeTrashFile(FILENAME_2, join(content2));
-		git.add().addFilepattern(FILENAME_2).call();
-		RevCommit c2 = git.commit().setMessage("change file2").call();
-
-		try (BlameGenerator generator = new BlameGenerator(db, FILENAME_2)) {
-			generator.push(null, db.resolve(Constants.HEAD));
-			assertEquals(3, generator.getResultContents().size());
-
-			assertTrue(generator.next());
-			assertEquals(c2, generator.getSourceCommit());
-			assertEquals(1, generator.getRegionLength());
-			assertEquals(0, generator.getResultStart());
-			assertEquals(1, generator.getResultEnd());
-			assertEquals(0, generator.getSourceStart());
-			assertEquals(1, generator.getSourceEnd());
-			assertEquals(FILENAME_2, generator.getSourcePath());
-
-			assertTrue(generator.next());
-			assertEquals(c1, generator.getSourceCommit());
-			assertEquals(2, generator.getRegionLength());
-			assertEquals(1, generator.getResultStart());
-			assertEquals(3, generator.getResultEnd());
-			assertEquals(0, generator.getSourceStart());
-			assertEquals(2, generator.getSourceEnd());
-			assertEquals(FILENAME_1, generator.getSourcePath());
-
-			assertFalse(generator.next());
-		}
-
-		// and test again with other BlameGenerator API:
-		try (BlameGenerator generator = new BlameGenerator(db, FILENAME_2)) {
-			generator.push(null, db.resolve(Constants.HEAD));
-			BlameResult result = generator.computeBlameResult();
-
-			assertEquals(3, result.getResultContents().size());
-
-			assertEquals(c2, result.getSourceCommit(0));
-			assertEquals(FILENAME_2, result.getSourcePath(0));
-
-			assertEquals(c1, result.getSourceCommit(1));
-			assertEquals(FILENAME_1, result.getSourcePath(1));
-
-			assertEquals(c1, result.getSourceCommit(2));
-			assertEquals(FILENAME_1, result.getSourcePath(2));
+		try (Git git = new Git(db)) {
+			final String FILENAME_1 = "subdir/file1.txt";
+			final String FILENAME_2 = "subdir/file2.txt";
+
+			String[] content1 = new String[] { "first", "second" };
+			writeTrashFile(FILENAME_1, join(content1));
+			git.add().addFilepattern(FILENAME_1).call();
+			RevCommit c1 = git.commit().setMessage("create file1").call();
+
+			// rename it
+			writeTrashFile(FILENAME_2, join(content1));
+			git.add().addFilepattern(FILENAME_2).call();
+			deleteTrashFile(FILENAME_1);
+			git.rm().addFilepattern(FILENAME_1).call();
+			git.commit().setMessage("rename file1.txt to file2.txt").call();
+
+			// and change the new file
+			String[] content2 = new String[] { "third", "first", "second" };
+			writeTrashFile(FILENAME_2, join(content2));
+			git.add().addFilepattern(FILENAME_2).call();
+			RevCommit c2 = git.commit().setMessage("change file2").call();
+
+			try (BlameGenerator generator = new BlameGenerator(db, FILENAME_2)) {
+				generator.push(null, db.resolve(Constants.HEAD));
+				assertEquals(3, generator.getResultContents().size());
+
+				assertTrue(generator.next());
+				assertEquals(c2, generator.getSourceCommit());
+				assertEquals(1, generator.getRegionLength());
+				assertEquals(0, generator.getResultStart());
+				assertEquals(1, generator.getResultEnd());
+				assertEquals(0, generator.getSourceStart());
+				assertEquals(1, generator.getSourceEnd());
+				assertEquals(FILENAME_2, generator.getSourcePath());
+
+				assertTrue(generator.next());
+				assertEquals(c1, generator.getSourceCommit());
+				assertEquals(2, generator.getRegionLength());
+				assertEquals(1, generator.getResultStart());
+				assertEquals(3, generator.getResultEnd());
+				assertEquals(0, generator.getSourceStart());
+				assertEquals(2, generator.getSourceEnd());
+				assertEquals(FILENAME_1, generator.getSourcePath());
+
+				assertFalse(generator.next());
+			}
+
+			// and test again with other BlameGenerator API:
+			try (BlameGenerator generator = new BlameGenerator(db, FILENAME_2)) {
+				generator.push(null, db.resolve(Constants.HEAD));
+				BlameResult result = generator.computeBlameResult();
+
+				assertEquals(3, result.getResultContents().size());
+
+				assertEquals(c2, result.getSourceCommit(0));
+				assertEquals(FILENAME_2, result.getSourcePath(0));
+
+				assertEquals(c1, result.getSourceCommit(1));
+				assertEquals(FILENAME_1, result.getSourcePath(1));
+
+				assertEquals(c1, result.getSourceCommit(2));
+				assertEquals(FILENAME_1, result.getSourcePath(2));
+			}
 		}
 	}
 
 	@Test
 	public void testLinesAllDeletedShortenedWalk() throws Exception {
-		Git git = new Git(db);
-
-		String[] content1 = new String[] { "first", "second", "third" };
+		try (Git git = new Git(db)) {
+			String[] content1 = new String[] { "first", "second", "third" };
 
-		writeTrashFile("file.txt", join(content1));
-		git.add().addFilepattern("file.txt").call();
-		git.commit().setMessage("create file").call();
+			writeTrashFile("file.txt", join(content1));
+			git.add().addFilepattern("file.txt").call();
+			git.commit().setMessage("create file").call();
 
-		String[] content2 = new String[] { "" };
+			String[] content2 = new String[] { "" };
 
-		writeTrashFile("file.txt", join(content2));
-		git.add().addFilepattern("file.txt").call();
-		git.commit().setMessage("create file").call();
+			writeTrashFile("file.txt", join(content2));
+			git.add().addFilepattern("file.txt").call();
+			git.commit().setMessage("create file").call();
 
-		writeTrashFile("file.txt", join(content1));
-		git.add().addFilepattern("file.txt").call();
-		RevCommit c3 = git.commit().setMessage("create file").call();
+			writeTrashFile("file.txt", join(content1));
+			git.add().addFilepattern("file.txt").call();
+			RevCommit c3 = git.commit().setMessage("create file").call();
 
-		try (BlameGenerator generator = new BlameGenerator(db, "file.txt")) {
-			generator.push(null, db.resolve(Constants.HEAD));
-			assertEquals(3, generator.getResultContents().size());
+			try (BlameGenerator generator = new BlameGenerator(db, "file.txt")) {
+				generator.push(null, db.resolve(Constants.HEAD));
+				assertEquals(3, generator.getResultContents().size());
 
-			assertTrue(generator.next());
-			assertEquals(c3, generator.getSourceCommit());
-			assertEquals(0, generator.getResultStart());
-			assertEquals(3, generator.getResultEnd());
+				assertTrue(generator.next());
+				assertEquals(c3, generator.getSourceCommit());
+				assertEquals(0, generator.getResultStart());
+				assertEquals(3, generator.getResultEnd());
 
-			assertFalse(generator.next());
+				assertFalse(generator.next());
+			}
 		}
 	}
 
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/DiffEntryTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/DiffEntryTest.java
index 5694e8337..443c956b7 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/DiffEntryTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/DiffEntryTest.java
@@ -77,260 +77,268 @@ public class DiffEntryTest extends RepositoryTestCase {
 	public void shouldListAddedFileInInitialCommit() throws Exception {
 		// given
 		writeTrashFile("a.txt", "content");
-		Git git = new Git(db);
-		git.add().addFilepattern("a.txt").call();
-		RevCommit c = git.commit().setMessage("initial commit").call();
-
-		// when
-		TreeWalk walk = new TreeWalk(db);
-		walk.addTree(new EmptyTreeIterator());
-		walk.addTree(c.getTree());
-		List<DiffEntry> result = DiffEntry.scan(walk);
-
-		// then
-		assertThat(result, notNullValue());
-		assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
-
-		DiffEntry entry = result.get(0);
-		assertThat(entry.getChangeType(), is(ChangeType.ADD));
-		assertThat(entry.getNewPath(), is("a.txt"));
-		assertThat(entry.getOldPath(), is(DEV_NULL));
+		try (Git git = new Git(db);
+				TreeWalk walk = new TreeWalk(db)) {
+			git.add().addFilepattern("a.txt").call();
+			RevCommit c = git.commit().setMessage("initial commit").call();
+
+			// when
+			walk.addTree(new EmptyTreeIterator());
+			walk.addTree(c.getTree());
+			List<DiffEntry> result = DiffEntry.scan(walk);
+
+			// then
+			assertThat(result, notNullValue());
+			assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
+
+			DiffEntry entry = result.get(0);
+			assertThat(entry.getChangeType(), is(ChangeType.ADD));
+			assertThat(entry.getNewPath(), is("a.txt"));
+			assertThat(entry.getOldPath(), is(DEV_NULL));
+		}
 	}
 
 	@Test
 	public void shouldListAddedFileBetweenTwoCommits() throws Exception {
 		// given
-		Git git = new Git(db);
-		RevCommit c1 = git.commit().setMessage("initial commit").call();
-		writeTrashFile("a.txt", "content");
-		git.add().addFilepattern("a.txt").call();
-		RevCommit c2 = git.commit().setMessage("second commit").call();
-
-		// when
-		TreeWalk walk = new TreeWalk(db);
-		walk.addTree(c1.getTree());
-		walk.addTree(c2.getTree());
-		List<DiffEntry> result = DiffEntry.scan(walk);
-
-		// then
-		assertThat(result, notNullValue());
-		assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
-
-		DiffEntry entry = result.get(0);
-		assertThat(entry.getChangeType(), is(ChangeType.ADD));
-		assertThat(entry.getNewPath(), is("a.txt"));
-		assertThat(entry.getOldPath(), is(DEV_NULL));
+		try (Git git = new Git(db);
+				TreeWalk walk = new TreeWalk(db)) {
+			RevCommit c1 = git.commit().setMessage("initial commit").call();
+			writeTrashFile("a.txt", "content");
+			git.add().addFilepattern("a.txt").call();
+			RevCommit c2 = git.commit().setMessage("second commit").call();
+
+			// when
+			walk.addTree(c1.getTree());
+			walk.addTree(c2.getTree());
+			List<DiffEntry> result = DiffEntry.scan(walk);
+
+			// then
+			assertThat(result, notNullValue());
+			assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
+
+			DiffEntry entry = result.get(0);
+			assertThat(entry.getChangeType(), is(ChangeType.ADD));
+			assertThat(entry.getNewPath(), is("a.txt"));
+			assertThat(entry.getOldPath(), is(DEV_NULL));
+		}
 	}
 
 	@Test
 	public void shouldListModificationBetweenTwoCommits() throws Exception {
 		// given
-		Git git = new Git(db);
-		File file = writeTrashFile("a.txt", "content");
-		git.add().addFilepattern("a.txt").call();
-		RevCommit c1 = git.commit().setMessage("initial commit").call();
-		write(file, "new content");
-		RevCommit c2 = git.commit().setAll(true).setMessage("second commit")
-				.call();
-
-		// when
-		TreeWalk walk = new TreeWalk(db);
-		walk.addTree(c1.getTree());
-		walk.addTree(c2.getTree());
-		List<DiffEntry> result = DiffEntry.scan(walk);
-
-		// then
-		assertThat(result, notNullValue());
-		assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
-
-		DiffEntry entry = result.get(0);
-		assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
-		assertThat(entry.getNewPath(), is("a.txt"));
+		try (Git git = new Git(db);
+				TreeWalk walk = new TreeWalk(db)) {
+			File file = writeTrashFile("a.txt", "content");
+			git.add().addFilepattern("a.txt").call();
+			RevCommit c1 = git.commit().setMessage("initial commit").call();
+			write(file, "new content");
+			RevCommit c2 = git.commit().setAll(true).setMessage("second commit")
+					.call();
+
+			// when
+			walk.addTree(c1.getTree());
+			walk.addTree(c2.getTree());
+			List<DiffEntry> result = DiffEntry.scan(walk);
+
+			// then
+			assertThat(result, notNullValue());
+			assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
+
+			DiffEntry entry = result.get(0);
+			assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
+			assertThat(entry.getNewPath(), is("a.txt"));
+		}
 	}
 
 	@Test
 	public void shouldListDeletionBetweenTwoCommits() throws Exception {
 		// given
-		Git git = new Git(db);
-		File file = writeTrashFile("a.txt", "content");
-		git.add().addFilepattern("a.txt").call();
-		RevCommit c1 = git.commit().setMessage("initial commit").call();
-		delete(file);
-		RevCommit c2 = git.commit().setAll(true).setMessage("delete a.txt")
-				.call();
-
-		// when
-		TreeWalk walk = new TreeWalk(db);
-		walk.addTree(c1.getTree());
-		walk.addTree(c2.getTree());
-		List<DiffEntry> result = DiffEntry.scan(walk);
-
-		// then
-		assertThat(result, notNullValue());
-		assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
-
-		DiffEntry entry = result.get(0);
-		assertThat(entry.getOldPath(), is("a.txt"));
-		assertThat(entry.getNewPath(), is(DEV_NULL));
-		assertThat(entry.getChangeType(), is(ChangeType.DELETE));
+		try (Git git = new Git(db);
+				TreeWalk walk = new TreeWalk(db)) {
+			File file = writeTrashFile("a.txt", "content");
+			git.add().addFilepattern("a.txt").call();
+			RevCommit c1 = git.commit().setMessage("initial commit").call();
+			delete(file);
+			RevCommit c2 = git.commit().setAll(true).setMessage("delete a.txt")
+					.call();
+
+			// when
+			walk.addTree(c1.getTree());
+			walk.addTree(c2.getTree());
+			List<DiffEntry> result = DiffEntry.scan(walk);
+
+			// then
+			assertThat(result, notNullValue());
+			assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
+
+			DiffEntry entry = result.get(0);
+			assertThat(entry.getOldPath(), is("a.txt"));
+			assertThat(entry.getNewPath(), is(DEV_NULL));
+			assertThat(entry.getChangeType(), is(ChangeType.DELETE));
+		}
 	}
 
 	@Test
 	public void shouldListModificationInDirWithoutModifiedTrees()
 			throws Exception {
 		// given
-		Git git = new Git(db);
-		File tree = new File(new File(db.getWorkTree(), "a"), "b");
-		FileUtils.mkdirs(tree);
-		File file = new File(tree, "c.txt");
-		FileUtils.createNewFile(file);
-		write(file, "content");
-		git.add().addFilepattern("a").call();
-		RevCommit c1 = git.commit().setMessage("initial commit").call();
-		write(file, "new line");
-		RevCommit c2 = git.commit().setAll(true).setMessage("second commit")
-				.call();
-
-		// when
-		TreeWalk walk = new TreeWalk(db);
-		walk.addTree(c1.getTree());
-		walk.addTree(c2.getTree());
-		walk.setRecursive(true);
-		List<DiffEntry> result = DiffEntry.scan(walk);
-
-		// then
-		assertThat(result, notNullValue());
-		assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
-
-		DiffEntry entry = result.get(0);
-		assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
-		assertThat(entry.getNewPath(), is("a/b/c.txt"));
+		try (Git git = new Git(db);
+				TreeWalk walk = new TreeWalk(db)) {
+			File tree = new File(new File(db.getWorkTree(), "a"), "b");
+			FileUtils.mkdirs(tree);
+			File file = new File(tree, "c.txt");
+			FileUtils.createNewFile(file);
+			write(file, "content");
+			git.add().addFilepattern("a").call();
+			RevCommit c1 = git.commit().setMessage("initial commit").call();
+			write(file, "new line");
+			RevCommit c2 = git.commit().setAll(true).setMessage("second commit")
+					.call();
+
+			// when
+			walk.addTree(c1.getTree());
+			walk.addTree(c2.getTree());
+			walk.setRecursive(true);
+			List<DiffEntry> result = DiffEntry.scan(walk);
+
+			// then
+			assertThat(result, notNullValue());
+			assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
+
+			DiffEntry entry = result.get(0);
+			assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
+			assertThat(entry.getNewPath(), is("a/b/c.txt"));
+		}
 	}
 
 	@Test
 	public void shouldListModificationInDirWithModifiedTrees() throws Exception {
 		// given
-		Git git = new Git(db);
-		File tree = new File(new File(db.getWorkTree(), "a"), "b");
-		FileUtils.mkdirs(tree);
-		File file = new File(tree, "c.txt");
-		FileUtils.createNewFile(file);
-		write(file, "content");
-		git.add().addFilepattern("a").call();
-		RevCommit c1 = git.commit().setMessage("initial commit").call();
-		write(file, "new line");
-		RevCommit c2 = git.commit().setAll(true).setMessage("second commit")
-				.call();
-
-		// when
-		TreeWalk walk = new TreeWalk(db);
-		walk.addTree(c1.getTree());
-		walk.addTree(c2.getTree());
-		List<DiffEntry> result = DiffEntry.scan(walk, true);
-
-		// then
-		assertThat(result, notNullValue());
-		assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(3)));
-
-		DiffEntry entry = result.get(0);
-		assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
-		assertThat(entry.getNewPath(), is("a"));
-
-		entry = result.get(1);
-		assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
-		assertThat(entry.getNewPath(), is("a/b"));
-
-		entry = result.get(2);
-		assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
-		assertThat(entry.getNewPath(), is("a/b/c.txt"));
+		try (Git git = new Git(db);
+				TreeWalk walk = new TreeWalk(db)) {
+			File tree = new File(new File(db.getWorkTree(), "a"), "b");
+			FileUtils.mkdirs(tree);
+			File file = new File(tree, "c.txt");
+			FileUtils.createNewFile(file);
+			write(file, "content");
+			git.add().addFilepattern("a").call();
+			RevCommit c1 = git.commit().setMessage("initial commit").call();
+			write(file, "new line");
+			RevCommit c2 = git.commit().setAll(true).setMessage("second commit")
+					.call();
+
+			// when
+			walk.addTree(c1.getTree());
+			walk.addTree(c2.getTree());
+			List<DiffEntry> result = DiffEntry.scan(walk, true);
+
+			// then
+			assertThat(result, notNullValue());
+			assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(3)));
+
+			DiffEntry entry = result.get(0);
+			assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
+			assertThat(entry.getNewPath(), is("a"));
+
+			entry = result.get(1);
+			assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
+			assertThat(entry.getNewPath(), is("a/b"));
+
+			entry = result.get(2);
+			assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
+			assertThat(entry.getNewPath(), is("a/b/c.txt"));
+		}
 	}
 
 	@Test
 	public void shouldListChangesInWorkingTree() throws Exception {
 		// given
 		writeTrashFile("a.txt", "content");
-		Git git = new Git(db);
-		git.add().addFilepattern("a.txt").call();
-		RevCommit c = git.commit().setMessage("initial commit").call();
-		writeTrashFile("b.txt", "new line");
-
-		// when
-		TreeWalk walk = new TreeWalk(db);
-		walk.addTree(c.getTree());
-		walk.addTree(new FileTreeIterator(db));
-		List<DiffEntry> result = DiffEntry.scan(walk, true);
-
-		// then
-		assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
-		DiffEntry entry = result.get(0);
-
-		assertThat(entry.getChangeType(), is(ChangeType.ADD));
-		assertThat(entry.getNewPath(), is("b.txt"));
+		try (Git git = new Git(db);
+				TreeWalk walk = new TreeWalk(db)) {
+			git.add().addFilepattern("a.txt").call();
+			RevCommit c = git.commit().setMessage("initial commit").call();
+			writeTrashFile("b.txt", "new line");
+
+			// when
+			walk.addTree(c.getTree());
+			walk.addTree(new FileTreeIterator(db));
+			List<DiffEntry> result = DiffEntry.scan(walk, true);
+
+			// then
+			assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
+			DiffEntry entry = result.get(0);
+
+			assertThat(entry.getChangeType(), is(ChangeType.ADD));
+			assertThat(entry.getNewPath(), is("b.txt"));
+		}
 	}
 
 	@Test
 	public void shouldMarkEntriesWhenGivenMarkTreeFilter() throws Exception {
 		// given
-		Git git = new Git(db);
-		RevCommit c1 = git.commit().setMessage("initial commit").call();
-		FileUtils.mkdir(new File(db.getWorkTree(), "b"));
-		writeTrashFile("a.txt", "a");
-		writeTrashFile("b/1.txt", "b1");
-		writeTrashFile("b/2.txt", "b2");
-		writeTrashFile("c.txt", "c");
-		git.add().addFilepattern("a.txt").addFilepattern("b")
-				.addFilepattern("c.txt").call();
-		RevCommit c2 = git.commit().setMessage("second commit").call();
-		TreeFilter filterA = PathFilterGroup.createFromStrings("a.txt");
-		TreeFilter filterB = PathFilterGroup.createFromStrings("b");
-		TreeFilter filterB2 = PathFilterGroup.createFromStrings("b/2.txt");
-
-		// when
-		TreeWalk walk = new TreeWalk(db);
-		walk.addTree(c1.getTree());
-		walk.addTree(c2.getTree());
-		List<DiffEntry> result = DiffEntry.scan(walk, true, new TreeFilter[] {
-				filterA, filterB, filterB2 });
-
-		// then
-		assertThat(result, notNullValue());
-		assertEquals(5, result.size());
-
-		DiffEntry entryA = result.get(0);
-		DiffEntry entryB = result.get(1);
-		DiffEntry entryB1 = result.get(2);
-		DiffEntry entryB2 = result.get(3);
-		DiffEntry entryC = result.get(4);
-
-		assertThat(entryA.getNewPath(), is("a.txt"));
-		assertTrue(entryA.isMarked(0));
-		assertFalse(entryA.isMarked(1));
-		assertFalse(entryA.isMarked(2));
-		assertEquals(1, entryA.getTreeFilterMarks());
-
-		assertThat(entryB.getNewPath(), is("b"));
-		assertFalse(entryB.isMarked(0));
-		assertTrue(entryB.isMarked(1));
-		assertTrue(entryB.isMarked(2));
-		assertEquals(6, entryB.getTreeFilterMarks());
-
-		assertThat(entryB1.getNewPath(), is("b/1.txt"));
-		assertFalse(entryB1.isMarked(0));
-		assertTrue(entryB1.isMarked(1));
-		assertFalse(entryB1.isMarked(2));
-		assertEquals(2, entryB1.getTreeFilterMarks());
-
-		assertThat(entryB2.getNewPath(), is("b/2.txt"));
-		assertFalse(entryB2.isMarked(0));
-		assertTrue(entryB2.isMarked(1));
-		assertTrue(entryB2.isMarked(2));
-		assertEquals(6, entryB2.getTreeFilterMarks());
-
-		assertThat(entryC.getNewPath(), is("c.txt"));
-		assertFalse(entryC.isMarked(0));
-		assertFalse(entryC.isMarked(1));
-		assertFalse(entryC.isMarked(2));
-		assertEquals(0, entryC.getTreeFilterMarks());
+		try (Git git = new Git(db);
+				TreeWalk walk = new TreeWalk(db)) {
+			RevCommit c1 = git.commit().setMessage("initial commit").call();
+			FileUtils.mkdir(new File(db.getWorkTree(), "b"));
+			writeTrashFile("a.txt", "a");
+			writeTrashFile("b/1.txt", "b1");
+			writeTrashFile("b/2.txt", "b2");
+			writeTrashFile("c.txt", "c");
+			git.add().addFilepattern("a.txt").addFilepattern("b")
+					.addFilepattern("c.txt").call();
+			RevCommit c2 = git.commit().setMessage("second commit").call();
+			TreeFilter filterA = PathFilterGroup.createFromStrings("a.txt");
+			TreeFilter filterB = PathFilterGroup.createFromStrings("b");
+			TreeFilter filterB2 = PathFilterGroup.createFromStrings("b/2.txt");
+
+			// when
+			walk.addTree(c1.getTree());
+			walk.addTree(c2.getTree());
+			List<DiffEntry> result = DiffEntry.scan(walk, true, new TreeFilter[] {
+					filterA, filterB, filterB2 });
+
+			// then
+			assertThat(result, notNullValue());
+			assertEquals(5, result.size());
+
+			DiffEntry entryA = result.get(0);
+			DiffEntry entryB = result.get(1);
+			DiffEntry entryB1 = result.get(2);
+			DiffEntry entryB2 = result.get(3);
+			DiffEntry entryC = result.get(4);
+
+			assertThat(entryA.getNewPath(), is("a.txt"));
+			assertTrue(entryA.isMarked(0));
+			assertFalse(entryA.isMarked(1));
+			assertFalse(entryA.isMarked(2));
+			assertEquals(1, entryA.getTreeFilterMarks());
+
+			assertThat(entryB.getNewPath(), is("b"));
+			assertFalse(entryB.isMarked(0));
+			assertTrue(entryB.isMarked(1));
+			assertTrue(entryB.isMarked(2));
+			assertEquals(6, entryB.getTreeFilterMarks());
+
+			assertThat(entryB1.getNewPath(), is("b/1.txt"));
+			assertFalse(entryB1.isMarked(0));
+			assertTrue(entryB1.isMarked(1));
+			assertFalse(entryB1.isMarked(2));
+			assertEquals(2, entryB1.getTreeFilterMarks());
+
+			assertThat(entryB2.getNewPath(), is("b/2.txt"));
+			assertFalse(entryB2.isMarked(0));
+			assertTrue(entryB2.isMarked(1));
+			assertTrue(entryB2.isMarked(2));
+			assertEquals(6, entryB2.getTreeFilterMarks());
+
+			assertThat(entryC.getNewPath(), is("c.txt"));
+			assertFalse(entryC.isMarked(0));
+			assertFalse(entryC.isMarked(1));
+			assertFalse(entryC.isMarked(2));
+			assertEquals(0, entryC.getTreeFilterMarks());
+		}
 	}
 
 	@Test(expected = IllegalArgumentException.class)
@@ -339,9 +347,10 @@ public class DiffEntryTest extends RepositoryTestCase {
 		// given - we don't need anything here
 
 		// when
-		TreeWalk walk = new TreeWalk(db);
-		walk.addTree(new EmptyTreeIterator());
-		DiffEntry.scan(walk);
+		try (TreeWalk walk = new TreeWalk(db)) {
+			walk.addTree(new EmptyTreeIterator());
+			DiffEntry.scan(walk);
+		}
 	}
 
 	@Test(expected = IllegalArgumentException.class)
@@ -350,11 +359,12 @@ public class DiffEntryTest extends RepositoryTestCase {
 		// given - we don't need anything here
 
 		// when
-		TreeWalk walk = new TreeWalk(db);
-		walk.addTree(new EmptyTreeIterator());
-		walk.addTree(new EmptyTreeIterator());
-		walk.addTree(new EmptyTreeIterator());
-		DiffEntry.scan(walk);
+		try (TreeWalk walk = new TreeWalk(db)) {
+			walk.addTree(new EmptyTreeIterator());
+			walk.addTree(new EmptyTreeIterator());
+			walk.addTree(new EmptyTreeIterator());
+			DiffEntry.scan(walk);
+		}
 	}
 
 	@Test(expected = IllegalArgumentException.class)
@@ -363,46 +373,47 @@ public class DiffEntryTest extends RepositoryTestCase {
 		// given - we don't need anything here
 
 		// when
-		TreeWalk walk = new TreeWalk(db);
-		walk.addTree(new EmptyTreeIterator());
-		walk.addTree(new EmptyTreeIterator());
-		walk.setRecursive(true);
-		DiffEntry.scan(walk, true);
+		try (TreeWalk walk = new TreeWalk(db)) {
+			walk.addTree(new EmptyTreeIterator());
+			walk.addTree(new EmptyTreeIterator());
+			walk.setRecursive(true);
+			DiffEntry.scan(walk, true);
+		}
 	}
 
 	@Test
 	public void shouldReportFileModeChange() throws Exception {
 		writeTrashFile("a.txt", "content");
-		Git git = new Git(db);
-		git.add().addFilepattern("a.txt").call();
-		RevCommit c1 = git.commit().setMessage("initial commit").call();
-		DirCache cache = db.lockDirCache();
-		DirCacheEditor editor = cache.editor();
-		final TreeWalk walk = new TreeWalk(db);
-		walk.addTree(c1.getTree());
-		walk.setRecursive(true);
-		assertTrue(walk.next());
-
-		editor.add(new PathEdit("a.txt") {
-
-			public void apply(DirCacheEntry ent) {
-				ent.setFileMode(FileMode.EXECUTABLE_FILE);
-				ent.setObjectId(walk.getObjectId(0));
-			}
-		});
-		assertTrue(editor.commit());
-		RevCommit c2 = git.commit().setMessage("second commit").call();
-		walk.reset();
-		walk.addTree(c1.getTree());
-		walk.addTree(c2.getTree());
-		List<DiffEntry> diffs = DiffEntry.scan(walk, false);
-		assertEquals(1, diffs.size());
-		DiffEntry diff = diffs.get(0);
-		assertEquals(ChangeType.MODIFY,diff.getChangeType());
-		assertEquals(diff.getOldId(), diff.getNewId());
-		assertEquals("a.txt", diff.getOldPath());
-		assertEquals(diff.getOldPath(), diff.getNewPath());
-		assertEquals(FileMode.EXECUTABLE_FILE, diff.getNewMode());
-		assertEquals(FileMode.REGULAR_FILE, diff.getOldMode());
+		try (Git git = new Git(db);
+				TreeWalk walk = new TreeWalk(db)) {
+			git.add().addFilepattern("a.txt").call();
+			RevCommit c1 = git.commit().setMessage("initial commit").call();
+			DirCache cache = db.lockDirCache();
+			DirCacheEditor editor = cache.editor();
+			walk.addTree(c1.getTree());
+			walk.setRecursive(true);
+			assertTrue(walk.next());
+
+			editor.add(new PathEdit("a.txt") {
+				public void apply(DirCacheEntry ent) {
+					ent.setFileMode(FileMode.EXECUTABLE_FILE);
+					ent.setObjectId(walk.getObjectId(0));
+				}
+			});
+			assertTrue(editor.commit());
+			RevCommit c2 = git.commit().setMessage("second commit").call();
+			walk.reset();
+			walk.addTree(c1.getTree());
+			walk.addTree(c2.getTree());
+			List<DiffEntry> diffs = DiffEntry.scan(walk, false);
+			assertEquals(1, diffs.size());
+			DiffEntry diff = diffs.get(0);
+			assertEquals(ChangeType.MODIFY,diff.getChangeType());
+			assertEquals(diff.getOldId(), diff.getNewId());
+			assertEquals("a.txt", diff.getOldPath());
+			assertEquals(diff.getOldPath(), diff.getNewPath());
+			assertEquals(FileMode.EXECUTABLE_FILE, diff.getNewMode());
+			assertEquals(FileMode.REGULAR_FILE, diff.getOldMode());
+		}
 	}
 }
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/T0003_BasicTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/T0003_BasicTest.java
index f4d655f86..cb8726be5 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/T0003_BasicTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/T0003_BasicTest.java
@@ -84,7 +84,6 @@ import org.eclipse.jgit.test.resources.SampleDataRepositoryTestCase;
 import org.eclipse.jgit.util.FileUtils;
 import org.junit.Test;
 
-@SuppressWarnings("deprecation")
 public class T0003_BasicTest extends SampleDataRepositoryTestCase {
 
 	@Test
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/IndexDiffTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/IndexDiffTest.java
index 7fcee3dc8..18c959607 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/IndexDiffTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/IndexDiffTest.java
@@ -77,7 +77,6 @@ import org.eclipse.jgit.treewalk.FileTreeIterator;
 import org.eclipse.jgit.util.IO;
 import org.junit.Test;
 
-@SuppressWarnings("deprecation")
 public class IndexDiffTest extends RepositoryTestCase {
 
 	static PathEdit add(final Repository db, final File workdir,
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/revwalk/ObjectWalkTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/revwalk/ObjectWalkTest.java
index 9c9edc147..e5ad313e6 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/revwalk/ObjectWalkTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/revwalk/ObjectWalkTest.java
@@ -53,7 +53,6 @@ import org.eclipse.jgit.lib.ObjectInserter;
 import org.eclipse.jgit.lib.TreeFormatter;
 import org.junit.Test;
 
-@SuppressWarnings("deprecation")
 public class ObjectWalkTest extends RevWalkTestCase {
 	protected ObjectWalk objw;
 
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/FileTreeIteratorTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/FileTreeIteratorTest.java
index 767e13d11..df17a3e2f 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/FileTreeIteratorTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/FileTreeIteratorTest.java
@@ -255,10 +255,11 @@ public class FileTreeIteratorTest extends RepositoryTestCase {
 	@Test
 	public void testDirCacheMatchingId() throws Exception {
 		File f = writeTrashFile("file", "content");
-		Git git = new Git(db);
-		writeTrashFile("file", "content");
-		fsTick(f);
-		git.add().addFilepattern("file").call();
+		try (Git git = new Git(db)) {
+			writeTrashFile("file", "content");
+			fsTick(f);
+			git.add().addFilepattern("file").call();
+		}
 		DirCacheEntry dce = db.readDirCache().getEntry("file");
 		TreeWalk tw = new TreeWalk(db);
 		FileTreeIterator fti = new FileTreeIterator(trash, db.getFS(), db
@@ -282,11 +283,12 @@ public class FileTreeIteratorTest extends RepositoryTestCase {
 	@Test
 	public void testIsModifiedSymlinkAsFile() throws Exception {
 		writeTrashFile("symlink", "content");
-		Git git = new Git(db);
-		db.getConfig().setString(ConfigConstants.CONFIG_CORE_SECTION, null,
-				ConfigConstants.CONFIG_KEY_SYMLINKS, "false");
-		git.add().addFilepattern("symlink").call();
-		git.commit().setMessage("commit").call();
+		try (Git git = new Git(db)) {
+			db.getConfig().setString(ConfigConstants.CONFIG_CORE_SECTION, null,
+					ConfigConstants.CONFIG_KEY_SYMLINKS, "false");
+			git.add().addFilepattern("symlink").call();
+			git.commit().setMessage("commit").call();
+		}
 
 		// Modify previously committed DirCacheEntry and write it back to disk
 		DirCacheEntry dce = db.readDirCache().getEntry("symlink");
@@ -305,20 +307,21 @@ public class FileTreeIteratorTest extends RepositoryTestCase {
 	@Test
 	public void testIsModifiedFileSmudged() throws Exception {
 		File f = writeTrashFile("file", "content");
-		Git git = new Git(db);
-		// The idea of this test is to check the smudged handling
-		// Hopefully fsTick will make sure our entry gets smudged
-		fsTick(f);
-		writeTrashFile("file", "content");
-		long lastModified = f.lastModified();
-		git.add().addFilepattern("file").call();
-		writeTrashFile("file", "conten2");
-		f.setLastModified(lastModified);
-		// We cannot trust this to go fast enough on
-		// a system with less than one-second lastModified
-		// resolution, so we force the index to have the
-		// same timestamp as the file we look at.
-		db.getIndexFile().setLastModified(lastModified);
+		try (Git git = new Git(db)) {
+			// The idea of this test is to check the smudged handling
+			// Hopefully fsTick will make sure our entry gets smudged
+			fsTick(f);
+			writeTrashFile("file", "content");
+			long lastModified = f.lastModified();
+			git.add().addFilepattern("file").call();
+			writeTrashFile("file", "conten2");
+			f.setLastModified(lastModified);
+			// We cannot trust this to go fast enough on
+			// a system with less than one-second lastModified
+			// resolution, so we force the index to have the
+			// same timestamp as the file we look at.
+			db.getIndexFile().setLastModified(lastModified);
+		}
 		DirCacheEntry dce = db.readDirCache().getEntry("file");
 		FileTreeIterator fti = new FileTreeIterator(trash, db.getFS(), db
 				.getConfig().get(WorkingTreeOptions.KEY));
@@ -334,198 +337,204 @@ public class FileTreeIteratorTest extends RepositoryTestCase {
 
 	@Test
 	public void submoduleHeadMatchesIndex() throws Exception {
-		Git git = new Git(db);
-		writeTrashFile("file.txt", "content");
-		git.add().addFilepattern("file.txt").call();
-		final RevCommit id = git.commit().setMessage("create file").call();
-		final String path = "sub";
-		DirCache cache = db.lockDirCache();
-		DirCacheEditor editor = cache.editor();
-		editor.add(new PathEdit(path) {
-
-			public void apply(DirCacheEntry ent) {
-				ent.setFileMode(FileMode.GITLINK);
-				ent.setObjectId(id);
-			}
-		});
-		editor.commit();
-
-		Git.cloneRepository().setURI(db.getDirectory().toURI().toString())
-				.setDirectory(new File(db.getWorkTree(), path)).call()
-				.getRepository().close();
-
-		TreeWalk walk = new TreeWalk(db);
-		DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
-		FileTreeIterator workTreeIter = new FileTreeIterator(db);
-		walk.addTree(indexIter);
-		walk.addTree(workTreeIter);
-		walk.setFilter(PathFilter.create(path));
-
-		assertTrue(walk.next());
-		assertTrue(indexIter.idEqual(workTreeIter));
+		try (Git git = new Git(db);
+				TreeWalk walk = new TreeWalk(db)) {
+			writeTrashFile("file.txt", "content");
+			git.add().addFilepattern("file.txt").call();
+			final RevCommit id = git.commit().setMessage("create file").call();
+			final String path = "sub";
+			DirCache cache = db.lockDirCache();
+			DirCacheEditor editor = cache.editor();
+			editor.add(new PathEdit(path) {
+	
+				public void apply(DirCacheEntry ent) {
+					ent.setFileMode(FileMode.GITLINK);
+					ent.setObjectId(id);
+				}
+			});
+			editor.commit();
+
+			Git.cloneRepository().setURI(db.getDirectory().toURI().toString())
+					.setDirectory(new File(db.getWorkTree(), path)).call()
+					.getRepository().close();
+
+			DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
+			FileTreeIterator workTreeIter = new FileTreeIterator(db);
+			walk.addTree(indexIter);
+			walk.addTree(workTreeIter);
+			walk.setFilter(PathFilter.create(path));
+	
+			assertTrue(walk.next());
+			assertTrue(indexIter.idEqual(workTreeIter));
+		}
 	}
 
 	@Test
 	public void submoduleWithNoGitDirectory() throws Exception {
-		Git git = new Git(db);
-		writeTrashFile("file.txt", "content");
-		git.add().addFilepattern("file.txt").call();
-		final RevCommit id = git.commit().setMessage("create file").call();
-		final String path = "sub";
-		DirCache cache = db.lockDirCache();
-		DirCacheEditor editor = cache.editor();
-		editor.add(new PathEdit(path) {
-
-			public void apply(DirCacheEntry ent) {
-				ent.setFileMode(FileMode.GITLINK);
-				ent.setObjectId(id);
-			}
-		});
-		editor.commit();
-
-		File submoduleRoot = new File(db.getWorkTree(), path);
-		assertTrue(submoduleRoot.mkdir());
-		assertTrue(new File(submoduleRoot, Constants.DOT_GIT).mkdir());
-
-		TreeWalk walk = new TreeWalk(db);
-		DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
-		FileTreeIterator workTreeIter = new FileTreeIterator(db);
-		walk.addTree(indexIter);
-		walk.addTree(workTreeIter);
-		walk.setFilter(PathFilter.create(path));
-
-		assertTrue(walk.next());
-		assertFalse(indexIter.idEqual(workTreeIter));
-		assertEquals(ObjectId.zeroId(), workTreeIter.getEntryObjectId());
+		try (Git git = new Git(db);
+				TreeWalk walk = new TreeWalk(db)) {
+			writeTrashFile("file.txt", "content");
+			git.add().addFilepattern("file.txt").call();
+			final RevCommit id = git.commit().setMessage("create file").call();
+			final String path = "sub";
+			DirCache cache = db.lockDirCache();
+			DirCacheEditor editor = cache.editor();
+			editor.add(new PathEdit(path) {
+
+				public void apply(DirCacheEntry ent) {
+					ent.setFileMode(FileMode.GITLINK);
+					ent.setObjectId(id);
+				}
+			});
+			editor.commit();
+
+			File submoduleRoot = new File(db.getWorkTree(), path);
+			assertTrue(submoduleRoot.mkdir());
+			assertTrue(new File(submoduleRoot, Constants.DOT_GIT).mkdir());
+
+			DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
+			FileTreeIterator workTreeIter = new FileTreeIterator(db);
+			walk.addTree(indexIter);
+			walk.addTree(workTreeIter);
+			walk.setFilter(PathFilter.create(path));
+
+			assertTrue(walk.next());
+			assertFalse(indexIter.idEqual(workTreeIter));
+			assertEquals(ObjectId.zeroId(), workTreeIter.getEntryObjectId());
+		}
 	}
 
 	@Test
 	public void submoduleWithNoHead() throws Exception {
-		Git git = new Git(db);
-		writeTrashFile("file.txt", "content");
-		git.add().addFilepattern("file.txt").call();
-		final RevCommit id = git.commit().setMessage("create file").call();
-		final String path = "sub";
-		DirCache cache = db.lockDirCache();
-		DirCacheEditor editor = cache.editor();
-		editor.add(new PathEdit(path) {
-
-			public void apply(DirCacheEntry ent) {
-				ent.setFileMode(FileMode.GITLINK);
-				ent.setObjectId(id);
-			}
-		});
-		editor.commit();
-
-		assertNotNull(Git.init().setDirectory(new File(db.getWorkTree(), path))
-				.call().getRepository());
-
-		TreeWalk walk = new TreeWalk(db);
-		DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
-		FileTreeIterator workTreeIter = new FileTreeIterator(db);
-		walk.addTree(indexIter);
-		walk.addTree(workTreeIter);
-		walk.setFilter(PathFilter.create(path));
-
-		assertTrue(walk.next());
-		assertFalse(indexIter.idEqual(workTreeIter));
-		assertEquals(ObjectId.zeroId(), workTreeIter.getEntryObjectId());
+		try (Git git = new Git(db);
+				TreeWalk walk = new TreeWalk(db)) {
+			writeTrashFile("file.txt", "content");
+			git.add().addFilepattern("file.txt").call();
+			final RevCommit id = git.commit().setMessage("create file").call();
+			final String path = "sub";
+			DirCache cache = db.lockDirCache();
+			DirCacheEditor editor = cache.editor();
+			editor.add(new PathEdit(path) {
+
+				public void apply(DirCacheEntry ent) {
+					ent.setFileMode(FileMode.GITLINK);
+					ent.setObjectId(id);
+				}
+			});
+			editor.commit();
+
+			assertNotNull(Git.init().setDirectory(new File(db.getWorkTree(), path))
+					.call().getRepository());
+
+			DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
+			FileTreeIterator workTreeIter = new FileTreeIterator(db);
+			walk.addTree(indexIter);
+			walk.addTree(workTreeIter);
+			walk.setFilter(PathFilter.create(path));
+
+			assertTrue(walk.next());
+			assertFalse(indexIter.idEqual(workTreeIter));
+			assertEquals(ObjectId.zeroId(), workTreeIter.getEntryObjectId());
+		}
 	}
 
 	@Test
 	public void submoduleDirectoryIterator() throws Exception {
-		Git git = new Git(db);
-		writeTrashFile("file.txt", "content");
-		git.add().addFilepattern("file.txt").call();
-		final RevCommit id = git.commit().setMessage("create file").call();
-		final String path = "sub";
-		DirCache cache = db.lockDirCache();
-		DirCacheEditor editor = cache.editor();
-		editor.add(new PathEdit(path) {
-
-			public void apply(DirCacheEntry ent) {
-				ent.setFileMode(FileMode.GITLINK);
-				ent.setObjectId(id);
-			}
-		});
-		editor.commit();
-
-		Git.cloneRepository().setURI(db.getDirectory().toURI().toString())
-				.setDirectory(new File(db.getWorkTree(), path)).call()
-				.getRepository().close();
-
-		TreeWalk walk = new TreeWalk(db);
-		DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
-		FileTreeIterator workTreeIter = new FileTreeIterator(db.getWorkTree(),
-				db.getFS(), db.getConfig().get(WorkingTreeOptions.KEY));
-		walk.addTree(indexIter);
-		walk.addTree(workTreeIter);
-		walk.setFilter(PathFilter.create(path));
-
-		assertTrue(walk.next());
-		assertTrue(indexIter.idEqual(workTreeIter));
+		try (Git git = new Git(db);
+				TreeWalk walk = new TreeWalk(db)) {
+			writeTrashFile("file.txt", "content");
+			git.add().addFilepattern("file.txt").call();
+			final RevCommit id = git.commit().setMessage("create file").call();
+			final String path = "sub";
+			DirCache cache = db.lockDirCache();
+			DirCacheEditor editor = cache.editor();
+			editor.add(new PathEdit(path) {
+
+				public void apply(DirCacheEntry ent) {
+					ent.setFileMode(FileMode.GITLINK);
+					ent.setObjectId(id);
+				}
+			});
+			editor.commit();
+
+			Git.cloneRepository().setURI(db.getDirectory().toURI().toString())
+					.setDirectory(new File(db.getWorkTree(), path)).call()
+					.getRepository().close();
+
+			DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
+			FileTreeIterator workTreeIter = new FileTreeIterator(db.getWorkTree(),
+					db.getFS(), db.getConfig().get(WorkingTreeOptions.KEY));
+			walk.addTree(indexIter);
+			walk.addTree(workTreeIter);
+			walk.setFilter(PathFilter.create(path));
+
+			assertTrue(walk.next());
+			assertTrue(indexIter.idEqual(workTreeIter));
+		}
 	}
 
 	@Test
 	public void submoduleNestedWithHeadMatchingIndex() throws Exception {
-		Git git = new Git(db);
-		writeTrashFile("file.txt", "content");
-		git.add().addFilepattern("file.txt").call();
-		final RevCommit id = git.commit().setMessage("create file").call();
-		final String path = "sub/dir1/dir2";
-		DirCache cache = db.lockDirCache();
-		DirCacheEditor editor = cache.editor();
-		editor.add(new PathEdit(path) {
-
-			public void apply(DirCacheEntry ent) {
-				ent.setFileMode(FileMode.GITLINK);
-				ent.setObjectId(id);
-			}
-		});
-		editor.commit();
-
-		Git.cloneRepository().setURI(db.getDirectory().toURI().toString())
-				.setDirectory(new File(db.getWorkTree(), path)).call()
-				.getRepository().close();
-
-		TreeWalk walk = new TreeWalk(db);
-		DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
-		FileTreeIterator workTreeIter = new FileTreeIterator(db);
-		walk.addTree(indexIter);
-		walk.addTree(workTreeIter);
-		walk.setFilter(PathFilter.create(path));
-
-		assertTrue(walk.next());
-		assertTrue(indexIter.idEqual(workTreeIter));
+		try (Git git = new Git(db);
+				TreeWalk walk = new TreeWalk(db)) {
+			writeTrashFile("file.txt", "content");
+			git.add().addFilepattern("file.txt").call();
+			final RevCommit id = git.commit().setMessage("create file").call();
+			final String path = "sub/dir1/dir2";
+			DirCache cache = db.lockDirCache();
+			DirCacheEditor editor = cache.editor();
+			editor.add(new PathEdit(path) {
+
+				public void apply(DirCacheEntry ent) {
+					ent.setFileMode(FileMode.GITLINK);
+					ent.setObjectId(id);
+				}
+			});
+			editor.commit();
+
+			Git.cloneRepository().setURI(db.getDirectory().toURI().toString())
+					.setDirectory(new File(db.getWorkTree(), path)).call()
+					.getRepository().close();
+
+			DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
+			FileTreeIterator workTreeIter = new FileTreeIterator(db);
+			walk.addTree(indexIter);
+			walk.addTree(workTreeIter);
+			walk.setFilter(PathFilter.create(path));
+
+			assertTrue(walk.next());
+			assertTrue(indexIter.idEqual(workTreeIter));
+		}
 	}
 
 	@Test
 	public void idOffset() throws Exception {
-		Git git = new Git(db);
-		writeTrashFile("fileAinfsonly", "A");
-		File fileBinindex = writeTrashFile("fileBinindex", "B");
-		fsTick(fileBinindex);
-		git.add().addFilepattern("fileBinindex").call();
-		writeTrashFile("fileCinfsonly", "C");
-		TreeWalk tw = new TreeWalk(db);
-		DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
-		FileTreeIterator workTreeIter = new FileTreeIterator(db);
-		tw.addTree(indexIter);
-		tw.addTree(workTreeIter);
-		workTreeIter.setDirCacheIterator(tw, 0);
-		assertEntry("d46c305e85b630558ee19cc47e73d2e5c8c64cdc", "a,", tw);
-		assertEntry("58ee403f98538ec02409538b3f80adf610accdec", "a,b", tw);
-		assertEntry("0000000000000000000000000000000000000000", "a", tw);
-		assertEntry("b8d30ff397626f0f1d3538d66067edf865e201d6", "a0b", tw);
-		// The reason for adding this test. Check that the id is correct for
-		// mixed
-		assertEntry("8c7e5a667f1b771847fe88c01c3de34413a1b220",
-				"fileAinfsonly", tw);
-		assertEntry("7371f47a6f8bd23a8fa1a8b2a9479cdd76380e54", "fileBinindex",
-				tw);
-		assertEntry("96d80cd6c4e7158dbebd0849f4fb7ce513e5828c",
-				"fileCinfsonly", tw);
-		assertFalse(tw.next());
+		try (Git git = new Git(db);
+				TreeWalk tw = new TreeWalk(db)) {
+			writeTrashFile("fileAinfsonly", "A");
+			File fileBinindex = writeTrashFile("fileBinindex", "B");
+			fsTick(fileBinindex);
+			git.add().addFilepattern("fileBinindex").call();
+			writeTrashFile("fileCinfsonly", "C");
+			DirCacheIterator indexIter = new DirCacheIterator(db.readDirCache());
+			FileTreeIterator workTreeIter = new FileTreeIterator(db);
+			tw.addTree(indexIter);
+			tw.addTree(workTreeIter);
+			workTreeIter.setDirCacheIterator(tw, 0);
+			assertEntry("d46c305e85b630558ee19cc47e73d2e5c8c64cdc", "a,", tw);
+			assertEntry("58ee403f98538ec02409538b3f80adf610accdec", "a,b", tw);
+			assertEntry("0000000000000000000000000000000000000000", "a", tw);
+			assertEntry("b8d30ff397626f0f1d3538d66067edf865e201d6", "a0b", tw);
+			// The reason for adding this test. Check that the id is correct for
+			// mixed
+			assertEntry("8c7e5a667f1b771847fe88c01c3de34413a1b220",
+					"fileAinfsonly", tw);
+			assertEntry("7371f47a6f8bd23a8fa1a8b2a9479cdd76380e54", "fileBinindex",
+					tw);
+			assertEntry("96d80cd6c4e7158dbebd0849f4fb7ce513e5828c",
+					"fileCinfsonly", tw);
+			assertFalse(tw.next());
+		}
 	}
 
 	private static void assertEntry(String sha1string, String path, TreeWalk tw)