Merge pull request #842 from libgit2/jamill/error_update

nulltoken · nulltoken · commit 05e81e73c370 · 2015-01-21T12:28:18.000+01:00
Throw NotFound and CannotDereference Exceptions - Reborn
diff --git a/LibGit2Sharp.Tests/BlameFixture.cs b/LibGit2Sharp.Tests/BlameFixture.cs
@@ -36,7 +36,7 @@ public void CanBlameFromADifferentCommit()
             using (var repo = new Repository(path))
             {
                 // 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
@@ -254,7 +254,7 @@ public void CreatingBranchWithUnknownNamedTargetThrows()
             string path = SandboxBareTestRepo();
             using (var repo = new Repository(path))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Branches.Add("my_new_branch", "my_old_branch"));
+                Assert.Throws<NotFoundException>(() => repo.Branches.Add("my_new_branch", "my_old_branch"));
             }
         }
 
@@ -264,8 +264,8 @@ public void CreatingBranchWithUnknownShaTargetThrows()
             string path = SandboxBareTestRepo();
             using (var repo = new Repository(path))
             {
-                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)));
             }
         }
 
@@ -729,7 +729,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
@@ -383,7 +383,7 @@ public void CheckingOutANonExistingBranchThrows()
             string path = SandboxBareTestRepo();
             using (var repo = new Repository(path))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Checkout("i-do-not-exist"));
+                Assert.Throws<NotFoundException>(() => repo.Checkout("i-do-not-exist"));
             }
         }
 
@@ -895,7 +895,7 @@ public void CheckoutLowerCasedHeadThrows()
             string path = SandboxStandardTestRepo();
             using (var repo = new Repository(path))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Checkout("head"));
+                Assert.Throws<NotFoundException>(() => repo.Checkout("head"));
             }
         }
 
diff --git a/LibGit2Sharp.Tests/CommitFixture.cs b/LibGit2Sharp.Tests/CommitFixture.cs
@@ -107,8 +107,8 @@ public void QueryingTheCommitHistoryWithUnknownShaOrInvalidEntryPointThrows()
             string path = SandboxBareTestRepo();
             using (var repo = new Repository(path))
             {
-                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());
             }
         }
@@ -121,8 +121,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 = SandboxBareTestRepo();
             using (var repo = new Repository(path))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Refs.Add(name, "master^42"));
+                Assert.Throws<NotFoundException>(() => repo.Refs.Add(name, "master^42"));
             }
         }
 
@@ -610,7 +610,7 @@ public void UpdatingADirectReferenceTargetWithARevparsePointingAtAnUnknownObject
             string path = SandboxBareTestRepo();
             using (var repo = new Repository(path))
             {
-                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/RepositoryFixture.cs b/LibGit2Sharp.Tests/RepositoryFixture.cs
@@ -493,6 +493,21 @@ public void LookingUpWithATooShortShaThrows()
             }
         }
 
+        [Fact]
+        public void LookingUpByAWrongRevParseExpressionThrows()
+        {
+            string path = SandboxBareTestRepo();
+            using (var repo = new Repository(path))
+            {
+                Assert.Throws<InvalidSpecificationException>(() => repo.Lookup("tags/point_to_blob^{tree}"));
+                Assert.Throws<InvalidSpecificationException>(() => repo.Lookup("tags/point_to_blob^{commit}"));
+                Assert.Throws<InvalidSpecificationException>(() => repo.Lookup<Commit>("tags/point_to_blob^{commit}"));
+                Assert.Throws<InvalidSpecificationException>(() => repo.Lookup("master^{tree}^{blob}"));
+                Assert.Throws<InvalidSpecificationException>(() => repo.Lookup<Blob>("master^{blob}"));
+                Assert.Throws<PeelException>(() => repo.Lookup<Blob>("tags/e90810b^{blob}"));
+            }
+        }
+
         [Fact]
         public void LookingUpAGitLinkThrows()
         {
diff --git a/LibGit2Sharp.Tests/ResetHeadFixture.cs b/LibGit2Sharp.Tests/ResetHeadFixture.cs
@@ -71,7 +71,7 @@ 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<NotFoundException>(() => repo.Reset(ResetMode.Soft, Constants.UnknownSha));
                 Assert.Throws<InvalidSpecificationException>(() => repo.Reset(ResetMode.Soft, repo.Head.Tip.Tree.Sha));
             }
         }
