Git API does not declare GitAPIException call() and related cleanups

All commands should throw a GitAPIException so new exceptions can be
added without breaking the builds of old code, i.e. anyone that calls
a Git API should catch GitAPIException and not just the currently known
exceptions.

Now the only checked exceptions on Git API calls are GitException and
subclasses of it. New checked exceptions that are subclasses of
GitException may be added without breaking the API.

Javadoc for GitAPIException is declared on GitCommand and
inherited to subclasses. JGitInternalException is not explicitly
documented anymore.

Unfortunately this change itself breaks the API. The intention is
that it shall be possible to add new checked subclasses of
GitAPIException without breaking the API.

Bug: 366914
EGit-Change-Id: I50380f13fc82c22d0036f47c7859cc3a77e767c5
Change-Id: I50380f13fc82c22d0036f47c7859cc3a77e767c5
Signed-off-by: Matthias Sohn <matthias.sohn@sap.com>

org.eclipse.jgit.ant/src/org/eclipse/jgit/ant/tasks/GitCloneTask.java

@@ -110,7 +110,7 @@ public class GitCloneTask extends Task {
 		try {
 			clone.setURI(uri).setDirectory(destination).setBranch(branch).setBare(bare);
 			clone.call();
-		} catch (RuntimeException e) {
+		} catch (Exception e) {
 			log("Could not clone repository: " + e, e, Project.MSG_ERR);
 			throw new BuildException("Could not clone repository: " + e.getMessage(), e);
 		}

org.eclipse.jgit.ant/src/org/eclipse/jgit/ant/tasks/GitInitTask.java

@@ -91,7 +91,7 @@ public class GitInitTask extends Task {
 			InitCommand init = Git.init();
 			init.setBare(bare).setDirectory(destination);
 			init.call();
-		} catch (JGitInternalException e) {
+		} catch (Exception e) {
 			throw new BuildException("Could not initialize repository", e);
 		}
 	}

org.eclipse.jgit.test/tst/org/eclipse/jgit/api/AddCommandTest.java

@@ -52,6 +52,7 @@ import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.PrintWriter;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.NoFilepatternException;
 import org.eclipse.jgit.dircache.DirCache;
 import org.eclipse.jgit.dircache.DirCacheBuilder;
