Throw NotFound and CannotDereference Exceptions

jamill · jamill · commit 49987df083c2 · 2014-10-05T14:39:57.000-04:00
This change is to throw more specific exceptions in several cases when
possible. If an object cannot be found, throw a more specific
NotFoundException. If an object exists but cannot be dereferenced to its
desired type, then throw a CannotDereferenceException.
diff --git a/LibGit2Sharp.Tests/BlameFixture.cs b/LibGit2Sharp.Tests/BlameFixture.cs
@@ -34,7 +34,7 @@ public void CanBlameFromADifferentCommit()
             using (var repo = new Repository(MergedTestRepoWorkingDirPath))
             {
                 // File doesn't exist at HEAD
-                Assert.Throws<LibGit2SharpException>(() => repo.Blame("ancestor-only.txt"));
+                Assert.Throws<NotFoundException>(() => repo.Blame("ancestor-only.txt"));
 
                 var blame = repo.Blame("ancestor-only.txt", new BlameOptions { StartingAt = "9107b30" });
                 Assert.Equal(1, blame.Count());
diff --git a/LibGit2Sharp.Tests/BranchFixture.cs b/LibGit2Sharp.Tests/BranchFixture.cs
@@ -241,9 +241,9 @@ public void CreatingABranchFromANonCommitObjectThrows()
             using (var repo = new Repository(BareTestRepoPath))
             {
                 const string name = "sorry-dude-i-do-not-do-blobs-nor-trees";
-                Assert.Throws<LibGit2SharpException>(() => repo.CreateBranch(name, "refs/tags/point_to_blob"));
-                Assert.Throws<LibGit2SharpException>(() => repo.CreateBranch(name, "53fc32d"));
-                Assert.Throws<LibGit2SharpException>(() => repo.CreateBranch(name, "0266163"));
+                Assert.Throws<CannotDereferenceException>(() => repo.CreateBranch(name, "refs/tags/point_to_blob"));
+                Assert.Throws<CannotDereferenceException>(() => repo.CreateBranch(name, "53fc32d"));
+                Assert.Throws<CannotDereferenceException>(() => repo.CreateBranch(name, "0266163"));
             }
         }
 
@@ -252,7 +252,7 @@ public void CreatingBranchWithUnknownNamedTargetThrows()
         {
             using (var repo = new Repository(BareTestRepoPath))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Branches.Add("my_new_branch", "my_old_branch"));
+                Assert.Throws<NotFoundException>(() => repo.Branches.Add("my_new_branch", "my_old_branch"));
             }
         }
 
@@ -261,8 +261,8 @@ public void CreatingBranchWithUnknownShaTargetThrows()
         {
             using (var repo = new Repository(BareTestRepoPath))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Branches.Add("my_new_branch", Constants.UnknownSha));
-                Assert.Throws<LibGit2SharpException>(() => repo.Branches.Add("my_new_branch", Constants.UnknownSha.Substring(0, 7)));
+                Assert.Throws<NotFoundException>(() => repo.Branches.Add("my_new_branch", Constants.UnknownSha));
+                Assert.Throws<NotFoundException>(() => repo.Branches.Add("my_new_branch", Constants.UnknownSha.Substring(0, 7)));
             }
         }
 
@@ -707,7 +707,7 @@ public void SetTrackedBranchForUnreasolvableRemoteThrows()
 
                 Branch trackedBranch = repo.Branches[trackedBranchName];
 
-                Assert.Throws<LibGit2SharpException>(() => repo.Branches.Update(branch,
+                Assert.Throws<NotFoundException>(() => repo.Branches.Update(branch,
                                                                                 b => b.TrackedBranch = trackedBranch.CanonicalName));
             }
         }
diff --git a/LibGit2Sharp.Tests/CheckoutFixture.cs b/LibGit2Sharp.Tests/CheckoutFixture.cs
@@ -381,7 +381,7 @@ public void CheckingOutANonExistingBranchThrows()
         {
             using (var repo = new Repository(StandardTestRepoWorkingDirPath))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Checkout("i-do-not-exist"));
+                Assert.Throws<NotFoundException>(() => repo.Checkout("i-do-not-exist"));
             }
         }
 