diff --git a/LibGit2Sharp.Tests/TagFixture.cs b/LibGit2Sharp.Tests/TagFixture.cs
@@ -258,7 +258,7 @@ public void CreatingATagForAnUnknowReferenceThrows()
             string path = SandboxBareTestRepo();
             using (var repo = new Repository(path))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.ApplyTag("mytagnorev", "aaaaaaaaaaa"));
+                Assert.Throws<NotFoundException>(() => repo.ApplyTag("mytagnorev", "aaaaaaaaaaa"));
             }
         }
 
@@ -269,7 +269,7 @@ public void CreatingATagForAnUnknowObjectIdThrows()
             string path = SandboxBareTestRepo();
             using (var repo = new Repository(path))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.ApplyTag("mytagnorev", Constants.UnknownSha));
+                Assert.Throws<NotFoundException>(() => repo.ApplyTag("mytagnorev", Constants.UnknownSha));
             }
         }
 
@@ -507,7 +507,7 @@ public void AddTagWithNotExistingTargetThrows()
             string path = SandboxBareTestRepo();
             using (var repo = new Repository(path))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Tags.Add("test_tag", Constants.UnknownSha, signatureTim, "message"));
+                Assert.Throws<NotFoundException>(() => repo.Tags.Add("test_tag", Constants.UnknownSha, signatureTim, "message"));
             }
         }
 
@@ -623,7 +623,7 @@ public void RemovingAnUnknownTagShouldFail()
             string path = SandboxBareTestRepo();
             using (var repo = new Repository(path))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Tags.Remove("unknown-tag"));
+                Assert.Throws<NotFoundException>(() => repo.Tags.Remove("unknown-tag"));
             }
         }
 
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.Peel, (m, r, c) => new PeelException(m, r, c)  },
                 };
 
         private static void HandleError(int result)
