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