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

 		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

 			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

 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;
 public class AddCommandTest extends RepositoryTestCase {
 
 	@Test
-	public void testAddNothing() {
+	public void testAddNothing() throws GitAPIException {
 		Git git = new Git(db);
 
 		try {
 	}
 
 	@Test
-	public void testAddNonExistingSingleFile() throws NoFilepatternException {
+	public void testAddNonExistingSingleFile() throws GitAPIException {
 		Git git = new Git(db);
 
 		DirCache dc = git.add().addFilepattern("a.txt").call();
 	}
 
 	@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);
 
 	@Test
 	public void testAddExistingSingleSmallFileWithNewLine() throws IOException,
-			NoFilepatternException {
+			GitAPIException {
 		File file = new File(db.getWorkTree(), "a.txt");
 		FileUtils.createNewFile(file);
 		PrintWriter writer = new PrintWriter(file);
 
 	@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();
 
 	@Test
 	public void testAddExistingSingleBinaryFile() throws IOException,
-			NoFilepatternException {
+			GitAPIException {
 		File file = new File(db.getWorkTree(), "a.txt");
 		FileUtils.createNewFile(file);
 		PrintWriter writer = new PrintWriter(file);
 	}
 
 	@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);
 	}
 
 	@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

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

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

 import java.io.IOException;
 
 import org.eclipse.jgit.api.CheckoutResult.Status;
-import org.eclipse.jgit.api.errors.CheckoutConflictException;
-import org.eclipse.jgit.api.errors.InvalidRefNameException;
+import org.eclipse.jgit.api.errors.GitAPIException;
 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;
 	}
 
 	@Test
-	public void testCheckoutToNonExistingBranch() throws JGitInternalException,
-			RefAlreadyExistsException, InvalidRefNameException,
-			CheckoutConflictException {
+	public void testCheckoutToNonExistingBranch() throws GitAPIException {
 		try {
 			git.checkout().setName("badbranch").call();
 			fail("Should have failed");
 
 	@Test
 	public void testDetachedHeadOnCheckout() throws JGitInternalException,
-			RefAlreadyExistsException, RefNotFoundException,
-			InvalidRefNameException, IOException, CheckoutConflictException {
+			IOException, GitAPIException {
 		CheckoutCommand co = git.checkout();
 		co.setName("master").call();
 

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

 
 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;
 	}
 
 	@Test
-	public void testClean() throws NoWorkTreeException, IOException {
+	public void testClean() throws NoWorkTreeException, GitAPIException {
 		// create status
 		StatusCommand command = git.status();
 		Status status = command.call();
 	}
 
 	@Test
-	public void testCleanWithPaths() throws NoWorkTreeException, IOException {
+	public void testCleanWithPaths() throws NoWorkTreeException,
+			GitAPIException {
 		// create status
 		StatusCommand command = git.status();
 		Status status = command.call();
 	}
 
 	@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

 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;
 	}
 
 	@Test
-	public void testCloneRepository() throws IOException {
+	public void testCloneRepository() throws IOException,
+			JGitInternalException, GitAPIException {
 		File directory = createTempDirectory("testCloneRepository");
 		CloneCommand command = Git.cloneRepository();
 		command.setDirectory(directory);
 	}
 
 	@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");
 	}
 
 	@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");
 
 	@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

 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;
  */
 public class CommitAndLogCommandTests extends RepositoryTestCase {
 	@Test
-	public void testSomeCommits() throws NoHeadException, NoMessageException,
-			ConcurrentRefUpdateException, JGitInternalException,
-			WrongRepositoryStateException, IOException {
+	public void testSomeCommits() throws JGitInternalException, IOException,
+			GitAPIException {
 
 		// do 4 commits
 		Git git = new Git(db);
 	}
 
 	@Test
-	public void testLogWithFilter() throws IOException, NoFilepatternException,
-			NoHeadException, NoMessageException, ConcurrentRefUpdateException,
-			JGitInternalException, WrongRepositoryStateException {
+	public void testLogWithFilter() throws IOException, JGitInternalException,
+			GitAPIException {
 
 		Git git = new Git(db);
 
 
 	// try to do a commit without specifying a message. Should fail!
 	@Test
-	public void testWrongParams() throws UnmergedPathException,
-			NoHeadException, ConcurrentRefUpdateException,
-			JGitInternalException, WrongRepositoryStateException {
+	public void testWrongParams() throws GitAPIException {
 		Git git = new Git(db);
 		try {
 			git.commit().setAuthor(author).call();
 	// try to work with Commands after command has been invoked. Should throw
 	// exceptions
 	@Test
-	public void testMultipleInvocations() throws NoHeadException,
-			ConcurrentRefUpdateException, NoMessageException,
-			UnmergedPathException, JGitInternalException,
-			WrongRepositoryStateException {
+	public void testMultipleInvocations() throws GitAPIException {
 		Git git = new Git(db);
 		CommitCommand commitCmd = git.commit();
 		commitCmd.setMessage("initial commit").call();
 	}
 
 	@Test
-	public void testMergeEmptyBranches() throws IOException, NoHeadException,
-			NoMessageException, ConcurrentRefUpdateException,
-			JGitInternalException, WrongRepositoryStateException {
+	public void testMergeEmptyBranches() throws IOException,
+			JGitInternalException, GitAPIException {
 		Git git = new Git(db);
 		git.commit().setMessage("initial commit").call();
 		RefUpdate r = db.updateRef("refs/heads/side");
 	}
 
 	@Test
-	public void testAddUnstagedChanges() throws IOException, NoHeadException,
-			NoMessageException, ConcurrentRefUpdateException,
-			JGitInternalException, WrongRepositoryStateException,
-			NoFilepatternException {
+	public void testAddUnstagedChanges() throws IOException,
+			JGitInternalException, GitAPIException {
 		File file = new File(db.getWorkTree(), "a.txt");
 		FileUtils.createNewFile(file);
 		PrintWriter writer = new PrintWriter(file);
 	}
 
 	@Test
-	public void testModeChange() throws IOException, NoFilepatternException,
-			NoHeadException, NoMessageException, ConcurrentRefUpdateException,
-			JGitInternalException, WrongRepositoryStateException {
+	public void testModeChange() throws IOException, GitAPIException {
 		Git git = new Git(db);
 
 		// create file
 	}
 
 	@Test
-	public void testCommitRange() throws NoHeadException, NoMessageException,
-			UnmergedPathException, ConcurrentRefUpdateException,
-			JGitInternalException, WrongRepositoryStateException,
-			IncorrectObjectTypeException, MissingObjectException {
+	public void testCommitRange() throws GitAPIException,
+			JGitInternalException, MissingObjectException,
+			IncorrectObjectTypeException {
 		// do 4 commits and set the range to the second and fourth one
 		Git git = new Git(db);
 		git.commit().setMessage("first commit").call();
 	}
 
 	@Test
-	public void testCommitAmend() throws NoHeadException, NoMessageException,
-			ConcurrentRefUpdateException, JGitInternalException,
-			WrongRepositoryStateException, IOException {
+	public void testCommitAmend() throws JGitInternalException, IOException,
+			GitAPIException {
 		Git git = new Git(db);
 		git.commit().setMessage("first comit").call(); // typo
 		git.commit().setAmend(true).setMessage("first commit").call();
 	}
 
 	@Test
-	public void testInsertChangeId() throws NoHeadException,
-			NoMessageException,
-			UnmergedPathException, ConcurrentRefUpdateException,
-			JGitInternalException, WrongRepositoryStateException {
+	public void testInsertChangeId() throws JGitInternalException,
+			GitAPIException {
 		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

 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;
 	}
 
 	@Test
-	public void testWrap() {
+	public void testWrap() throws JGitInternalException, GitAPIException {
 		Git git = Git.wrap(db);
 		assertEquals(1, git.branchList().call().size());
 
 	}
 
 	@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

 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;
 	}
 
 	@Test
-	public void testInitRepository() throws IOException {
+	public void testInitRepository() throws IOException, JGitInternalException,
+			GitAPIException {
 		File directory = createTempDirectory("testInitRepository");
 		InitCommand command = new InitCommand();
 		command.setDirectory(directory);
 	}
 
 	@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();
 	}
 
 	@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

 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;
 
 	private DirCacheEntry prestage;
 
-	public void setupRepository() throws IOException, NoFilepatternException,
-			NoHeadException, NoMessageException, ConcurrentRefUpdateException,
-			JGitInternalException, WrongRepositoryStateException {
+	public void setupRepository() throws IOException, JGitInternalException,
+			GitAPIException {
 
 		// create initial commit
 		git = new Git(db);
 
 	@Test
 	public void testHardReset() throws JGitInternalException,
-			AmbiguousObjectException, IOException, NoFilepatternException,
-			NoHeadException, NoMessageException, ConcurrentRefUpdateException,
-			WrongRepositoryStateException {
+			AmbiguousObjectException, IOException, GitAPIException {
 		setupRepository();
 		ObjectId prevHead = db.resolve(Constants.HEAD);
 		git.reset().setMode(ResetType.HARD).setRef(initialCommit.getName())
 
 	@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);
 
 	@Test
 	public void testSoftReset() throws JGitInternalException,
-			AmbiguousObjectException, IOException, NoFilepatternException,
-			NoHeadException, NoMessageException, ConcurrentRefUpdateException,
-			WrongRepositoryStateException {
+			AmbiguousObjectException, IOException, GitAPIException {
 		setupRepository();
 		ObjectId prevHead = db.resolve(Constants.HEAD);
 		git.reset().setMode(ResetType.SOFT).setRef(initialCommit.getName())
 
 	@Test
 	public void testMixedReset() throws JGitInternalException,
-			AmbiguousObjectException, IOException, NoFilepatternException,
-			NoHeadException, NoMessageException, ConcurrentRefUpdateException,
-			WrongRepositoryStateException {
+			AmbiguousObjectException, IOException, GitAPIException {
 		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

 
 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;
 
 	@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

 
 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

 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;
 public class TagCommandTest extends RepositoryTestCase {
 
 	@Test
-	public void testTaggingOnHead() throws NoHeadException, NoMessageException,
-			ConcurrentRefUpdateException, JGitInternalException,
-			WrongRepositoryStateException, InvalidTagNameException,
-			MissingObjectException, IncorrectObjectTypeException, IOException {
+	public void testTaggingOnHead() throws GitAPIException, IOException {
 		Git git = new Git(db);
 		RevCommit commit = git.commit().setMessage("initial commit").call();
 		Ref tagRef = git.tag().setName("tag").call();
 	}
 
 	@Test
-	public void testTagging() throws NoHeadException, NoMessageException,
-			UnmergedPathException, ConcurrentRefUpdateException,
-			JGitInternalException, WrongRepositoryStateException,
-			InvalidTagNameException {
+	public void testTagging() throws GitAPIException, JGitInternalException {
 		Git git = new Git(db);
 		git.commit().setMessage("initial commit").call();
 		RevCommit commit = git.commit().setMessage("second commit").call();
 	}
 
 	@Test
-	public void testEmptyTagName() throws NoHeadException, NoMessageException,
-			UnmergedPathException, ConcurrentRefUpdateException,
-			JGitInternalException, WrongRepositoryStateException {
+	public void testEmptyTagName() throws GitAPIException {
 		Git git = new Git(db);
 		git.commit().setMessage("initial commit").call();
 		try {
 	}
 
 	@Test
-	public void testInvalidTagName() throws NoHeadException,
-			NoMessageException, UnmergedPathException,
-			ConcurrentRefUpdateException, JGitInternalException,
-			WrongRepositoryStateException {
+	public void testInvalidTagName() throws GitAPIException {
 		Git git = new Git(db);
 		git.commit().setMessage("initial commit").call();
 		try {
 	}
 
 	@Test
-	public void testFailureOnSignedTags() throws NoHeadException,
-			NoMessageException, UnmergedPathException,
-			ConcurrentRefUpdateException, JGitInternalException,
-			WrongRepositoryStateException, InvalidTagNameException {
+	public void testFailureOnSignedTags() throws GitAPIException {
 		Git git = new Git(db);
 		git.commit().setMessage("initial commit").call();
 		try {

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

 import java.util.Arrays;
 
 import org.eclipse.jgit.api.Git;
-import org.eclipse.jgit.api.errors.CheckoutConflictException;
-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.api.errors.GitAPIException;
 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;
 	 *            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)
-			throws IOException, RefAlreadyExistsException,
-			RefNotFoundException, InvalidRefNameException,
-			MissingObjectException, IncorrectObjectTypeException,
-			JGitInternalException, CheckoutConflictException {
+	private void testMaliciousPath(boolean good, boolean secondCheckout,
+			String... path) throws GitAPIException, IOException {
 		Git git = new Git(db);
 		ObjectInserter newObjectInserter;
 		newObjectInserter = git.getRepository().newObjectInserter();

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

 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;
 	}
 
 	@Test
-	public void testModified() throws IOException, NoFilepatternException {
+	public void testModified() throws IOException, GitAPIException {
 
 		writeTrashFile("file2", "file2");
 		writeTrashFile("dir/file3", "dir/file3");
 	}
 
 	@Test
-	public void testUnchangedSimple() throws IOException,
-			NoFilepatternException {
+	public void testUnchangedSimple() throws IOException, GitAPIException {
 		writeTrashFile("a.b", "a.b");
 		writeTrashFile("a.c", "a.c");
 		writeTrashFile("a=c", "a=c");
 	 * used by Git.
 	 *
 	 * @throws IOException
-	 * @throws NoFilepatternException
+	 * @throws GitAPIException
 	 */
 	@Test
-	public void testUnchangedComplex() throws IOException,
-			NoFilepatternException {
+	public void testUnchangedComplex() throws IOException, GitAPIException {
 		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

 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;
 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");
 	}
 
 	@Test
-	public void commandWithEmptyPath() {
+	public void commandWithEmptyPath() throws GitAPIException {
 		try {
 			new SubmoduleAddCommand(db).setPath("").setURI("uri").call();
 			fail("Exception not thrown");
 	}
 
 	@Test
-	public void commandWithNullUri() {
+	public void commandWithNullUri() throws GitAPIException {
 		try {
 			new SubmoduleAddCommand(db).setPath("sub").call();
 			fail("Exception not thrown");
 	}
 
 	@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

 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;
 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);
 
 	@Test
 	public void repositoryWithUninitializedModule() throws IOException,
-			ConfigInvalidException {
+			ConfigInvalidException, GitAPIException {
 		final String path = addSubmoduleToIndex();
 
 		SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
 
 	@Test
 	public void resolveOneLevelHigherRelativeUrl() throws IOException,
-			ConfigInvalidException {
+			ConfigInvalidException, GitAPIException {
 		final String path = addSubmoduleToIndex();
 
 		String base = "git://server/repo.git";
 
 	@Test
 	public void resolveTwoLevelHigherRelativeUrl() throws IOException,
-			ConfigInvalidException {
+			ConfigInvalidException, GitAPIException {
 		final String path = addSubmoduleToIndex();
 
 		String base = "git://server/repo.git";
 
 	@Test
 	public void resolveWorkingDirectoryRelativeUrl() throws IOException,
-			ConfigInvalidException {
+			GitAPIException, ConfigInvalidException {
 		final String path = addSubmoduleToIndex();
 
 		String base = db.getWorkTree().getAbsolutePath();
 
 	@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

 
 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;
 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);
 	}
 
 	@Test
-	public void repositoryWithMissingSubmodule() throws IOException {
+	public void repositoryWithMissingSubmodule() throws IOException,
+			GitAPIException {
 		final ObjectId id = ObjectId
 				.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
 		final String path = "sub";
 	}
 
 	@Test
-	public void repositoryWithUninitializedSubmodule() throws IOException {
+	public void repositoryWithUninitializedSubmodule() throws IOException,
+			GitAPIException {
 		final ObjectId id = ObjectId
 				.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
 		final String path = "sub";
 	}
 
 	@Test
-	public void repositoryWithNoHeadInSubmodule() throws IOException {
+	public void repositoryWithNoHeadInSubmodule() throws IOException,
+			GitAPIException {
 		final ObjectId id = ObjectId
 				.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
 		final String path = "sub";
 	}
 
 	@Test
-	public void repositoryWithNoSubmoduleRepository() throws IOException {
+	public void repositoryWithNoSubmoduleRepository() throws IOException,
+			GitAPIException {
 		final ObjectId id = ObjectId
 				.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
 		final String path = "sub";
 	}
 
 	@Test
-	public void repositoryWithInitializedSubmodule() throws IOException {
+	public void repositoryWithInitializedSubmodule() throws IOException,
+			GitAPIException {
 		final ObjectId id = ObjectId
 				.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
 		final String path = "sub";
 
 	@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

 
 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;
 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

 
 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;
 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);
 	}
 
 	@Test
-	public void repositoryWithUnconfiguredSubmodule() throws IOException {
+	public void repositoryWithUnconfiguredSubmodule() throws IOException,
+			GitAPIException {
 		final ObjectId id = ObjectId
 				.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
 		final String path = "sub";
 	}
 
 	@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

 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;
 	 *
 	 * @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

 
 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;
 		super(repo);
 	}
 
-	/**
-	 * @throws JGitInternalException
-	 *             upon internal failure
-	 */
-	public Note call() throws JGitInternalException {
+	public Note call() throws GitAPIException {
 		checkCallable();
 		RevWalk walk = new RevWalk(repo);
 		ObjectInserter inserter = repo.newObjectInserter();

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

 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;
 	 *
 	 * @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

 
 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;
 	 * @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

 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;
 	 *
 	 * @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);
 
 	/**
 	 * If dryRun is set, the paths in question will not actually be deleted.
-	 * 
+	 *
 	 * @param dryRun
 	 *            whether to do a dry run or not
 	 * @return {@code this}

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

 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;
 	/**
 	 * 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);
 		}
 	}
 
-	private Repository init(URIish u) {
+	private Repository init(URIish u) throws GitAPIException {
 		InitCommand command = Git.init();
 		command.setBare(bare);
 		if (directory == null)
 	}
 
 	private FetchResult fetch(Repository clonedRepo, URIish u)
-			throws URISyntaxException,
-			JGitInternalException,
-			InvalidRemoteException, IOException {
+			throws URISyntaxException, IOException, GitAPIException {
 		// create the remote config and save it
 		RemoteConfig config = new RemoteConfig(clonedRepo.getConfig(), remote);
 		config.addURI(u);
 	}
 
 	private void checkout(Repository clonedRepo, FetchResult result)
-			throws JGitInternalException,
-			MissingObjectException, IncorrectObjectTypeException, IOException {
+			throws MissingObjectException, IncorrectObjectTypeException,
+			IOException, GitAPIException {
 
 		Ref head = result.getAdvertisedRef(branch);
 		if (branch.equals(Constants.HEAD)) {
 		}
 	}
 
-	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

 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;
 	 *             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,
-			UnmergedPathException, ConcurrentRefUpdateException,
-			JGitInternalException, WrongRepositoryStateException {
+	public RevCommit call() throws GitAPIException, NoHeadException,
+			NoMessageException, UnmergedPathsException,
+			ConcurrentRefUpdateException,
+			WrongRepositoryStateException {
 		checkCallable();
 
 		RepositoryState state = repo.getRepositoryState();
 				index.unlock();
 			}
 		} catch (UnmergedPathException e) {
-			// since UnmergedPathException is a subclass of IOException
-			// which should not be wrapped by a JGitInternalException we
-			// have to catch and re-throw it here
-			throw e;
+			throw new UnmergedPathsException(e);
 		} catch (IOException e) {
 			throw new JGitInternalException(
 					JGitText.get().exceptionCaughtDuringExecutionOfCommitCommand, e);

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

 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;
 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;
 
 	 *             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

 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;
 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;
 
 	 * @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

 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;
 	}
 
 	/**
-	 * @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

 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;
 	 *
 	 * @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));
 				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

 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;
 	 *         result
 	 * @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()}.
+	 * @throws org.eclipse.jgit.api.errors.TransportException
+	 *             when an error occurs during transport
 	 */
-	public FetchResult call() throws JGitInternalException,
-			InvalidRemoteException {
+	public FetchResult call() throws GitAPIException, InvalidRemoteException,
+			org.eclipse.jgit.api.errors.TransportException {
 		checkCallable();
 
 		try {
 			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

 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;
 
 					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

 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;
 	/**
 	 * 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

 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;
 		super(repo);
 	}
 
-	/**
-	 * @throws JGitInternalException
-	 *             upon internal failure
-	 */
-	public List<Ref> call() throws JGitInternalException {
+	public List<Ref> call() throws GitAPIException {
 		checkCallable();
 		Map<String, Ref> refList;
 		try {

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

 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;
 	}
 
 	/**
-	 * @throws JGitInternalException
-	 *             upon internal failure
+	 * @return the requested notes
 	 */
-	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

 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;
 	}
 
 	/**
-	 * @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

 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;
 	 * 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,
-			JGitInternalException {
+	public Iterable<RevCommit> call() throws GitAPIException, NoHeadException {
 		checkCallable();
 		if (pathFilters.size() > 0)
 			walk.setTreeFilter(AndTreeFilter.create(
 	 *             typically not wrapped here but thrown as original exception
 	 */
 	public LogCommand add(AnyObjectId start) throws MissingObjectException,
-			IncorrectObjectTypeException, JGitInternalException {
+			IncorrectObjectTypeException {
 		return add(true, start);
 	}
 
 	 *             typically not wrapped here but thrown as original exception
 	 */
 	public LogCommand not(AnyObjectId start) throws MissingObjectException,
-			IncorrectObjectTypeException, JGitInternalException {
+			IncorrectObjectTypeException {
 		return add(false, start);
 	}
 
 	 *             typically not wrapped here but thrown as original exception
 	 */
 	public LogCommand addRange(AnyObjectId since, AnyObjectId until)
-			throws MissingObjectException, IncorrectObjectTypeException,
-			JGitInternalException {
+			throws MissingObjectException, IncorrectObjectTypeException {
 		return not(since).add(until);
 	}
 

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

 	 * @return a collection of references in the remote repository
 	 * @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()}.
+	 * @throws org.eclipse.jgit.api.errors.TransportException
+	 *             for errors that occurs during transport
 	 */
 	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

 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;
 	 *
 	 * @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

 	 *
 	 * @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

 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;
 	 * @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();
 
 	 * @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

 	 *
 	 * @return an object describing the result of this command
 	 */
-	public RebaseResult call() throws NoHeadException, RefNotFoundException,
-			JGitInternalException, GitAPIException {
+	public RebaseResult call() throws GitAPIException, NoHeadException,
+			RefNotFoundException {
 		RevCommit newHead = null;
 		boolean lastStepWasForward = false;
 		checkCallable();
 		}
 	}
 
-	private RevCommit checkoutCurrentHead() throws IOException,
-			NoHeadException, JGitInternalException {
+	private RevCommit checkoutCurrentHead() throws IOException, NoHeadException {
 		ObjectId headTree = repo.resolve(Constants.HEAD + "^{tree}");
 		if (headTree == null)
 			throw new NoHeadException(
 		}
 	}
 
-	private RebaseResult initFilesAndRewind() throws RefNotFoundException,
-			IOException, NoHeadException, JGitInternalException {
+	private RebaseResult initFilesAndRewind() throws IOException,
+			GitAPIException {
 		// we need to store everything into files so that we can implement
 		// --skip, --continue, and --abort
 
 	 *
 	 * @param newCommit
 	 * @return the new head, or null
-	 * @throws RefNotFoundException
 	 * @throws IOException
+	 * @throws GitAPIException
 	 */
-	public RevCommit tryFastForward(RevCommit newCommit)
-			throws RefNotFoundException, IOException {
+	public RevCommit tryFastForward(RevCommit newCommit) throws IOException,
+			GitAPIException {
 		Ref head = repo.getRef(Constants.HEAD);
 		if (head == null || head.getObjectId() == null)
 			throw new RefNotFoundException(MessageFormat.format(
 	}
 
 	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

 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;
 		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

 
 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;
 		super(repo);
 	}
 
-	/**
-	 * @throws JGitInternalException
-	 *             upon internal failure
-	 */
-	public Note call() throws JGitInternalException {
+	public Note call() throws GitAPIException {
 		checkCallable();
 		RevWalk walk = new RevWalk(repo);
 		ObjectInserter inserter = repo.newObjectInserter();

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

 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;
 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.
 	 *             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

 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;
 	 *
 	 * @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

 
 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

 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;
 	 *
 	 * @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

 
 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;
 		super(repo);
 	}
 
-	/**
-	 * @throws JGitInternalException
-	 *             upon internal failure
-	 */
-	public Note call() throws JGitInternalException {
+	public Note call() throws GitAPIException {
 		checkCallable();
 		RevWalk walk = new RevWalk(repo);
 		NoteMap map = NoteMap.newEmptyMap();

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

 		return false;
 	}
 
-	private ObjectId getHeadTree() throws JGitInternalException,
-			GitAPIException {
+	private ObjectId getHeadTree() throws GitAPIException {
 		final ObjectId headTree;
 		try {
 			headTree = repo.resolve(Constants.HEAD + "^{tree}");
 		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 {
 	 *
 	 * @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

 	 *
 	 * @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

 	 *
 	 * @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

 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;
 		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

 
 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;
 	 * @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);
 
-		IndexDiff diff = new IndexDiff(repo, Constants.HEAD, workingTreeIt);
-		diff.diff();
-
-		return new Status(diff);
+		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

 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;
 		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

 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;
 		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

 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;
 		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

 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;
 			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

 		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

 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;
 	 * @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,
-			ConcurrentRefUpdateException, InvalidTagNameException, NoHeadException {
+	public Ref call() throws GitAPIException, ConcurrentRefUpdateException,
+			InvalidTagNameException, NoHeadException {
 		checkCallable();
 
 		RepositoryState state = repo.getRepositoryState();

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

 	 * 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);
 	}
 }