public virtual void TestSingleDeletion() { 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()); git.Add().AddFilepattern("b").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(); RevCommit thirdCommit = 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.MERGED, result.GetMergeStatus()); NUnit.Framework.Assert.AreEqual("1\na\n3(main)\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")) ); // Do the opposite, be on a branch where we have deleted a file and // merge in a old commit where this file was not deleted CheckoutBranch("refs/heads/side"); NUnit.Framework.Assert.IsFalse(new FilePath(db.WorkTree, "b").Exists()); result = git.Merge().Include(thirdCommit.Id).SetStrategy(MergeStrategy.RESOLVE).Call (); NUnit.Framework.Assert.AreEqual(MergeStatus.MERGED, result.GetMergeStatus()); NUnit.Framework.Assert.AreEqual("1\na\n3(main)\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 TestDeletionOnSideConflict() { 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(); // create side branch and delete "a" CreateBranch(initialCommit, "refs/heads/side"); CheckoutBranch("refs/heads/side"); git.Rm().AddFilepattern("a").Call(); RevCommit secondCommit = git.Commit().SetMessage("side").Call(); // update a on master to generate conflict CheckoutBranch("refs/heads/master"); WriteTrashFile("a", "1\na(main)\n3\n"); git.Add().AddFilepattern("a").Call(); git.Commit().SetMessage("main").Call(); // merge side with master MergeCommandResult result = git.Merge().Include(secondCommit.Id).SetStrategy(MergeStrategy .RESOLVE).Call(); NUnit.Framework.Assert.AreEqual(MergeStatus.CONFLICTING, result.GetMergeStatus()); NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "a").Exists()); NUnit.Framework.Assert.AreEqual("1\na(main)\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, result.GetConflicts().Count); NUnit.Framework.Assert.AreEqual(3, result.GetConflicts().Get("a")[0].Length); }
public virtual void TestConflictingMergeFailsDueToDirtyWorktree() { Git git = new Git(db); FilePath fileA = WriteTrashFile("a", "a"); RevCommit initialCommit = AddAllAndCommit(git); // switch branch CreateBranch(initialCommit, "refs/heads/side"); CheckoutBranch("refs/heads/side"); // modify file a Write(fileA, "a(side)"); WriteTrashFile("b", "b"); RevCommit sideCommit = AddAllAndCommit(git); // switch branch CheckoutBranch("refs/heads/master"); // modify file a - this will cause a conflict during merge Write(fileA, "a(master)"); WriteTrashFile("c", "c"); AddAllAndCommit(git); // modify file a Write(fileA, "a(modified)"); // do not add and commit // get current index state string indexState = IndexState(CONTENT); // merge MergeCommandResult result = git.Merge().Include(sideCommit.Id).SetStrategy(MergeStrategy .RESOLVE).Call(); CheckMergeFailedResult(result, ResolveMerger.MergeFailureReason.DIRTY_WORKTREE, indexState , fileA); }
public virtual void TestFastForwardWithFiles() { 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"); WriteTrashFile("file2", "file2"); git.Add().AddFilepattern("file2").Call(); RevCommit second = git.Commit().SetMessage("second commit").Call(); NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "file2").Exists()); CheckoutBranch("refs/heads/branch1"); NUnit.Framework.Assert.IsFalse(new FilePath(db.WorkTree, "file2").Exists()); MergeCommandResult result = git.Merge().Include(db.GetRef(Constants.MASTER)).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, result.GetMergeStatus() ); NUnit.Framework.Assert.AreEqual(second, result.GetNewHead()); }
public virtual void TestSuccessfulMergeFailsDueToDirtyIndex() { Git git = new Git(db); FilePath fileA = WriteTrashFile("a", "a"); RevCommit initialCommit = AddAllAndCommit(git); // switch branch CreateBranch(initialCommit, "refs/heads/side"); CheckoutBranch("refs/heads/side"); // modify file a Write(fileA, "a(side)"); WriteTrashFile("b", "b"); RevCommit sideCommit = AddAllAndCommit(git); // switch branch CheckoutBranch("refs/heads/master"); WriteTrashFile("c", "c"); AddAllAndCommit(git); // modify and add file a Write(fileA, "a(modified)"); git.Add().AddFilepattern("a").Call(); // do not commit // get current index state string indexState = IndexState(CONTENT); // merge MergeCommandResult result = git.Merge().Include(sideCommit.Id).SetStrategy(MergeStrategy .RESOLVE).Call(); CheckMergeFailedResult(result, ResolveMerger.MergeFailureReason.DIRTY_INDEX, indexState , fileA); }
public virtual void TestHardResetAfterSquashMerge() { Git g = new Git(db); WriteTrashFile("file1", "file1"); g.Add().AddFilepattern("file1").Call(); RevCommit first = g.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"); g.Add().AddFilepattern("file2").Call(); g.Commit().SetMessage("second commit").Call(); NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "file2").Exists()); CheckoutBranch("refs/heads/master"); MergeCommandResult result = g.Merge().Include(db.GetRef("branch1")).SetSquash(true ).Call(); NUnit.Framework.Assert.AreEqual(MergeStatus.FAST_FORWARD_SQUASHED, result.GetMergeStatus ()); NUnit.Framework.Assert.IsNotNull(db.ReadSquashCommitMsg()); g.Reset().SetMode(ResetCommand.ResetType.HARD).SetRef(first.GetName()).Call(); NUnit.Framework.Assert.IsNull(db.ReadSquashCommitMsg()); }
public virtual void TestPullFastForwardWithBranchInSource() { PullResult res = target.Pull().Call(); // nothing to update since we don't have different data yet NUnit.Framework.Assert.IsTrue(res.GetFetchResult().GetTrackingRefUpdates().IsEmpty ()); NUnit.Framework.Assert.AreEqual(RebaseResult.Status.UP_TO_DATE, res.GetRebaseResult ().GetStatus()); AssertFileContentsEqual(targetFile, "Hello world"); // change the source file WriteToFile(sourceFile, "Another change\n\n\n\nFoo"); source.Add().AddFilepattern("SomeFile.txt").Call(); RevCommit initialCommit = source.Commit().SetMessage("Some change in remote").Call (); // modify the source file in a branch CreateBranch(initialCommit, "refs/heads/side"); CheckoutBranch("refs/heads/side"); WriteToFile(sourceFile, "Another change\n\n\n\nBoo"); source.Add().AddFilepattern("SomeFile.txt").Call(); RevCommit sideCommit = source.Commit().SetMessage("Some change in remote").Call(); // modify the source file on master CheckoutBranch("refs/heads/master"); WriteToFile(sourceFile, "More change\n\n\n\nFoo"); source.Add().AddFilepattern("SomeFile.txt").Call(); source.Commit().SetMessage("Some change in remote").Call(); // merge side into master MergeCommandResult result = source.Merge().Include(sideCommit.Id).SetStrategy(MergeStrategy .RESOLVE).Call(); NUnit.Framework.Assert.AreEqual(MergeStatus.MERGED, result.GetMergeStatus()); }
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 virtual void TestMultipleCreationsSameContent() { 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(1)\n3\n"); git.Add().AddFilepattern("b").Call(); RevCommit secondCommit = git.Commit().SetMessage("side").Call(); CheckoutBranch("refs/heads/master"); WriteTrashFile("b", "1\nb(1)\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.MERGED, result.GetMergeStatus()); NUnit.Framework.Assert.AreEqual("1\nb(1)\n3\n", Read(new FilePath(db.WorkTree, "b" ))); }
public virtual void TestMultipleDeletions() { 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"); NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "a").Delete()); git.Add().AddFilepattern("a").SetUpdate(true).Call(); RevCommit secondCommit = git.Commit().SetMessage("side").Call(); NUnit.Framework.Assert.IsFalse(new FilePath(db.WorkTree, "a").Exists()); CheckoutBranch("refs/heads/master"); NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "a").Exists()); NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "a").Delete()); git.Add().AddFilepattern("a").SetUpdate(true).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.MERGED, result.GetMergeStatus()); }
public virtual void TestMultipleHeads() { Git git = new Git(db); WriteTrashFile("file1", "file1"); git.Add().AddFilepattern("file1").Call(); RevCommit first = git.Commit().SetMessage("initial commit").Call(); CreateBranch(first, "refs/heads/branch1"); WriteTrashFile("file2", "file2"); git.Add().AddFilepattern("file2").Call(); RevCommit second = git.Commit().SetMessage("second commit").Call(); WriteTrashFile("file3", "file3"); git.Add().AddFilepattern("file3").Call(); git.Commit().SetMessage("third commit").Call(); CheckoutBranch("refs/heads/branch1"); NUnit.Framework.Assert.IsFalse(new FilePath(db.WorkTree, "file2").Exists()); NUnit.Framework.Assert.IsFalse(new FilePath(db.WorkTree, "file3").Exists()); MergeCommand merge = git.Merge(); merge.Include(second.Id); merge.Include(db.GetRef(Constants.MASTER)); try { merge.Call(); NUnit.Framework.Assert.Fail("Expected exception not thrown when merging multiple heads" ); } catch (InvalidMergeHeadsException) { } }
public virtual void TestMergeInItself() { Git git = new Git(db); git.Commit().SetMessage("initial commit").Call(); MergeCommandResult result = git.Merge().Include(db.GetRef(Constants.HEAD)).Call(); NUnit.Framework.Assert.AreEqual(MergeStatus.ALREADY_UP_TO_DATE, result.GetMergeStatus ()); }
/// <exception cref="System.Exception"></exception> public virtual void UnmergedPathsShouldCauseException() { CommitFile("file.txt", "master", "base"); RevCommit side = CommitFile("file.txt", "side", "side"); CommitFile("file.txt", "master", "master"); git.Merge().Include(side).Call(); git.StashCreate().Call(); }
public virtual void TestSuccessfulContentMergeAndDirtyworkingTree() { 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"); 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"); WriteTrashFile("c/c/c", "1\nc(main)\n3\n"); git.Add().AddFilepattern("a").AddFilepattern("c/c/c").Call(); RevCommit thirdCommit = git.Commit().SetMessage("main").Call(); WriteTrashFile("d", "--- dirty ---"); MergeCommandResult result = git.Merge().Include(secondCommit.Id).SetStrategy(MergeStrategy .RESOLVE).Call(); NUnit.Framework.Assert.AreEqual(MergeStatus.MERGED, result.GetMergeStatus()); NUnit.Framework.Assert.AreEqual("1(side)\na\n3(main)\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("--- dirty ---", Read(new FilePath(db.WorkTree, "d" ))); NUnit.Framework.Assert.AreEqual(null, result.GetConflicts()); NUnit.Framework.Assert.IsTrue(2 == result.GetMergedCommits().Length); NUnit.Framework.Assert.AreEqual(thirdCommit, result.GetMergedCommits()[0]); NUnit.Framework.Assert.AreEqual(secondCommit, result.GetMergedCommits()[1]); Iterator <RevCommit> it = git.Log().Call().Iterator(); RevCommit newHead = it.Next(); NUnit.Framework.Assert.AreEqual(newHead, result.GetNewHead()); NUnit.Framework.Assert.AreEqual(2, newHead.ParentCount); NUnit.Framework.Assert.AreEqual(thirdCommit, newHead.GetParent(0)); NUnit.Framework.Assert.AreEqual(secondCommit, newHead.GetParent(1)); NUnit.Framework.Assert.AreEqual("Merge commit '064d54d98a4cdb0fed1802a21c656bfda67fe879'" , newHead.GetFullMessage()); NUnit.Framework.Assert.AreEqual(RepositoryState.SAFE, db.GetRepositoryState()); }
public virtual void TestAlreadyUpToDate() { Git git = new Git(db); RevCommit first = git.Commit().SetMessage("initial commit").Call(); CreateBranch(first, "refs/heads/branch1"); RevCommit second = git.Commit().SetMessage("second commit").Call(); MergeCommandResult result = git.Merge().Include(db.GetRef("refs/heads/branch1")). Call(); NUnit.Framework.Assert.AreEqual(MergeStatus.ALREADY_UP_TO_DATE, result.GetMergeStatus ()); NUnit.Framework.Assert.AreEqual(second, result.GetNewHead()); }
public virtual void TestMergeInItself() { Git git = new Git(db); git.Commit().SetMessage("initial commit").Call(); MergeCommandResult result = git.Merge().Include(db.GetRef(Constants.HEAD)).Call(); NUnit.Framework.Assert.AreEqual(MergeStatus.ALREADY_UP_TO_DATE, result.GetMergeStatus ()); // no reflog entry written by merge NUnit.Framework.Assert.AreEqual("commit: initial commit", db.GetReflogReader(Constants .HEAD).GetLastEntry().GetComment()); NUnit.Framework.Assert.AreEqual("commit: initial commit", db.GetReflogReader(db.GetBranch ()).GetLastEntry().GetComment()); }
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); }
/// <exception cref="System.Exception"></exception> public virtual void TestCheckoutOfConflictingFileShouldThrow() { // Setup git.Checkout().SetCreateBranch(true).SetName("conflict").SetStartPoint(initialCommit ).Call(); WriteTrashFile(FILE1, "Conflicting"); RevCommit conflict = git.Commit().SetAll(true).SetMessage("Conflicting change").Call (); git.Checkout().SetName("master").Call(); git.Merge().Include(conflict).Call(); NUnit.Framework.Assert.AreEqual(RepositoryState.MERGING, db.GetRepositoryState()); // Now check out the conflicting path git.Checkout().AddPath(FILE1).Call(); }
public virtual void TestFastForward() { Git git = new Git(db); RevCommit first = git.Commit().SetMessage("initial commit").Call(); CreateBranch(first, "refs/heads/branch1"); RevCommit second = git.Commit().SetMessage("second commit").Call(); CheckoutBranch("refs/heads/branch1"); MergeCommandResult result = git.Merge().Include(db.GetRef(Constants.MASTER)).Call (); NUnit.Framework.Assert.AreEqual(MergeStatus.FAST_FORWARD, result.GetMergeStatus() ); NUnit.Framework.Assert.AreEqual(second, result.GetNewHead()); }
public virtual void TestMergeNonVersionedPaths() { 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(); WriteTrashFile("d", "1\nd\n3\n"); NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "e").Mkdir()); 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\nd\n3\n", Read(new FilePath(db.WorkTree, "d")) ); FilePath dir = new FilePath(db.WorkTree, "e"); NUnit.Framework.Assert.IsTrue(dir.IsDirectory()); 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 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 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 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 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 TestFastForward() { Git git = new Git(db); RevCommit first = git.Commit().SetMessage("initial commit").Call(); CreateBranch(first, "refs/heads/branch1"); RevCommit second = git.Commit().SetMessage("second commit").Call(); CheckoutBranch("refs/heads/branch1"); MergeCommandResult result = git.Merge().Include(db.GetRef(Constants.MASTER)).Call (); NUnit.Framework.Assert.AreEqual(MergeStatus.FAST_FORWARD, result.GetMergeStatus() ); NUnit.Framework.Assert.AreEqual(second, result.GetNewHead()); NUnit.Framework.Assert.AreEqual("merge refs/heads/master: Fast-forward", db.GetReflogReader (Constants.HEAD).GetLastEntry().GetComment()); NUnit.Framework.Assert.AreEqual("merge refs/heads/master: Fast-forward", db.GetReflogReader (db.GetBranch()).GetLastEntry().GetComment()); }
public virtual void TestFileModeMergeWithDirtyWorkTree() { if (!FS.DETECTED.SupportsExecute()) { return; } // Only Java6 (or set x bit in index) Git git = new Git(db); WriteTrashFile("mergeableButDirty", "a"); SetExecutable(git, "mergeableButDirty", false); RevCommit initialCommit = AddAllAndCommit(git); // switch branch CreateBranch(initialCommit, "refs/heads/side"); CheckoutBranch("refs/heads/side"); SetExecutable(git, "mergeableButDirty", true); RevCommit sideCommit = AddAllAndCommit(git); // switch branch CreateBranch(initialCommit, "refs/heads/side2"); CheckoutBranch("refs/heads/side2"); SetExecutable(git, "mergeableButDirty", false); AddAllAndCommit(git); WriteTrashFile("mergeableButDirty", "b"); // merge MergeCommandResult result = git.Merge().Include(sideCommit.Id).SetStrategy(MergeStrategy .RESOLVE).Call(); NUnit.Framework.Assert.AreEqual(MergeStatus.FAILED, result.GetMergeStatus()); NUnit.Framework.Assert.IsFalse(CanExecute(git, "mergeableButDirty")); }
public virtual void TestResetHard() { Git git = new Git(db); WriteTrashFile("f", "f()"); WriteTrashFile("D/g", "g()"); git.Add().AddFilepattern(".").Call(); git.Commit().SetMessage("inital").Call(); AssertIndex(Mkmap("f", "f()", "D/g", "g()")); git.BranchCreate().SetName("topic").Call(); WriteTrashFile("f", "f()\nmaster"); WriteTrashFile("D/g", "g()\ng2()"); WriteTrashFile("E/h", "h()"); git.Add().AddFilepattern(".").Call(); RevCommit master = git.Commit().SetMessage("master-1").Call(); AssertIndex(Mkmap("f", "f()\nmaster", "D/g", "g()\ng2()", "E/h", "h()")); CheckoutBranch("refs/heads/topic"); AssertIndex(Mkmap("f", "f()", "D/g", "g()")); WriteTrashFile("f", "f()\nside"); NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "D/g").Delete()); WriteTrashFile("G/i", "i()"); git.Add().AddFilepattern(".").Call(); git.Add().AddFilepattern(".").SetUpdate(true).Call(); RevCommit topic = git.Commit().SetMessage("topic-1").Call(); AssertIndex(Mkmap("f", "f()\nside", "G/i", "i()")); WriteTrashFile("untracked", "untracked"); ResetHard(master); AssertIndex(Mkmap("f", "f()\nmaster", "D/g", "g()\ng2()", "E/h", "h()")); ResetHard(topic); AssertIndex(Mkmap("f", "f()\nside", "G/i", "i()")); AssertWorkDir(Mkmap("f", "f()\nside", "G/i", "i()", "untracked", "untracked")); NUnit.Framework.Assert.AreEqual(MergeStatus.CONFLICTING, git.Merge().Include(master ).Call().GetMergeStatus()); NUnit.Framework.Assert.AreEqual("[D/g, mode:100644, stage:1][D/g, mode:100644, stage:3][E/h, mode:100644][G/i, mode:100644][f, mode:100644, stage:1][f, mode:100644, stage:2][f, mode:100644, stage:3]" , IndexState(0)); ResetHard(master); AssertIndex(Mkmap("f", "f()\nmaster", "D/g", "g()\ng2()", "E/h", "h()")); AssertWorkDir(Mkmap("f", "f()\nmaster", "D/g", "g()\ng2()", "E/h", "h()", "untracked" , "untracked")); }
public void Merge (string branch, GitUpdateOptions options, IProgressMonitor monitor) { IEnumerable<DiffEntry> statusList = null; Stash stash = null; StashCollection stashes = GetStashes (RootRepository); NGit.Api.Git git = new NGit.Api.Git (RootRepository); try { monitor.BeginTask (GettextCatalog.GetString ("Merging"), 5); List<string> UpdateSubmodules = new List<string> (); // TODO: Fix stash so we don't have to do update before the main repo update. if ((options & GitUpdateOptions.UpdateSubmodules) == GitUpdateOptions.UpdateSubmodules) { monitor.Log.WriteLine (GettextCatalog.GetString ("Checking repository submodules")); if (!GetSubmodulesToUpdate (UpdateSubmodules)) return; monitor.Log.WriteLine (GettextCatalog.GetString ("Updating repository submodules")); var submoduleUpdate = git.SubmoduleUpdate (); foreach (var submodule in UpdateSubmodules) submoduleUpdate.AddPath (submodule); submoduleUpdate.Call (); monitor.Step (1); } // Get a list of files that are different in the target branch statusList = GitUtil.GetChangedFiles (RootRepository, branch); monitor.Step (1); if ((options & GitUpdateOptions.SaveLocalChanges) != GitUpdateOptions.SaveLocalChanges) { const VersionStatus unclean = VersionStatus.Modified | VersionStatus.ScheduledAdd | VersionStatus.ScheduledDelete; bool modified = false; if (GetDirectoryVersionInfo (RootPath, false, true).Any (v => (v.Status & unclean) != VersionStatus.Unversioned)) modified = true; if (modified) { if (MessageService.GenericAlert ( MonoDevelop.Ide.Gui.Stock.Question, GettextCatalog.GetString ("You have uncommitted changes"), GettextCatalog.GetString ("What do you want to do?"), AlertButton.Cancel, new AlertButton ("Stash")) == AlertButton.Cancel) return; options |= GitUpdateOptions.SaveLocalChanges; } } if ((options & GitUpdateOptions.SaveLocalChanges) == GitUpdateOptions.SaveLocalChanges) { monitor.Log.WriteLine (GettextCatalog.GetString ("Saving local changes")); using (var gm = new GitMonitor (monitor)) stash = stashes.Create (gm, GetStashName ("_tmp_")); monitor.Step (1); } // Apply changes ObjectId branchId = RootRepository.Resolve (branch); MergeCommandResult mergeResult = git.Merge ().SetStrategy (MergeStrategy.RESOLVE).Include (branchId).Call (); if (mergeResult.GetMergeStatus () == MergeStatus.CONFLICTING || mergeResult.GetMergeStatus () == MergeStatus.FAILED) { var conflicts = mergeResult.GetConflicts (); bool commit = true; if (conflicts != null) { foreach (string conflictFile in conflicts.Keys) { ConflictResult res = ResolveConflict (RootRepository.FromGitPath (conflictFile)); if (res == ConflictResult.Abort) { GitUtil.HardReset (RootRepository, GetHeadCommit (RootRepository)); commit = false; break; } else if (res == ConflictResult.Skip) { Revert (RootRepository.FromGitPath (conflictFile), false, monitor); break; } } } if (commit) git.Commit ().Call (); } if ((options & GitUpdateOptions.UpdateSubmodules) == GitUpdateOptions.UpdateSubmodules) { monitor.Log.WriteLine (GettextCatalog.GetString ("Updating repository submodules")); var submoduleUpdate = git.SubmoduleUpdate (); foreach (var submodule in CachedSubmodules) submoduleUpdate.AddPath (submodule.Item1); submoduleUpdate.Call (); monitor.Step (1); } } finally { if ((options & GitUpdateOptions.SaveLocalChanges) == GitUpdateOptions.SaveLocalChanges) monitor.Step (1); // Restore local changes if (stash != null) { monitor.Log.WriteLine (GettextCatalog.GetString ("Restoring local changes")); using (var gm = new GitMonitor (monitor)) stash.Apply (gm); stashes.Remove (stash); monitor.Step (1); } monitor.EndTask (); } // Notify changes if (statusList != null) NotifyFileChanges (monitor, statusList); }
public virtual void TestSquashMergeConflict() { 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"); WriteTrashFile("file2", "master"); git.Add().AddFilepattern("file2").Call(); RevCommit second = git.Commit().SetMessage("second commit").Call(); NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "file2").Exists()); CheckoutBranch("refs/heads/branch1"); WriteTrashFile("file2", "branch"); git.Add().AddFilepattern("file2").Call(); RevCommit third = git.Commit().SetMessage("third commit").Call(); NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "file2").Exists()); CheckoutBranch("refs/heads/master"); NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "file1").Exists()); NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "file2").Exists()); 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.CONFLICTING, result.GetMergeStatus()); NUnit.Framework.Assert.IsNull(result.GetNewHead()); NUnit.Framework.Assert.AreEqual(second, db.Resolve(Constants.HEAD + "^{commit}")); NUnit.Framework.Assert.AreEqual("Squashed commit of the following:\n\ncommit " + third.GetName() + "\nAuthor: " + third.GetAuthorIdent().GetName() + " <" + third .GetAuthorIdent().GetEmailAddress() + ">\nDate: " + dateFormatter.FormatDate(third .GetAuthorIdent()) + "\n\n\tthird commit\n", db.ReadSquashCommitMsg()); NUnit.Framework.Assert.AreEqual("\nConflicts:\n\tfile2\n", db.ReadMergeCommitMsg( )); Status stat = git.Status().Call(); NUnit.Framework.CollectionAssert.AreEquivalent(StatusCommandTest.Set("file2"), stat.GetConflicting ()); }
public virtual void TestAlreadyUpToDate() { Git git = new Git(db); RevCommit first = git.Commit().SetMessage("initial commit").Call(); CreateBranch(first, "refs/heads/branch1"); RevCommit second = git.Commit().SetMessage("second commit").Call(); MergeCommandResult result = git.Merge().Include(db.GetRef("refs/heads/branch1")). Call(); NUnit.Framework.Assert.AreEqual(MergeStatus.ALREADY_UP_TO_DATE, result.GetMergeStatus ()); NUnit.Framework.Assert.AreEqual(second, result.GetNewHead()); // no reflog entry written by merge NUnit.Framework.Assert.AreEqual("commit: second commit", db.GetReflogReader(Constants .HEAD).GetLastEntry().GetComment()); NUnit.Framework.Assert.AreEqual("commit: second commit", db.GetReflogReader(db.GetBranch ()).GetLastEntry().GetComment()); }
public virtual void TestMultipleCreationsSameContent() { 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(1)\n3\n"); git.Add().AddFilepattern("b").Call(); RevCommit secondCommit = git.Commit().SetMessage("side").Call(); CheckoutBranch("refs/heads/master"); WriteTrashFile("b", "1\nb(1)\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.MERGED, result.GetMergeStatus()); NUnit.Framework.Assert.AreEqual("1\nb(1)\n3\n", Read(new FilePath(db.WorkTree, "b" ))); NUnit.Framework.Assert.AreEqual("merge " + secondCommit.Id.GetName() + ": Merge made by resolve." , db.GetReflogReader(Constants.HEAD).GetLastEntry().GetComment()); NUnit.Framework.Assert.AreEqual("merge " + secondCommit.Id.GetName() + ": Merge made by resolve." , db.GetReflogReader(db.GetBranch()).GetLastEntry().GetComment()); }
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 TestFileModeMerge() { if (!FS.DETECTED.SupportsExecute()) { return; } // Only Java6 Git git = new Git(db); WriteTrashFile("mergeableMode", "a"); SetExecutable(git, "mergeableMode", false); WriteTrashFile("conflictingModeWithBase", "a"); SetExecutable(git, "conflictingModeWithBase", false); RevCommit initialCommit = AddAllAndCommit(git); // switch branch CreateBranch(initialCommit, "refs/heads/side"); CheckoutBranch("refs/heads/side"); SetExecutable(git, "mergeableMode", true); WriteTrashFile("conflictingModeNoBase", "b"); SetExecutable(git, "conflictingModeNoBase", true); RevCommit sideCommit = AddAllAndCommit(git); // switch branch CreateBranch(initialCommit, "refs/heads/side2"); CheckoutBranch("refs/heads/side2"); SetExecutable(git, "mergeableMode", false); NUnit.Framework.Assert.IsFalse(new FilePath(git.GetRepository().WorkTree, "conflictingModeNoBase" ).Exists()); WriteTrashFile("conflictingModeNoBase", "b"); SetExecutable(git, "conflictingModeNoBase", false); AddAllAndCommit(git); // merge MergeCommandResult result = git.Merge().Include(sideCommit.Id).SetStrategy(MergeStrategy .RESOLVE).Call(); NUnit.Framework.Assert.AreEqual(MergeStatus.CONFLICTING, result.GetMergeStatus()); NUnit.Framework.Assert.IsTrue(CanExecute(git, "mergeableMode")); NUnit.Framework.Assert.IsFalse(CanExecute(git, "conflictingModeNoBase")); }
public virtual void TestSuccessfulContentMergeAndDirtyworkingTree() { 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"); 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"); WriteTrashFile("c/c/c", "1\nc(main)\n3\n"); git.Add().AddFilepattern("a").AddFilepattern("c/c/c").Call(); RevCommit thirdCommit = git.Commit().SetMessage("main").Call(); WriteTrashFile("d", "--- dirty ---"); MergeCommandResult result = git.Merge().Include(secondCommit.Id).SetStrategy(MergeStrategy .RESOLVE).Call(); NUnit.Framework.Assert.AreEqual(MergeStatus.MERGED, result.GetMergeStatus()); NUnit.Framework.Assert.AreEqual("1(side)\na\n3(main)\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("--- dirty ---", Read(new FilePath(db.WorkTree, "d" ))); NUnit.Framework.Assert.AreEqual(null, result.GetConflicts()); NUnit.Framework.Assert.IsTrue(2 == result.GetMergedCommits().Length); NUnit.Framework.Assert.AreEqual(thirdCommit, result.GetMergedCommits()[0]); NUnit.Framework.Assert.AreEqual(secondCommit, result.GetMergedCommits()[1]); Iterator<RevCommit> it = git.Log().Call().Iterator(); RevCommit newHead = it.Next(); NUnit.Framework.Assert.AreEqual(newHead, result.GetNewHead()); NUnit.Framework.Assert.AreEqual(2, newHead.ParentCount); NUnit.Framework.Assert.AreEqual(thirdCommit, newHead.GetParent(0)); NUnit.Framework.Assert.AreEqual(secondCommit, newHead.GetParent(1)); NUnit.Framework.Assert.AreEqual("Merge commit '064d54d98a4cdb0fed1802a21c656bfda67fe879'" , newHead.GetFullMessage()); NUnit.Framework.Assert.AreEqual(RepositoryState.SAFE, db.GetRepositoryState()); }
public virtual void TestMergeRemovingFoldersWithoutFastForward() { FilePath folder1 = new FilePath(db.WorkTree, "folder1"); FilePath folder2 = new FilePath(db.WorkTree, "folder2"); FileUtils.Mkdir(folder1); FileUtils.Mkdir(folder2); FilePath file = new FilePath(folder1, "file1.txt"); Write(file, "folder1--file1.txt"); file = new FilePath(folder1, "file2.txt"); Write(file, "folder1--file2.txt"); file = new FilePath(folder2, "file1.txt"); Write(file, "folder--file1.txt"); file = new FilePath(folder2, "file2.txt"); Write(file, "folder2--file2.txt"); Git git = new Git(db); git.Add().AddFilepattern(folder1.GetName()).AddFilepattern(folder2.GetName()).Call (); RevCommit @base = git.Commit().SetMessage("adding folders").Call(); RecursiveDelete(folder1); RecursiveDelete(folder2); git.Rm().AddFilepattern("folder1/file1.txt").AddFilepattern("folder1/file2.txt"). AddFilepattern("folder2/file1.txt").AddFilepattern("folder2/file2.txt").Call(); RevCommit other = git.Commit().SetMessage("removing folders on 'branch'").Call(); git.Checkout().SetName(@base.Name).Call(); file = new FilePath(folder2, "file3.txt"); Write(file, "folder2--file3.txt"); git.Add().AddFilepattern(folder2.GetName()).Call(); git.Commit().SetMessage("adding another file").Call(); MergeCommandResult result = git.Merge().Include(other.Id).SetStrategy(MergeStrategy .RESOLVE).Call(); NUnit.Framework.Assert.AreEqual(MergeStatus.MERGED, result.GetMergeStatus()); NUnit.Framework.Assert.IsFalse(folder1.Exists()); }
public virtual void TestFastForwardWithFiles() { 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"); WriteTrashFile("file2", "file2"); git.Add().AddFilepattern("file2").Call(); RevCommit second = git.Commit().SetMessage("second commit").Call(); NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "file2").Exists()); CheckoutBranch("refs/heads/branch1"); NUnit.Framework.Assert.IsFalse(new FilePath(db.WorkTree, "file2").Exists()); MergeCommandResult result = git.Merge().Include(db.GetRef(Constants.MASTER)).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, result.GetMergeStatus() ); NUnit.Framework.Assert.AreEqual(second, result.GetNewHead()); NUnit.Framework.Assert.AreEqual("merge refs/heads/master: Fast-forward", db.GetReflogReader (Constants.HEAD).GetLastEntry().GetComment()); NUnit.Framework.Assert.AreEqual("merge refs/heads/master: Fast-forward", db.GetReflogReader (db.GetBranch()).GetLastEntry().GetComment()); }
// expected this exception /// <exception cref="System.Exception"></exception> // [Theory] public virtual void TestMergeSuccessAllStrategies(MergeStrategy mergeStrategy) { Git git = new Git(db); RevCommit first = git.Commit().SetMessage("first").Call(); CreateBranch(first, "refs/heads/side"); WriteTrashFile("a", "a"); git.Add().AddFilepattern("a").Call(); git.Commit().SetMessage("second").Call(); CheckoutBranch("refs/heads/side"); WriteTrashFile("b", "b"); git.Add().AddFilepattern("b").Call(); git.Commit().SetMessage("third").Call(); MergeCommandResult result = git.Merge().SetStrategy(mergeStrategy).Include(db.GetRef (Constants.MASTER)).Call(); NUnit.Framework.Assert.AreEqual(MergeStatus.MERGED, result.GetMergeStatus()); NUnit.Framework.Assert.AreEqual("merge refs/heads/master: Merge made by " + mergeStrategy .GetName() + ".", db.GetReflogReader(Constants.HEAD).GetLastEntry().GetComment() ); NUnit.Framework.Assert.AreEqual("merge refs/heads/master: Merge made by " + mergeStrategy .GetName() + ".", db.GetReflogReader(db.GetBranch()).GetLastEntry().GetComment() ); }
public void Merge (string branch, bool saveLocalChanges, IProgressMonitor monitor) { IEnumerable<DiffEntry> statusList = null; Stash stash = null; StashCollection stashes = GetStashes (RootRepository); monitor.BeginTask (null, 4); try { // Get a list of files that are different in the target branch statusList = GitUtil.GetChangedFiles (RootRepository, branch); monitor.Step (1); if (saveLocalChanges) { monitor.BeginTask (GettextCatalog.GetString ("Merging"), 3); monitor.Log.WriteLine (GettextCatalog.GetString ("Saving local changes")); using (var gm = new GitMonitor (monitor)) stash = stashes.Create (gm, GetStashName ("_tmp_")); monitor.Step (1); } // Apply changes ObjectId branchId = RootRepository.Resolve (branch); NGit.Api.Git git = new NGit.Api.Git (RootRepository); MergeCommandResult mergeResult = git.Merge ().SetStrategy (MergeStrategy.RESOLVE).Include (branchId).Call (); if (mergeResult.GetMergeStatus () == MergeStatus.CONFLICTING || mergeResult.GetMergeStatus () == MergeStatus.FAILED) { var conflicts = mergeResult.GetConflicts (); bool commit = true; if (conflicts != null) { foreach (string conflictFile in conflicts.Keys) { ConflictResult res = ResolveConflict (RootRepository.FromGitPath (conflictFile)); if (res == ConflictResult.Abort) { GitUtil.HardReset (RootRepository, GetHeadCommit (RootRepository)); commit = false; break; } else if (res == ConflictResult.Skip) { Revert (RootRepository.FromGitPath (conflictFile), false, monitor); break; } } } if (commit) git.Commit ().Call (); } } finally { if (saveLocalChanges) monitor.Step (1); // Restore local changes if (stash != null) { monitor.Log.WriteLine (GettextCatalog.GetString ("Restoring local changes")); using (var gm = new GitMonitor (monitor)) stash.Apply (gm); stashes.Remove (stash); monitor.EndTask (); } } monitor.Step (1); // Notify changes if (statusList != null) NotifyFileChanges (monitor, statusList); monitor.EndTask (); }