@@ -72,7 +73,7 @@ import org.junit.Test;
 public class AddCommandTest extends RepositoryTestCase {
 
 	@Test
-	public void testAddNothing() {
+	public void testAddNothing() throws GitAPIException {
 		Git git = new Git(db);
 
 		try {
@@ -85,7 +86,7 @@ public class AddCommandTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testAddNonExistingSingleFile() throws NoFilepatternException {
+	public void testAddNonExistingSingleFile() throws GitAPIException {
 		Git git = new Git(db);
 
 		DirCache dc = git.add().addFilepattern("a.txt").call();
@@ -94,7 +95,7 @@ public class AddCommandTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testAddExistingSingleFile() throws IOException, NoFilepatternException {
+	public void testAddExistingSingleFile() throws IOException, GitAPIException {
 		File file = new File(db.getWorkTree(), "a.txt");
 		FileUtils.createNewFile(file);
 		PrintWriter writer = new PrintWriter(file);
@@ -112,7 +113,7 @@ public class AddCommandTest extends RepositoryTestCase {
 
 	@Test
 	public void testAddExistingSingleSmallFileWithNewLine() throws IOException,
-			NoFilepatternException {
+			GitAPIException {
 		File file = new File(db.getWorkTree(), "a.txt");
 		FileUtils.createNewFile(file);
 		PrintWriter writer = new PrintWriter(file);
@@ -136,7 +137,7 @@ public class AddCommandTest extends RepositoryTestCase {
 
 	@Test
 	public void testAddExistingSingleMediumSizeFileWithNewLine()
-			throws IOException, NoFilepatternException {
+			throws IOException, GitAPIException {
 		File file = new File(db.getWorkTree(), "a.txt");
 		FileUtils.createNewFile(file);
 		StringBuilder data = new StringBuilder();
@@ -165,7 +166,7 @@ public class AddCommandTest extends RepositoryTestCase {
 
 	@Test
 	public void testAddExistingSingleBinaryFile() throws IOException,
-			NoFilepatternException {
+			GitAPIException {
 		File file = new File(db.getWorkTree(), "a.txt");
 		FileUtils.createNewFile(file);
 		PrintWriter writer = new PrintWriter(file);
@@ -188,7 +189,8 @@ public class AddCommandTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testAddExistingSingleFileInSubDir() throws IOException, NoFilepatternException {
+	public void testAddExistingSingleFileInSubDir() throws IOException,
+			GitAPIException {
 		FileUtils.mkdir(new File(db.getWorkTree(), "sub"));
 		File file = new File(db.getWorkTree(), "sub/a.txt");
 		FileUtils.createNewFile(file);
@@ -206,7 +208,8 @@ public class AddCommandTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testAddExistingSingleFileTwice() throws IOException, NoFilepatternException {
+	public void testAddExistingSingleFileTwice() throws IOException,
+			GitAPIException {
 		File file = new File(db.getWorkTree(), "a.txt");
 		FileUtils.createNewFile(file);
 		PrintWriter writer = new PrintWriter(file);

org.eclipse.jgit.test/tst/org/eclipse/jgit/api/BranchCommandTest.java

@@ -466,9 +466,7 @@ public class BranchCommandTest extends RepositoryTestCase {
 
 	public Ref createBranch(Git actGit, String name, boolean force,
 			String startPoint, SetupUpstreamMode mode)
-			throws JGitInternalException, RefAlreadyExistsException,
+			throws JGitInternalException, GitAPIException {
-			RefNotFoundException,
-			InvalidRefNameException {
 		CreateBranchCommand cmd = actGit.branchCreate();
 		cmd.setName(name);
 		cmd.setForce(force);

org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CheckoutCommandTest.java

@@ -56,10 +56,8 @@ import java.io.FileInputStream;
 import java.io.IOException;
 
 import org.eclipse.jgit.api.CheckoutResult.Status;
-import org.eclipse.jgit.api.errors.CheckoutConflictException;
+import org.eclipse.jgit.api.errors.GitAPIException;
-import org.eclipse.jgit.api.errors.InvalidRefNameException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
-import org.eclipse.jgit.api.errors.RefAlreadyExistsException;
 import org.eclipse.jgit.api.errors.RefNotFoundException;
 import org.eclipse.jgit.dircache.DirCache;
 import org.eclipse.jgit.dircache.DirCacheEntry;
@@ -129,9 +127,7 @@ public class CheckoutCommandTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testCheckoutToNonExistingBranch() throws JGitInternalException,
+	public void testCheckoutToNonExistingBranch() throws GitAPIException {
-			RefAlreadyExistsException, InvalidRefNameException,
-			CheckoutConflictException {
 		try {
 			git.checkout().setName("badbranch").call();
 			fail("Should have failed");
@@ -225,8 +221,7 @@ public class CheckoutCommandTest extends RepositoryTestCase {
 
 	@Test
 	public void testDetachedHeadOnCheckout() throws JGitInternalException,
-			RefAlreadyExistsException, RefNotFoundException,
+			IOException, GitAPIException {
-			InvalidRefNameException, IOException, CheckoutConflictException {
 		CheckoutCommand co = git.checkout();
 		co.setName("master").call();
 

org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CleanCommandTest.java

@@ -44,10 +44,10 @@ package org.eclipse.jgit.api;
 
 import static org.junit.Assert.assertTrue;
 
-import java.io.IOException;
 import java.util.Set;
 import java.util.TreeSet;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.errors.NoWorkTreeException;
 import org.eclipse.jgit.lib.RepositoryTestCase;
 import org.junit.Before;
@@ -75,7 +75,7 @@ public class CleanCommandTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testClean() throws NoWorkTreeException, IOException {
+	public void testClean() throws NoWorkTreeException, GitAPIException {
 		// create status
 		StatusCommand command = git.status();
 		Status status = command.call();
@@ -94,7 +94,8 @@ public class CleanCommandTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testCleanWithPaths() throws NoWorkTreeException, IOException {
+	public void testCleanWithPaths() throws NoWorkTreeException,
+			GitAPIException {
 		// create status
 		StatusCommand command = git.status();
 		Status status = command.call();
@@ -114,7 +115,8 @@ public class CleanCommandTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testCleanWithDryRun() throws NoWorkTreeException, IOException {
+	public void testCleanWithDryRun() throws NoWorkTreeException,
+			GitAPIException {
 		// create status
 		StatusCommand command = git.status();
 		Status status = command.call();

org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CloneCommandTest.java

@@ -55,6 +55,7 @@ import java.util.List;
 import java.util.Map;
 
 import org.eclipse.jgit.api.ListBranchCommand.ListMode;
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.junit.TestRepository;
 import org.eclipse.jgit.lib.ConfigConstants;
@@ -103,7 +104,8 @@ public class CloneCommandTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testCloneRepository() throws IOException {
+	public void testCloneRepository() throws IOException,
+			JGitInternalException, GitAPIException {
 		File directory = createTempDirectory("testCloneRepository");
 		CloneCommand command = Git.cloneRepository();
 		command.setDirectory(directory);
@@ -131,7 +133,8 @@ public class CloneCommandTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testCloneRepositoryWithBranch() throws IOException {
+	public void testCloneRepositoryWithBranch() throws IOException,
+			JGitInternalException, GitAPIException {
 		File directory = createTempDirectory("testCloneRepositoryWithBranch");
 		CloneCommand command = Git.cloneRepository();
 		command.setBranch("refs/heads/master");
@@ -178,7 +181,8 @@ public class CloneCommandTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testCloneRepositoryOnlyOneBranch() throws IOException {
+	public void testCloneRepositoryOnlyOneBranch() throws IOException,
+			JGitInternalException, GitAPIException {
 		File directory = createTempDirectory("testCloneRepositoryWithBranch");
 		CloneCommand command = Git.cloneRepository();
 		command.setBranch("refs/heads/master");
@@ -222,7 +226,7 @@ public class CloneCommandTest extends RepositoryTestCase {
 
 	@Test
 	public void testCloneRepositoryWhenDestinationDirectoryExistsAndIsNotEmpty()
-			throws IOException {
+			throws IOException, JGitInternalException, GitAPIException {
 		String dirName = "testCloneTargetDirectoryNotEmpty";
 		File directory = createTempDirectory(dirName);
 		CloneCommand command = Git.cloneRepository();

org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CommitAndLogCommandTests.java

@@ -50,15 +50,12 @@ import static org.junit.Assert.fail;
 import java.io.File;
 import java.io.IOException;
 import java.io.PrintWriter;
-import org.eclipse.jgit.api.errors.ConcurrentRefUpdateException;
+
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
-import org.eclipse.jgit.api.errors.NoFilepatternException;
-import org.eclipse.jgit.api.errors.NoHeadException;
 import org.eclipse.jgit.api.errors.NoMessageException;
-import org.eclipse.jgit.api.errors.WrongRepositoryStateException;
 import org.eclipse.jgit.errors.IncorrectObjectTypeException;
 import org.eclipse.jgit.errors.MissingObjectException;
-import org.eclipse.jgit.errors.UnmergedPathException;
 import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.lib.PersonIdent;
@@ -77,9 +74,8 @@ import org.junit.Test;
  */
 public class CommitAndLogCommandTests extends RepositoryTestCase {
 	@Test
-	public void testSomeCommits() throws NoHeadException, NoMessageException,
+	public void testSomeCommits() throws JGitInternalException, IOException,
-			ConcurrentRefUpdateException, JGitInternalException,
+			GitAPIException {
-			WrongRepositoryStateException, IOException {
 
 		// do 4 commits
 		Git git = new Git(db);
@@ -115,9 +111,8 @@ public class CommitAndLogCommandTests extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testLogWithFilter() throws IOException, NoFilepatternException,
+	public void testLogWithFilter() throws IOException, JGitInternalException,
-			NoHeadException, NoMessageException, ConcurrentRefUpdateException,
+			GitAPIException {
-			JGitInternalException, WrongRepositoryStateException {
 
 		Git git = new Git(db);
 
@@ -170,9 +165,7 @@ public class CommitAndLogCommandTests extends RepositoryTestCase {
 
 	// try to do a commit without specifying a message. Should fail!
 	@Test
-	public void testWrongParams() throws UnmergedPathException,
+	public void testWrongParams() throws GitAPIException {
-			NoHeadException, ConcurrentRefUpdateException,
-			JGitInternalException, WrongRepositoryStateException {
 		Git git = new Git(db);
 		try {
 			git.commit().setAuthor(author).call();
@@ -185,10 +178,7 @@ public class CommitAndLogCommandTests extends RepositoryTestCase {
 	// try to work with Commands after command has been invoked. Should throw
 	// exceptions
 	@Test
-	public void testMultipleInvocations() throws NoHeadException,
+	public void testMultipleInvocations() throws GitAPIException {
-			ConcurrentRefUpdateException, NoMessageException,
-			UnmergedPathException, JGitInternalException,
-			WrongRepositoryStateException {
 		Git git = new Git(db);
 		CommitCommand commitCmd = git.commit();
 		commitCmd.setMessage("initial commit").call();
@@ -211,9 +201,8 @@ public class CommitAndLogCommandTests extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testMergeEmptyBranches() throws IOException, NoHeadException,
+	public void testMergeEmptyBranches() throws IOException,
-			NoMessageException, ConcurrentRefUpdateException,
+			JGitInternalException, GitAPIException {
-			JGitInternalException, WrongRepositoryStateException {
 		Git git = new Git(db);
 		git.commit().setMessage("initial commit").call();
 		RefUpdate r = db.updateRef("refs/heads/side");
@@ -235,10 +224,8 @@ public class CommitAndLogCommandTests extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testAddUnstagedChanges() throws IOException, NoHeadException,
+	public void testAddUnstagedChanges() throws IOException,
-			NoMessageException, ConcurrentRefUpdateException,
+			JGitInternalException, GitAPIException {
-			JGitInternalException, WrongRepositoryStateException,
-			NoFilepatternException {
 		File file = new File(db.getWorkTree(), "a.txt");
 		FileUtils.createNewFile(file);
 		PrintWriter writer = new PrintWriter(file);
@@ -268,9 +255,7 @@ public class CommitAndLogCommandTests extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testModeChange() throws IOException, NoFilepatternException,
+	public void testModeChange() throws IOException, GitAPIException {
-			NoHeadException, NoMessageException, ConcurrentRefUpdateException,
-			JGitInternalException, WrongRepositoryStateException {
 		Git git = new Git(db);
 
 		// create file
@@ -298,10 +283,9 @@ public class CommitAndLogCommandTests extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testCommitRange() throws NoHeadException, NoMessageException,
+	public void testCommitRange() throws GitAPIException,
-			UnmergedPathException, ConcurrentRefUpdateException,
+			JGitInternalException, MissingObjectException,
-			JGitInternalException, WrongRepositoryStateException,
+			IncorrectObjectTypeException {
-			IncorrectObjectTypeException, MissingObjectException {
 		// do 4 commits and set the range to the second and fourth one
 		Git git = new Git(db);
 		git.commit().setMessage("first commit").call();
@@ -334,9 +318,8 @@ public class CommitAndLogCommandTests extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testCommitAmend() throws NoHeadException, NoMessageException,
+	public void testCommitAmend() throws JGitInternalException, IOException,
-			ConcurrentRefUpdateException, JGitInternalException,
+			GitAPIException {
-			WrongRepositoryStateException, IOException {
 		Git git = new Git(db);
 		git.commit().setMessage("first comit").call(); // typo
 		git.commit().setAmend(true).setMessage("first commit").call();
@@ -357,10 +340,8 @@ public class CommitAndLogCommandTests extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testInsertChangeId() throws NoHeadException,
+	public void testInsertChangeId() throws JGitInternalException,
-			NoMessageException,
+			GitAPIException {
-			UnmergedPathException, ConcurrentRefUpdateException,
-			JGitInternalException, WrongRepositoryStateException {
 		Git git = new Git(db);
 		String messageHeader = "Some header line\n\nSome detail explanation\n";
 		String changeIdTemplate = "\nChange-Id: I"

org.eclipse.jgit.test/tst/org/eclipse/jgit/api/GitConstructionTest.java

@@ -48,6 +48,8 @@ import static org.junit.Assert.fail;
 import java.io.IOException;
 
 import org.eclipse.jgit.api.ListBranchCommand.ListMode;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.errors.RepositoryNotFoundException;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.lib.RepositoryTestCase;
@@ -84,7 +86,7 @@ public class GitConstructionTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testWrap() {
+	public void testWrap() throws JGitInternalException, GitAPIException {
 		Git git = Git.wrap(db);
 		assertEquals(1, git.branchList().call().size());
 
@@ -101,7 +103,8 @@ public class GitConstructionTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testOpen() throws IOException {
+	public void testOpen() throws IOException, JGitInternalException,
+			GitAPIException {
 		Git git = Git.open(db.getDirectory());
 		assertEquals(1, git.branchList().call().size());
 

org.eclipse.jgit.test/tst/org/eclipse/jgit/api/InitCommandTest.java

@@ -48,6 +48,8 @@ import static org.junit.Assert.assertTrue;
 import java.io.File;
 import java.io.IOException;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.lib.RepositoryTestCase;
 import org.junit.Before;
@@ -62,7 +64,8 @@ public class InitCommandTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testInitRepository() throws IOException {
+	public void testInitRepository() throws IOException, JGitInternalException,
+			GitAPIException {
 		File directory = createTempDirectory("testInitRepository");
 		InitCommand command = new InitCommand();
 		command.setDirectory(directory);
@@ -72,7 +75,8 @@ public class InitCommandTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testInitNonEmptyRepository() throws IOException {
+	public void testInitNonEmptyRepository() throws IOException,
+			JGitInternalException, GitAPIException {
 		File directory = createTempDirectory("testInitRepository2");
 		File someFile = new File(directory, "someFile");
 		someFile.createNewFile();
@@ -86,7 +90,8 @@ public class InitCommandTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testInitBareRepository() throws IOException {
+	public void testInitBareRepository() throws IOException,
+			JGitInternalException, GitAPIException {
 		File directory = createTempDirectory("testInitBareRepository");
 		InitCommand command = new InitCommand();
 		command.setDirectory(directory);

org.eclipse.jgit.test/tst/org/eclipse/jgit/api/ResetCommandTest.java

@@ -54,12 +54,8 @@ import java.io.IOException;
 import java.io.PrintWriter;
 
 import org.eclipse.jgit.api.ResetCommand.ResetType;
-import org.eclipse.jgit.api.errors.ConcurrentRefUpdateException;
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
-import org.eclipse.jgit.api.errors.NoFilepatternException;
-import org.eclipse.jgit.api.errors.NoHeadException;
-import org.eclipse.jgit.api.errors.NoMessageException;
-import org.eclipse.jgit.api.errors.WrongRepositoryStateException;
 import org.eclipse.jgit.dircache.DirCache;
 import org.eclipse.jgit.dircache.DirCacheEntry;
 import org.eclipse.jgit.errors.AmbiguousObjectException;
@@ -87,9 +83,8 @@ public class ResetCommandTest extends RepositoryTestCase {
 
 	private DirCacheEntry prestage;
 
-	public void setupRepository() throws IOException, NoFilepatternException,
+	public void setupRepository() throws IOException, JGitInternalException,
-			NoHeadException, NoMessageException, ConcurrentRefUpdateException,
+			GitAPIException {
-			JGitInternalException, WrongRepositoryStateException {
 
 		// create initial commit
 		git = new Git(db);
@@ -138,9 +133,7 @@ public class ResetCommandTest extends RepositoryTestCase {
 
 	@Test
 	public void testHardReset() throws JGitInternalException,
-			AmbiguousObjectException, IOException, NoFilepatternException,
+			AmbiguousObjectException, IOException, GitAPIException {
-			NoHeadException, NoMessageException, ConcurrentRefUpdateException,
-			WrongRepositoryStateException {
 		setupRepository();
 		ObjectId prevHead = db.resolve(Constants.HEAD);
 		git.reset().setMode(ResetType.HARD).setRef(initialCommit.getName())
@@ -160,7 +153,7 @@ public class ResetCommandTest extends RepositoryTestCase {
 
 	@Test
 	public void testResetToNonexistingHEAD() throws JGitInternalException,
-			AmbiguousObjectException, IOException {
+			AmbiguousObjectException, IOException, GitAPIException {
 
 		// create a file in the working tree of a fresh repo
 		git = new Git(db);
@@ -176,9 +169,7 @@ public class ResetCommandTest extends RepositoryTestCase {
 
 	@Test
 	public void testSoftReset() throws JGitInternalException,
-			AmbiguousObjectException, IOException, NoFilepatternException,
+			AmbiguousObjectException, IOException, GitAPIException {
-			NoHeadException, NoMessageException, ConcurrentRefUpdateException,
-			WrongRepositoryStateException {
 		setupRepository();
 		ObjectId prevHead = db.resolve(Constants.HEAD);
 		git.reset().setMode(ResetType.SOFT).setRef(initialCommit.getName())
@@ -198,9 +189,7 @@ public class ResetCommandTest extends RepositoryTestCase {
 
 	@Test
 	public void testMixedReset() throws JGitInternalException,
-			AmbiguousObjectException, IOException, NoFilepatternException,
+			AmbiguousObjectException, IOException, GitAPIException {
-			NoHeadException, NoMessageException, ConcurrentRefUpdateException,
-			WrongRepositoryStateException {
 		setupRepository();
 		ObjectId prevHead = db.resolve(Constants.HEAD);
 		git.reset().setMode(ResetType.MIXED).setRef(initialCommit.getName())

org.eclipse.jgit.test/tst/org/eclipse/jgit/api/RmCommandTest.java

@@ -46,8 +46,8 @@ import static org.junit.Assert.assertEquals;
 
 import java.io.IOException;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
-import org.eclipse.jgit.api.errors.NoFilepatternException;
 import org.eclipse.jgit.lib.RepositoryTestCase;
 import org.junit.Before;
 import org.junit.Test;
@@ -71,7 +71,7 @@ public class RmCommandTest extends RepositoryTestCase {
 
 	@Test
 	public void testRemove() throws JGitInternalException,
-			NoFilepatternException, IllegalStateException, IOException {
+			IllegalStateException, IOException, GitAPIException {
 		assertEquals("[test.txt, mode:100644, content:Hello world]",
 				indexState(CONTENT));
 		RmCommand command = git.rm();

org.eclipse.jgit.test/tst/org/eclipse/jgit/api/StatusCommandTest.java

@@ -52,13 +52,15 @@ import java.util.Set;
 
 import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.NoFilepatternException;
+import org.eclipse.jgit.errors.NoWorkTreeException;
 import org.eclipse.jgit.lib.RepositoryTestCase;
 import org.junit.Test;
 
 public class StatusCommandTest extends RepositoryTestCase {
 
 	@Test
-	public void testEmptyStatus() throws IOException {
+	public void testEmptyStatus() throws NoWorkTreeException,
+			GitAPIException {
 		Git git = new Git(db);
 
 		Status stat = git.status().call();

org.eclipse.jgit.test/tst/org/eclipse/jgit/api/TagCommandTest.java

@@ -48,15 +48,9 @@ import static org.junit.Assert.fail;
 import java.io.IOException;
 import java.util.List;
 
-import org.eclipse.jgit.api.errors.ConcurrentRefUpdateException;
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.InvalidTagNameException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
-import org.eclipse.jgit.api.errors.NoHeadException;
-import org.eclipse.jgit.api.errors.NoMessageException;
-import org.eclipse.jgit.api.errors.WrongRepositoryStateException;
-import org.eclipse.jgit.errors.IncorrectObjectTypeException;
-import org.eclipse.jgit.errors.MissingObjectException;
-import org.eclipse.jgit.errors.UnmergedPathException;
 import org.eclipse.jgit.lib.Ref;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.lib.RepositoryTestCase;
@@ -67,10 +61,7 @@ import org.junit.Test;
 public class TagCommandTest extends RepositoryTestCase {
 
 	@Test
-	public void testTaggingOnHead() throws NoHeadException, NoMessageException,
+	public void testTaggingOnHead() throws GitAPIException, IOException {
-			ConcurrentRefUpdateException, JGitInternalException,
-			WrongRepositoryStateException, InvalidTagNameException,
-			MissingObjectException, IncorrectObjectTypeException, IOException {
 		Git git = new Git(db);
 		RevCommit commit = git.commit().setMessage("initial commit").call();
 		Ref tagRef = git.tag().setName("tag").call();
@@ -80,10 +71,7 @@ public class TagCommandTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testTagging() throws NoHeadException, NoMessageException,
+	public void testTagging() throws GitAPIException, JGitInternalException {
-			UnmergedPathException, ConcurrentRefUpdateException,
-			JGitInternalException, WrongRepositoryStateException,
-			InvalidTagNameException {
 		Git git = new Git(db);
 		git.commit().setMessage("initial commit").call();
 		RevCommit commit = git.commit().setMessage("second commit").call();
@@ -93,9 +81,7 @@ public class TagCommandTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testEmptyTagName() throws NoHeadException, NoMessageException,
+	public void testEmptyTagName() throws GitAPIException {
-			UnmergedPathException, ConcurrentRefUpdateException,
-			JGitInternalException, WrongRepositoryStateException {
 		Git git = new Git(db);
 		git.commit().setMessage("initial commit").call();
 		try {
@@ -108,10 +94,7 @@ public class TagCommandTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testInvalidTagName() throws NoHeadException,
+	public void testInvalidTagName() throws GitAPIException {
-			NoMessageException, UnmergedPathException,
-			ConcurrentRefUpdateException, JGitInternalException,
-			WrongRepositoryStateException {
 		Git git = new Git(db);
 		git.commit().setMessage("initial commit").call();
 		try {
@@ -123,10 +106,7 @@ public class TagCommandTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testFailureOnSignedTags() throws NoHeadException,
+	public void testFailureOnSignedTags() throws GitAPIException {
-			NoMessageException, UnmergedPathException,
-			ConcurrentRefUpdateException, JGitInternalException,
-			WrongRepositoryStateException, InvalidTagNameException {
 		Git git = new Git(db);
 		git.commit().setMessage("initial commit").call();
 		try {

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

@@ -46,14 +46,8 @@ import java.io.IOException;
 import java.util.Arrays;
 
 import org.eclipse.jgit.api.Git;
-import org.eclipse.jgit.api.errors.CheckoutConflictException;
+import org.eclipse.jgit.api.errors.GitAPIException;
-import org.eclipse.jgit.api.errors.InvalidRefNameException;
-import org.eclipse.jgit.api.errors.JGitInternalException;
-import org.eclipse.jgit.api.errors.RefAlreadyExistsException;
-import org.eclipse.jgit.api.errors.RefNotFoundException;
 import org.eclipse.jgit.dircache.InvalidPathException;
-import org.eclipse.jgit.errors.IncorrectObjectTypeException;
-import org.eclipse.jgit.errors.MissingObjectException;
 import org.eclipse.jgit.junit.MockSystemReader;
 import org.eclipse.jgit.revwalk.RevWalk;
 import org.eclipse.jgit.util.SystemReader;
@@ -338,20 +332,11 @@ public class DirCacheCheckoutMaliciousPathTest extends RepositoryTestCase {
 	 *            perform the actual test on the second checkout
 	 * @param path
 	 *            to the blob, one or more levels
+	 * @throws GitAPIException
 	 * @throws IOException
-	 * @throws RefAlreadyExistsException
-	 * @throws RefNotFoundException
-	 * @throws InvalidRefNameException
-	 * @throws MissingObjectException
-	 * @throws IncorrectObjectTypeException
-	 * @throws CheckoutConflictException
-	 * @throws JGitInternalException
 	 */
-	private void testMaliciousPath(boolean good, boolean secondCheckout, String... path)
+	private void testMaliciousPath(boolean good, boolean secondCheckout,
-			throws IOException, RefAlreadyExistsException,
+			String... path) throws GitAPIException, IOException {
-			RefNotFoundException, InvalidRefNameException,
-			MissingObjectException, IncorrectObjectTypeException,
-			JGitInternalException, CheckoutConflictException {
 		Git git = new Git(db);
 		ObjectInserter newObjectInserter;
 		newObjectInserter = git.getRepository().newObjectInserter();

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

@@ -59,7 +59,7 @@ import java.util.TreeSet;
 import org.eclipse.jgit.api.Git;
 import org.eclipse.jgit.api.MergeResult;
 import org.eclipse.jgit.api.MergeResult.MergeStatus;
-import org.eclipse.jgit.api.errors.NoFilepatternException;
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.dircache.DirCache;
 import org.eclipse.jgit.dircache.DirCacheEditor;
 import org.eclipse.jgit.dircache.DirCacheEditor.PathEdit;
@@ -139,7 +139,7 @@ public class IndexDiffTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testModified() throws IOException, NoFilepatternException {
+	public void testModified() throws IOException, GitAPIException {
 
 		writeTrashFile("file2", "file2");
 		writeTrashFile("dir/file3", "dir/file3");
@@ -291,8 +291,7 @@ public class IndexDiffTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void testUnchangedSimple() throws IOException,
+	public void testUnchangedSimple() throws IOException, GitAPIException {
-			NoFilepatternException {
 		writeTrashFile("a.b", "a.b");
 		writeTrashFile("a.c", "a.c");
 		writeTrashFile("a=c", "a=c");
@@ -328,11 +327,10 @@ public class IndexDiffTest extends RepositoryTestCase {
 	 * used by Git.
 	 *
 	 * @throws IOException
-	 * @throws NoFilepatternException
+	 * @throws GitAPIException
 	 */
 	@Test
-	public void testUnchangedComplex() throws IOException,
+	public void testUnchangedComplex() throws IOException, GitAPIException {
-			NoFilepatternException {
 		Git git = new Git(db);
 		writeTrashFile("a.b", "a.b");
 		writeTrashFile("a.c", "a.c");

org.eclipse.jgit.test/tst/org/eclipse/jgit/submodule/SubmoduleAddTest.java

@@ -53,6 +53,7 @@ import java.text.MessageFormat;
 import org.eclipse.jgit.api.Git;
 import org.eclipse.jgit.api.Status;
 import org.eclipse.jgit.api.SubmoduleAddCommand;
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.dircache.DirCache;
 import org.eclipse.jgit.dircache.DirCacheEditor;
@@ -75,7 +76,7 @@ import org.junit.Test;
 public class SubmoduleAddTest extends RepositoryTestCase {
 
 	@Test
-	public void commandWithNullPath() {
+	public void commandWithNullPath() throws GitAPIException {
 		try {
 			new SubmoduleAddCommand(db).setURI("uri").call();
 			fail("Exception not thrown");
@@ -85,7 +86,7 @@ public class SubmoduleAddTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void commandWithEmptyPath() {
+	public void commandWithEmptyPath() throws GitAPIException {
 		try {
 			new SubmoduleAddCommand(db).setPath("").setURI("uri").call();
 			fail("Exception not thrown");
@@ -95,7 +96,7 @@ public class SubmoduleAddTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void commandWithNullUri() {
+	public void commandWithNullUri() throws GitAPIException {
 		try {
 			new SubmoduleAddCommand(db).setPath("sub").call();
 			fail("Exception not thrown");
@@ -105,7 +106,7 @@ public class SubmoduleAddTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void commandWithEmptyUri() {
+	public void commandWithEmptyUri() throws GitAPIException {
 		try {
 			new SubmoduleAddCommand(db).setPath("sub").setURI("").call();
 			fail("Exception not thrown");

org.eclipse.jgit.test/tst/org/eclipse/jgit/submodule/SubmoduleInitTest.java

@@ -53,6 +53,7 @@ import java.io.IOException;
 import java.util.Collection;
 
 import org.eclipse.jgit.api.SubmoduleInitCommand;
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.dircache.DirCache;
 import org.eclipse.jgit.dircache.DirCacheEditor;
@@ -73,7 +74,7 @@ import org.junit.Test;
 public class SubmoduleInitTest extends RepositoryTestCase {
 
 	@Test
-	public void repositoryWithNoSubmodules() {
+	public void repositoryWithNoSubmodules() throws GitAPIException {
 		SubmoduleInitCommand command = new SubmoduleInitCommand(db);
 		Collection<String> modules = command.call();
 		assertNotNull(modules);
@@ -82,7 +83,7 @@ public class SubmoduleInitTest extends RepositoryTestCase {
 
 	@Test
 	public void repositoryWithUninitializedModule() throws IOException,
-			ConfigInvalidException {
+			ConfigInvalidException, GitAPIException {
 		final String path = addSubmoduleToIndex();
 
 		SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
@@ -156,7 +157,7 @@ public class SubmoduleInitTest extends RepositoryTestCase {
 
 	@Test
 	public void resolveOneLevelHigherRelativeUrl() throws IOException,
-			ConfigInvalidException {
+			ConfigInvalidException, GitAPIException {
 		final String path = addSubmoduleToIndex();
 
 		String base = "git://server/repo.git";
@@ -197,7 +198,7 @@ public class SubmoduleInitTest extends RepositoryTestCase {
 
 	@Test
 	public void resolveTwoLevelHigherRelativeUrl() throws IOException,
-			ConfigInvalidException {
+			ConfigInvalidException, GitAPIException {
 		final String path = addSubmoduleToIndex();
 
 		String base = "git://server/repo.git";
@@ -238,7 +239,7 @@ public class SubmoduleInitTest extends RepositoryTestCase {
 
 	@Test
 	public void resolveWorkingDirectoryRelativeUrl() throws IOException,
-			ConfigInvalidException {
+			GitAPIException, ConfigInvalidException {
 		final String path = addSubmoduleToIndex();
 
 		String base = db.getWorkTree().getAbsolutePath();
@@ -281,7 +282,7 @@ public class SubmoduleInitTest extends RepositoryTestCase {
 
 	@Test
 	public void resolveInvalidParentUrl() throws IOException,
-			ConfigInvalidException {
+			ConfigInvalidException, GitAPIException {
 		final String path = addSubmoduleToIndex();
 
 		String base = "no_slash";

org.eclipse.jgit.test/tst/org/eclipse/jgit/submodule/SubmoduleStatusTest.java

@@ -53,6 +53,7 @@ import java.util.Map.Entry;
 
 import org.eclipse.jgit.api.Git;
 import org.eclipse.jgit.api.SubmoduleStatusCommand;
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.dircache.DirCache;
 import org.eclipse.jgit.dircache.DirCacheEditor;
 import org.eclipse.jgit.dircache.DirCacheEditor.PathEdit;
@@ -74,7 +75,7 @@ import org.junit.Test;
 public class SubmoduleStatusTest extends RepositoryTestCase {
 
 	@Test
-	public void repositoryWithNoSubmodules() {
+	public void repositoryWithNoSubmodules() throws GitAPIException {
 		SubmoduleStatusCommand command = new SubmoduleStatusCommand(db);
 		Map<String, SubmoduleStatus> statuses = command.call();
 		assertNotNull(statuses);
@@ -82,7 +83,8 @@ public class SubmoduleStatusTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void repositoryWithMissingSubmodule() throws IOException {
+	public void repositoryWithMissingSubmodule() throws IOException,
+			GitAPIException {
 		final ObjectId id = ObjectId
 				.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
 		final String path = "sub";
@@ -113,7 +115,8 @@ public class SubmoduleStatusTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void repositoryWithUninitializedSubmodule() throws IOException {
+	public void repositoryWithUninitializedSubmodule() throws IOException,
+			GitAPIException {
 		final ObjectId id = ObjectId
 				.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
 		final String path = "sub";
@@ -152,7 +155,8 @@ public class SubmoduleStatusTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void repositoryWithNoHeadInSubmodule() throws IOException {
+	public void repositoryWithNoHeadInSubmodule() throws IOException,
+			GitAPIException {
 		final ObjectId id = ObjectId
 				.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
 		final String path = "sub";
@@ -202,7 +206,8 @@ public class SubmoduleStatusTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void repositoryWithNoSubmoduleRepository() throws IOException {
+	public void repositoryWithNoSubmoduleRepository() throws IOException,
+			GitAPIException {
 		final ObjectId id = ObjectId
 				.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
 		final String path = "sub";
@@ -247,7 +252,8 @@ public class SubmoduleStatusTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void repositoryWithInitializedSubmodule() throws IOException {
+	public void repositoryWithInitializedSubmodule() throws IOException,
+			GitAPIException {
 		final ObjectId id = ObjectId
 				.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
 		final String path = "sub";
@@ -302,7 +308,7 @@ public class SubmoduleStatusTest extends RepositoryTestCase {
 
 	@Test
 	public void repositoryWithDifferentRevCheckedOutSubmodule()
-			throws IOException {
+			throws IOException, GitAPIException {
 		final ObjectId id = ObjectId
 				.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
 		final String path = "sub";

org.eclipse.jgit.test/tst/org/eclipse/jgit/submodule/SubmoduleSyncTest.java

@@ -53,6 +53,7 @@ import java.util.Map.Entry;
 
 import org.eclipse.jgit.api.Git;
 import org.eclipse.jgit.api.SubmoduleSyncCommand;
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.dircache.DirCache;
 import org.eclipse.jgit.dircache.DirCacheEditor;
 import org.eclipse.jgit.dircache.DirCacheEditor.PathEdit;
@@ -73,7 +74,7 @@ import org.junit.Test;
 public class SubmoduleSyncTest extends RepositoryTestCase {
 
 	@Test
-	public void repositoryWithNoSubmodules() {
+	public void repositoryWithNoSubmodules() throws GitAPIException {
 		SubmoduleSyncCommand command = new SubmoduleSyncCommand(db);
 		Map<String, String> modules = command.call();
 		assertNotNull(modules);

org.eclipse.jgit.test/tst/org/eclipse/jgit/submodule/SubmoduleUpdateTest.java

@@ -52,6 +52,7 @@ import java.util.Collection;
 
 import org.eclipse.jgit.api.Git;
 import org.eclipse.jgit.api.SubmoduleUpdateCommand;
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.dircache.DirCache;
 import org.eclipse.jgit.dircache.DirCacheEditor;
 import org.eclipse.jgit.dircache.DirCacheEditor.PathEdit;
@@ -73,7 +74,7 @@ import org.junit.Test;
 public class SubmoduleUpdateTest extends RepositoryTestCase {
 
 	@Test
-	public void repositoryWithNoSubmodules() {
+	public void repositoryWithNoSubmodules() throws GitAPIException {
 		SubmoduleUpdateCommand command = new SubmoduleUpdateCommand(db);
 		Collection<String> modules = command.call();
 		assertNotNull(modules);
@@ -125,7 +126,8 @@ public class SubmoduleUpdateTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void repositoryWithUnconfiguredSubmodule() throws IOException {
+	public void repositoryWithUnconfiguredSubmodule() throws IOException,
+			GitAPIException {
 		final ObjectId id = ObjectId
 				.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
 		final String path = "sub";
@@ -159,7 +161,8 @@ public class SubmoduleUpdateTest extends RepositoryTestCase {
 	}
 
 	@Test
-	public void repositoryWithInitializedSubmodule() throws IOException {
+	public void repositoryWithInitializedSubmodule() throws IOException,
+			GitAPIException {
 		final ObjectId id = ObjectId
 				.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
 		final String path = "sub";

org.eclipse.jgit/src/org/eclipse/jgit/api/AddCommand.java

@@ -48,6 +48,7 @@ import java.io.InputStream;
 import java.util.Collection;
 import java.util.LinkedList;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.api.errors.NoFilepatternException;
 import org.eclipse.jgit.dircache.DirCache;
@@ -122,7 +123,7 @@ public class AddCommand extends GitCommand<DirCache> {
 	 *
 	 * @return the DirCache after Add
 	 */
-	public DirCache call() throws NoFilepatternException {
+	public DirCache call() throws GitAPIException, NoFilepatternException {
 
 		if (filepatterns.isEmpty())
 			throw new NoFilepatternException(JGitText.get().atLeastOnePatternIsRequired);

org.eclipse.jgit/src/org/eclipse/jgit/api/AddNoteCommand.java

@@ -44,6 +44,7 @@ package org.eclipse.jgit.api;
 
 import java.io.IOException;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.lib.CommitBuilder;
 import org.eclipse.jgit.lib.Constants;
@@ -80,11 +81,7 @@ public class AddNoteCommand extends GitCommand<Note> {
 		super(repo);
 	}
 
-	/**
+	public Note call() throws GitAPIException {
-	 * @throws JGitInternalException
-	 *             upon internal failure
-	 */
-	public Note call() throws JGitInternalException {
 		checkCallable();
 		RevWalk walk = new RevWalk(repo);
 		ObjectInserter inserter = repo.newObjectInserter();

org.eclipse.jgit/src/org/eclipse/jgit/api/BlameCommand.java

@@ -48,6 +48,7 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.blame.BlameGenerator;
 import org.eclipse.jgit.blame.BlameResult;
@@ -189,7 +190,7 @@ public class BlameCommand extends GitCommand<BlameResult> {
 	 *
 	 * @return list of lines
 	 */
-	public BlameResult call() throws JGitInternalException {
+	public BlameResult call() throws GitAPIException {
 		checkCallable();
 		BlameGenerator gen = new BlameGenerator(repo, path);
 		try {

org.eclipse.jgit/src/org/eclipse/jgit/api/CheckoutCommand.java

@@ -51,6 +51,7 @@ import java.util.List;
 
 import org.eclipse.jgit.api.CheckoutResult.Status;
 import org.eclipse.jgit.api.errors.CheckoutConflictException;
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.InvalidRefNameException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.api.errors.RefAlreadyExistsException;
@@ -121,9 +122,11 @@ public class CheckoutCommand extends GitCommand<Ref> {
 	 * @throws InvalidRefNameException
 	 *             if the provided name is <code>null</code> or otherwise
 	 *             invalid
+	 * @throws CheckoutConflictException
+	 *             if the checkout results in a conflict
 	 * @return the newly created branch
 	 */
-	public Ref call() throws JGitInternalException, RefAlreadyExistsException,
+	public Ref call() throws GitAPIException, RefAlreadyExistsException,
 			RefNotFoundException, InvalidRefNameException,
 			CheckoutConflictException {
 		checkCallable();

org.eclipse.jgit/src/org/eclipse/jgit/api/CleanCommand.java

@@ -49,6 +49,7 @@ import java.util.Collections;
 import java.util.Set;
 import java.util.TreeSet;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.util.FileUtils;
@@ -81,7 +82,7 @@ public class CleanCommand extends GitCommand<Set<String>> {
 	 *
 	 * @return a set of strings representing each file cleaned.
 	 */
-	public Set<String> call() {
+	public Set<String> call() throws GitAPIException {
 		Set<String> files = new TreeSet<String>();
 		try {
 			StatusCommand command = new StatusCommand(repo);

org.eclipse.jgit/src/org/eclipse/jgit/api/CloneCommand.java

@@ -50,6 +50,7 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.InvalidRemoteException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.dircache.DirCache;
@@ -111,11 +112,9 @@ public class CloneCommand extends TransportCommand<CloneCommand, Git> {
 	/**
 	 * Executes the {@code Clone} command.
 	 *
-	 * @throws JGitInternalException
-	 *             if the repository can't be created
 	 * @return the newly created {@code Git} object with associated repository
 	 */
-	public Git call() throws JGitInternalException {
+	public Git call() throws GitAPIException {
 		try {
 			URIish u = new URIish(uri);
 			Repository repository = init(u);
@@ -132,7 +131,7 @@ public class CloneCommand extends TransportCommand<CloneCommand, Git> {
 		}
 	}
 
-	private Repository init(URIish u) {
+	private Repository init(URIish u) throws GitAPIException {
 		InitCommand command = Git.init();
 		command.setBare(bare);
 		if (directory == null)
@@ -145,9 +144,7 @@ public class CloneCommand extends TransportCommand<CloneCommand, Git> {
 	}
 
 	private FetchResult fetch(Repository clonedRepo, URIish u)
-			throws URISyntaxException,
+			throws URISyntaxException, IOException, GitAPIException {
-			JGitInternalException,
-			InvalidRemoteException, IOException {
 		// create the remote config and save it
 		RemoteConfig config = new RemoteConfig(clonedRepo.getConfig(), remote);
 		config.addURI(u);
@@ -193,8 +190,8 @@ public class CloneCommand extends TransportCommand<CloneCommand, Git> {
 	}
 
 	private void checkout(Repository clonedRepo, FetchResult result)
-			throws JGitInternalException,
+			throws MissingObjectException, IncorrectObjectTypeException,
-			MissingObjectException, IncorrectObjectTypeException, IOException {
+			IOException, GitAPIException {
 
 		Ref head = result.getAdvertisedRef(branch);
 		if (branch.equals(Constants.HEAD)) {
@@ -230,7 +227,8 @@ public class CloneCommand extends TransportCommand<CloneCommand, Git> {
 		}
 	}
 
-	private void cloneSubmodules(Repository clonedRepo) throws IOException {
+	private void cloneSubmodules(Repository clonedRepo) throws IOException,
+			GitAPIException {
 		SubmoduleInitCommand init = new SubmoduleInitCommand(clonedRepo);
 		if (init.call().isEmpty())
 			return;

org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java

@@ -50,10 +50,12 @@ import java.util.LinkedList;
 import java.util.List;
 
 import org.eclipse.jgit.api.errors.ConcurrentRefUpdateException;
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.api.errors.NoFilepatternException;
 import org.eclipse.jgit.api.errors.NoHeadException;
 import org.eclipse.jgit.api.errors.NoMessageException;
+import org.eclipse.jgit.api.errors.UnmergedPathsException;
 import org.eclipse.jgit.api.errors.WrongRepositoryStateException;
 import org.eclipse.jgit.dircache.DirCache;
 import org.eclipse.jgit.dircache.DirCacheBuilder;
@@ -134,21 +136,18 @@ public class CommitCommand extends GitCommand<RevCommit> {
 	 *             when called on a git repo without a HEAD reference
 	 * @throws NoMessageException
 	 *             when called without specifying a commit message
-	 * @throws UnmergedPathException
+	 * @throws UnmergedPathsException
 	 *             when the current index contained unmerged paths (conflicts)
+	 * @throws ConcurrentRefUpdateException
+	 *             when HEAD or branch ref is updated concurrently by someone
+	 *             else
 	 * @throws WrongRepositoryStateException
 	 *             when repository is not in the right state for committing
-	 * @throws JGitInternalException
-	 *             a low-level exception of JGit has occurred. The original
-	 *             exception can be retrieved by calling
-	 *             {@link Exception#getCause()}. Expect only
-	 *             {@code IOException's} to be wrapped. Subclasses of
-	 *             {@link IOException} (e.g. {@link UnmergedPathException}) are
-	 *             typically not wrapped here but thrown as original exception
 	 */
-	public RevCommit call() throws NoHeadException, NoMessageException,
+	public RevCommit call() throws GitAPIException, NoHeadException,
-			UnmergedPathException, ConcurrentRefUpdateException,
+			NoMessageException, UnmergedPathsException,
-			JGitInternalException, WrongRepositoryStateException {
+			ConcurrentRefUpdateException,
+			WrongRepositoryStateException {
 		checkCallable();
 
 		RepositoryState state = repo.getRepositoryState();
@@ -269,10 +268,7 @@ public class CommitCommand extends GitCommand<RevCommit> {
 				index.unlock();
 			}
 		} catch (UnmergedPathException e) {
-			// since UnmergedPathException is a subclass of IOException
+			throw new UnmergedPathsException(e);
-			// which should not be wrapped by a JGitInternalException we
-			// have to catch and re-throw it here
-			throw e;
 		} catch (IOException e) {
 			throw new JGitInternalException(
 					JGitText.get().exceptionCaughtDuringExecutionOfCommitCommand, e);

org.eclipse.jgit/src/org/eclipse/jgit/api/CreateBranchCommand.java

@@ -46,6 +46,7 @@ package org.eclipse.jgit.api;
 import java.io.IOException;
 import java.text.MessageFormat;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.InvalidRefNameException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.api.errors.RefAlreadyExistsException;
@@ -57,9 +58,9 @@ import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.lib.Ref;
 import org.eclipse.jgit.lib.RefUpdate;
+import org.eclipse.jgit.lib.RefUpdate.Result;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.lib.StoredConfig;
-import org.eclipse.jgit.lib.RefUpdate.Result;
 import org.eclipse.jgit.revwalk.RevCommit;
 import org.eclipse.jgit.revwalk.RevWalk;
 
@@ -119,7 +120,7 @@ public class CreateBranchCommand extends GitCommand<Ref> {
 	 *             invalid
 	 * @return the newly created branch
 	 */
-	public Ref call() throws JGitInternalException, RefAlreadyExistsException,
+	public Ref call() throws GitAPIException, RefAlreadyExistsException,
 			RefNotFoundException, InvalidRefNameException {
 		checkCallable();
 		processOptions();

org.eclipse.jgit/src/org/eclipse/jgit/api/DeleteBranchCommand.java

@@ -51,6 +51,7 @@ import java.util.List;
 import java.util.Set;
 
 import org.eclipse.jgit.api.errors.CannotDeleteCurrentBranchException;
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.api.errors.NotMergedException;
 import org.eclipse.jgit.internal.JGitText;
@@ -58,9 +59,9 @@ import org.eclipse.jgit.lib.ConfigConstants;
 import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.Ref;
 import org.eclipse.jgit.lib.RefUpdate;
+import org.eclipse.jgit.lib.RefUpdate.Result;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.lib.StoredConfig;
-import org.eclipse.jgit.lib.RefUpdate.Result;
 import org.eclipse.jgit.revwalk.RevCommit;
 import org.eclipse.jgit.revwalk.RevWalk;
 
@@ -93,9 +94,10 @@ public class DeleteBranchCommand extends GitCommand<List<String>> {
 	 * @throws NotMergedException
 	 *             when trying to delete a branch which has not been merged into
 	 *             the currently checked out branch without force
+	 * @throws CannotDeleteCurrentBranchException
 	 * @return the list with the (full) names of the deleted branches
 	 */
-	public List<String> call() throws JGitInternalException,
+	public List<String> call() throws GitAPIException,
 			NotMergedException, CannotDeleteCurrentBranchException {
 		checkCallable();
 		List<String> result = new ArrayList<String>();

org.eclipse.jgit/src/org/eclipse/jgit/api/DeleteTagCommand.java

@@ -49,6 +49,7 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.internal.JGitText;
 import org.eclipse.jgit.lib.Ref;
@@ -77,12 +78,9 @@ public class DeleteTagCommand extends GitCommand<List<String>> {
 	}
 
 	/**
-	 * @throws JGitInternalException
-	 *             when trying to delete a tag that doesn't exist
-	 *
 	 * @return the list with the full names of the deleted tags
 	 */
-	public List<String> call() throws JGitInternalException {
+	public List<String> call() throws GitAPIException {
 		checkCallable();
 		List<String> result = new ArrayList<String>();
 		if (tags.isEmpty())

org.eclipse.jgit/src/org/eclipse/jgit/api/DiffCommand.java

@@ -50,6 +50,7 @@ import java.io.OutputStream;
 import java.util.List;
 
 import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.api.errors.NoHeadException;
 import org.eclipse.jgit.diff.DiffEntry;
 import org.eclipse.jgit.diff.DiffFormatter;
@@ -108,7 +109,7 @@ public class DiffCommand extends GitCommand<List<DiffEntry>> {
 	 *
 	 * @return a DiffEntry for each path which is different
 	 */
-	public List<DiffEntry> call() throws GitAPIException, IOException {
+	public List<DiffEntry> call() throws GitAPIException {
 		final DiffFormatter diffFmt;
 		if (out != null && !showNameAndStatusOnly)
 			diffFmt = new DiffFormatter(new BufferedOutputStream(out));
@@ -155,6 +156,8 @@ public class DiffCommand extends GitCommand<List<DiffEntry>> {
 				diffFmt.flush();
 				return result;
 			}
+		} catch (IOException e) {
+			throw new JGitInternalException(e.getMessage(), e);
 		} finally {
 			diffFmt.release();
 		}

org.eclipse.jgit/src/org/eclipse/jgit/api/FetchCommand.java

@@ -47,6 +47,7 @@ import java.text.MessageFormat;
 import java.util.ArrayList;
 import java.util.List;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.InvalidRemoteException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.errors.NoRemoteRepositoryException;
@@ -106,13 +107,11 @@ public class FetchCommand extends TransportCommand<FetchCommand, FetchResult> {
 	 *         result
 	 * @throws InvalidRemoteException
 	 *             when called with an invalid remote uri
-	 * @throws JGitInternalException
+	 * @throws org.eclipse.jgit.api.errors.TransportException
-	 *             a low-level exception of JGit has occurred. The original
+	 *             when an error occurs during transport
-	 *             exception can be retrieved by calling
-	 *             {@link Exception#getCause()}.
 	 */
-	public FetchResult call() throws JGitInternalException,
+	public FetchResult call() throws GitAPIException, InvalidRemoteException,
-			InvalidRemoteException {
+			org.eclipse.jgit.api.errors.TransportException {
 		checkCallable();
 
 		try {
@@ -135,7 +134,7 @@ public class FetchCommand extends TransportCommand<FetchCommand, FetchResult> {
 			throw new InvalidRemoteException(MessageFormat.format(
 					JGitText.get().invalidRemote, remote), e);
 		} catch (TransportException e) {
-			throw new JGitInternalException(
+			throw new org.eclipse.jgit.api.errors.TransportException(
 					JGitText.get().exceptionCaughtDuringExecutionOfFetchCommand,
 					e);
 		} catch (URISyntaxException e) {

org.eclipse.jgit/src/org/eclipse/jgit/api/GitCommand.java

@@ -40,6 +40,7 @@ package org.eclipse.jgit.api;
 import java.text.MessageFormat;
 import java.util.concurrent.Callable;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.internal.JGitText;
 import org.eclipse.jgit.lib.Repository;
 
@@ -116,4 +117,13 @@ public abstract class GitCommand<T> implements Callable<T> {
 					JGitText.get().commandWasCalledInTheWrongState
 					, this.getClass().getName()));
 	}
+
+	/**
+	 * Executes the command
+	 *
+	 * @return T a result. Each command has its own return type
+	 * @throws GitAPIException
+	 *             or subclass thereof when an error occurs
+	 */
+	public abstract T call() throws GitAPIException;
 }

org.eclipse.jgit/src/org/eclipse/jgit/api/InitCommand.java

@@ -46,6 +46,7 @@ import java.io.File;
 import java.io.IOException;
 import java.util.concurrent.Callable;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.Repository;
@@ -65,11 +66,9 @@ public class InitCommand implements Callable<Git> {
 	/**
 	 * Executes the {@code Init} command.
 	 *
-	 * @throws JGitInternalException
-	 *             if the repository can't be created
 	 * @return the newly created {@code Git} object with associated repository
 	 */
-	public Git call() throws JGitInternalException {
+	public Git call() throws GitAPIException {
 		try {
 			RepositoryBuilder builder = new RepositoryBuilder();
 			if (bare)

org.eclipse.jgit/src/org/eclipse/jgit/api/ListBranchCommand.java

@@ -47,10 +47,11 @@ import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.HashMap;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.Ref;
@@ -88,11 +89,7 @@ public class ListBranchCommand extends GitCommand<List<Ref>> {
 		super(repo);
 	}
 
-	/**
+	public List<Ref> call() throws GitAPIException {
-	 * @throws JGitInternalException
-	 *             upon internal failure
-	 */
-	public List<Ref> call() throws JGitInternalException {
 		checkCallable();
 		Map<String, Ref> refList;
 		try {

org.eclipse.jgit/src/org/eclipse/jgit/api/ListNotesCommand.java

@@ -47,6 +47,7 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.Ref;
@@ -74,10 +75,9 @@ public class ListNotesCommand extends GitCommand<List<Note>> {
 	}
 
 	/**
-	 * @throws JGitInternalException
+	 * @return the requested notes
-	 *             upon internal failure
 	 */
-	public List<Note> call() throws JGitInternalException {
+	public List<Note> call() throws GitAPIException {
 		checkCallable();
 		List<Note> notes = new ArrayList<Note>();
 		RevWalk walk = new RevWalk(repo);

org.eclipse.jgit/src/org/eclipse/jgit/api/ListTagCommand.java

@@ -49,6 +49,7 @@ import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.Ref;
@@ -71,11 +72,9 @@ public class ListTagCommand extends GitCommand<List<Ref>> {
 	}
 
 	/**
-	 * @throws JGitInternalException
-	 *             upon internal failure
 	 * @return the tags available
 	 */
-	public List<Ref> call() throws JGitInternalException {
+	public List<Ref> call() throws GitAPIException {
 		checkCallable();
 		Map<String, Ref> refList;
 		List<Ref> tags = new ArrayList<Ref>();

org.eclipse.jgit/src/org/eclipse/jgit/api/LogCommand.java

@@ -47,6 +47,7 @@ import java.text.MessageFormat;
 import java.util.ArrayList;
 import java.util.List;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.api.errors.NoHeadException;
 import org.eclipse.jgit.errors.IncorrectObjectTypeException;
@@ -108,9 +109,10 @@ public class LogCommand extends GitCommand<Iterable<RevCommit>> {
 	 * method twice on an instance.
 	 *
 	 * @return an iteration over RevCommits
+	 * @throws NoHeadException
+	 *             of the references ref cannot be resolved
 	 */
-	public Iterable<RevCommit> call() throws NoHeadException,
+	public Iterable<RevCommit> call() throws GitAPIException, NoHeadException {
-			JGitInternalException {
 		checkCallable();
 		if (pathFilters.size() > 0)
 			walk.setTreeFilter(AndTreeFilter.create(
@@ -166,7 +168,7 @@ public class LogCommand extends GitCommand<Iterable<RevCommit>> {
 	 *             typically not wrapped here but thrown as original exception
 	 */
 	public LogCommand add(AnyObjectId start) throws MissingObjectException,
-			IncorrectObjectTypeException, JGitInternalException {
+			IncorrectObjectTypeException {
 		return add(true, start);
 	}
 
@@ -194,7 +196,7 @@ public class LogCommand extends GitCommand<Iterable<RevCommit>> {
 	 *             typically not wrapped here but thrown as original exception
 	 */
 	public LogCommand not(AnyObjectId start) throws MissingObjectException,
-			IncorrectObjectTypeException, JGitInternalException {
+			IncorrectObjectTypeException {
 		return add(false, start);
 	}
 
@@ -223,8 +225,7 @@ public class LogCommand extends GitCommand<Iterable<RevCommit>> {
 	 *             typically not wrapped here but thrown as original exception
 	 */
 	public LogCommand addRange(AnyObjectId since, AnyObjectId until)
-			throws MissingObjectException, IncorrectObjectTypeException,
+			throws MissingObjectException, IncorrectObjectTypeException {
-			JGitInternalException {
 		return not(since).add(until);
 	}
 

org.eclipse.jgit/src/org/eclipse/jgit/api/LsRemoteCommand.java

@@ -144,13 +144,11 @@ public class LsRemoteCommand extends
 	 * @return a collection of references in the remote repository
 	 * @throws InvalidRemoteException
 	 *             when called with an invalid remote uri
-	 * @throws JGitInternalException
+	 * @throws org.eclipse.jgit.api.errors.TransportException
-	 *             a low-level exception of JGit has occurred. The original
+	 *             for errors that occurs during transport
-	 *             exception can be retrieved by calling
-	 *             {@link Exception#getCause()}.
 	 */
 	public Collection<Ref> call() throws GitAPIException,
-			JGitInternalException {
+			org.eclipse.jgit.api.errors.TransportException {
 		checkCallable();
 
 		Transport transport = null;

org.eclipse.jgit/src/org/eclipse/jgit/api/MergeCommand.java

@@ -54,6 +54,7 @@ import java.util.Map;
 import org.eclipse.jgit.api.MergeResult.MergeStatus;
 import org.eclipse.jgit.api.errors.CheckoutConflictException;
 import org.eclipse.jgit.api.errors.ConcurrentRefUpdateException;
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.InvalidMergeHeadsException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.api.errors.NoHeadException;
@@ -109,7 +110,7 @@ public class MergeCommand extends GitCommand<MergeResult> {
 	 *
 	 * @return the result of the merge
 	 */
-	public MergeResult call() throws NoHeadException,
+	public MergeResult call() throws GitAPIException, NoHeadException,
 			ConcurrentRefUpdateException, CheckoutConflictException,
 			InvalidMergeHeadsException, WrongRepositoryStateException, NoMessageException {
 		checkCallable();

org.eclipse.jgit/src/org/eclipse/jgit/api/PullCommand.java

@@ -110,7 +110,7 @@ public class PullCommand extends TransportCommand<PullCommand, PullResult> {
 	 *
 	 * @return the result of the pull
 	 */
-	public PullResult call() throws WrongRepositoryStateException,
+	public PullResult call() throws GitAPIException, WrongRepositoryStateException,
 			InvalidConfigurationException, DetachedHeadException,
 			InvalidRemoteException, CanceledException, RefNotFoundException,
 			NoHeadException {

org.eclipse.jgit/src/org/eclipse/jgit/api/PushCommand.java

@@ -50,6 +50,7 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.InvalidRemoteException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.errors.NotSupportedException;
@@ -108,12 +109,8 @@ public class PushCommand extends
 	 * @return an iteration over {@link PushResult} objects
 	 * @throws InvalidRemoteException
 	 *             when called with an invalid remote uri
-	 * @throws JGitInternalException
-	 *             a low-level exception of JGit has occurred. The original
-	 *             exception can be retrieved by calling
-	 *             {@link Exception#getCause()}.
 	 */
-	public Iterable<PushResult> call() throws JGitInternalException,
+	public Iterable<PushResult> call() throws GitAPIException,
 			InvalidRemoteException {
 		checkCallable();
 
@@ -325,7 +322,7 @@ public class PushCommand extends
 	 * @throws JGitInternalException
 	 *             the reference name cannot be resolved.
 	 */
-	public PushCommand add(String nameOrSpec) throws JGitInternalException {
+	public PushCommand add(String nameOrSpec) {
 		if (0 <= nameOrSpec.indexOf(':')) {
 			refSpecs.add(new RefSpec(nameOrSpec));
 		} else {

org.eclipse.jgit/src/org/eclipse/jgit/api/RebaseCommand.java

@@ -190,8 +190,8 @@ public class RebaseCommand extends GitCommand<RebaseResult> {
 	 *
 	 * @return an object describing the result of this command
 	 */
-	public RebaseResult call() throws NoHeadException, RefNotFoundException,
+	public RebaseResult call() throws GitAPIException, NoHeadException,
-			JGitInternalException, GitAPIException {
+			RefNotFoundException {
 		RevCommit newHead = null;
 		boolean lastStepWasForward = false;
 		checkCallable();
@@ -325,8 +325,7 @@ public class RebaseCommand extends GitCommand<RebaseResult> {
 		}
 	}
 
-	private RevCommit checkoutCurrentHead() throws IOException,
+	private RevCommit checkoutCurrentHead() throws IOException, NoHeadException {
-			NoHeadException, JGitInternalException {
 		ObjectId headTree = repo.resolve(Constants.HEAD + "^{tree}");
 		if (headTree == null)
 			throw new NoHeadException(
@@ -517,8 +516,8 @@ public class RebaseCommand extends GitCommand<RebaseResult> {
 		}
 	}
 
-	private RebaseResult initFilesAndRewind() throws RefNotFoundException,
+	private RebaseResult initFilesAndRewind() throws IOException,
-			IOException, NoHeadException, JGitInternalException {
+			GitAPIException {
 		// we need to store everything into files so that we can implement
 		// --skip, --continue, and --abort
 
@@ -626,11 +625,11 @@ public class RebaseCommand extends GitCommand<RebaseResult> {
 	 *
 	 * @param newCommit
 	 * @return the new head, or null
-	 * @throws RefNotFoundException
 	 * @throws IOException
+	 * @throws GitAPIException
 	 */
-	public RevCommit tryFastForward(RevCommit newCommit)
+	public RevCommit tryFastForward(RevCommit newCommit) throws IOException,
-			throws RefNotFoundException, IOException {
+			GitAPIException {
 		Ref head = repo.getRef(Constants.HEAD);
 		if (head == null || head.getObjectId() == null)
 			throw new RefNotFoundException(MessageFormat.format(
@@ -653,7 +652,7 @@ public class RebaseCommand extends GitCommand<RebaseResult> {
 	}
 
 	private RevCommit tryFastForward(String headName, RevCommit oldCommit,
-			RevCommit newCommit) throws IOException, JGitInternalException {
+			RevCommit newCommit) throws IOException, GitAPIException {
 		boolean tryRebase = false;
 		for (RevCommit parentCommit : newCommit.getParents())
 			if (parentCommit.equals(oldCommit))

org.eclipse.jgit/src/org/eclipse/jgit/api/ReflogCommand.java

@@ -46,6 +46,7 @@ import java.io.IOException;
 import java.text.MessageFormat;
 import java.util.Collection;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.InvalidRefNameException;
 import org.eclipse.jgit.internal.JGitText;
 import org.eclipse.jgit.lib.Constants;
@@ -84,7 +85,7 @@ public class ReflogCommand extends GitCommand<Collection<ReflogEntry>> {
 		return this;
 	}
 
-	public Collection<ReflogEntry> call() throws Exception {
+	public Collection<ReflogEntry> call() throws GitAPIException {
 		checkCallable();
 
 		try {

org.eclipse.jgit/src/org/eclipse/jgit/api/RemoveNoteCommand.java

@@ -44,6 +44,7 @@ package org.eclipse.jgit.api;
 
 import java.io.IOException;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.lib.CommitBuilder;
 import org.eclipse.jgit.lib.Constants;
@@ -78,11 +79,7 @@ public class RemoveNoteCommand extends GitCommand<Note> {
 		super(repo);
 	}
 
-	/**
+	public Note call() throws GitAPIException {
-	 * @throws JGitInternalException
-	 *             upon internal failure
-	 */
-	public Note call() throws JGitInternalException {
 		checkCallable();
 		RevWalk walk = new RevWalk(repo);
 		ObjectInserter inserter = repo.newObjectInserter();

org.eclipse.jgit/src/org/eclipse/jgit/api/RenameBranchCommand.java

@@ -48,6 +48,7 @@ import java.text.MessageFormat;
 import java.util.Arrays;
 
 import org.eclipse.jgit.api.errors.DetachedHeadException;
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.InvalidRefNameException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.api.errors.RefAlreadyExistsException;
@@ -58,9 +59,9 @@ import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.lib.Ref;
 import org.eclipse.jgit.lib.RefRename;
+import org.eclipse.jgit.lib.RefUpdate.Result;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.lib.StoredConfig;
-import org.eclipse.jgit.lib.RefUpdate.Result;
 
 /**
  * Used to rename branches.
@@ -94,7 +95,7 @@ public class RenameBranchCommand extends GitCommand<Ref> {
 	 *             if rename is tried without specifying the old name and HEAD
 	 *             is detached
 	 */
-	public Ref call() throws RefNotFoundException, InvalidRefNameException,
+	public Ref call() throws GitAPIException, RefNotFoundException, InvalidRefNameException,
 			RefAlreadyExistsException, DetachedHeadException {
 		checkCallable();
 

org.eclipse.jgit/src/org/eclipse/jgit/api/ResetCommand.java

@@ -47,6 +47,7 @@ import java.text.MessageFormat;
 import java.util.Collection;
 import java.util.LinkedList;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.dircache.DirCache;
 import org.eclipse.jgit.dircache.DirCacheCheckout;
@@ -135,7 +136,7 @@ public class ResetCommand extends GitCommand<Ref> {
 	 *
 	 * @return the Ref after reset
 	 */
-	public Ref call() throws IOException {
+	public Ref call() throws GitAPIException {
 		checkCallable();
 
 		Ref r;

org.eclipse.jgit/src/org/eclipse/jgit/api/RevertCommand.java

@@ -50,8 +50,8 @@ import java.util.Map;
 
 import org.eclipse.jgit.api.MergeResult.MergeStatus;
 import org.eclipse.jgit.api.errors.GitAPIException;
-import org.eclipse.jgit.api.errors.MultipleParentsNotAllowedException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
+import org.eclipse.jgit.api.errors.MultipleParentsNotAllowedException;
 import org.eclipse.jgit.api.errors.NoHeadException;
 import org.eclipse.jgit.dircache.DirCacheCheckout;
 import org.eclipse.jgit.internal.JGitText;

org.eclipse.jgit/src/org/eclipse/jgit/api/RmCommand.java

@@ -47,6 +47,7 @@ import java.io.IOException;
 import java.util.Collection;
 import java.util.LinkedList;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.api.errors.NoFilepatternException;
 import org.eclipse.jgit.dircache.DirCache;
@@ -99,7 +100,8 @@ public class RmCommand extends GitCommand<DirCache> {
 	 *
 	 * @return the DirCache after Rm
 	 */
-	public DirCache call() throws NoFilepatternException {
+	public DirCache call() throws GitAPIException,
+			NoFilepatternException {
 
 		if (filepatterns.isEmpty())
 			throw new NoFilepatternException(JGitText.get().atLeastOnePatternIsRequired);

org.eclipse.jgit/src/org/eclipse/jgit/api/ShowNoteCommand.java

@@ -44,6 +44,7 @@ package org.eclipse.jgit.api;
 
 import java.io.IOException;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.Ref;
@@ -73,11 +74,7 @@ public class ShowNoteCommand extends GitCommand<Note> {
 		super(repo);
 	}
 
-	/**
+	public Note call() throws GitAPIException {
-	 * @throws JGitInternalException
-	 *             upon internal failure
-	 */
-	public Note call() throws JGitInternalException {
 		checkCallable();
 		RevWalk walk = new RevWalk(repo);
 		NoteMap map = NoteMap.newEmptyMap();

org.eclipse.jgit/src/org/eclipse/jgit/api/StashApplyCommand.java

@@ -189,8 +189,7 @@ public class StashApplyCommand extends GitCommand<ObjectId> {
 		return false;
 	}
 
-	private ObjectId getHeadTree() throws JGitInternalException,
+	private ObjectId getHeadTree() throws GitAPIException {
-			GitAPIException {
 		final ObjectId headTree;
 		try {
 			headTree = repo.resolve(Constants.HEAD + "^{tree}");
@@ -202,7 +201,7 @@ public class StashApplyCommand extends GitCommand<ObjectId> {
 		return headTree;
 	}
 
-	private ObjectId getStashId() throws JGitInternalException, GitAPIException {
+	private ObjectId getStashId() throws GitAPIException {
 		final String revision = stashRef != null ? stashRef : DEFAULT_REF;
 		final ObjectId stashId;
 		try {
@@ -298,7 +297,7 @@ public class StashApplyCommand extends GitCommand<ObjectId> {
 	 *
 	 * @return id of stashed commit that was applied
 	 */
-	public ObjectId call() throws GitAPIException, JGitInternalException {
+	public ObjectId call() throws GitAPIException {
 		checkCallable();
 
 		if (repo.getRepositoryState() != RepositoryState.SAFE)

org.eclipse.jgit/src/org/eclipse/jgit/api/StashCreateCommand.java

@@ -212,7 +212,7 @@ public class StashCreateCommand extends GitCommand<RevCommit> {
 	 *
 	 * @return stashed commit or null if no changes to stash
 	 */
-	public RevCommit call() throws GitAPIException, JGitInternalException {
+	public RevCommit call() throws GitAPIException {
 		checkCallable();
 
 		Ref head = getHead();

org.eclipse.jgit/src/org/eclipse/jgit/api/StashDropCommand.java

@@ -168,7 +168,7 @@ public class StashDropCommand extends GitCommand<ObjectId> {
 	 *
 	 * @return commit id of stash reference or null if no more stashed changes
 	 */
-	public ObjectId call() throws GitAPIException, JGitInternalException {
+	public ObjectId call() throws GitAPIException {
 		checkCallable();
 
 		Ref stashRef = getRef();

org.eclipse.jgit/src/org/eclipse/jgit/api/StashListCommand.java

@@ -49,6 +49,7 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.InvalidRefNameException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.internal.JGitText;
@@ -75,7 +76,7 @@ public class StashListCommand extends GitCommand<Collection<RevCommit>> {
 		super(repo);
 	}
 
-	public Collection<RevCommit> call() throws Exception {
+	public Collection<RevCommit> call() throws GitAPIException {
 		checkCallable();
 
 		try {

org.eclipse.jgit/src/org/eclipse/jgit/api/StatusCommand.java

@@ -44,6 +44,8 @@ package org.eclipse.jgit.api;
 
 import java.io.IOException;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.errors.NoWorkTreeException;
 import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.IndexDiff;
@@ -80,14 +82,17 @@ public class StatusCommand extends GitCommand<Status> {
 	 * @return a {@link Status} object telling about each path where working
 	 *         tree, index or HEAD differ from each other.
 	 */
-	public Status call() throws IOException, NoWorkTreeException {
+	public Status call() throws GitAPIException, NoWorkTreeException {
 		if (workingTreeIt == null)
 			workingTreeIt = new FileTreeIterator(repo);
 
+		try {
 			IndexDiff diff = new IndexDiff(repo, Constants.HEAD, workingTreeIt);
 			diff.diff();
-
 			return new Status(diff);
+		} catch (IOException e) {
+			throw new JGitInternalException(e.getMessage(), e);
+		}
 	}
 
 	/**

org.eclipse.jgit/src/org/eclipse/jgit/api/SubmoduleAddCommand.java

@@ -46,6 +46,7 @@ import java.io.File;
 import java.io.IOException;
 import java.text.MessageFormat;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.api.errors.NoFilepatternException;
 import org.eclipse.jgit.errors.ConfigInvalidException;
@@ -134,7 +135,7 @@ public class SubmoduleAddCommand extends
 		return SubmoduleWalk.forIndex(repo).setFilter(filter).next();
 	}
 
-	public Repository call() throws JGitInternalException {
+	public Repository call() throws GitAPIException {
 		checkCallable();
 		if (path == null || path.length() == 0)
 			throw new IllegalArgumentException(JGitText.get().pathNotConfigured);

org.eclipse.jgit/src/org/eclipse/jgit/api/SubmoduleInitCommand.java

@@ -47,6 +47,7 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.errors.ConfigInvalidException;
 import org.eclipse.jgit.lib.ConfigConstants;
@@ -89,7 +90,7 @@ public class SubmoduleInitCommand extends GitCommand<Collection<String>> {
 		return this;
 	}
 
-	public Collection<String> call() throws JGitInternalException {
+	public Collection<String> call() throws GitAPIException {
 		checkCallable();
 
 		try {

org.eclipse.jgit/src/org/eclipse/jgit/api/SubmoduleStatusCommand.java

@@ -48,6 +48,7 @@ import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.errors.ConfigInvalidException;
 import org.eclipse.jgit.lib.Constants;
@@ -89,7 +90,7 @@ public class SubmoduleStatusCommand extends
 		return this;
 	}
 
-	public Map<String, SubmoduleStatus> call() throws JGitInternalException {
+	public Map<String, SubmoduleStatus> call() throws GitAPIException {
 		checkCallable();
 
 		try {

org.eclipse.jgit/src/org/eclipse/jgit/api/SubmoduleSyncCommand.java

@@ -48,6 +48,7 @@ import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
 
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.errors.ConfigInvalidException;
 import org.eclipse.jgit.lib.ConfigConstants;
@@ -106,7 +107,7 @@ public class SubmoduleSyncCommand extends GitCommand<Map<String, String>> {
 			return null;
 	}
 
-	public Map<String, String> call() throws JGitInternalException {
+	public Map<String, String> call() throws GitAPIException {
 		checkCallable();
 
 		try {

org.eclipse.jgit/src/org/eclipse/jgit/api/SubmoduleUpdateCommand.java

@@ -109,7 +109,7 @@ public class SubmoduleUpdateCommand extends
 		return this;
 	}
 
-	public Collection<String> call() throws JGitInternalException {
+	public Collection<String> call() throws GitAPIException {
 		checkCallable();
 
 		try {

org.eclipse.jgit/src/org/eclipse/jgit/api/TagCommand.java

@@ -46,6 +46,7 @@ import java.io.IOException;
 import java.text.MessageFormat;
 
 import org.eclipse.jgit.api.errors.ConcurrentRefUpdateException;
+import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.InvalidTagNameException;
 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.api.errors.NoHeadException;
@@ -100,15 +101,10 @@ public class TagCommand extends GitCommand<Ref> {
 	 * @return a {@link Ref} a ref pointing to a tag
 	 * @throws NoHeadException
 	 *             when called on a git repo without a HEAD reference
-	 * @throws JGitInternalException
-	 *             a low-level exception of JGit has occurred. The original
-	 *             exception can be retrieved by calling
-	 *             {@link Exception#getCause()}. Expect only
-	 *             {@code IOException's} to be wrapped.
 	 * @since 2.0
 	 */
-	public Ref call() throws JGitInternalException,
+	public Ref call() throws GitAPIException, ConcurrentRefUpdateException,
-			ConcurrentRefUpdateException, InvalidTagNameException, NoHeadException {
+			InvalidTagNameException, NoHeadException {
 		checkCallable();
 
 		RepositoryState state = repo.getRepositoryState();

org.eclipse.jgit/src/org/eclipse/jgit/api/errors/UnmergedPathsException.java

@@ -49,6 +49,16 @@ public class UnmergedPathsException extends GitAPIException {
 	 * The default constructor with a default message
 	 */
 	public UnmergedPathsException() {
-		super(JGitText.get().unmergedPaths);
+		this(null);
+	}
+
+	/**
+	 * The default constructor with a default message
+	 *
+	 * @param cause
+	 *            original exception
+	 */
+	public UnmergedPathsException(Throwable cause) {
+		super(JGitText.get().unmergedPaths, cause);
 	}
 }