@@ -891,7 +891,7 @@ public void CheckoutLowerCasedHeadThrows()
         {
             using (var repo = new Repository(StandardTestRepoWorkingDirPath))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Checkout("head"));
+                Assert.Throws<NotFoundException>(() => repo.Checkout("head"));
             }
         }
 
diff --git a/LibGit2Sharp.Tests/CommitFixture.cs b/LibGit2Sharp.Tests/CommitFixture.cs
@@ -101,8 +101,8 @@ public void QueryingTheCommitHistoryWithUnknownShaOrInvalidEntryPointThrows()
         {
             using (var repo = new Repository(BareTestRepoPath))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Commits.QueryBy(new CommitFilter { Since = Constants.UnknownSha }).Count());
-                Assert.Throws<LibGit2SharpException>(() => repo.Commits.QueryBy(new CommitFilter { Since = "refs/heads/deadbeef" }).Count());
+                Assert.Throws<NotFoundException>(() => repo.Commits.QueryBy(new CommitFilter { Since = Constants.UnknownSha }).Count());
+                Assert.Throws<NotFoundException>(() => repo.Commits.QueryBy(new CommitFilter { Since = "refs/heads/deadbeef" }).Count());
                 Assert.Throws<ArgumentNullException>(() => repo.Commits.QueryBy(new CommitFilter { Since = null }).Count());
             }
         }
@@ -115,8 +115,8 @@ public void QueryingTheCommitHistoryFromACorruptedReferenceThrows()
             {
                 CreateCorruptedDeadBeefHead(repo.Info.Path);
 
-                Assert.Throws<LibGit2SharpException>(() => repo.Commits.QueryBy(new CommitFilter { Since = repo.Branches["deadbeef"] }).Count());
-                Assert.Throws<LibGit2SharpException>(() => repo.Commits.QueryBy(new CommitFilter { Since = repo.Refs["refs/heads/deadbeef"] }).Count());
+                Assert.Throws<NotFoundException>(() => repo.Commits.QueryBy(new CommitFilter { Since = repo.Branches["deadbeef"] }).Count());
+                Assert.Throws<NotFoundException>(() => repo.Commits.QueryBy(new CommitFilter { Since = repo.Refs["refs/heads/deadbeef"] }).Count());
             }
         }
 
diff --git a/LibGit2Sharp.Tests/ReferenceFixture.cs b/LibGit2Sharp.Tests/ReferenceFixture.cs
@@ -73,7 +73,7 @@ public void CreatingADirectReferenceWithARevparseSpecPointingAtAnUnknownObjectFa
             string path = CloneBareTestRepo();
             using (var repo = new Repository(path))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Refs.Add(name, "master^42"));
+                Assert.Throws<NotFoundException>(() => repo.Refs.Add(name, "master^42"));
             }
         }
 
@@ -596,7 +596,7 @@ public void UpdatingADirectReferenceTargetWithARevparsePointingAtAnUnknownObject
         {
             using (var repo = new Repository(BareTestRepoPath))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Refs.UpdateTarget(repo.Refs["refs/heads/master"], "refs/heads/nope"));
+                Assert.Throws<NotFoundException>(() => repo.Refs.UpdateTarget(repo.Refs["refs/heads/master"], "refs/heads/nope"));
             }
         }
 
diff --git a/LibGit2Sharp.Tests/ResetHeadFixture.cs b/LibGit2Sharp.Tests/ResetHeadFixture.cs
@@ -70,8 +70,8 @@ public void ResettingWithBadParamsThrows()
                 Assert.Throws<ArgumentNullException>(() => repo.Reset(ResetMode.Soft, (string)null));
                 Assert.Throws<ArgumentNullException>(() => repo.Reset(ResetMode.Soft, (Commit)null));
                 Assert.Throws<ArgumentException>(() => repo.Reset(ResetMode.Soft, ""));
