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