@@ -215,7 +217,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/InvalidSpecificationException.cs b/LibGit2Sharp/InvalidSpecificationException.cs
@@ -5,7 +5,10 @@
 namespace LibGit2Sharp
 {
     /// <summary>
-    /// The exception that is thrown when the provided specification is syntactically incorrect.
+    /// The exception that is thrown when a provided specification is bad. This
+    /// can happen if the provided specification is syntactically incorrect, or
+    /// if the spec refers to an object of an incorrect type (e.g. asking to
+    /// create a branch from a blob, or peeling a blob to a commit).
     /// </summary>
     [Serializable]
     public class InvalidSpecificationException : LibGit2SharpException
diff --git a/LibGit2Sharp/LibGit2Sharp.csproj b/LibGit2Sharp/LibGit2Sharp.csproj
@@ -98,6 +98,7 @@
     <Compile Include="GitObjectMetadata.cs" />
     <Compile Include="PatchEntryChanges.cs" />
     <Compile Include="PatchStats.cs" />
+    <Compile Include="PeelException.cs" />
     <Compile Include="PullOptions.cs" />
     <Compile Include="RefSpec.cs" />
     <Compile Include="RefSpecCollection.cs" />
diff --git a/LibGit2Sharp/PeelException.cs b/LibGit2Sharp/PeelException.cs
@@ -0,0 +1,55 @@
+using System;
+using System.Runtime.Serialization;
+using LibGit2Sharp.Core;
+
+namespace LibGit2Sharp
+{
+    /// <summary>
+    /// The exception that is thrown when a tag cannot be peeled to the
+    /// target type due to the object model.
+    /// </summary>
+    [Serializable]
+    public class PeelException : LibGit2SharpException
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PeelException"/> class.
+        /// </summary>
+        public PeelException()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PeelException"/> class with a specified error message.
+        /// </summary>
+        /// <param name="message">A message that describes the error.</param>
+        public PeelException(string message)
+            : base(message)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PeelException"/> 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 PeelException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PeelException"/> 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 PeelException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+        }
+
+        internal PeelException(string message, GitErrorCode code, GitErrorCategory category)
+            : base(message, code, category)
+        {
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ public void CanBlameFromADifferentCommit()`
`36`	`36`	`using (var repo = new Repository(path))`
`37`	`37`	`{`
`38`	`38`	`// File doesn't exist at HEAD`
`39`		`- Assert.Throws<LibGit2SharpException>(() => repo.Blame("ancestor-only.txt"));`
	`39`	`+ Assert.Throws<NotFoundException>(() => repo.Blame("ancestor-only.txt"));`
`40`	`40`
`41`	`41`	`var blame = repo.Blame("ancestor-only.txt", new BlameOptions { StartingAt = "9107b30" });`
`42`	`42`	`Assert.Equal(1, blame.Count());`
Original file line number	Diff line number	Diff line change
`@@ -254,7 +254,7 @@ public void CreatingBranchWithUnknownNamedTargetThrows()`
`254`	`254`	`string path = SandboxBareTestRepo();`
`255`	`255`	`using (var repo = new Repository(path))`
`256`	`256`	`{`
`257`		`- Assert.Throws<LibGit2SharpException>(() => repo.Branches.Add("my_new_branch", "my_old_branch"));`
	`257`	`+ Assert.Throws<NotFoundException>(() => repo.Branches.Add("my_new_branch", "my_old_branch"));`
`258`	`258`	`}`
`259`	`259`	`}`
`260`	`260`
`@@ -264,8 +264,8 @@ public void CreatingBranchWithUnknownShaTargetThrows()`
`264`	`264`	`string path = SandboxBareTestRepo();`
`265`	`265`	`using (var repo = new Repository(path))`
`266`	`266`	`{`
`267`		`- Assert.Throws<LibGit2SharpException>(() => repo.Branches.Add("my_new_branch", Constants.UnknownSha));`
`268`		`- Assert.Throws<LibGit2SharpException>(() => repo.Branches.Add("my_new_branch", Constants.UnknownSha.Substring(0, 7)));`
	`267`	`+ Assert.Throws<NotFoundException>(() => repo.Branches.Add("my_new_branch", Constants.UnknownSha));`
	`268`	`+ Assert.Throws<NotFoundException>(() => repo.Branches.Add("my_new_branch", Constants.UnknownSha.Substring(0, 7)));`
`269`	`269`	`}`
`270`	`270`	`}`
`271`	`271`
`@@ -729,7 +729,7 @@ public void SetTrackedBranchForUnreasolvableRemoteThrows()`
`729`	`729`
`730`	`730`	`Branch trackedBranch = repo.Branches[trackedBranchName];`
`731`	`731`
`732`		`- Assert.Throws<LibGit2SharpException>(() => repo.Branches.Update(branch,`
	`732`	`+ Assert.Throws<NotFoundException>(() => repo.Branches.Update(branch,`
`733`	`733`	`b => b.TrackedBranch = trackedBranch.CanonicalName));`
`734`	`734`	`}`
`735`	`735`	`}`
Original file line number	Diff line number	Diff line change
`@@ -383,7 +383,7 @@ public void CheckingOutANonExistingBranchThrows()`
`383`	`383`	`string path = SandboxBareTestRepo();`
`384`	`384`	`using (var repo = new Repository(path))`
`385`	`385`	`{`
`386`		`- Assert.Throws<LibGit2SharpException>(() => repo.Checkout("i-do-not-exist"));`
	`386`	`+ Assert.Throws<NotFoundException>(() => repo.Checkout("i-do-not-exist"));`
`387`	`387`	`}`
`388`	`388`	`}`
`389`	`389`
`@@ -895,7 +895,7 @@ public void CheckoutLowerCasedHeadThrows()`
`895`	`895`	`string path = SandboxStandardTestRepo();`
`896`	`896`	`using (var repo = new Repository(path))`
`897`	`897`	`{`
`898`		`- Assert.Throws<LibGit2SharpException>(() => repo.Checkout("head"));`
	`898`	`+ Assert.Throws<NotFoundException>(() => repo.Checkout("head"));`
`899`	`899`	`}`
`900`	`900`	`}`
`901`	`901`
Original file line number	Diff line number	Diff line change
`@@ -107,8 +107,8 @@ public void QueryingTheCommitHistoryWithUnknownShaOrInvalidEntryPointThrows()`
`107`	`107`	`string path = SandboxBareTestRepo();`
`108`	`108`	`using (var repo = new Repository(path))`
`109`	`109`	`{`
`110`		`- Assert.Throws<LibGit2SharpException>(() => repo.Commits.QueryBy(new CommitFilter { Since = Constants.UnknownSha }).Count());`
`111`		`- Assert.Throws<LibGit2SharpException>(() => repo.Commits.QueryBy(new CommitFilter { Since = "refs/heads/deadbeef" }).Count());`
	`110`	`+ Assert.Throws<NotFoundException>(() => repo.Commits.QueryBy(new CommitFilter { Since = Constants.UnknownSha }).Count());`
	`111`	`+ Assert.Throws<NotFoundException>(() => repo.Commits.QueryBy(new CommitFilter { Since = "refs/heads/deadbeef" }).Count());`
`112`	`112`	`Assert.Throws<ArgumentNullException>(() => repo.Commits.QueryBy(new CommitFilter { Since = null }).Count());`
`113`	`113`	`}`
`114`	`114`	`}`
`@@ -121,8 +121,8 @@ public void QueryingTheCommitHistoryFromACorruptedReferenceThrows()`
`121`	`121`	`{`
`122`	`122`	`CreateCorruptedDeadBeefHead(repo.Info.Path);`
`123`	`123`
`124`		`- Assert.Throws<LibGit2SharpException>(() => repo.Commits.QueryBy(new CommitFilter { Since = repo.Branches["deadbeef"] }).Count());`
`125`		`- Assert.Throws<LibGit2SharpException>(() => repo.Commits.QueryBy(new CommitFilter { Since = repo.Refs["refs/heads/deadbeef"] }).Count());`
	`124`	`+ Assert.Throws<NotFoundException>(() => repo.Commits.QueryBy(new CommitFilter { Since = repo.Branches["deadbeef"] }).Count());`
	`125`	`+ Assert.Throws<NotFoundException>(() => repo.Commits.QueryBy(new CommitFilter { Since = repo.Refs["refs/heads/deadbeef"] }).Count());`
`126`	`126`	`}`
`127`	`127`	`}`
`128`	`128`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ public void CreatingADirectReferenceWithARevparseSpecPointingAtAnUnknownObjectFa`
`73`	`73`	`string path = SandboxBareTestRepo();`
`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`
`@@ -610,7 +610,7 @@ public void UpdatingADirectReferenceTargetWithARevparsePointingAtAnUnknownObject`
`610`	`610`	`string path = SandboxBareTestRepo();`
`611`	`611`	`using (var repo = new Repository(path))`
`612`	`612`	`{`
`613`		`- Assert.Throws<LibGit2SharpException>(() => repo.Refs.UpdateTarget(repo.Refs["refs/heads/master"], "refs/heads/nope"));`
	`613`	`+ Assert.Throws<NotFoundException>(() => repo.Refs.UpdateTarget(repo.Refs["refs/heads/master"], "refs/heads/nope"));`
`614`	`614`	`}`
`615`	`615`	`}`
`616`	`616`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ public void ResettingWithBadParamsThrows()`
`71`	`71`	`Assert.Throws<ArgumentNullException>(() => repo.Reset(ResetMode.Soft, (string)null));`
`72`	`72`	`Assert.Throws<ArgumentNullException>(() => repo.Reset(ResetMode.Soft, (Commit)null));`
`73`	`73`	`Assert.Throws<ArgumentException>(() => repo.Reset(ResetMode.Soft, ""));`
`74`		`- Assert.Throws<LibGit2SharpException>(() => repo.Reset(ResetMode.Soft, Constants.UnknownSha));`
	`74`	`+ Assert.Throws<NotFoundException>(() => repo.Reset(ResetMode.Soft, Constants.UnknownSha));`
`75`	`75`	`Assert.Throws<InvalidSpecificationException>(() => repo.Reset(ResetMode.Soft, repo.Head.Tip.Tree.Sha));`
`76`	`76`	`}`
`77`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -258,7 +258,7 @@ public void CreatingATagForAnUnknowReferenceThrows()`
`258`	`258`	`string path = SandboxBareTestRepo();`
`259`	`259`	`using (var repo = new Repository(path))`
`260`	`260`	`{`
`261`		`- Assert.Throws<LibGit2SharpException>(() => repo.ApplyTag("mytagnorev", "aaaaaaaaaaa"));`
	`261`	`+ Assert.Throws<NotFoundException>(() => repo.ApplyTag("mytagnorev", "aaaaaaaaaaa"));`
`262`	`262`	`}`
`263`	`263`	`}`
`264`	`264`
`@@ -269,7 +269,7 @@ public void CreatingATagForAnUnknowObjectIdThrows()`
`269`	`269`	`string path = SandboxBareTestRepo();`
`270`	`270`	`using (var repo = new Repository(path))`
`271`	`271`	`{`
`272`		`- Assert.Throws<LibGit2SharpException>(() => repo.ApplyTag("mytagnorev", Constants.UnknownSha));`
	`272`	`+ Assert.Throws<NotFoundException>(() => repo.ApplyTag("mytagnorev", Constants.UnknownSha));`
`273`	`273`	`}`
`274`	`274`	`}`
`275`	`275`
`@@ -507,7 +507,7 @@ public void AddTagWithNotExistingTargetThrows()`
`507`	`507`	`string path = SandboxBareTestRepo();`
`508`	`508`	`using (var repo = new Repository(path))`
`509`	`509`	`{`
`510`		`- Assert.Throws<LibGit2SharpException>(() => repo.Tags.Add("test_tag", Constants.UnknownSha, signatureTim, "message"));`
	`510`	`+ Assert.Throws<NotFoundException>(() => repo.Tags.Add("test_tag", Constants.UnknownSha, signatureTim, "message"));`
`511`	`511`	`}`
`512`	`512`	`}`
`513`	`513`
`@@ -623,7 +623,7 @@ public void RemovingAnUnknownTagShouldFail()`
`623`	`623`	`string path = SandboxBareTestRepo();`
`624`	`624`	`using (var repo = new Repository(path))`
`625`	`625`	`{`
`626`		`- Assert.Throws<LibGit2SharpException>(() => repo.Tags.Remove("unknown-tag"));`
	`626`	`+ Assert.Throws<NotFoundException>(() => repo.Tags.Remove("unknown-tag"));`
`627`	`627`	`}`
`628`	`628`	`}`
`629`	`629`
Original file line number	Diff line number	Diff line change
`@@ -100,6 +100,8 @@ private static readonly Dictionary<GitErrorCode, Func<string, GitErrorCode, GitE`
`100`	`100`	`{ GitErrorCode.NonFastForward, (m, r, c) => new NonFastForwardException(m, r, c) },`
`101`	`101`	`{ GitErrorCode.MergeConflict, (m, r, c) => new MergeConflictException(m, r, c) },`
`102`	`102`	`{ GitErrorCode.LockedFile, (m, r, c) => new LockedFileException(m, r, c) },`
	`103`	`+ { GitErrorCode.NotFound, (m, r, c) => new NotFoundException(m, r, c) },`
	`104`	`+ { GitErrorCode.Peel, (m, r, c) => new PeelException(m, r, c) },`
`103`	`105`	`};`
`104`	`106`
`105`	`107`	`private static void HandleError(int result)`
`@@ -215,7 +217,7 @@ public static void GitObjectIsNotNull(GitObject gitObject, string identifier)`
`215`	`217`	`}`
`216`	`218`	`else`
`217`	`219`	`{`
`218`		`- exceptionBuilder = m => new LibGit2SharpException(m);`
	`220`	`+ exceptionBuilder = m => new NotFoundException(m);`
`219`	`221`	`}`
`220`	`222`
`221`	`223`	`GitObjectIsNotNull(gitObject, identifier, exceptionBuilder);`