-                Assert.Throws<LibGit2SharpException>(() => repo.Reset(ResetMode.Soft, Constants.UnknownSha));
-                Assert.Throws<LibGit2SharpException>(() => repo.Reset(ResetMode.Soft, repo.Head.Tip.Tree.Sha));
+                Assert.Throws<NotFoundException>(() => repo.Reset(ResetMode.Soft, Constants.UnknownSha));
+                Assert.Throws<CannotDereferenceException>(() => repo.Reset(ResetMode.Soft, repo.Head.Tip.Tree.Sha));
             }
         }
 
diff --git a/LibGit2Sharp.Tests/TagFixture.cs b/LibGit2Sharp.Tests/TagFixture.cs
@@ -257,7 +257,7 @@ public void CreatingATagForAnUnknowReferenceThrows()
         {
             using (var repo = new Repository(BareTestRepoPath))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.ApplyTag("mytagnorev", "aaaaaaaaaaa"));
+                Assert.Throws<NotFoundException>(() => repo.ApplyTag("mytagnorev", "aaaaaaaaaaa"));
             }
         }
 
@@ -267,7 +267,7 @@ public void CreatingATagForAnUnknowObjectIdThrows()
         {
             using (var repo = new Repository(BareTestRepoPath))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.ApplyTag("mytagnorev", Constants.UnknownSha));
+                Assert.Throws<NotFoundException>(() => repo.ApplyTag("mytagnorev", Constants.UnknownSha));
             }
         }
 
@@ -497,7 +497,7 @@ public void AddTagWithNotExistingTargetThrows()
         {
             using (var repo = new Repository(BareTestRepoPath))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Tags.Add("test_tag", Constants.UnknownSha, signatureTim, "message"));
+                Assert.Throws<NotFoundException>(() => repo.Tags.Add("test_tag", Constants.UnknownSha, signatureTim, "message"));
             }
         }
 
@@ -608,7 +608,7 @@ public void RemovingAnUnknownTagShouldFail()
         {
             using (var repo = new Repository(BareTestRepoPath))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Tags.Remove("unknown-tag"));
+                Assert.Throws<NotFoundException>(() => repo.Tags.Remove("unknown-tag"));
             }
         }
 
diff --git a/LibGit2Sharp/AmbiguousSpecificationException.cs b/LibGit2Sharp/AmbiguousSpecificationException.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Runtime.Serialization;
+using LibGit2Sharp.Core;
 
 namespace LibGit2Sharp
 {
@@ -44,5 +45,10 @@ protected AmbiguousSpecificationException(SerializationInfo info, StreamingConte
             : base(info, context)
         {
         }
+
+        internal AmbiguousSpecificationException(string message, GitErrorCode code, GitErrorCategory category)
+            : base(message, code, category)
+        {
+        }
     }
 }
diff --git a/LibGit2Sharp/Blob.cs b/LibGit2Sharp/Blob.cs
@@ -25,6 +25,21 @@ internal Blob(Repository repo, ObjectId id)
             lazyIsBinary = GitObjectLazyGroup.Singleton(repo, id, Proxy.git_blob_is_binary);
         }
 
+        /// <summary>
+        /// A blob cannot be dereferenced to a commit - throws or returns null.
+        /// </summary>
+        /// <param name="throwsIfCanNotBeDereferencedToACommit"></param>
+        /// <returns></returns>
+        internal override Commit DereferenceToCommit(bool throwsIfCanNotBeDereferencedToACommit)
+        {
+            if (throwsIfCanNotBeDereferencedToACommit)
+            {
+                throw new CannotDereferenceException("Cannot dereference a blob object to a commit.");
+            }
+
+            return null;
+        }
+
         /// <summary>
         /// Gets the size in bytes of the raw content of a blob.
         /// </summary>
