public virtual void TestRevert()
{
Git git = new Git(db);
WriteTrashFile("a", "first line\nsec. line\nthird line\n");
git.Add().AddFilepattern("a").Call();
git.Commit().SetMessage("create a").Call();
WriteTrashFile("b", "content\n");
git.Add().AddFilepattern("b").Call();
git.Commit().SetMessage("create b").Call();
WriteTrashFile("a", "first line\nsec. line\nthird line\nfourth line\n");
git.Add().AddFilepattern("a").Call();
git.Commit().SetMessage("enlarged a").Call();
WriteTrashFile("a", "first line\nsecond line\nthird line\nfourth line\n");
git.Add().AddFilepattern("a").Call();
RevCommit fixingA = git.Commit().SetMessage("fixed a").Call();
WriteTrashFile("b", "first line\n");
git.Add().AddFilepattern("b").Call();
git.Commit().SetMessage("fixed b").Call();
git.Revert().Include(fixingA).Call();
NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "b").Exists());
CheckFile(new FilePath(db.WorkTree, "a"), "first line\nsec. line\nthird line\nfourth line\n"
);
Iterator<RevCommit> history = git.Log().Call().Iterator();
RevCommit revertCommit = history.Next();
string expectedMessage = "Revert \"fixed a\"\n\n" + "This reverts commit " + fixingA
.Id.GetName() + ".\n";
NUnit.Framework.Assert.AreEqual(expectedMessage, revertCommit.GetFullMessage());
NUnit.Framework.Assert.AreEqual("fixed b", history.Next().GetFullMessage());
NUnit.Framework.Assert.AreEqual("fixed a", history.Next().GetFullMessage());
NUnit.Framework.Assert.AreEqual("enlarged a", history.Next().GetFullMessage());
NUnit.Framework.Assert.AreEqual("create b", history.Next().GetFullMessage());
NUnit.Framework.Assert.AreEqual("create a", history.Next().GetFullMessage());
NUnit.Framework.Assert.IsFalse(history.HasNext());
}
public virtual void ResolveUnnamedCurrentBranchCommits()
{
Git git = new Git(db);
WriteTrashFile("file.txt", "content");
git.Add().AddFilepattern("file.txt").Call();
RevCommit c1 = git.Commit().SetMessage("create file").Call();
WriteTrashFile("file.txt", "content2");
git.Add().AddFilepattern("file.txt").Call();
RevCommit c2 = git.Commit().SetMessage("edit file").Call();
NUnit.Framework.Assert.AreEqual(c2, db.Resolve("master@{0}"));
NUnit.Framework.Assert.AreEqual(c1, db.Resolve("master@{1}"));
git.Checkout().SetCreateBranch(true).SetName("newbranch").SetStartPoint(c1).Call(
);
// same as current branch, e.g. master
NUnit.Framework.Assert.AreEqual(c1, db.Resolve("@{0}"));
try
{
NUnit.Framework.Assert.AreEqual(c1, db.Resolve("@{1}"));
NUnit.Framework.Assert.Fail();
}
catch (RevisionSyntaxException e)
{
// Looking at wrong ref, e.g HEAD
NUnit.Framework.Assert.IsNotNull(e);
}
// detached head, read HEAD reflog
git.Checkout().SetName(c2.GetName()).Call();
NUnit.Framework.Assert.AreEqual(c2, db.Resolve("@{0}"));
NUnit.Framework.Assert.AreEqual(c1, db.Resolve("@{1}"));
NUnit.Framework.Assert.AreEqual(c2, db.Resolve("@{2}"));
}
public virtual void TestCherryPick()
{
Git git = new Git(db);
WriteTrashFile("a", "first line\nsec. line\nthird line\n");
git.Add().AddFilepattern("a").Call();
RevCommit firstCommit = git.Commit().SetMessage("create a").Call();
WriteTrashFile("b", "content\n");
git.Add().AddFilepattern("b").Call();
git.Commit().SetMessage("create b").Call();
WriteTrashFile("a", "first line\nsec. line\nthird line\nfourth line\n");
git.Add().AddFilepattern("a").Call();
git.Commit().SetMessage("enlarged a").Call();
WriteTrashFile("a", "first line\nsecond line\nthird line\nfourth line\n");
git.Add().AddFilepattern("a").Call();
RevCommit fixingA = git.Commit().SetMessage("fixed a").Call();
git.BranchCreate().SetName("side").SetStartPoint(firstCommit).Call();
CheckoutBranch("refs/heads/side");
WriteTrashFile("a", "first line\nsec. line\nthird line\nfeature++\n");
git.Add().AddFilepattern("a").Call();
git.Commit().SetMessage("enhanced a").Call();
git.CherryPick().Include(fixingA).Call();
NUnit.Framework.Assert.IsFalse(new FilePath(db.WorkTree, "b").Exists());
CheckFile(new FilePath(db.WorkTree, "a"), "first line\nsecond line\nthird line\nfeature++\n"
);
Iterator<RevCommit> history = git.Log().Call().Iterator();
NUnit.Framework.Assert.AreEqual("fixed a", history.Next().GetFullMessage());
NUnit.Framework.Assert.AreEqual("enhanced a", history.Next().GetFullMessage());
NUnit.Framework.Assert.AreEqual("create a", history.Next().GetFullMessage());
NUnit.Framework.Assert.IsFalse(history.HasNext());
}
public virtual void TestLastModifiedTimes()
{
Git git = new Git(db);
string path = "file";
WriteTrashFile(path, "content");
string path2 = "file2";
WriteTrashFile(path2, "content2");
git.Add().AddFilepattern(path).Call();
git.Add().AddFilepattern(path2).Call();
git.Commit().SetMessage("commit").Call();
DirCache dc = db.ReadDirCache();
DirCacheEntry entry = dc.GetEntry(path);
DirCacheEntry entry2 = dc.GetEntry(path);
NUnit.Framework.Assert.IsTrue(entry.LastModified != 0, "last modified shall not be zero!"
);
NUnit.Framework.Assert.IsTrue(entry2.LastModified != 0, "last modified shall not be zero!"
);
WriteTrashFile(path, "new content");
git.Add().AddFilepattern(path).Call();
git.Commit().SetMessage("commit2").Call();
dc = db.ReadDirCache();
entry = dc.GetEntry(path);
entry2 = dc.GetEntry(path);
NUnit.Framework.Assert.IsTrue(entry.LastModified != 0, "last modified shall not be zero!"
);
NUnit.Framework.Assert.IsTrue(entry2.LastModified != 0, "last modified shall not be zero!"
);
}
public virtual void FailingPathsShouldNotResultInOKReturnValue()
{
FilePath folder1 = new FilePath(db.WorkTree, "folder1");
FileUtils.Mkdir(folder1);
FilePath file = new FilePath(folder1, "file1.txt");
Write(file, "folder1--file1.txt");
file = new FilePath(folder1, "file2.txt");
Write(file, "folder1--file2.txt");
Git git = new Git(db);
git.Add().AddFilepattern(folder1.GetName()).Call();
RevCommit @base = git.Commit().SetMessage("adding folder").Call();
RecursiveDelete(folder1);
git.Rm().AddFilepattern("folder1/file1.txt").AddFilepattern("folder1/file2.txt").
Call();
RevCommit other = git.Commit().SetMessage("removing folders on 'other'").Call();
git.Checkout().SetName(@base.Name).Call();
file = new FilePath(db.WorkTree, "unrelated.txt");
Write(file, "unrelated");
git.Add().AddFilepattern("unrelated").Call();
RevCommit head = git.Commit().SetMessage("Adding another file").Call();
// Untracked file to cause failing path for delete() of folder1
file = new FilePath(folder1, "file3.txt");
Write(file, "folder1--file3.txt");
ResolveMerger merger = new ResolveMerger(db, false);
merger.SetCommitNames(new string[] { "BASE", "HEAD", "other" });
merger.SetWorkingTreeIterator(new FileTreeIterator(db));
bool ok = merger.Merge(head.Id, other.Id);
NUnit.Framework.Assert.IsFalse(merger.GetFailingPaths().IsEmpty());
NUnit.Framework.Assert.IsFalse(ok);
}
public virtual void ResolveMasterCommits()
{
Git git = new Git(db);
WriteTrashFile("file.txt", "content");
git.Add().AddFilepattern("file.txt").Call();
RevCommit c1 = git.Commit().SetMessage("create file").Call();
WriteTrashFile("file.txt", "content2");
git.Add().AddFilepattern("file.txt").Call();
RevCommit c2 = git.Commit().SetMessage("edit file").Call();
NUnit.Framework.Assert.AreEqual(c2, db.Resolve("master@{0}"));
NUnit.Framework.Assert.AreEqual(c1, db.Resolve("master@{1}"));
}
public virtual void CommitAfterSquashMerge()
{
Git git = new Git(db);
WriteTrashFile("file1", "file1");
git.Add().AddFilepattern("file1").Call();
RevCommit first = git.Commit().SetMessage("initial commit").Call();
NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "file1").Exists());
CreateBranch(first, "refs/heads/branch1");
CheckoutBranch("refs/heads/branch1");
WriteTrashFile("file2", "file2");
git.Add().AddFilepattern("file2").Call();
git.Commit().SetMessage("second commit").Call();
NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "file2").Exists());
CheckoutBranch("refs/heads/master");
MergeCommandResult result = git.Merge().Include(db.GetRef("branch1")).SetSquash(true
).Call();
NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "file1").Exists());
NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "file2").Exists());
NUnit.Framework.Assert.AreEqual(MergeStatus.FAST_FORWARD_SQUASHED, result.GetMergeStatus
());
// comment not set, should be inferred from SQUASH_MSG
RevCommit squashedCommit = git.Commit().Call();
NUnit.Framework.Assert.AreEqual(1, squashedCommit.ParentCount);
NUnit.Framework.Assert.IsNull(db.ReadSquashCommitMsg());
NUnit.Framework.Assert.AreEqual("commit: Squashed commit of the following:", db.GetReflogReader
(Constants.HEAD).GetLastEntry().GetComment());
NUnit.Framework.Assert.AreEqual("commit: Squashed commit of the following:", db.GetReflogReader
(db.GetBranch()).GetLastEntry().GetComment());
}
public override void SetUp()
{
base.SetUp();
dbTarget = CreateWorkRepository();
source = new Git(db);
target = new Git(dbTarget);
// put some file in the source repo
sourceFile = new FilePath(db.WorkTree, "SomeFile.txt");
WriteToFile(sourceFile, "Hello world");
// and commit it
source.Add().AddFilepattern("SomeFile.txt").Call();
source.Commit().SetMessage("Initial commit for source").Call();
// configure the target repo to connect to the source via "origin"
StoredConfig targetConfig = ((FileBasedConfig)dbTarget.GetConfig());
targetConfig.SetString("branch", "master", "remote", "origin");
targetConfig.SetString("branch", "master", "merge", "refs/heads/master");
RemoteConfig config = new RemoteConfig(targetConfig, "origin");
config.AddURI(new URIish(source.GetRepository().WorkTree.GetPath()));
config.AddFetchRefSpec(new RefSpec("+refs/heads/*:refs/remotes/origin/*"));
config.Update(targetConfig);
targetConfig.Save();
targetFile = new FilePath(dbTarget.WorkTree, "SomeFile.txt");
// make sure we have the same content
target.Pull().Call();
target.Checkout().SetStartPoint("refs/remotes/origin/master").SetName("master").Call
();
targetConfig.SetString("branch", "master", "merge", "refs/heads/master");
targetConfig.SetBoolean("branch", "master", "rebase", true);
targetConfig.Save();
AssertFileContentsEqual(targetFile, "Hello world");
}
public virtual void IdOffset()
{
Git git = new Git(db);
WriteTrashFile("fileAinfsonly", "A");
FilePath fileBinindex = WriteTrashFile("fileBinindex", "B");
FsTick(fileBinindex);
git.Add().AddFilepattern("fileBinindex").Call();
WriteTrashFile("fileCinfsonly", "C");
TreeWalk tw = new TreeWalk(db);
DirCacheIterator indexIter = new DirCacheIterator(db.ReadDirCache());
FileTreeIterator workTreeIter = new FileTreeIterator(db);
tw.AddTree(indexIter);
tw.AddTree(workTreeIter);
workTreeIter.SetDirCacheIterator(tw, 0);
AssertEntry("d46c305e85b630558ee19cc47e73d2e5c8c64cdc", "a,", tw);
AssertEntry("58ee403f98538ec02409538b3f80adf610accdec", "a,b", tw);
AssertEntry("0000000000000000000000000000000000000000", "a", tw);
AssertEntry("b8d30ff397626f0f1d3538d66067edf865e201d6", "a0b", tw);
// The reason for adding this test. Check that the id is correct for
// mixed
AssertEntry("8c7e5a667f1b771847fe88c01c3de34413a1b220", "fileAinfsonly", tw);
AssertEntry("7371f47a6f8bd23a8fa1a8b2a9479cdd76380e54", "fileBinindex", tw);
AssertEntry("96d80cd6c4e7158dbebd0849f4fb7ce513e5828c", "fileCinfsonly", tw);
NUnit.Framework.Assert.IsFalse(tw.Next());
}
public virtual void TestAddUnstagedChanges()
{
FilePath file = new FilePath(db.WorkTree, "a.txt");
FileUtils.CreateNewFile(file);
PrintWriter writer = new PrintWriter(file);
writer.Write("content");
writer.Close();
Git git = new Git(db);
git.Add().AddFilepattern("a.txt").Call();
RevCommit commit = git.Commit().SetMessage("initial commit").Call();
TreeWalk tw = TreeWalk.ForPath(db, "a.txt", commit.Tree);
NUnit.Framework.Assert.AreEqual("6b584e8ece562ebffc15d38808cd6b98fc3d97ea", tw.GetObjectId
(0).GetName());
writer = new PrintWriter(file);
writer.Write("content2");
writer.Close();
commit = git.Commit().SetMessage("second commit").Call();
tw = TreeWalk.ForPath(db, "a.txt", commit.Tree);
NUnit.Framework.Assert.AreEqual("6b584e8ece562ebffc15d38808cd6b98fc3d97ea", tw.GetObjectId
(0).GetName());
commit = git.Commit().SetAll(true).SetMessage("third commit").SetAll(true).Call();
tw = TreeWalk.ForPath(db, "a.txt", commit.Tree);
NUnit.Framework.Assert.AreEqual("db00fd65b218578127ea51f3dffac701f12f486a", tw.GetObjectId
(0).GetName());
}
public override void SetUp()
{
base.SetUp();
git = new Git(db);
WriteTrashFile(FILE1, "1");
WriteTrashFile(FILE2, "a");
git.Add().AddFilepattern(FILE1).AddFilepattern(FILE2).Call();
initialCommit = git.Commit().SetMessage("Initial commit").Call();
WriteTrashFile(FILE1, "2");
WriteTrashFile(FILE2, "b");
git.Add().AddFilepattern(FILE1).AddFilepattern(FILE2).Call();
secondCommit = git.Commit().SetMessage("Second commit").Call();
WriteTrashFile(FILE1, "3");
WriteTrashFile(FILE2, "c");
git.Add().AddFilepattern(FILE1).AddFilepattern(FILE2).Call();
git.Commit().SetMessage("Third commit").Call();
}
public override void SetUp()
{
base.SetUp();
git = new Git(db);
// commit something
WriteTrashFile("Test.txt", "Hello world");
git.Add().AddFilepattern("Test.txt").Call();
initialCommit = git.Commit().SetMessage("Initial commit").Call();
// create a master branch and switch to it
git.BranchCreate().SetName("test").Call();
RefUpdate rup = db.UpdateRef(Constants.HEAD);
rup.Link("refs/heads/test");
// commit something on the test branch
WriteTrashFile("Test.txt", "Some change");
git.Add().AddFilepattern("Test.txt").Call();
secondCommit = git.Commit().SetMessage("Second commit").Call();
}
public override void SetUp()
{
base.SetUp();
git = new Git(db);
// commit something
WriteTrashFile(FILE, "Hello world");
git.Add().AddFilepattern(FILE).Call();
git.Commit().SetMessage("Initial commit").Call();
}
public override void SetUp()
{
base.SetUp();
git = Git.Wrap(db);
committedFile = WriteTrashFile(PATH, "content");
git.Add().AddFilepattern(PATH).Call();
head = git.Commit().SetMessage("add file").Call();
NUnit.Framework.Assert.IsNotNull(head);
}
public override void SetUp()
{
base.SetUp();
git = new Git(db);
// checkout master
git.Commit().SetMessage("initial commit").Call();
// commit something
WriteTrashFile("Test.txt", "Hello world");
git.Add().AddFilepattern("Test.txt").Call();
initialCommit = git.Commit().SetMessage("Initial commit").Call();
WriteTrashFile("Test.txt", "Some change");
git.Add().AddFilepattern("Test.txt").Call();
secondCommit = git.Commit().SetMessage("Second commit").Call();
// create a master branch
RefUpdate rup = db.UpdateRef("refs/heads/master");
rup.SetNewObjectId(initialCommit.Id);
rup.SetForceUpdate(true);
rup.Update();
}
public override void SetUp()
{
base.SetUp();
git = new Git(db);
// checkout master
git.Commit().SetMessage("initial commit").Call();
// commit something
WriteTrashFile("Test.txt", "Hello world");
git.Add().AddFilepattern("Test.txt").Call();
initialCommit = git.Commit().SetMessage("Initial commit").Call();
WriteTrashFile("Test.txt", "Some change");
git.Add().AddFilepattern("Test.txt").Call();
secondCommit = git.Commit().SetMessage("Second commit").Call();
// create a master branch
RefUpdate rup = db.UpdateRef("refs/heads/master");
rup.SetNewObjectId(initialCommit.Id);
rup.SetForceUpdate(true);
rup.Update();
}
public virtual void TestAddRemovedCommittedFile()
{
FilePath file = new FilePath(db.WorkTree, "a.txt");
FileUtils.CreateNewFile(file);
PrintWriter writer = new PrintWriter(file);
writer.Write("content");
writer.Close();
Git git = new Git(db);
DirCache dc = git.Add().AddFilepattern("a.txt").Call();
git.Commit().SetMessage("commit a.txt").Call();
dc.GetEntry(0).GetObjectId();
FileUtils.Delete(file);
// is supposed to do nothing
dc = git.Add().AddFilepattern("a.txt").Call();
NUnit.Framework.Assert.AreEqual("[a.txt, mode:100644, content:content]", IndexState
(CONTENT));
}
public override void SetUp()
{
base.SetUp();
Git git = new Git(db);
git.Commit().SetMessage("initial commit").Call();
WriteTrashFile("Test.txt", "Hello world");
git.Add().AddFilepattern("Test.txt").Call();
git.Commit().SetMessage("Initial commit").Call();
bareRepo = Git.CloneRepository().SetBare(true).SetURI(db.Directory.ToURI().ToString
()).SetDirectory(CreateUniqueTestGitDir(true)).Call().GetRepository();
}
/// <exception cref="System.Exception"></exception>
public override void SetUp()
{
base.SetUp();
tr = new TestRepository<Repository>(db);
git = new Git(db);
// commit something
WriteTrashFile("Test.txt", "Hello world");
git.Add().AddFilepattern("Test.txt").Call();
git.Commit().SetMessage("Initial commit").Call();
// create a master branch and switch to it
git.BranchCreate().SetName("test").Call();
RefUpdate rup = db.UpdateRef(Constants.HEAD);
rup.Link("refs/heads/test");
// commit something on the test branch
WriteTrashFile("Test.txt", "Some change");
git.Add().AddFilepattern("Test.txt").Call();
git.Commit().SetMessage("Second commit").Call();
RevBlob blob = tr.Blob("blob-not-in-master-branch");
git.Tag().SetName("tag-for-blob").SetObjectId(blob).Call();
}
public virtual void TestAddExistingSingleFileTwice()
{
FilePath file = new FilePath(db.WorkTree, "a.txt");
FileUtils.CreateNewFile(file);
PrintWriter writer = new PrintWriter(file);
writer.Write("content");
writer.Close();
Git git = new Git(db);
DirCache dc = git.Add().AddFilepattern("a.txt").Call();
dc.GetEntry(0).GetObjectId();
writer = new PrintWriter(file);
writer.Write("other content");
writer.Close();
dc = git.Add().AddFilepattern("a.txt").Call();
NUnit.Framework.Assert.AreEqual("[a.txt, mode:100644, content:other content]", IndexState
(CONTENT));
}
public override void SetUp()
{
base.SetUp();
git = new Git(db);
// create test files
WriteTrashFile("File1.txt", "Hello world");
WriteTrashFile("File2.txt", "Delete Me");
WriteTrashFile("File3.txt", "Delete Me");
// add and commit first file
git.Add().AddFilepattern("File1.txt").Call();
git.Commit().SetMessage("Initial commit").Call();
}
public virtual void TestAddNothing()
{
Git git = new Git(db);
try
{
git.Add().Call();
NUnit.Framework.Assert.Fail("Expected IllegalArgumentException");
}
catch (NoFilepatternException)
{
}
}
public override void SetUp()
{
base.SetUp();
git = new Git(db);
// create test files
WriteTrashFile("File1.txt", "Hello world");
WriteTrashFile("File2.txt", "Delete Me");
WriteTrashFile("File3.txt", "Delete Me");
// add and commit first file
git.Add().AddFilepattern("File1.txt").Call();
git.Commit().SetMessage("Initial commit").Call();
}
public virtual void TestCherryPickDirtyIndex()
{
Git git = new Git(db);
RevCommit sideCommit = PrepareCherryPick(git);
// modify and add file a
WriteTrashFile("a", "a(modified)");
git.Add().AddFilepattern("a").Call();
// do not commit
DoCherryPickAndCheckResult(git, sideCommit, ResolveMerger.MergeFailureReason.DIRTY_INDEX
);
}
public override void SetUp()
{
base.SetUp();
git = new Git(db);
// commit something
WriteTrashFile(FILE, "Hello world");
git.Add().AddFilepattern(FILE).Call();
commit1 = git.Commit().SetMessage("Initial commit").Call();
git.Rm().AddFilepattern(FILE).Call();
commit2 = git.Commit().SetMessage("Removed file").Call();
git.NotesAdd().SetObjectId(commit1).SetMessage("data").Call();
}
public override void SetUp()
{
base.SetUp();
git = new Git(db);
// commit something
WriteTrashFile(FILE, "Hello world");
git.Add().AddFilepattern(FILE).Call();
commit1 = git.Commit().SetMessage("Initial commit").Call();
git.Rm().AddFilepattern(FILE).Call();
commit2 = git.Commit().SetMessage("Removed file").Call();
git.NotesAdd().SetObjectId(commit1).SetMessage("data").Call();
}
public virtual void TestAddExistingSingleBinaryFile()
{
FilePath file = new FilePath(db.WorkTree, "a.txt");
FileUtils.CreateNewFile(file);
PrintWriter writer = new PrintWriter(file);
writer.Write("row1\r\nrow2\u0000");
writer.Close();
Git git = new Git(db);
((FileBasedConfig)db.GetConfig()).SetString("core", null, "autocrlf", "false");
git.Add().AddFilepattern("a.txt").Call();
NUnit.Framework.Assert.AreEqual("[a.txt, mode:100644, content:row1\r\nrow2\u0000]"
, IndexState(CONTENT));
((FileBasedConfig)db.GetConfig()).SetString("core", null, "autocrlf", "true");
git.Add().AddFilepattern("a.txt").Call();
NUnit.Framework.Assert.AreEqual("[a.txt, mode:100644, content:row1\r\nrow2\u0000]"
, IndexState(CONTENT));
((FileBasedConfig)db.GetConfig()).SetString("core", null, "autocrlf", "input");
git.Add().AddFilepattern("a.txt").Call();
NUnit.Framework.Assert.AreEqual("[a.txt, mode:100644, content:row1\r\nrow2\u0000]"
, IndexState(CONTENT));
}
public virtual void TestDeletionAndConflict()
{
Git git = new Git(db);
WriteTrashFile("a", "1\na\n3\n");
WriteTrashFile("b", "1\nb\n3\n");
WriteTrashFile("d", "1\nd\n3\n");
WriteTrashFile("c/c/c", "1\nc\n3\n");
git.Add().AddFilepattern("a").AddFilepattern("b").AddFilepattern("c/c/c").AddFilepattern
("d").Call();
RevCommit initialCommit = git.Commit().SetMessage("initial").Call();
CreateBranch(initialCommit, "refs/heads/side");
CheckoutBranch("refs/heads/side");
NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "b").Delete());
WriteTrashFile("a", "1\na\n3(side)\n");
git.Add().AddFilepattern("b").SetUpdate(true).Call();
git.Add().AddFilepattern("a").SetUpdate(true).Call();
RevCommit secondCommit = git.Commit().SetMessage("side").Call();
NUnit.Framework.Assert.IsFalse(new FilePath(db.WorkTree, "b").Exists());
CheckoutBranch("refs/heads/master");
NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "b").Exists());
WriteTrashFile("a", "1\na\n3(main)\n");
WriteTrashFile("c/c/c", "1\nc(main)\n3\n");
git.Add().AddFilepattern("a").AddFilepattern("c/c/c").Call();
git.Commit().SetMessage("main").Call();
// We are merging a deletion into our branch
MergeCommandResult result = git.Merge().Include(secondCommit.Id).SetStrategy(MergeStrategy
.RESOLVE).Call();
NUnit.Framework.Assert.AreEqual(MergeStatus.CONFLICTING, result.GetMergeStatus());
NUnit.Framework.Assert.AreEqual("1\na\n<<<<<<< HEAD\n3(main)\n=======\n3(side)\n>>>>>>> 54ffed45d62d252715fc20e41da92d44c48fb0ff\n"
, Read(new FilePath(db.WorkTree, "a")));
NUnit.Framework.Assert.IsFalse(new FilePath(db.WorkTree, "b").Exists());
NUnit.Framework.Assert.AreEqual("1\nc(main)\n3\n", Read(new FilePath(db.WorkTree,
"c/c/c")));
NUnit.Framework.Assert.AreEqual("1\nd\n3\n", Read(new FilePath(db.WorkTree, "d"))
);
}
public virtual void TestContentMerge()
{
Git git = new Git(db);
WriteTrashFile("a", "1\na\n3\n");
WriteTrashFile("b", "1\nb\n3\n");
WriteTrashFile("c/c/c", "1\nc\n3\n");
git.Add().AddFilepattern("a").AddFilepattern("b").AddFilepattern("c/c/c").Call();
RevCommit initialCommit = git.Commit().SetMessage("initial").Call();
CreateBranch(initialCommit, "refs/heads/side");
CheckoutBranch("refs/heads/side");
WriteTrashFile("a", "1\na(side)\n3\n");
WriteTrashFile("b", "1\nb(side)\n3\n");
git.Add().AddFilepattern("a").AddFilepattern("b").Call();
RevCommit secondCommit = git.Commit().SetMessage("side").Call();
NUnit.Framework.Assert.AreEqual("1\nb(side)\n3\n", Read(new FilePath(db.WorkTree,
"b")));
CheckoutBranch("refs/heads/master");
NUnit.Framework.Assert.AreEqual("1\nb\n3\n", Read(new FilePath(db.WorkTree, "b"))
);
WriteTrashFile("a", "1\na(main)\n3\n");
WriteTrashFile("c/c/c", "1\nc(main)\n3\n");
git.Add().AddFilepattern("a").AddFilepattern("c/c/c").Call();
git.Commit().SetMessage("main").Call();
MergeCommandResult result = git.Merge().Include(secondCommit.Id).SetStrategy(MergeStrategy
.RESOLVE).Call();
NUnit.Framework.Assert.AreEqual(MergeStatus.CONFLICTING, result.GetMergeStatus());
NUnit.Framework.Assert.AreEqual("1\n<<<<<<< HEAD\na(main)\n=======\na(side)\n>>>>>>> 86503e7e397465588cc267b65d778538bffccb83\n3\n"
, Read(new FilePath(db.WorkTree, "a")));
NUnit.Framework.Assert.AreEqual("1\nb(side)\n3\n", Read(new FilePath(db.WorkTree,
"b")));
NUnit.Framework.Assert.AreEqual("1\nc(main)\n3\n", Read(new FilePath(db.WorkTree,
"c/c/c")));
NUnit.Framework.Assert.AreEqual(1, result.GetConflicts().Count);
NUnit.Framework.Assert.AreEqual(3, result.GetConflicts().Get("a")[0].Length);
NUnit.Framework.Assert.AreEqual(RepositoryState.MERGING, db.GetRepositoryState());
}
public virtual void TestBoundLineDelete()
{
Git git = new Git(db);
string[] content1 = new string[] { "first", "second" };
WriteTrashFile("file.txt", Join(content1));
git.Add().AddFilepattern("file.txt").Call();
RevCommit c1 = git.Commit().SetMessage("create file").Call();
string[] content2 = new string[] { "third", "first", "second" };
WriteTrashFile("file.txt", Join(content2));
git.Add().AddFilepattern("file.txt").Call();
RevCommit c2 = git.Commit().SetMessage("create file").Call();
BlameGenerator generator = new BlameGenerator(db, "file.txt");
try
{
generator.Push(null, db.Resolve(Constants.HEAD));
NUnit.Framework.Assert.AreEqual(3, generator.GetResultContents().Size());
NUnit.Framework.Assert.IsTrue(generator.Next());
NUnit.Framework.Assert.AreEqual(c2, generator.GetSourceCommit());
NUnit.Framework.Assert.AreEqual(1, generator.GetRegionLength());
NUnit.Framework.Assert.AreEqual(0, generator.GetResultStart());
NUnit.Framework.Assert.AreEqual(1, generator.GetResultEnd());
NUnit.Framework.Assert.AreEqual(0, generator.GetSourceStart());
NUnit.Framework.Assert.AreEqual(1, generator.GetSourceEnd());
NUnit.Framework.Assert.AreEqual("file.txt", generator.GetSourcePath());
NUnit.Framework.Assert.IsTrue(generator.Next());
NUnit.Framework.Assert.AreEqual(c1, generator.GetSourceCommit());
NUnit.Framework.Assert.AreEqual(2, generator.GetRegionLength());
NUnit.Framework.Assert.AreEqual(1, generator.GetResultStart());
NUnit.Framework.Assert.AreEqual(3, generator.GetResultEnd());
NUnit.Framework.Assert.AreEqual(0, generator.GetSourceStart());
NUnit.Framework.Assert.AreEqual(2, generator.GetSourceEnd());
NUnit.Framework.Assert.AreEqual("file.txt", generator.GetSourcePath());
NUnit.Framework.Assert.IsFalse(generator.Next());
}
finally
{
generator.Release();
}
}
public virtual void TestEditAllLines()
{
Git git = new Git(db);
string[] content1 = new string[] { "a", "1" };
string[] content2 = new string[] { "b", "2" };
WriteTrashFile("file.txt", Join(content1));
git.Add().AddFilepattern("file.txt").Call();
git.Commit().SetMessage("edit file").Call();
WriteTrashFile("file.txt", Join(content2));
git.Add().AddFilepattern("file.txt").Call();
RevCommit commit2 = git.Commit().SetMessage("create file").Call();
BlameCommand command = new BlameCommand(db);
command.SetFilePath("file.txt");
BlameResult lines = command.Call();
NUnit.Framework.Assert.AreEqual(content2.Length, lines.GetResultContents().Size()
);
NUnit.Framework.Assert.AreEqual(commit2, lines.GetSourceCommit(0));
NUnit.Framework.Assert.AreEqual(commit2, lines.GetSourceCommit(1));
}
public override void SetUp()
{
base.SetUp();
Git git = new Git(db);
git.Commit().SetMessage("initial commit").Call();
WriteTrashFile("Test.txt", "Hello world");
git.Add().AddFilepattern("Test.txt").Call();
git.Commit().SetMessage("Initial commit").Call();
bareRepo = Git.CloneRepository().SetBare(true).SetURI(db.Directory.ToURI().ToString
()).SetDirectory(CreateUniqueTestGitDir(true)).Call().GetRepository();
AddRepoToClose(bareRepo);
}
public virtual void TestTwoRenames()
{
Git git = new Git(db);
// Commit 1: Add file.txt
string[] content1 = new string[] { "a" };
WriteTrashFile("file.txt", Join(content1));
git.Add().AddFilepattern("file.txt").Call();
RevCommit commit1 = git.Commit().SetMessage("create file").Call();
// Commit 2: Rename to file1.txt
WriteTrashFile("file1.txt", Join(content1));
git.Add().AddFilepattern("file1.txt").Call();
git.Rm().AddFilepattern("file.txt").Call();
git.Commit().SetMessage("moving file").Call();
// Commit 3: Edit file1.txt
string[] content2 = new string[] { "a", "b" };
WriteTrashFile("file1.txt", Join(content2));
git.Add().AddFilepattern("file1.txt").Call();
RevCommit commit3 = git.Commit().SetMessage("editing file").Call();
// Commit 4: Rename to file2.txt
WriteTrashFile("file2.txt", Join(content2));
git.Add().AddFilepattern("file2.txt").Call();
git.Rm().AddFilepattern("file1.txt").Call();
git.Commit().SetMessage("moving file again").Call();
BlameCommand command = new BlameCommand(db);
command.SetFollowFileRenames(true);
command.SetFilePath("file2.txt");
BlameResult lines = command.Call();
NUnit.Framework.Assert.AreEqual(commit1, lines.GetSourceCommit(0));
NUnit.Framework.Assert.AreEqual(0, lines.GetSourceLine(0));
NUnit.Framework.Assert.AreEqual("file.txt", lines.GetSourcePath(0));
NUnit.Framework.Assert.AreEqual(commit3, lines.GetSourceCommit(1));
NUnit.Framework.Assert.AreEqual(1, lines.GetSourceLine(1));
NUnit.Framework.Assert.AreEqual("file1.txt", lines.GetSourcePath(1));
}
/// <exception cref="System.Exception"></exception>
public override void SetUp()
{
base.SetUp();
tr = new TestRepository <Repository>(db);
git = new Git(db);
// commit something
WriteTrashFile("Test.txt", "Hello world");
git.Add().AddFilepattern("Test.txt").Call();
git.Commit().SetMessage("Initial commit").Call();
// create a master branch and switch to it
git.BranchCreate().SetName("test").Call();
RefUpdate rup = db.UpdateRef(Constants.HEAD);
rup.Link("refs/heads/test");
// commit something on the test branch
WriteTrashFile("Test.txt", "Some change");
git.Add().AddFilepattern("Test.txt").Call();
git.Commit().SetMessage("Second commit").Call();
RevBlob blob = tr.Blob("blob-not-in-master-branch");
git.Tag().SetName("tag-for-blob").SetObjectId(blob).Call();
}
public virtual void TestAddNothing()
{
Git git = new Git(db);
try
{
git.Add().Call();
NUnit.Framework.Assert.Fail("Expected IllegalArgumentException");
}
catch (NoFilepatternException)
{
}
}
public virtual void CommitNewSubmodule()
{
Git git = new Git(db);
WriteTrashFile("file.txt", "content");
git.Add().AddFilepattern("file.txt").Call();
RevCommit commit = git.Commit().SetMessage("create file").Call();
SubmoduleAddCommand command = new SubmoduleAddCommand(db);
string path = "sub";
command.SetPath(path);
string uri = db.Directory.ToURI().ToString();
command.SetURI(uri);
Repository repo = command.Call();
NUnit.Framework.Assert.IsNotNull(repo);
AddRepoToClose(repo);
SubmoduleWalk generator = SubmoduleWalk.ForIndex(db);
NUnit.Framework.Assert.IsTrue(generator.Next());
NUnit.Framework.Assert.AreEqual(path, generator.GetPath());
NUnit.Framework.Assert.AreEqual(commit, generator.GetObjectId());
NUnit.Framework.Assert.AreEqual(uri, generator.GetModulesUrl());
NUnit.Framework.Assert.AreEqual(path, generator.GetModulesPath());
NUnit.Framework.Assert.AreEqual(uri, generator.GetConfigUrl());
Repository subModRepo = generator.GetRepository();
AddRepoToClose(subModRepo);
NUnit.Framework.Assert.IsNotNull(subModRepo);
NUnit.Framework.Assert.AreEqual(commit, repo.Resolve(Constants.HEAD));
RevCommit submoduleCommit = git.Commit().SetMessage("submodule add").SetOnly(path
).Call();
NUnit.Framework.Assert.IsNotNull(submoduleCommit);
TreeWalk walk = new TreeWalk(db);
walk.AddTree(commit.Tree);
walk.AddTree(submoduleCommit.Tree);
walk.Filter = TreeFilter.ANY_DIFF;
IList <DiffEntry> diffs = DiffEntry.Scan(walk);
NUnit.Framework.Assert.AreEqual(1, diffs.Count);
DiffEntry subDiff = diffs[0];
NUnit.Framework.Assert.AreEqual(FileMode.MISSING, subDiff.GetOldMode());
NUnit.Framework.Assert.AreEqual(FileMode.GITLINK, subDiff.GetNewMode());
NUnit.Framework.Assert.AreEqual(ObjectId.ZeroId, subDiff.GetOldId().ToObjectId());
NUnit.Framework.Assert.AreEqual(commit, subDiff.GetNewId().ToObjectId());
NUnit.Framework.Assert.AreEqual(path, subDiff.GetNewPath());
}
/// <exception cref="System.Exception"></exception>
private Git SetUpRepoWithRemote()
{
Repository remoteRepository = CreateWorkRepository();
Git remoteGit = new Git(remoteRepository);
// commit something
WriteTrashFile("Test.txt", "Hello world");
remoteGit.Add().AddFilepattern("Test.txt").Call();
initialCommit = remoteGit.Commit().SetMessage("Initial commit").Call();
WriteTrashFile("Test.txt", "Some change");
remoteGit.Add().AddFilepattern("Test.txt").Call();
secondCommit = remoteGit.Commit().SetMessage("Second commit").Call();
// create a master branch
RefUpdate rup = remoteRepository.UpdateRef("refs/heads/master");
rup.SetNewObjectId(initialCommit.Id);
rup.ForceUpdate();
Repository localRepository = CreateWorkRepository();
Git localGit = new Git(localRepository);
StoredConfig config = localRepository.GetConfig();
RemoteConfig rc = new RemoteConfig(config, "origin");
rc.AddURI(new URIish(remoteRepository.Directory.GetPath()));
rc.AddFetchRefSpec(new RefSpec("+refs/heads/*:refs/remotes/origin/*"));
rc.Update(config);
config.Save();
FetchResult res = localGit.Fetch().SetRemote("origin").Call();
NUnit.Framework.Assert.IsFalse(res.GetTrackingRefUpdates().IsEmpty());
rup = localRepository.UpdateRef("refs/heads/master");
rup.SetNewObjectId(initialCommit.Id);
rup.ForceUpdate();
rup = localRepository.UpdateRef(Constants.HEAD);
rup.Link("refs/heads/master");
rup.SetNewObjectId(initialCommit.Id);
rup.Update();
return(localGit);
}
public virtual void TestMixedResetRetainsSizeAndModifiedTime()
{
git = new Git(db);
WriteTrashFile("a.txt", "a").SetLastModified(Runtime.CurrentTimeMillis() - 60 * 1000
);
NUnit.Framework.Assert.IsNotNull(git.Add().AddFilepattern("a.txt").Call());
NUnit.Framework.Assert.IsNotNull(git.Commit().SetMessage("a commit").Call());
WriteTrashFile("b.txt", "b").SetLastModified(Runtime.CurrentTimeMillis() - 60 * 1000
);
NUnit.Framework.Assert.IsNotNull(git.Add().AddFilepattern("b.txt").Call());
RevCommit commit2 = git.Commit().SetMessage("b commit").Call();
NUnit.Framework.Assert.IsNotNull(commit2);
DirCache cache = db.ReadDirCache();
DirCacheEntry aEntry = cache.GetEntry("a.txt");
NUnit.Framework.Assert.IsNotNull(aEntry);
NUnit.Framework.Assert.IsTrue(aEntry.Length > 0);
NUnit.Framework.Assert.IsTrue(aEntry.LastModified > 0);
DirCacheEntry bEntry = cache.GetEntry("b.txt");
NUnit.Framework.Assert.IsNotNull(bEntry);
NUnit.Framework.Assert.IsTrue(bEntry.Length > 0);
NUnit.Framework.Assert.IsTrue(bEntry.LastModified > 0);
git.Reset().SetMode(ResetCommand.ResetType.MIXED).SetRef(commit2.GetName()).Call(
);
cache = db.ReadDirCache();
DirCacheEntry mixedAEntry = cache.GetEntry("a.txt");
NUnit.Framework.Assert.IsNotNull(mixedAEntry);
NUnit.Framework.Assert.AreEqual(aEntry.LastModified, mixedAEntry.LastModified);
NUnit.Framework.Assert.AreEqual(aEntry.LastModified, mixedAEntry.LastModified);
DirCacheEntry mixedBEntry = cache.GetEntry("b.txt");
NUnit.Framework.Assert.IsNotNull(mixedBEntry);
NUnit.Framework.Assert.AreEqual(bEntry.LastModified, mixedBEntry.LastModified);
NUnit.Framework.Assert.AreEqual(bEntry.LastModified, mixedBEntry.LastModified);
}
public virtual void TestDifferentStates()
{
Git git = new Git(db);
WriteTrashFile("a", "content of a");
WriteTrashFile("b", "content of b");
WriteTrashFile("c", "content of c");
git.Add().AddFilepattern("a").AddFilepattern("b").Call();
Status stat = git.Status().Call();
NUnit.Framework.Assert.AreEqual(Set("a", "b"), Set (stat.GetAdded()));
NUnit.Framework.Assert.AreEqual(0, stat.GetChanged().Count);
NUnit.Framework.Assert.AreEqual(0, stat.GetMissing().Count);
NUnit.Framework.Assert.AreEqual(0, stat.GetModified().Count);
NUnit.Framework.Assert.AreEqual(0, stat.GetRemoved().Count);
NUnit.Framework.Assert.AreEqual(Set("c"), Set (stat.GetUntracked()));
git.Commit().SetMessage("initial").Call();
WriteTrashFile("a", "modified content of a");
WriteTrashFile("b", "modified content of b");
WriteTrashFile("d", "content of d");
git.Add().AddFilepattern("a").AddFilepattern("d").Call();
WriteTrashFile("a", "again modified content of a");
stat = git.Status().Call();
NUnit.Framework.Assert.AreEqual(Set("d"), Set (stat.GetAdded()));
NUnit.Framework.Assert.AreEqual(Set("a"), Set (stat.GetChanged()));
NUnit.Framework.Assert.AreEqual(0, stat.GetMissing().Count);
NUnit.Framework.Assert.AreEqual(Set("b", "a"), Set (stat.GetModified()));
NUnit.Framework.Assert.AreEqual(0, stat.GetRemoved().Count);
NUnit.Framework.Assert.AreEqual(Set("c"), Set (stat.GetUntracked()));
git.Add().AddFilepattern(".").Call();
git.Commit().SetMessage("second").Call();
stat = git.Status().Call();
NUnit.Framework.Assert.AreEqual(0, stat.GetAdded().Count);
NUnit.Framework.Assert.AreEqual(0, stat.GetChanged().Count);
NUnit.Framework.Assert.AreEqual(0, stat.GetMissing().Count);
NUnit.Framework.Assert.AreEqual(0, stat.GetModified().Count);
NUnit.Framework.Assert.AreEqual(0, stat.GetRemoved().Count);
NUnit.Framework.Assert.AreEqual(0, stat.GetUntracked().Count);
DeleteTrashFile("a");
NUnit.Framework.Assert.IsFalse(new FilePath(git.GetRepository().WorkTree, "a").Exists
());
git.Add().AddFilepattern("a").SetUpdate(true).Call();
WriteTrashFile("a", "recreated content of a");
stat = git.Status().Call();
NUnit.Framework.Assert.AreEqual(0, stat.GetAdded().Count);
NUnit.Framework.Assert.AreEqual(0, stat.GetChanged().Count);
NUnit.Framework.Assert.AreEqual(0, stat.GetMissing().Count);
NUnit.Framework.Assert.AreEqual(0, stat.GetModified().Count);
NUnit.Framework.Assert.AreEqual(Set("a"), Set (stat.GetRemoved()));
NUnit.Framework.Assert.AreEqual(Set("a"), Set (stat.GetUntracked()));
git.Commit().SetMessage("t").Call();
}
/// <exception cref="System.Exception"></exception>
private RevCommit PrepareCherryPick(Git git)
{
// create, add and commit file a
WriteTrashFile("a", "a");
git.Add().AddFilepattern("a").Call();
RevCommit firstMasterCommit = git.Commit().SetMessage("first master").Call();
// create and checkout side branch
CreateBranch(firstMasterCommit, "refs/heads/side");
CheckoutBranch("refs/heads/side");
// modify, add and commit file a
WriteTrashFile("a", "a(side)");
git.Add().AddFilepattern("a").Call();
RevCommit sideCommit = git.Commit().SetMessage("side").Call();
// checkout master branch
CheckoutBranch("refs/heads/master");
// modify, add and commit file a
WriteTrashFile("a", "a(master)");
git.Add().AddFilepattern("a").Call();
git.Commit().SetMessage("second master").Call();
return(sideCommit);
}
public virtual void TestMultipleCreations()
{
Git git = new Git(db);
WriteTrashFile("a", "1\na\n3\n");
git.Add().AddFilepattern("a").Call();
RevCommit initialCommit = git.Commit().SetMessage("initial").Call();
CreateBranch(initialCommit, "refs/heads/side");
CheckoutBranch("refs/heads/side");
WriteTrashFile("b", "1\nb(side)\n3\n");
git.Add().AddFilepattern("b").Call();
RevCommit secondCommit = git.Commit().SetMessage("side").Call();
CheckoutBranch("refs/heads/master");
WriteTrashFile("b", "1\nb(main)\n3\n");
git.Add().AddFilepattern("b").Call();
git.Commit().SetMessage("main").Call();
MergeCommandResult result = git.Merge().Include(secondCommit.Id).SetStrategy(MergeStrategy
.RESOLVE).Call();
NUnit.Framework.Assert.AreEqual(MergeStatus.CONFLICTING, result.GetMergeStatus());
}
public virtual void TestMergeMessage()
{
Git git = new Git(db);
WriteTrashFile("a", "1\na\n3\n");
git.Add().AddFilepattern("a").Call();
RevCommit initialCommit = git.Commit().SetMessage("initial").Call();
CreateBranch(initialCommit, "refs/heads/side");
CheckoutBranch("refs/heads/side");
WriteTrashFile("a", "1\na(side)\n3\n");
git.Add().AddFilepattern("a").Call();
git.Commit().SetMessage("side").Call();
CheckoutBranch("refs/heads/master");
WriteTrashFile("a", "1\na(main)\n3\n");
git.Add().AddFilepattern("a").Call();
git.Commit().SetMessage("main").Call();
Ref sideBranch = db.GetRef("side");
git.Merge().Include(sideBranch).SetStrategy(MergeStrategy.RESOLVE).Call();
NUnit.Framework.Assert.AreEqual("Merge branch 'side'\n\nConflicts:\n\ta\n", db.ReadMergeCommitMsg
());
}
public virtual void TestRevert()
{
Git git = new Git(db);
WriteTrashFile("a", "first line\nsec. line\nthird line\n");
git.Add().AddFilepattern("a").Call();
git.Commit().SetMessage("create a").Call();
WriteTrashFile("b", "content\n");
git.Add().AddFilepattern("b").Call();
git.Commit().SetMessage("create b").Call();
WriteTrashFile("a", "first line\nsec. line\nthird line\nfourth line\n");
git.Add().AddFilepattern("a").Call();
git.Commit().SetMessage("enlarged a").Call();
WriteTrashFile("a", "first line\nsecond line\nthird line\nfourth line\n");
git.Add().AddFilepattern("a").Call();
RevCommit fixingA = git.Commit().SetMessage("fixed a").Call();
WriteTrashFile("b", "first line\n");
git.Add().AddFilepattern("b").Call();
git.Commit().SetMessage("fixed b").Call();
git.Revert().Include(fixingA).Call();
NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "b").Exists());
CheckFile(new FilePath(db.WorkTree, "a"), "first line\nsec. line\nthird line\nfourth line\n"
);
Iterator <RevCommit> history = git.Log().Call().Iterator();
RevCommit revertCommit = history.Next();
string expectedMessage = "Revert \"fixed a\"\n\n" + "This reverts commit " + fixingA
.Id.GetName() + ".\n";
NUnit.Framework.Assert.AreEqual(expectedMessage, revertCommit.GetFullMessage());
NUnit.Framework.Assert.AreEqual("fixed b", history.Next().GetFullMessage());
NUnit.Framework.Assert.AreEqual("fixed a", history.Next().GetFullMessage());
NUnit.Framework.Assert.AreEqual("enlarged a", history.Next().GetFullMessage());
NUnit.Framework.Assert.AreEqual("create b", history.Next().GetFullMessage());
NUnit.Framework.Assert.AreEqual("create a", history.Next().GetFullMessage());
NUnit.Framework.Assert.IsFalse(history.HasNext());
}
public virtual void TestModifiedAndRenamed()
{
// this test is essentially the same as testDeletionOnSideConflict,
// however if once rename support is added this test should result in a
// successful merge instead of a conflict
Git git = new Git(db);
WriteTrashFile("x", "add x");
git.Add().AddFilepattern("x").Call();
RevCommit initial = git.Commit().SetMessage("add x").Call();
CreateBranch(initial, "refs/heads/d1");
CreateBranch(initial, "refs/heads/d2");
// rename x to y on d1
CheckoutBranch("refs/heads/d1");
new FilePath(db.WorkTree, "x").RenameTo(new FilePath(db.WorkTree, "y"));
git.Rm().AddFilepattern("x").Call();
git.Add().AddFilepattern("y").Call();
RevCommit d1Commit = git.Commit().SetMessage("d1 rename x -> y").Call();
CheckoutBranch("refs/heads/d2");
WriteTrashFile("x", "d2 change");
git.Add().AddFilepattern("x").Call();
RevCommit d2Commit = git.Commit().SetMessage("d2 change in x").Call();
CheckoutBranch("refs/heads/master");
MergeCommandResult d1Merge = git.Merge().Include(d1Commit).Call();
NUnit.Framework.Assert.AreEqual(MergeStatus.FAST_FORWARD, d1Merge.GetMergeStatus(
));
MergeCommandResult d2Merge = git.Merge().Include(d2Commit).Call();
NUnit.Framework.Assert.AreEqual(MergeStatus.CONFLICTING, d2Merge.GetMergeStatus()
);
NUnit.Framework.Assert.AreEqual(1, d2Merge.GetConflicts().Count);
NUnit.Framework.Assert.AreEqual(3, d2Merge.GetConflicts().Get("x")[0].Length);
}
public virtual void TestMergeFailingWithDirtyWorkingTree()
{
Git git = new Git(db);
WriteTrashFile("a", "1\na\n3\n");
WriteTrashFile("b", "1\nb\n3\n");
git.Add().AddFilepattern("a").AddFilepattern("b").Call();
RevCommit initialCommit = git.Commit().SetMessage("initial").Call();
CreateBranch(initialCommit, "refs/heads/side");
CheckoutBranch("refs/heads/side");
WriteTrashFile("a", "1(side)\na\n3\n");
WriteTrashFile("b", "1\nb(side)\n3\n");
git.Add().AddFilepattern("a").AddFilepattern("b").Call();
RevCommit secondCommit = git.Commit().SetMessage("side").Call();
NUnit.Framework.Assert.AreEqual("1\nb(side)\n3\n", Read(new FilePath(db.WorkTree,
"b")));
CheckoutBranch("refs/heads/master");
NUnit.Framework.Assert.AreEqual("1\nb\n3\n", Read(new FilePath(db.WorkTree, "b"))
);
WriteTrashFile("a", "1\na\n3(main)\n");
git.Add().AddFilepattern("a").Call();
git.Commit().SetMessage("main").Call();
WriteTrashFile("a", "--- dirty ---");
MergeCommandResult result = git.Merge().Include(secondCommit.Id).SetStrategy(MergeStrategy
.RESOLVE).Call();
NUnit.Framework.Assert.AreEqual(MergeStatus.FAILED, result.GetMergeStatus());
NUnit.Framework.Assert.AreEqual("--- dirty ---", Read(new FilePath(db.WorkTree, "a"
)));
NUnit.Framework.Assert.AreEqual("1\nb\n3\n", Read(new FilePath(db.WorkTree, "b"))
);
NUnit.Framework.Assert.AreEqual(null, result.GetConflicts());
NUnit.Framework.Assert.AreEqual(RepositoryState.SAFE, db.GetRepositoryState());
}
public virtual void LockFailedExceptionRecovery()
{
Git git = new Git(db);
WriteTrashFile("file.txt", "content");
git.Add().AddFilepattern("file.txt").Call();
RevCommit commit1 = git.Commit().SetMessage("create file").Call();
NUnit.Framework.Assert.IsNotNull(commit1);
WriteTrashFile("file.txt", "content2");
git.Add().AddFilepattern("file.txt").Call();
NUnit.Framework.Assert.IsNotNull(git.Commit().SetMessage("edit file").Call());
NUnit.Framework.Assert.IsTrue(new LockFile(db.GetIndexFile(), db.FileSystem).Lock
());
try
{
git.Checkout().SetName(commit1.Name).Call();
NUnit.Framework.Assert.Fail("JGitInternalException not thrown");
}
catch (JGitInternalException e)
{
NUnit.Framework.Assert.IsTrue(e.InnerException is LockFailedException);
LockFile.Unlock(((LockFailedException)e.InnerException).GetFile());
git.Checkout().SetName(commit1.Name).Call();
}
}
public virtual void TestDiffCached()
{
Write(new FilePath(db.WorkTree, "test.txt"), "test");
FilePath folder = new FilePath(db.WorkTree, "folder");
folder.Mkdir();
Git git = new Git(db);
git.Add().AddFilepattern(".").Call();
git.Commit().SetMessage("Initial commit").Call();
Write(new FilePath(folder, "folder.txt"), "folder");
git.Add().AddFilepattern(".").Call();
OutputStream @out = new ByteArrayOutputStream();
IList<DiffEntry> entries = git.Diff().SetOutputStream(@out).SetCached(true).Call(
);
NUnit.Framework.Assert.AreEqual(1, entries.Count);
NUnit.Framework.Assert.AreEqual(DiffEntry.ChangeType.ADD, entries[0].GetChangeType
());
NUnit.Framework.Assert.AreEqual("/dev/null", entries[0].GetOldPath());
NUnit.Framework.Assert.AreEqual("folder/folder.txt", entries[0].GetNewPath());
string actual = @out.ToString();
string expected = "diff --git a/folder/folder.txt b/folder/folder.txt\n" + "new file mode 100644\n"
+ "index 0000000..0119635\n" + "--- /dev/null\n" + "+++ b/folder/folder.txt\n"
+ "@@ -0,0 +1 @@\n" + "+folder\n" + "\\ No newline at end of file\n";
NUnit.Framework.Assert.AreEqual(expected.ToString(), actual);
}
public virtual void CommitAmendWithAuthorShouldUseIt()
{
Git git = new Git(db);
WriteTrashFile("file1", "file1");
git.Add().AddFilepattern("file1").Call();
git.Commit().SetMessage("initial commit").Call();
RevCommit amended = git.Commit().SetAmend(true).SetAuthor("New Author", "*****@*****.**"
).SetMessage("amend commit").Call();
PersonIdent amendedAuthor = amended.GetAuthorIdent();
NUnit.Framework.Assert.AreEqual("New Author", amendedAuthor.GetName());
NUnit.Framework.Assert.AreEqual("*****@*****.**", amendedAuthor.GetEmailAddress
());
}
public virtual void TestMergeConflictFileFolder()
{
Git git = new Git(db);
WriteTrashFile("a", "1\na\n3\n");
WriteTrashFile("b", "1\nb\n3\n");
git.Add().AddFilepattern("a").AddFilepattern("b").Call();
RevCommit initialCommit = git.Commit().SetMessage("initial").Call();
CreateBranch(initialCommit, "refs/heads/side");
CheckoutBranch("refs/heads/side");
WriteTrashFile("c/c/c", "1\nc(side)\n3\n");
WriteTrashFile("d", "1\nd(side)\n3\n");
git.Add().AddFilepattern("c/c/c").AddFilepattern("d").Call();
RevCommit secondCommit = git.Commit().SetMessage("side").Call();
CheckoutBranch("refs/heads/master");
WriteTrashFile("c", "1\nc(main)\n3\n");
WriteTrashFile("d/d/d", "1\nd(main)\n3\n");
git.Add().AddFilepattern("c").AddFilepattern("d/d/d").Call();
git.Commit().SetMessage("main").Call();
MergeCommandResult result = git.Merge().Include(secondCommit.Id).SetStrategy(MergeStrategy
.RESOLVE).Call();
NUnit.Framework.Assert.AreEqual(MergeStatus.CONFLICTING, result.GetMergeStatus());
NUnit.Framework.Assert.AreEqual("1\na\n3\n", Read(new FilePath(db.WorkTree, "a"))
);
NUnit.Framework.Assert.AreEqual("1\nb\n3\n", Read(new FilePath(db.WorkTree, "b"))
);
NUnit.Framework.Assert.AreEqual("1\nc(main)\n3\n", Read(new FilePath(db.WorkTree,
"c")));
NUnit.Framework.Assert.AreEqual("1\nd(main)\n3\n", Read(new FilePath(db.WorkTree,
"d/d/d")));
NUnit.Framework.Assert.AreEqual(null, result.GetConflicts());
NUnit.Framework.Assert.AreEqual(RepositoryState.MERGING, db.GetRepositoryState());
}
public virtual void TestAddExistingSingleBinaryFile()
{
FilePath file = new FilePath(db.WorkTree, "a.txt");
FileUtils.CreateNewFile(file);
PrintWriter writer = new PrintWriter(file);
writer.Write("row1\r\nrow2\u0000");
writer.Close();
Git git = new Git(db);
((FileBasedConfig)db.GetConfig()).SetString("core", null, "autocrlf", "false");
git.Add().AddFilepattern("a.txt").Call();
NUnit.Framework.Assert.AreEqual("[a.txt, mode:100644, content:row1\r\nrow2\u0000]"
, IndexState(CONTENT));
((FileBasedConfig)db.GetConfig()).SetString("core", null, "autocrlf", "true");
git.Add().AddFilepattern("a.txt").Call();
NUnit.Framework.Assert.AreEqual("[a.txt, mode:100644, content:row1\r\nrow2\u0000]"
, IndexState(CONTENT));
((FileBasedConfig)db.GetConfig()).SetString("core", null, "autocrlf", "input");
git.Add().AddFilepattern("a.txt").Call();
NUnit.Framework.Assert.AreEqual("[a.txt, mode:100644, content:row1\r\nrow2\u0000]"
, IndexState(CONTENT));
}
public virtual void TestListAllTagsInRepositoryInOrder()
{
Git git = new Git(db);
git.Add().AddFilepattern("*").Call();
git.Commit().SetMessage("initial commit").Call();
git.Tag().SetName("v3").Call();
git.Tag().SetName("v2").Call();
git.Tag().SetName("v10").Call();
IList <Ref> list = git.TagList().Call();
NUnit.Framework.Assert.AreEqual(3, list.Count);
NUnit.Framework.Assert.AreEqual("refs/tags/v10", list[0].GetName());
NUnit.Framework.Assert.AreEqual("refs/tags/v2", list[1].GetName());
NUnit.Framework.Assert.AreEqual("refs/tags/v3", list[2].GetName());
}
public virtual void TestAddExistingSingleFileInSubDir()
{
FileUtils.Mkdir(new FilePath(db.WorkTree, "sub"));
FilePath file = new FilePath(db.WorkTree, "sub/a.txt");
FileUtils.CreateNewFile(file);
PrintWriter writer = new PrintWriter(file);
writer.Write("content");
writer.Close();
Git git = new Git(db);
git.Add().AddFilepattern("sub/a.txt").Call();
NUnit.Framework.Assert.AreEqual("[sub/a.txt, mode:100644, content:content]", IndexState
(CONTENT));
}
public virtual void ResolveDate()
{
Git git = new Git(db);
WriteTrashFile("file.txt", "content");
git.Add().AddFilepattern("file.txt").Call();
git.Commit().SetMessage("create file").Call();
try
{
db.Resolve("master@{yesterday}");
NUnit.Framework.Assert.Fail("Exception not thrown");
}
catch (RevisionSyntaxException e)
{
NUnit.Framework.Assert.IsNotNull(e);
}
}
public virtual void TestCheckoutWithNonDeletedFiles()
{
FilePath testFile = WriteTrashFile("temp", string.Empty);
FileInputStream fis = new FileInputStream(testFile);
try
{
FileUtils.Delete(testFile);
return;
}
catch (IOException)
{
}
// the test makes only sense if deletion of
// a file with open stream fails
fis.Close();
FileUtils.Delete(testFile);
CheckoutCommand co = git.Checkout();
// delete Test.txt in branch test
testFile = new FilePath(db.WorkTree, "Test.txt");
NUnit.Framework.Assert.IsTrue(testFile.Exists());
FileUtils.Delete(testFile);
NUnit.Framework.Assert.IsFalse(testFile.Exists());
git.Add().AddFilepattern("Test.txt");
git.Commit().SetMessage("Delete Test.txt").SetAll(true).Call();
git.Checkout().SetName("master").Call();
NUnit.Framework.Assert.IsTrue(testFile.Exists());
// lock the file so it can't be deleted (in Windows, that is)
fis = new FileInputStream(testFile);
try
{
NUnit.Framework.Assert.AreEqual(CheckoutResult.Status.NOT_TRIED, co.GetResult().GetStatus
());
co.SetName("test").Call();
NUnit.Framework.Assert.IsTrue(testFile.Exists());
NUnit.Framework.Assert.AreEqual(CheckoutResult.Status.NONDELETED, co.GetResult().
GetStatus());
NUnit.Framework.Assert.IsTrue(co.GetResult().GetUndeletedList().Contains("Test.txt"
));
}
finally
{
fis.Close();
}
}
public virtual void TestUpdateWorkingDirectoryFromIndex()
{
CheckoutCommand co = git.Checkout();
FilePath written = WriteTrashFile(FILE1, "3a");
git.Add().AddFilepattern(FILE1).Call();
written = WriteTrashFile(FILE1, string.Empty);
NUnit.Framework.Assert.AreEqual(string.Empty, Read(written));
co.AddPath(FILE1).Call();
NUnit.Framework.Assert.AreEqual("3a", Read(written));
NUnit.Framework.Assert.AreEqual("c", Read(new FilePath(db.WorkTree, FILE2)));
}
public virtual void TestDiffWithNegativeLineCount()
{
Write(new FilePath(db.WorkTree, "test.txt"), "0\n1\n2\n3\n4\n5\n6\n7\n8\n9");
Git git = new Git(db);
git.Add().AddFilepattern(".").Call();
git.Commit().SetMessage("Initial commit").Call();
Write(new FilePath(db.WorkTree, "test.txt"), "0\n1\n2\n3\n4a\n5\n6\n7\n8\n9");
OutputStream @out = new ByteArrayOutputStream();
git.Diff().SetOutputStream(@out).SetContextLines(1).Call();
string actual = @out.ToString();
string expected = "diff --git a/test.txt b/test.txt\n" + "index f55b5c9..c5ec8fd 100644\n"
+ "--- a/test.txt\n" + "+++ b/test.txt\n" + "@@ -4,3 +4,3 @@\n" + " 3\n" + "-4\n"
+ "+4a\n" + " 5\n";
NUnit.Framework.Assert.AreEqual(expected.ToString(), actual);
}
/// <exception cref="System.Exception"></exception>
private ApplyResult Init(string name, bool preExists, bool postExists)
{
Git git = new Git(db);
if (preExists)
{
a = new RawText(ReadFile(name + "_PreImage"));
Write(new FilePath(db.Directory.GetParent(), name), a.GetString(0, a.Size(), false
));
git.Add().AddFilepattern(name).Call();
git.Commit().SetMessage("PreImage").Call();
}
if (postExists)
{
b = new RawText(ReadFile(name + "_PostImage"));
}
return git.Apply().SetPatch(typeof(DiffFormatterReflowTest).GetResourceAsStream(name
+ ".patch")).Call();
}
public virtual void TestSingleRevision()
{
Git git = new Git(db);
string[] content = new string[] { "first", "second", "third" };
WriteTrashFile("file.txt", Join(content));
git.Add().AddFilepattern("file.txt").Call();
RevCommit commit = git.Commit().SetMessage("create file").Call();
BlameCommand command = new BlameCommand(db);
command.SetFilePath("file.txt");
BlameResult lines = command.Call();
NUnit.Framework.Assert.IsNotNull(lines);
NUnit.Framework.Assert.AreEqual(3, lines.GetResultContents().Size());
for (int i = 0; i < 3; i++)
{
NUnit.Framework.Assert.AreEqual(commit, lines.GetSourceCommit(i));
NUnit.Framework.Assert.AreEqual(i, lines.GetSourceLine(i));
}
}
public virtual void ShouldListAddedFileInInitialCommit()
{
// given
WriteTrashFile("a.txt", "content");
Git git = new Git(db);
git.Add().AddFilepattern("a.txt").Call();
RevCommit c = git.Commit().SetMessage("initial commit").Call();
// when
TreeWalk walk = new TreeWalk(db);
walk.AddTree(new EmptyTreeIterator());
walk.AddTree(c.Tree);
IList<DiffEntry> result = DiffEntry.Scan(walk);
// then
Assert.IsNotNull (result);
Assert.AreEqual(1, result.Count);
DiffEntry entry = result[0];
Assert.AreEqual(entry.GetChangeType(), DiffEntry.ChangeType.ADD);
Assert.AreEqual(entry.GetNewPath(), "a.txt");
Assert.AreEqual(entry.GetOldPath(), DiffEntry.DEV_NULL);
}
public virtual void TestDiff()
{
Write(new FilePath(db.Directory.GetParent(), "test.txt"), "test");
FilePath folder = new FilePath(db.Directory.GetParent(), "folder");
folder.Mkdir();
Write(new FilePath(folder, "folder.txt"), "folder");
Git git = new Git(db);
git.Add().AddFilepattern(".").Call();
git.Commit().SetMessage("Initial commit").Call();
Write(new FilePath(folder, "folder.txt"), "folder change");
PatchIdDiffFormatter df = new PatchIdDiffFormatter();
df.SetRepository(db);
df.SetPathFilter(PathFilter.Create("folder"));
DirCacheIterator oldTree = new DirCacheIterator(db.ReadDirCache());
FileTreeIterator newTree = new FileTreeIterator(db);
df.Format(oldTree, newTree);
df.Flush();
NUnit.Framework.Assert.AreEqual("1ff64e0f9333e9b81967c3e8d7a81362b14d5441", df.GetCalulatedPatchId
().Name);
}
