public void CanCompareTheWorkDirAgainstTheIndexWithLaxUnmatchedExplicitPathsValidation(string relativePath, FileStatus currentStatus) { using (var repo = new Repository(StandardTestRepoPath)) { Assert.Equal(currentStatus, repo.Index.RetrieveStatus(relativePath)); TreeChanges changes = repo.Diff.Compare(new[] { relativePath }, false, new ExplicitPathsOptions { ShouldFailOnUnmatchedPath = false }); Assert.Equal(0, changes.Count()); changes = repo.Diff.Compare(new[] { relativePath }); Assert.Equal(0, changes.Count()); } }
public void CanNotDetectTheExactCopyingOfModifiedFilesWhenNotEnabled() { SelfCleaningDirectory scd = BuildSelfCleaningDirectory(); var path = Repository.Init(scd.DirectoryPath); using (var repo = new Repository(path)) { const string originalPath = "original.txt"; const string copiedPath = "copied.txt"; string originalFullPath = Path.Combine(repo.Info.WorkingDirectory, originalPath); string copiedFullPath = Path.Combine(repo.Info.WorkingDirectory, copiedPath); Touch(repo.Info.WorkingDirectory, originalPath, "a\nb\nc\nd\n"); repo.Index.Stage(originalPath); Commit old = repo.Commit("Initial", Constants.Signature, Constants.Signature); File.Copy(originalFullPath, copiedFullPath); File.AppendAllText(originalFullPath, "e\n"); repo.Index.Stage(originalPath); repo.Index.Stage(copiedPath); Commit @new = repo.Commit("Updated", Constants.Signature, Constants.Signature); TreeChanges changes = repo.Diff.Compare <TreeChanges>(old.Tree, @new.Tree); Assert.Equal(2, changes.Count()); Assert.Equal(0, changes.Copied.Count()); } }
public void CanCompareTwoVersionsOfAFileWithADiffOfTwoHunks(int contextLines, int interhunkLines) { var compareOptions = new CompareOptions { ContextLines = contextLines, InterhunkLines = interhunkLines, }; using (var repo = new Repository(StandardTestRepoPath)) { Tree rootCommitTree = repo.Lookup <Commit>("f8d44d7").Tree; Tree mergedCommitTree = repo.Lookup <Commit>("7252fe2").Tree; TreeChanges changes = repo.Diff.Compare(rootCommitTree, mergedCommitTree, compareOptions: compareOptions); Assert.Equal(3, changes.Count()); Assert.Equal(1, changes.Modified.Count()); Assert.Equal(1, changes.Deleted.Count()); Assert.Equal(1, changes.Added.Count()); TreeEntryChanges treeEntryChanges = changes["numbers.txt"]; Assert.Equal(3, treeEntryChanges.LinesAdded); Assert.Equal(1, treeEntryChanges.LinesDeleted); Assert.Equal(Mode.Nonexistent, changes["my-name-does-not-feel-right.txt"].Mode); Assert.Equal(Expected("f8d44d7...7252fe2/numbers.txt-{0}-{1}.diff", contextLines, interhunkLines), treeEntryChanges.Patch); Assert.Equal(Expected("f8d44d7...7252fe2/full-{0}-{1}.diff", contextLines, interhunkLines), changes.Patch); } }
public void CanIncludeUnmodifiedEntriesWhenEnabled() { SelfCleaningDirectory scd = BuildSelfCleaningDirectory(); var path = Repository.Init(scd.DirectoryPath); using (var repo = new Repository(path)) { Touch(repo.Info.WorkingDirectory, "a.txt", "abc\ndef\n"); Touch(repo.Info.WorkingDirectory, "b.txt", "abc\ndef\n"); repo.Index.Stage(new[] { "a.txt", "b.txt" }); Commit old = repo.Commit("Initial", Constants.Signature, Constants.Signature); File.AppendAllText(Path.Combine(repo.Info.WorkingDirectory, "b.txt"), "ghi\njkl\n"); repo.Index.Stage("b.txt"); Commit @new = repo.Commit("Updated", Constants.Signature, Constants.Signature); TreeChanges changes = repo.Diff.Compare <TreeChanges>(old.Tree, @new.Tree, compareOptions: new CompareOptions { IncludeUnmodified = true }); Assert.Equal(2, changes.Count()); Assert.Equal(1, changes.Unmodified.Count()); Assert.Equal(1, changes.Modified.Count()); } }
public void CanNotDetectTheExactRenamingFilesWhenNotEnabled() { SelfCleaningDirectory scd = BuildSelfCleaningDirectory(); var path = Repository.Init(scd.DirectoryPath); using (var repo = new Repository(path)) { const string originalPath = "original.txt"; const string renamedPath = "renamed.txt"; Touch(repo.Info.WorkingDirectory, originalPath, "a\nb\nc\nd\n"); repo.Index.Stage(originalPath); Commit old = repo.Commit("Initial", Constants.Signature, Constants.Signature); repo.Index.Move(originalPath, renamedPath); Commit @new = repo.Commit("Updated", Constants.Signature, Constants.Signature); TreeChanges changes = repo.Diff.Compare <TreeChanges>(old.Tree, @new.Tree, compareOptions: new CompareOptions { Similarity = SimilarityOptions.None, }); Assert.Equal(2, changes.Count()); Assert.Equal(0, changes.Renamed.Count()); } }
public void ExactModeDoesntDetectRenamesWithEdits() { SelfCleaningDirectory scd = BuildSelfCleaningDirectory(); var path = Repository.Init(scd.DirectoryPath); using (var repo = new Repository(path)) { const string originalPath = "original.txt"; const string renamedPath = "renamed.txt"; Touch(repo.Info.WorkingDirectory, originalPath, "a\nb\nc\nd\n"); repo.Index.Stage(originalPath); Commit old = repo.Commit("Initial", Constants.Signature, Constants.Signature); repo.Index.Move(originalPath, renamedPath); File.AppendAllText(Path.Combine(repo.Info.WorkingDirectory, renamedPath), "e\nf\n"); repo.Index.Stage(renamedPath); Commit @new = repo.Commit("Updated", Constants.Signature, Constants.Signature); TreeChanges changes = repo.Diff.Compare <TreeChanges>(old.Tree, @new.Tree, compareOptions: new CompareOptions { Similarity = SimilarityOptions.Exact, }); Assert.Equal(2, changes.Count()); Assert.Equal(0, changes.Renamed.Count()); Assert.Equal(1, changes.Added.Count()); Assert.Equal(1, changes.Deleted.Count()); } }
public void ExactModeDetectsExactCopies() { SelfCleaningDirectory scd = BuildSelfCleaningDirectory(); var path = Repository.Init(scd.DirectoryPath); using (var repo = new Repository(path)) { const string originalPath = "original.txt"; const string copiedPath = "copied.txt"; var originalFullPath = Path.Combine(repo.Info.WorkingDirectory, originalPath); var copiedFullPath = Path.Combine(repo.Info.WorkingDirectory, copiedPath); Touch(repo.Info.WorkingDirectory, originalPath, "a\nb\nc\nd\n"); repo.Index.Stage(originalPath); Commit old = repo.Commit("Initial", Constants.Signature, Constants.Signature); File.Copy(originalFullPath, copiedFullPath); repo.Index.Stage(copiedPath); Commit @new = repo.Commit("Updated", Constants.Signature, Constants.Signature); TreeChanges changes = repo.Diff.Compare <TreeChanges>(old.Tree, @new.Tree, compareOptions: new CompareOptions { Similarity = SimilarityOptions.Exact, }); Assert.Equal(1, changes.Count()); Assert.Equal(1, changes.Copied.Count()); } }
public void DetectsTheExactRenamingOfFilesByDefault() { SelfCleaningDirectory scd = BuildSelfCleaningDirectory(); var path = Repository.Init(scd.DirectoryPath); using (var repo = new Repository(path)) { const string originalPath = "original.txt"; const string renamedPath = "renamed.txt"; Touch(repo.Info.WorkingDirectory, originalPath, "a\nb\nc\nd\n"); repo.Index.Stage(originalPath); Commit old = repo.Commit("Initial", Constants.Signature, Constants.Signature); repo.Index.Move(originalPath, renamedPath); Commit @new = repo.Commit("Updated", Constants.Signature, Constants.Signature); TreeChanges changes = repo.Diff.Compare <TreeChanges>(old.Tree, @new.Tree); Assert.Equal(1, changes.Count()); Assert.Equal(1, changes.Renamed.Count()); Assert.Equal("original.txt", changes.Renamed.Single().OldPath); Assert.Equal("renamed.txt", changes.Renamed.Single().Path); } }
public void CanDetectTheExactRenamingExactCopyingOfNonModifiedAndModifiedFilesWhenEnabled() { SelfCleaningDirectory scd = BuildSelfCleaningDirectory(); var path = Repository.Init(scd.DirectoryPath); using (var repo = new Repository(path)) { const string originalPath = "original.txt"; const string renamedPath = "renamed.txt"; const string originalPath2 = "original2.txt"; const string copiedPath1 = "copied.txt"; const string originalPath3 = "original3.txt"; const string copiedPath2 = "copied2.txt"; Touch(repo.Info.WorkingDirectory, originalPath, "a\nb\nc\nd\n"); Touch(repo.Info.WorkingDirectory, originalPath2, "1\n2\n3\n4\n"); Touch(repo.Info.WorkingDirectory, originalPath3, "5\n6\n7\n8\n"); repo.Index.Stage(originalPath); repo.Index.Stage(originalPath2); repo.Index.Stage(originalPath3); Commit old = repo.Commit("Initial", Constants.Signature, Constants.Signature); var originalFullPath2 = Path.Combine(repo.Info.WorkingDirectory, originalPath2); var originalFullPath3 = Path.Combine(repo.Info.WorkingDirectory, originalPath3); var copiedFullPath1 = Path.Combine(repo.Info.WorkingDirectory, copiedPath1); var copiedFullPath2 = Path.Combine(repo.Info.WorkingDirectory, copiedPath2); File.Copy(originalFullPath2, copiedFullPath1); File.Copy(originalFullPath3, copiedFullPath2); File.AppendAllText(originalFullPath3, "9\n"); repo.Index.Stage(originalPath3); repo.Index.Stage(copiedPath1); repo.Index.Stage(copiedPath2); repo.Index.Move(originalPath, renamedPath); Commit @new = repo.Commit("Updated", Constants.Signature, Constants.Signature); TreeChanges changes = repo.Diff.Compare <TreeChanges>(old.Tree, @new.Tree, compareOptions: new CompareOptions { Similarity = SimilarityOptions.CopiesHarder, }); Assert.Equal(4, changes.Count()); Assert.Equal(1, changes.Modified.Count()); Assert.Equal(1, changes.Renamed.Count()); Assert.Equal("original.txt", changes.Renamed.Single().OldPath); Assert.Equal("renamed.txt", changes.Renamed.Single().Path); Assert.Equal(2, changes.Copied.Count()); Assert.Equal("original2.txt", changes.Copied.ElementAt(0).OldPath); Assert.Equal("copied.txt", changes.Copied.ElementAt(0).Path); Assert.Equal("original3.txt", changes.Copied.ElementAt(1).OldPath); Assert.Equal("copied2.txt", changes.Copied.ElementAt(1).Path); } }
public void CanCompareATreeAgainstAnotherTreeWithLaxExplicitPathsValidationAndNonExistentPath() { using (var repo = new Repository(StandardTestRepoPath)) { Tree commitTree = repo.Head.Tip.Tree; Tree commitTreeWithDifferentAncestor = repo.Branches["refs/remotes/origin/test"].Tip.Tree; TreeChanges changes = repo.Diff.Compare(commitTreeWithDifferentAncestor, commitTree, new[] { "if-I-exist-this-test-is-really-unlucky.txt" }, new ExplicitPathsOptions { ShouldFailOnUnmatchedPath = false }); Assert.Equal(0, changes.Count()); changes = repo.Diff.Compare(commitTreeWithDifferentAncestor, commitTree, new[] { "if-I-exist-this-test-is-really-unlucky.txt" }); Assert.Equal(0, changes.Count()); } }
public void ComparingTwoNullTreesReturnsAnEmptyTreeChanges() { using (var repo = new Repository(StandardTestRepoPath)) { TreeChanges changes = repo.Diff.Compare(null, null, null); Assert.Equal(0, changes.Count()); } }
public void CanCompareTheWorkDirAgainstTheIndex() { using (var repo = new Repository(StandardTestRepoPath)) { TreeChanges changes = repo.Diff.Compare(); Assert.Equal(2, changes.Count()); Assert.Equal("deleted_unstaged_file.txt", changes.Deleted.Single().Path); Assert.Equal("modified_unstaged_file.txt", changes.Modified.Single().Path); } }
public void CanCompareATreeAgainstANullTree() { using (var repo = new Repository(StandardTestRepoPath)) { Tree tree = repo.Branches["refs/remotes/origin/test"].Tip.Tree; TreeChanges changes = repo.Diff.Compare(tree, null); Assert.Equal(1, changes.Count()); Assert.Equal(1, changes.Deleted.Count()); Assert.Equal("readme.txt", changes.Deleted.Single().Path); changes = repo.Diff.Compare(null, tree); Assert.Equal(1, changes.Count()); Assert.Equal(1, changes.Added.Count()); Assert.Equal("readme.txt", changes.Added.Single().Path); } }
private void CheckOnline(bool silent = false) { // Is remote on in the config if (cfg["UseGitRemote"]) { // Check if the remote is there if (IsGITAlive(cfg["GitRemote"]) || IsHTTPSAlive(cfg["GitRemote"])) { // looks good, let's try GITRepoOffline = false; } // Do a fetch to get the latest repo. if (!GitFetch()) { // nope not online GITRepoOffline = true; MessageBox.Show(Strings.Error_connection, Strings.Error, MessageBoxButtons.OK, MessageBoxIcon.Error); } else { // We're online toolStripOffline.Visible = false; // look if we have changes we should sync using (var repo = new LibGit2Sharp.Repository(cfg["PassDirectory"])) { TreeChanges tc = repo.Diff.Compare <TreeChanges>(repo.Branches["origin/master"].Tip.Tree, repo.Head.Tip.Tree); if (tc.Count() > 0) { var remote = repo.Network.Remotes["origin"]; var options = new PushOptions(); options.CredentialsProvider = (_url, _user, _cred) => new UsernamePasswordCredentials { Username = cfg["GitUser"], Password = DecryptConfig(cfg["GitPass"], "pass4win") }; var pushRefSpec = @"refs/heads/master"; repo.Network.Push(remote, pushRefSpec, options); } } } } else { // no remote checkbox so we're staying offline if (!silent) { MessageBox.Show(Strings.Error_remote_disabled, Strings.Error, MessageBoxButtons.OK, MessageBoxIcon.Error); } } }
public void CanCompareASubsetofTheTreeAgainstOneOfItsAncestor() { using (var repo = new Repository(StandardTestRepoPath)) { Tree tree = repo.Head.Tip.Tree; Tree ancestor = repo.Lookup <Commit>("9fd738e").Tree; TreeChanges changes = repo.Diff.Compare(ancestor, tree, new[] { "1", "2/" }); Assert.NotNull(changes); Assert.Equal(1, changes.Count()); Assert.Equal(subBranchFilePath, changes.Added.Single().Path); } }
public void CanCompareAMoreComplexTreeAgainstTheIndex() { using (var repo = new Repository(StandardTestRepoPath)) { Tree tree = repo.Head.Tip.Tree; TreeChanges changes = repo.Diff.Compare(tree, DiffTarget.Index); Assert.NotNull(changes); Assert.Equal(3, changes.Count()); Assert.Equal("deleted_staged_file.txt", changes.Deleted.Single().Path); Assert.Equal("new_tracked_file.txt", changes.Added.Single().Path); Assert.Equal("modified_staged_file.txt", changes.Modified.Single().Path); } }
public void CanCompareASubsetofTheTreeAgainstTheIndex() { using (var repo = new Repository(StandardTestRepoPath)) { Tree tree = repo.Head.Tip.Tree; TreeChanges changes = repo.Diff.Compare(tree, DiffTargets.Index, new[] { "deleted_staged_file.txt", "1/branch_file.txt" }); Assert.NotNull(changes); Assert.Equal(1, changes.Count()); Assert.Equal("deleted_staged_file.txt", changes.Deleted.Single().Path); } }
public void CanDetectTheRenamingOfAModifiedFile() { using (var repo = new Repository(StandardTestRepoPath)) { Tree rootCommitTree = repo.Lookup <Commit>("f8d44d7").Tree; Tree commitTreeWithRenamedFile = repo.Lookup <Commit>("4be51d6").Tree; TreeChanges changes = repo.Diff.Compare(rootCommitTree, commitTreeWithRenamedFile); Assert.Equal(1, changes.Count()); Assert.Equal("super-file.txt", changes["super-file.txt"].Path); Assert.Equal("my-name-does-not-feel-right.txt", changes["super-file.txt"].OldPath); //Assert.Equal(1, changes.FilesRenamed.Count()); } }
public void CanCompareANullTreeAgainstTheWorkdirAndTheIndex() { var scd = BuildSelfCleaningDirectory(); using (var repo = Repository.Init(scd.RootedDirectoryPath)) { SetUpSimpleDiffContext(repo); TreeChanges changes = repo.Diff.Compare(null, DiffTargets.WorkingDirectory | DiffTargets.Index); Assert.Equal(1, changes.Count()); Assert.Equal(1, changes.Added.Count()); Assert.Equal("file.txt", changes.Added.Single().Path); Assert.Equal(3, changes.Added.Single().LinesAdded); } }
public void CanCompareANullTreeAgainstTheWorkdirAndTheIndex() { string repoPath = InitNewRepository(); using (var repo = new Repository(repoPath)) { SetUpSimpleDiffContext(repo); TreeChanges changes = repo.Diff.Compare(null, DiffTargets.WorkingDirectory | DiffTargets.Index); Assert.Equal(1, changes.Count()); Assert.Equal(1, changes.Added.Count()); Assert.Equal("file.txt", changes.Added.Single().Path); Assert.Equal(3, changes.Added.Single().LinesAdded); } }
public void CanCompareTwoVersionsOfAFileWithATrailingNewlineDeletion() { using (var repo = new Repository(StandardTestRepoPath)) { Tree rootCommitTree = repo.Lookup <Commit>("f8d44d7").Tree; Tree commitTreeWithUpdatedFile = repo.Lookup <Commit>("ec9e401").Tree; TreeChanges changes = repo.Diff.Compare(rootCommitTree, commitTreeWithUpdatedFile); Assert.Equal(1, changes.Count()); Assert.Equal(1, changes.Modified.Count()); TreeEntryChanges treeEntryChanges = changes.Modified.Single(); Assert.Equal(2, treeEntryChanges.LinesAdded); Assert.Equal(1, treeEntryChanges.LinesDeleted); } }
public void ComparingReliesOnProvidedConfigEntriesIfAny() { TemporaryCloneOfTestRepo path = BuildTemporaryCloneOfTestRepo(StandardTestRepoWorkingDirPath); const string file = "1/branch_file.txt"; using (var repo = new Repository(path.DirectoryPath)) { TreeEntry entry = repo.Head[file]; Assert.Equal(Mode.ExecutableFile, entry.Mode); // Recreate the file in the workdir without the executable bit string fullpath = Path.Combine(repo.Info.WorkingDirectory, file); File.Delete(fullpath); File.WriteAllBytes(fullpath, ((Blob)(entry.Target)).Content); // Unset the local core.filemode, if any. repo.Config.Unset("core.filemode", ConfigurationLevel.Local); } SelfCleaningDirectory scd = BuildSelfCleaningDirectory(); var options = BuildFakeSystemConfigFilemodeOption(scd, true); using (var repo = new Repository(path.DirectoryPath, options)) { TreeChanges changes = repo.Diff.Compare(new [] { file }); Assert.Equal(1, changes.Count()); var change = changes.Modified.Single(); Assert.Equal(Mode.ExecutableFile, change.OldMode); Assert.Equal(Mode.NonExecutableFile, change.Mode); } options = BuildFakeSystemConfigFilemodeOption(scd, false); using (var repo = new Repository(path.DirectoryPath, options)) { TreeChanges changes = repo.Diff.Compare(new[] { file }); Assert.Equal(0, changes.Count()); } }
public void CanCompareAMoreComplexTreeAgainstTheWorkdir() { using (var repo = new Repository(StandardTestRepoPath)) { Tree tree = repo.Head.Tip.Tree; TreeChanges changes = repo.Diff.Compare(tree, DiffTargets.WorkingDirectory); Assert.NotNull(changes); Assert.Equal(6, changes.Count()); Assert.Equal(new[] { "deleted_staged_file.txt", "deleted_unstaged_file.txt" }, changes.Deleted.Select(tec => tec.Path)); Assert.Equal(new[] { "new_tracked_file.txt", "new_untracked_file.txt" }, changes.Added.Select(tec => tec.Path)); Assert.Equal(new[] { "modified_staged_file.txt", "modified_unstaged_file.txt" }, changes.Modified.Select(tec => tec.Path)); } }
public void CanCompareACommitTreeAgainstATreeWithNoCommonAncestor() { using (var repo = new Repository(StandardTestRepoPath)) { Tree commitTree = repo.Head.Tip.Tree; Tree commitTreeWithDifferentAncestor = repo.Branches["refs/remotes/origin/test"].Tip.Tree; TreeChanges changes = repo.Diff.Compare(commitTreeWithDifferentAncestor, commitTree); Assert.Equal(10, changes.Count()); Assert.Equal(9, changes.Added.Count()); Assert.Equal(1, changes.Deleted.Count()); Assert.Equal("readme.txt", changes.Deleted.Single().Path); Assert.Equal(new[] { "1.txt", subBranchFilePath, "README", "branch_file.txt", "deleted_staged_file.txt", "deleted_unstaged_file.txt", "modified_staged_file.txt", "modified_unstaged_file.txt", "new.txt" }, changes.Added.Select(x => x.Path).OrderBy(p => p, StringComparer.Ordinal).ToArray()); Assert.Equal(9, changes.LinesAdded); Assert.Equal(2, changes.LinesDeleted); Assert.Equal(2, changes["readme.txt"].LinesDeleted); } }
public void CanIncludeUnmodifiedEntriesWhenDetectingTheExactRenamingOfFilesWhenEnabled() { SelfCleaningDirectory scd = BuildSelfCleaningDirectory(); var path = Repository.Init(scd.DirectoryPath); using (var repo = new Repository(path)) { const string originalPath = "original.txt"; const string copiedPath = "copied.txt"; string originalFullPath = Path.Combine(repo.Info.WorkingDirectory, originalPath); string copiedFullPath = Path.Combine(repo.Info.WorkingDirectory, copiedPath); Touch(repo.Info.WorkingDirectory, originalPath, "a\nb\nc\nd\n"); repo.Index.Stage(originalPath); Commit old = repo.Commit("Initial", Constants.Signature, Constants.Signature); File.Copy(originalFullPath, copiedFullPath); repo.Index.Stage(copiedPath); Commit @new = repo.Commit("Updated", Constants.Signature, Constants.Signature); TreeChanges changes = repo.Diff.Compare <TreeChanges>(old.Tree, @new.Tree, compareOptions: new CompareOptions { Similarity = SimilarityOptions.CopiesHarder, IncludeUnmodified = true, }); Assert.Equal(2, changes.Count()); Assert.Equal(1, changes.Unmodified.Count()); Assert.Equal(1, changes.Copied.Count()); Assert.Equal("original.txt", changes.Copied.Single().OldPath); Assert.Equal("copied.txt", changes.Copied.Single().Path); } }
public void CanCompareACommitTreeAgainstItsParent() { using (var repo = new Repository(StandardTestRepoPath)) { Tree commitTree = repo.Head.Tip.Tree; Tree parentCommitTree = repo.Head.Tip.Parents.Single().Tree; TreeChanges changes = repo.Diff.Compare(parentCommitTree, commitTree); Assert.Equal(1, changes.Count()); Assert.Equal(1, changes.Added.Count()); TreeEntryChanges treeEntryChanges = changes["1.txt"]; Assert.False(treeEntryChanges.IsBinaryComparison); Assert.Equal("1.txt", treeEntryChanges.Path); Assert.Equal(ChangeKind.Added, treeEntryChanges.Status); Assert.Equal(treeEntryChanges, changes.Added.Single()); Assert.Equal(1, treeEntryChanges.LinesAdded); Assert.Equal(Mode.Nonexistent, treeEntryChanges.OldMode); } }
private static void AssertCanCompareASubsetOfTheTreeAgainstTheIndex(TreeChanges changes) { Assert.NotNull(changes); Assert.Equal(1, changes.Count()); Assert.Equal("deleted_staged_file.txt", changes.Deleted.Single().Path); }
public void CanCompareTwoVersionsOfAFileWithADiffOfTwoHunks() { using (var repo = new Repository(StandardTestRepoPath)) { Tree rootCommitTree = repo.Lookup <Commit>("f8d44d7").Tree; Tree mergedCommitTree = repo.Lookup <Commit>("7252fe2").Tree; TreeChanges changes = repo.Diff.Compare(rootCommitTree, mergedCommitTree); Assert.Equal(3, changes.Count()); Assert.Equal(1, changes.Modified.Count()); Assert.Equal(1, changes.Deleted.Count()); Assert.Equal(1, changes.Added.Count()); TreeEntryChanges treeEntryChanges = changes["numbers.txt"]; Assert.Equal(3, treeEntryChanges.LinesAdded); Assert.Equal(1, treeEntryChanges.LinesDeleted); Assert.Equal(Mode.Nonexistent, changes["my-name-does-not-feel-right.txt"].Mode); var expected = new StringBuilder() .Append("diff --git a/numbers.txt b/numbers.txt\n") .Append("index 7909961..4e935b7 100644\n") .Append("--- a/numbers.txt\n") .Append("+++ b/numbers.txt\n") .Append("@@ -1,4 +1,5 @@\n") .Append(" 1\n") .Append("+2\n") .Append(" 3\n") .Append(" 4\n") .Append(" 5\n") .Append("@@ -8,8 +9,9 @@\n") .Append(" 8\n") .Append(" 9\n") .Append(" 10\n") .Append("-12\n") .Append("+11\n") .Append(" 12\n") .Append(" 13\n") .Append(" 14\n") .Append(" 15\n") .Append("+16\n"); Assert.Equal(expected.ToString(), treeEntryChanges.Patch); expected = new StringBuilder() .Append("diff --git a/my-name-does-not-feel-right.txt b/my-name-does-not-feel-right.txt\n") .Append("deleted file mode 100644\n") .Append("index e8953ab..0000000\n") .Append("--- a/my-name-does-not-feel-right.txt\n") .Append("+++ /dev/null\n") .Append("@@ -1,4 +0,0 @@\n") .Append("-That's a terrible name!\n") .Append("-I don't like it.\n") .Append("-People look down at me and laugh. :-(\n") .Append("-Really!!!!\n") .Append("diff --git a/numbers.txt b/numbers.txt\n") .Append("index 7909961..4e935b7 100644\n") .Append("--- a/numbers.txt\n") .Append("+++ b/numbers.txt\n") .Append("@@ -1,4 +1,5 @@\n") .Append(" 1\n") .Append("+2\n") .Append(" 3\n") .Append(" 4\n") .Append(" 5\n") .Append("@@ -8,8 +9,9 @@\n") .Append(" 8\n") .Append(" 9\n") .Append(" 10\n") .Append("-12\n") .Append("+11\n") .Append(" 12\n") .Append(" 13\n") .Append(" 14\n") .Append(" 15\n") .Append("+16\n") .Append("diff --git a/super-file.txt b/super-file.txt\n") .Append("new file mode 100644\n") .Append("index 0000000..16bdf1d\n") .Append("--- /dev/null\n") .Append("+++ b/super-file.txt\n") .Append("@@ -0,0 +1,5 @@\n") .Append("+That's a terrible name!\n") .Append("+I don't like it.\n") .Append("+People look down at me and laugh. :-(\n") .Append("+Really!!!!\n") .Append("+Yeah! Better!\n"); Assert.Equal(expected.ToString(), changes.Patch); } }