diff --git a/LibGit2Sharp/CannotDereferenceException.cs b/LibGit2Sharp/CannotDereferenceException.cs
@@ -0,0 +1,48 @@
+﻿using System;
+using System.Runtime.Serialization;
+
+namespace LibGit2Sharp
+{
+    /// <summary>
+    /// The exception that is thrown when a GitObject cannot be dereferenced to the desired type.
+    /// </summary>
+    [Serializable]
+    public class CannotDereferenceException : LibGit2SharpException
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CannotDereferenceException"/> class.
+        /// </summary>
+        public CannotDereferenceException()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CannotDereferenceException"/> class with a specified error message.
+        /// </summary>
+        /// <param name="message">A message that describes the error.</param>
+        public CannotDereferenceException(string message)
+            : base(message)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CannotDereferenceException"/> class with a specified error message and a reference to the inner exception that is the cause of this exception.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception. If the <paramref name="innerException"/> parameter is not a null reference, the current exception is raised in a catch block that handles the inner exception.</param>
+        public CannotDereferenceException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CannotDereferenceException"/> class with a serialized data.
+        /// </summary>
+        /// <param name="info">The <see cref="SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="StreamingContext"/> that contains contextual information about the source or destination.</param>
+        protected CannotDereferenceException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+        }
+    }
+}
diff --git a/LibGit2Sharp/Commit.cs b/LibGit2Sharp/Commit.cs
@@ -51,6 +51,16 @@ internal Commit(Repository repo, ObjectId id)
             parents = new ParentsCollection(repo, id);
         }
 
+        /// <summary>
+        /// This object is already a commit - no need to further dereference.
+        /// </summary>
+        /// <param name="throwsIfCanNotBeDereferencedToACommit"></param>
+        /// <returns></returns>
+        internal override Commit DereferenceToCommit(bool throwsIfCanNotBeDereferencedToACommit)
+        {
+            return this;
+        }
+
         /// <summary>
         /// Gets the <see cref="TreeEntry"/> pointed at by the <paramref name="relativePath"/> in the <see cref="Tree"/>.
         /// </summary>
diff --git a/LibGit2Sharp/Core/Ensure.cs b/LibGit2Sharp/Core/Ensure.cs
@@ -100,6 +100,8 @@ private static readonly Dictionary<GitErrorCode, Func<string, GitErrorCode, GitE
                     { GitErrorCode.NonFastForward, (m, r, c) => new NonFastForwardException(m, r, c) },
                     { GitErrorCode.MergeConflict, (m, r, c) => new MergeConflictException(m, r, c) },
                     { GitErrorCode.LockedFile, (m, r, c) => new LockedFileException(m, r, c) },
+                    { GitErrorCode.NotFound, (m, r, c) => new NotFoundException(m, r, c) },
+                    { GitErrorCode.Ambiguous, (m, r, c) => new AmbiguousSpecificationException(m, r, c) },
                 };
 
         private static void HandleError(int result)
@@ -218,7 +220,7 @@ public static void GitObjectIsNotNull(GitObject gitObject, string identifier)
             }
             else
             {
-                exceptionBuilder = m => new LibGit2SharpException(m);
+                exceptionBuilder = m => new NotFoundException(m);
             }
 
             GitObjectIsNotNull(gitObject, identifier, exceptionBuilder);
diff --git a/LibGit2Sharp/GitLink.cs b/LibGit2Sharp/GitLink.cs
@@ -14,6 +14,21 @@ public class GitLink : GitObject
         protected GitLink()
         { }
 
+        /// <summary>
+        /// A GitLink cannot be dereferenced to a commit - throws or returns null.
+        /// </summary>
+        /// <param name="throwsIfCanNotBeDereferencedToACommit"></param>
+        /// <returns></returns>
+        internal override Commit DereferenceToCommit(bool throwsIfCanNotBeDereferencedToACommit)
+        {
+            if (throwsIfCanNotBeDereferencedToACommit)
+            {
+                throw new CannotDereferenceException("Cannot dereference a git-link object to a commit.");
+            }
+
+            return null;
+        }
+
         internal GitLink(Repository repo, ObjectId id)
             : base(repo, id)
         {
diff --git a/LibGit2Sharp/GitObject.cs b/LibGit2Sharp/GitObject.cs
@@ -77,7 +77,12 @@ internal static GitObject BuildFrom(Repository repo, ObjectId id, GitObjectType
             }
         }
 
-        internal Commit DereferenceToCommit(bool throwsIfCanNotBeDereferencedToACommit)
+        /// <summary>
+        /// Dereference object to a commit.
+        /// </summary>
+        /// <param name="throwsIfCanNotBeDereferencedToACommit"></param>
+        /// <returns></returns>
+        internal virtual Commit DereferenceToCommit(bool throwsIfCanNotBeDereferencedToACommit)
         {
             using (GitObjectSafeHandle peeledHandle = Proxy.git_object_peel(repo.Handle, Id, GitObjectType.Commit, throwsIfCanNotBeDereferencedToACommit))
             {
diff --git a/LibGit2Sharp/LibGit2Sharp.csproj b/LibGit2Sharp/LibGit2Sharp.csproj
@@ -68,6 +68,7 @@
     <Compile Include="BranchCollectionExtensions.cs" />
     <Compile Include="BranchTrackingDetails.cs" />
     <Compile Include="BranchUpdater.cs" />
+    <Compile Include="CannotDereferenceException.cs" />
     <Compile Include="CheckoutCallbacks.cs" />
     <Compile Include="CheckoutFileConflictStrategy.cs" />
     <Compile Include="CheckoutModifiers.cs" />
diff --git a/LibGit2Sharp/TagAnnotation.cs b/LibGit2Sharp/TagAnnotation.cs
@@ -1,4 +1,5 @@
 ﻿using LibGit2Sharp.Core;
+using LibGit2Sharp.Core.Handles;
 
 namespace LibGit2Sharp
 {
@@ -31,6 +32,24 @@ internal TagAnnotation(Repository repo, ObjectId id)
             lazyMessage = group.AddLazy(Proxy.git_tag_message);
         }
 
+        /// <summary>
+        /// Dereference tag to a commit.
+        /// </summary>
+        /// <param name="throwsIfCanNotBeDereferencedToACommit"></param>
+        /// <returns></returns>
+        internal override Commit DereferenceToCommit(bool throwsIfCanNotBeDereferencedToACommit)
+        {
+            using (GitObjectSafeHandle peeledHandle = Proxy.git_object_peel(repo.Handle, Id, GitObjectType.Commit, throwsIfCanNotBeDereferencedToACommit))
+            {
+                if (peeledHandle == null)
+                {
+                    return null;
+                }
+
+                return (Commit)BuildFrom(repo, Proxy.git_object_id(peeledHandle), GitObjectType.Commit, null);
+            }
+        }
+
         /// <summary>
         /// Gets the name of this tag.
         /// </summary>
diff --git a/LibGit2Sharp/Tree.cs b/LibGit2Sharp/Tree.cs
@@ -32,6 +32,21 @@ internal Tree(Repository repo, ObjectId id, FilePath path)
             lazyCount = GitObjectLazyGroup.Singleton(repo, id, Proxy.git_tree_entrycount);
         }
 
+        /// <summary>
+        /// A tree cannot be dereferenced to a commit - throws or returns null.
+        /// </summary>
+        /// <param name="throwsIfCanNotBeDereferencedToACommit"></param>
+        /// <returns></returns>
+        internal override Commit DereferenceToCommit(bool throwsIfCanNotBeDereferencedToACommit)
+        {
+            if (throwsIfCanNotBeDereferencedToACommit)
+            {
+                throw new CannotDereferenceException("Cannot dereference a tree object to a commit.");
+            }
+
+            return null;
+        }
+
         /// <summary>
         /// Gets the number of <see cref="TreeEntry"/> immediately under this <see cref="Tree"/>.
         /// </summary>

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ public void CanBlameFromADifferentCommit()`
`34`	`34`	`using (var repo = new Repository(MergedTestRepoWorkingDirPath))`
`35`	`35`	`{`
`36`	`36`	`// File doesn't exist at HEAD`
`37`		`- Assert.Throws<LibGit2SharpException>(() => repo.Blame("ancestor-only.txt"));`
	`37`	`+ Assert.Throws<NotFoundException>(() => repo.Blame("ancestor-only.txt"));`
`38`	`38`
`39`	`39`	`var blame = repo.Blame("ancestor-only.txt", new BlameOptions { StartingAt = "9107b30" });`
`40`	`40`	`Assert.Equal(1, blame.Count());`
Original file line number	Diff line number	Diff line change
`@@ -241,9 +241,9 @@ public void CreatingABranchFromANonCommitObjectThrows()`
`241`	`241`	`using (var repo = new Repository(BareTestRepoPath))`
`242`	`242`	`{`
`243`	`243`	`const string name = "sorry-dude-i-do-not-do-blobs-nor-trees";`
`244`		`- Assert.Throws<LibGit2SharpException>(() => repo.CreateBranch(name, "refs/tags/point_to_blob"));`
`245`		`- Assert.Throws<LibGit2SharpException>(() => repo.CreateBranch(name, "53fc32d"));`
`246`		`- Assert.Throws<LibGit2SharpException>(() => repo.CreateBranch(name, "0266163"));`
	`244`	`+ Assert.Throws<CannotDereferenceException>(() => repo.CreateBranch(name, "refs/tags/point_to_blob"));`
	`245`	`+ Assert.Throws<CannotDereferenceException>(() => repo.CreateBranch(name, "53fc32d"));`
	`246`	`+ Assert.Throws<CannotDereferenceException>(() => repo.CreateBranch(name, "0266163"));`
`247`	`247`	`}`
`248`	`248`	`}`
`249`	`249`
`@@ -252,7 +252,7 @@ public void CreatingBranchWithUnknownNamedTargetThrows()`
`252`	`252`	`{`
`253`	`253`	`using (var repo = new Repository(BareTestRepoPath))`
`254`	`254`	`{`
`255`		`- Assert.Throws<LibGit2SharpException>(() => repo.Branches.Add("my_new_branch", "my_old_branch"));`
	`255`	`+ Assert.Throws<NotFoundException>(() => repo.Branches.Add("my_new_branch", "my_old_branch"));`
`256`	`256`	`}`
`257`	`257`	`}`
`258`	`258`
`@@ -261,8 +261,8 @@ public void CreatingBranchWithUnknownShaTargetThrows()`
`261`	`261`	`{`
`262`	`262`	`using (var repo = new Repository(BareTestRepoPath))`
`263`	`263`	`{`
`264`		`- Assert.Throws<LibGit2SharpException>(() => repo.Branches.Add("my_new_branch", Constants.UnknownSha));`
`265`		`- Assert.Throws<LibGit2SharpException>(() => repo.Branches.Add("my_new_branch", Constants.UnknownSha.Substring(0, 7)));`
	`264`	`+ Assert.Throws<NotFoundException>(() => repo.Branches.Add("my_new_branch", Constants.UnknownSha));`
	`265`	`+ Assert.Throws<NotFoundException>(() => repo.Branches.Add("my_new_branch", Constants.UnknownSha.Substring(0, 7)));`
`266`	`266`	`}`
`267`	`267`	`}`
`268`	`268`
`@@ -707,7 +707,7 @@ public void SetTrackedBranchForUnreasolvableRemoteThrows()`
`707`	`707`
`708`	`708`	`Branch trackedBranch = repo.Branches[trackedBranchName];`
`709`	`709`
`710`		`- Assert.Throws<LibGit2SharpException>(() => repo.Branches.Update(branch,`
	`710`	`+ Assert.Throws<NotFoundException>(() => repo.Branches.Update(branch,`
`711`	`711`	`b => b.TrackedBranch = trackedBranch.CanonicalName));`
`712`	`712`	`}`
`713`	`713`	`}`
Original file line number	Diff line number	Diff line change
`@@ -381,7 +381,7 @@ public void CheckingOutANonExistingBranchThrows()`
`381`	`381`	`{`
`382`	`382`	`using (var repo = new Repository(StandardTestRepoWorkingDirPath))`
`383`	`383`	`{`
`384`		`- Assert.Throws<LibGit2SharpException>(() => repo.Checkout("i-do-not-exist"));`
	`384`	`+ Assert.Throws<NotFoundException>(() => repo.Checkout("i-do-not-exist"));`
`385`	`385`	`}`
`386`	`386`	`}`
`387`	`387`
`@@ -891,7 +891,7 @@ public void CheckoutLowerCasedHeadThrows()`
`891`	`891`	`{`
`892`	`892`	`using (var repo = new Repository(StandardTestRepoWorkingDirPath))`
`893`	`893`	`{`
`894`		`- Assert.Throws<LibGit2SharpException>(() => repo.Checkout("head"));`
	`894`	`+ Assert.Throws<NotFoundException>(() => repo.Checkout("head"));`
`895`	`895`	`}`
`896`	`896`	`}`
`897`	`897`
Original file line number	Diff line number	Diff line change
`@@ -101,8 +101,8 @@ public void QueryingTheCommitHistoryWithUnknownShaOrInvalidEntryPointThrows()`
`101`	`101`	`{`
`102`	`102`	`using (var repo = new Repository(BareTestRepoPath))`
`103`	`103`	`{`
`104`		`- Assert.Throws<LibGit2SharpException>(() => repo.Commits.QueryBy(new CommitFilter { Since = Constants.UnknownSha }).Count());`
`105`		`- Assert.Throws<LibGit2SharpException>(() => repo.Commits.QueryBy(new CommitFilter { Since = "refs/heads/deadbeef" }).Count());`
	`104`	`+ Assert.Throws<NotFoundException>(() => repo.Commits.QueryBy(new CommitFilter { Since = Constants.UnknownSha }).Count());`
	`105`	`+ Assert.Throws<NotFoundException>(() => repo.Commits.QueryBy(new CommitFilter { Since = "refs/heads/deadbeef" }).Count());`
`106`	`106`	`Assert.Throws<ArgumentNullException>(() => repo.Commits.QueryBy(new CommitFilter { Since = null }).Count());`
`107`	`107`	`}`
`108`	`108`	`}`
`@@ -115,8 +115,8 @@ public void QueryingTheCommitHistoryFromACorruptedReferenceThrows()`
`115`	`115`	`{`
`116`	`116`	`CreateCorruptedDeadBeefHead(repo.Info.Path);`
`117`	`117`
`118`		`- Assert.Throws<LibGit2SharpException>(() => repo.Commits.QueryBy(new CommitFilter { Since = repo.Branches["deadbeef"] }).Count());`
`119`		`- Assert.Throws<LibGit2SharpException>(() => repo.Commits.QueryBy(new CommitFilter { Since = repo.Refs["refs/heads/deadbeef"] }).Count());`
	`118`	`+ Assert.Throws<NotFoundException>(() => repo.Commits.QueryBy(new CommitFilter { Since = repo.Branches["deadbeef"] }).Count());`
	`119`	`+ Assert.Throws<NotFoundException>(() => repo.Commits.QueryBy(new CommitFilter { Since = repo.Refs["refs/heads/deadbeef"] }).Count());`
`120`	`120`	`}`
`121`	`121`	`}`
`122`	`122`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ public void CreatingADirectReferenceWithARevparseSpecPointingAtAnUnknownObjectFa`
`73`	`73`	`string path = CloneBareTestRepo();`
`74`	`74`	`using (var repo = new Repository(path))`
`75`	`75`	`{`
`76`		`- Assert.Throws<LibGit2SharpException>(() => repo.Refs.Add(name, "master^42"));`
	`76`	`+ Assert.Throws<NotFoundException>(() => repo.Refs.Add(name, "master^42"));`
`77`	`77`	`}`
`78`	`78`	`}`
`79`	`79`
`@@ -596,7 +596,7 @@ public void UpdatingADirectReferenceTargetWithARevparsePointingAtAnUnknownObject`
`596`	`596`	`{`
`597`	`597`	`using (var repo = new Repository(BareTestRepoPath))`
`598`	`598`	`{`
`599`		`- Assert.Throws<LibGit2SharpException>(() => repo.Refs.UpdateTarget(repo.Refs["refs/heads/master"], "refs/heads/nope"));`
	`599`	`+ Assert.Throws<NotFoundException>(() => repo.Refs.UpdateTarget(repo.Refs["refs/heads/master"], "refs/heads/nope"));`
`600`	`600`	`}`
`601`	`601`	`}`
`602`	`602`
Original file line number	Diff line number	Diff line change
`@@ -70,8 +70,8 @@ public void ResettingWithBadParamsThrows()`
`70`	`70`	`Assert.Throws<ArgumentNullException>(() => repo.Reset(ResetMode.Soft, (string)null));`
`71`	`71`	`Assert.Throws<ArgumentNullException>(() => repo.Reset(ResetMode.Soft, (Commit)null));`
`72`	`72`	`Assert.Throws<ArgumentException>(() => repo.Reset(ResetMode.Soft, ""));`
`73`		`- Assert.Throws<LibGit2SharpException>(() => repo.Reset(ResetMode.Soft, Constants.UnknownSha));`
`74`		`- Assert.Throws<LibGit2SharpException>(() => repo.Reset(ResetMode.Soft, repo.Head.Tip.Tree.Sha));`
	`73`	`+ Assert.Throws<NotFoundException>(() => repo.Reset(ResetMode.Soft, Constants.UnknownSha));`
	`74`	`+ Assert.Throws<CannotDereferenceException>(() => repo.Reset(ResetMode.Soft, repo.Head.Tip.Tree.Sha));`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`
Original file line number	Diff line number	Diff line change
`@@ -257,7 +257,7 @@ public void CreatingATagForAnUnknowReferenceThrows()`
`257`	`257`	`{`
`258`	`258`	`using (var repo = new Repository(BareTestRepoPath))`
`259`	`259`	`{`
`260`		`- Assert.Throws<LibGit2SharpException>(() => repo.ApplyTag("mytagnorev", "aaaaaaaaaaa"));`
	`260`	`+ Assert.Throws<NotFoundException>(() => repo.ApplyTag("mytagnorev", "aaaaaaaaaaa"));`
`261`	`261`	`}`
`262`	`262`	`}`
`263`	`263`
`@@ -267,7 +267,7 @@ public void CreatingATagForAnUnknowObjectIdThrows()`
`267`	`267`	`{`
`268`	`268`	`using (var repo = new Repository(BareTestRepoPath))`
`269`	`269`	`{`
`270`		`- Assert.Throws<LibGit2SharpException>(() => repo.ApplyTag("mytagnorev", Constants.UnknownSha));`
	`270`	`+ Assert.Throws<NotFoundException>(() => repo.ApplyTag("mytagnorev", Constants.UnknownSha));`
`271`	`271`	`}`
`272`	`272`	`}`
`273`	`273`
`@@ -497,7 +497,7 @@ public void AddTagWithNotExistingTargetThrows()`
`497`	`497`	`{`
`498`	`498`	`using (var repo = new Repository(BareTestRepoPath))`
`499`	`499`	`{`
`500`		`- Assert.Throws<LibGit2SharpException>(() => repo.Tags.Add("test_tag", Constants.UnknownSha, signatureTim, "message"));`
	`500`	`+ Assert.Throws<NotFoundException>(() => repo.Tags.Add("test_tag", Constants.UnknownSha, signatureTim, "message"));`
`501`	`501`	`}`
`502`	`502`	`}`
`503`	`503`
`@@ -608,7 +608,7 @@ public void RemovingAnUnknownTagShouldFail()`
`608`	`608`	`{`
`609`	`609`	`using (var repo = new Repository(BareTestRepoPath))`
`610`	`610`	`{`
`611`		`- Assert.Throws<LibGit2SharpException>(() => repo.Tags.Remove("unknown-tag"));`
	`611`	`+ Assert.Throws<NotFoundException>(() => repo.Tags.Remove("unknown-tag"));`
`612`	`612`	`}`
`613`	`613`	`}`
`614`	`614`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Runtime.Serialization;`
	`3`	`+using LibGit2Sharp.Core;`
`3`	`4`
`4`	`5`	`namespace LibGit2Sharp`
`5`	`6`	`{`
`@@ -44,5 +45,10 @@ protected AmbiguousSpecificationException(SerializationInfo info, StreamingConte`
`44`	`45`	`: base(info, context)`
`45`	`46`	`{`
`46`	`47`	`}`
	`48`	`+`
	`49`	`+ internal AmbiguousSpecificationException(string message, GitErrorCode code, GitErrorCategory category)`
	`50`	`+ : base(message, code, category)`
	`51`	`+ {`
	`52`	`+ }`
`47`	`53`	`}`
`48`	`54`	`}`