public void testRefsCacheAfterUpdate() { // Do not use the defalt repo for this case. Dictionary <string, Core.Ref> allRefs = db.getAllRefs(); ObjectId oldValue = db.Resolve("HEAD"); ObjectId newValue = db.Resolve("HEAD^"); // first make HEAD refer to loose ref RefUpdate updateRef = db.UpdateRef(Constants.HEAD); updateRef.IsForceUpdate = true; updateRef.NewObjectId = newValue; RefUpdate.RefUpdateResult update = updateRef.Update(); Assert.AreEqual(RefUpdate.RefUpdateResult.Forced, update); // now update that ref updateRef = db.UpdateRef(Constants.HEAD); updateRef.IsForceUpdate = true; updateRef.NewObjectId = oldValue; update = updateRef.Update(); Assert.AreEqual(RefUpdate.RefUpdateResult.FastForward, update); allRefs = db.getAllRefs(); Assert.AreEqual("refs/heads/master", allRefs.GetValue("refs/heads/master").Name); Assert.AreEqual("refs/heads/master", allRefs.GetValue("refs/heads/master").OriginalName); Assert.AreEqual("refs/heads/master", allRefs.GetValue("HEAD").Name); Assert.AreEqual("HEAD", allRefs.GetValue("HEAD").OriginalName); }
public virtual void TestRefsCacheAfterUpdate() { // Do not use the defalt repo for this case. IDictionary <string, Ref> allRefs = db.GetAllRefs(); ObjectId oldValue = db.Resolve("HEAD"); ObjectId newValue = db.Resolve("HEAD^"); // first make HEAD refer to loose ref RefUpdate updateRef = db.UpdateRef(Constants.HEAD); updateRef.SetForceUpdate(true); updateRef.SetNewObjectId(newValue); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FORCED, update); // now update that ref updateRef = db.UpdateRef(Constants.HEAD); updateRef.SetForceUpdate(true); updateRef.SetNewObjectId(oldValue); update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FAST_FORWARD, update); allRefs = db.GetAllRefs(); Ref master = allRefs.Get("refs/heads/master"); Ref head = allRefs.Get("HEAD"); NUnit.Framework.Assert.AreEqual("refs/heads/master", master.GetName()); NUnit.Framework.Assert.AreEqual("HEAD", head.GetName()); NUnit.Framework.Assert.IsTrue(head.IsSymbolic(), "is symbolic reference"); NUnit.Framework.Assert.AreSame(master, head.GetTarget()); }
public virtual void TestNoCacheObjectIdSubclass() { string newRef = "refs/heads/abc"; RefUpdate ru = UpdateRef(newRef); RefUpdateTest.SubclassedId newid = new RefUpdateTest.SubclassedId(ru.GetNewObjectId ()); ru.SetNewObjectId(newid); RefUpdate.Result update = ru.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.NEW, update); Ref r = db.GetAllRefs().Get(newRef); NUnit.Framework.Assert.IsNotNull(r); NUnit.Framework.Assert.AreEqual(newRef, r.GetName()); NUnit.Framework.Assert.IsNotNull(r.GetObjectId()); NUnit.Framework.Assert.AreNotSame(newid, r.GetObjectId()); NUnit.Framework.Assert.AreSame(typeof(ObjectId), r.GetObjectId().GetType()); NUnit.Framework.Assert.AreEqual(newid, r.GetObjectId()); IList <ReflogEntry> reverseEntries1 = db.GetReflogReader("refs/heads/abc").GetReverseEntries (); ReflogEntry entry1 = reverseEntries1[0]; NUnit.Framework.Assert.AreEqual(1, reverseEntries1.Count); NUnit.Framework.Assert.AreEqual(ObjectId.ZeroId, entry1.GetOldId()); NUnit.Framework.Assert.AreEqual(r.GetObjectId(), entry1.GetNewId()); NUnit.Framework.Assert.AreEqual(new PersonIdent(db).ToString(), entry1.GetWho().ToString ()); NUnit.Framework.Assert.AreEqual(string.Empty, entry1.GetComment()); IList <ReflogEntry> reverseEntries2 = db.GetReflogReader("HEAD").GetReverseEntries (); NUnit.Framework.Assert.AreEqual(0, reverseEntries2.Count); }
public virtual void MultipleStashedCommits() { Git git = Git.Wrap(db); WriteTrashFile("file.txt", "content"); git.Add().AddFilepattern("file.txt").Call(); RevCommit commit1 = git.Commit().SetMessage("create file").Call(); WriteTrashFile("file.txt", "content2"); git.Add().AddFilepattern("file.txt").Call(); RevCommit commit2 = git.Commit().SetMessage("edit file").Call(); RefUpdate create = db.UpdateRef(Constants.R_STASH); create.SetNewObjectId(commit1); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.NEW, create.Update()); RefUpdate update = db.UpdateRef(Constants.R_STASH); update.SetNewObjectId(commit2); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FAST_FORWARD, update.Update()); StashListCommand command = git.StashList(); ICollection <RevCommit> stashed = command.Call(); NUnit.Framework.Assert.IsNotNull(stashed); NUnit.Framework.Assert.AreEqual(2, stashed.Count); Iterator <RevCommit> iter = stashed.Iterator(); NUnit.Framework.Assert.AreEqual(commit2, iter.Next()); NUnit.Framework.Assert.AreEqual(commit1, iter.Next()); }
public virtual void DeleteMergedBranch_historyNotPruned() { RevCommit parent = tr.Commit().Create(); RevCommit b1Tip = tr.Branch("b1").Commit().Parent(parent).Add("x", "x").Create(); RevCommit b2Tip = tr.Branch("b2").Commit().Parent(parent).Add("y", "y").Create(); // merge b1Tip and b2Tip and update refs/heads/b1 to the merge commit Merger merger = ((ThreeWayMerger)MergeStrategy.SIMPLE_TWO_WAY_IN_CORE.NewMerger(repo )); merger.Merge(b1Tip, b2Tip); NGit.Junit.CommitBuilder cb = tr.Commit(); cb.Parent(b1Tip).Parent(b2Tip); cb.SetTopLevelTree(merger.GetResultTreeId()); RevCommit mergeCommit = cb.Create(); RefUpdate u = repo.UpdateRef("refs/heads/b1"); u.SetNewObjectId(mergeCommit); u.Update(); RefUpdate update = repo.UpdateRef("refs/heads/b2"); update.SetForceUpdate(true); update.Delete(); gc.SetExpireAgeMillis(0); gc.Prune(Collections.EmptySet <ObjectId>()); NUnit.Framework.Assert.IsTrue(repo.HasObject(b2Tip)); }
private void UpdateRef(Ref stashRef, ObjectId newId) { try { RefUpdate update = CreateRefUpdate(stashRef); update.SetNewObjectId(newId); RefUpdate.Result result = update.Update(); switch (result) { case RefUpdate.Result.FORCED: case RefUpdate.Result.NEW: case RefUpdate.Result.NO_CHANGE: { return; } default: { throw new JGitInternalException(MessageFormat.Format(JGitText.Get().updatingRefFailed , Constants.R_STASH, newId, result)); } } } catch (IOException e) { throw new JGitInternalException(JGitText.Get().stashDropFailed, e); } }
/// <exception cref="System.IO.IOException"></exception> private void CommitNoteMap(RevWalk walk, NoteMap map, RevCommit notesCommit, ObjectInserter inserter, string msg) { // commit the note NGit.CommitBuilder builder = new NGit.CommitBuilder(); builder.TreeId = map.WriteTree(inserter); builder.Author = new PersonIdent(repo); builder.Committer = builder.Author; builder.Message = msg; if (notesCommit != null) { builder.SetParentIds(notesCommit); } ObjectId commit = inserter.Insert(builder); inserter.Flush(); RefUpdate refUpdate = repo.UpdateRef(notesRef); if (notesCommit != null) { refUpdate.SetExpectedOldObjectId(notesCommit); } else { refUpdate.SetExpectedOldObjectId(ObjectId.ZeroId); } refUpdate.SetNewObjectId(commit); refUpdate.Update(walk); }
public void testRenameRefNameColission1avoided() { // setup ObjectId rb = db.Resolve("refs/heads/b"); db.WriteSymref(Constants.HEAD, "refs/heads/a"); RefUpdate updateRef = db.UpdateRef("refs/heads/a"); updateRef.NewObjectId = rb; updateRef.SetRefLogMessage("Setup", false); Assert.AreEqual(RefUpdate.RefUpdateResult.FastForward, updateRef.Update()); ObjectId oldHead = db.Resolve(Constants.HEAD); Assert.IsTrue(rb.Equals(oldHead)); // assumption for this test RefLogWriter.WriteReflog(db, rb, rb, "Just a message", "refs/heads/a"); Assert.IsTrue(new FileInfo(Path.Combine(db.Directory.FullName, "logs/refs/heads/a")).Exists, "internal check, we have a log"); // Now this is our test RefRename renameRef = db.RenameRef("refs/heads/a", "refs/heads/a/b"); RefUpdate.RefUpdateResult result = renameRef.Rename(); Assert.AreEqual(RefUpdate.RefUpdateResult.Renamed, result); Assert.IsNull(db.Resolve("refs/heads/a")); Assert.AreEqual(rb, db.Resolve("refs/heads/a/b")); Assert.AreEqual(3, db.ReflogReader("a/b").getReverseEntries().Count); Assert.AreEqual("Branch: renamed a to a/b", db.ReflogReader("a/b") .getReverseEntries()[0].getComment()); Assert.AreEqual("Just a message", db.ReflogReader("a/b") .getReverseEntries()[1].getComment()); Assert.AreEqual("Setup", db.ReflogReader("a/b").getReverseEntries() [2].getComment()); // same thing was logged to HEAD Assert.AreEqual("Branch: renamed a to a/b", db.ReflogReader("HEAD") .getReverseEntries()[0].getComment()); }
public virtual void TestDeleteLooseAndItsDirectory() { ObjectId pid = db.Resolve("refs/heads/c^"); RefUpdate updateRef = db.UpdateRef("refs/heads/z/c"); updateRef.SetNewObjectId(pid); updateRef.SetForceUpdate(true); updateRef.SetRefLogMessage("new test ref", false); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.NEW, update); // internal NUnit.Framework.Assert.IsTrue(new FilePath(db.Directory, Constants.R_HEADS + "z") .Exists()); NUnit.Framework.Assert.IsTrue(new FilePath(db.Directory, "logs/refs/heads/z").Exists ()); // The real test here RefUpdate updateRef2 = db.UpdateRef("refs/heads/z/c"); updateRef2.SetForceUpdate(true); RefUpdate.Result delete = updateRef2.Delete(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FORCED, delete); NUnit.Framework.Assert.IsNull(db.Resolve("refs/heads/z/c")); NUnit.Framework.Assert.IsFalse(new FilePath(db.Directory, Constants.R_HEADS + "z" ).Exists()); NUnit.Framework.Assert.IsFalse(new FilePath(db.Directory, "logs/refs/heads/z").Exists ()); }
private void Execute(ReceiveCommand cmd) { try { RefUpdate ru = db.UpdateRef(cmd.getRefName()); ru.RefLogIdent = getRefLogIdent(); switch (cmd.getType()) { case ReceiveCommand.Type.DELETE: if (!ObjectId.ZeroId.Equals(cmd.getOldId())) { ru.ExpectedOldObjectId = cmd.getOldId(); } ru.IsForceUpdate = true; Status(cmd, ru.Delete(walk)); break; case ReceiveCommand.Type.CREATE: case ReceiveCommand.Type.UPDATE: case ReceiveCommand.Type.UPDATE_NONFASTFORWARD: ru.IsForceUpdate = isAllowNonFastForwards(); ru.ExpectedOldObjectId = cmd.getOldId(); ru.NewObjectId = cmd.getNewId(); ru.SetRefLogMessage("push", true); Status(cmd, ru.Update(walk)); break; } } catch (IOException err) { cmd.setResult(ReceiveCommand.Result.REJECTED_OTHER_REASON, "lock error: " + err.Message); } }
public void testNewNamespaceConflictWithLoosePrefixOfExisting() { string newRef = "refs/heads/z/a"; RefUpdate ru = updateRef(newRef); RevCommit newid = new RevCommit(ru.NewObjectId) { // empty }; ru.NewObjectId = newid; RefUpdate.RefUpdateResult update = ru.Update(); Assert.AreEqual(RefUpdate.RefUpdateResult.New, update); // end setup string newRef2 = "refs/heads/z"; RefUpdate ru2 = updateRef(newRef2); RevCommit newid2 = new RevCommit(ru2.NewObjectId) { // empty }; ru.NewObjectId = newid2; RefUpdate.RefUpdateResult update2 = ru2.Update(); Assert.AreEqual(RefUpdate.RefUpdateResult.LockFailure, update2); Assert.AreEqual(1, db.ReflogReader("refs/heads/z/a").getReverseEntries().Count); Assert.IsNull(db.ReflogReader("refs/heads/z")); Assert.AreEqual(0, db.ReflogReader("HEAD").getReverseEntries().Count); }
/// <exception cref="System.IO.IOException"></exception> private void CreateBranch(ObjectId objectId, string branchName) { RefUpdate updateRef = db.UpdateRef(branchName); updateRef.SetNewObjectId(objectId); updateRef.Update(); }
public virtual void testReadAllIncludingSymrefs() { ObjectId masterId = db.Resolve("refs/heads/master"); RefUpdate updateRef = db.UpdateRef("refs/remotes/origin/master"); updateRef.NewObjectId = masterId; updateRef.IsForceUpdate = true; updateRef.Update(); db.WriteSymref("refs/remotes/origin/HEAD", "refs/remotes/origin/master"); ObjectId r = db.Resolve("refs/remotes/origin/HEAD"); Assert.AreEqual(masterId, r); IDictionary <string, Core.Ref> allRefs = db.getAllRefs(); Core.Ref refHEAD = allRefs["refs/remotes/origin/HEAD"]; Assert.IsNotNull(refHEAD); Assert.AreEqual(masterId, refHEAD.ObjectId); Assert.IsTrue(refHEAD.Peeled); Assert.IsNull(refHEAD.PeeledObjectId); Core.Ref refmaster = allRefs["refs/remotes/origin/master"]; Assert.AreEqual(masterId, refmaster.ObjectId); Assert.IsFalse(refmaster.Peeled); Assert.IsNull(refmaster.PeeledObjectId); }
/// <exception cref="System.IO.IOException"></exception> /// <exception cref="NGit.Api.Errors.ConcurrentRefUpdateException"></exception> private void UpdateHead(StringBuilder refLogMessage, ObjectId newHeadId, ObjectId oldHeadID) { RefUpdate refUpdate = repo.UpdateRef(Constants.HEAD); refUpdate.SetNewObjectId(newHeadId); refUpdate.SetRefLogMessage(refLogMessage.ToString(), false); refUpdate.SetExpectedOldObjectId(oldHeadID); RefUpdate.Result rc = refUpdate.Update(); switch (rc) { case RefUpdate.Result.NEW: case RefUpdate.Result.FAST_FORWARD: { return; } case RefUpdate.Result.REJECTED: case RefUpdate.Result.LOCK_FAILURE: { throw new ConcurrentRefUpdateException(JGitText.Get().couldNotLockHEAD, refUpdate .GetRef(), rc); } default: { throw new JGitInternalException(MessageFormat.Format(JGitText.Get().updatingRefFailed , Constants.HEAD, newHeadId.ToString(), rc)); } } }
public virtual void TestUpdateRefLockFailureLocked() { ObjectId opid = db.Resolve("refs/heads/master"); ObjectId pid = db.Resolve("refs/heads/master^"); RefUpdate updateRef = db.UpdateRef("refs/heads/master"); updateRef.SetNewObjectId(pid); LockFile lockFile1 = new LockFile(new FilePath(db.Directory, "refs/heads/master") , db.FileSystem); try { NUnit.Framework.Assert.IsTrue(lockFile1.Lock()); // precondition to test RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.LOCK_FAILURE, update); NUnit.Framework.Assert.AreEqual(opid, db.Resolve("refs/heads/master")); LockFile lockFile2 = new LockFile(new FilePath(db.Directory, "refs/heads/master") , db.FileSystem); NUnit.Framework.Assert.IsFalse(lockFile2.Lock()); } finally { // was locked, still is lockFile1.Unlock(); } }
public virtual void TestUpdateRefDetachedUnbornHead() { ObjectId ppid = db.Resolve("refs/heads/master^"); WriteSymref("HEAD", "refs/heads/unborn"); RefUpdate updateRef = db.UpdateRef("HEAD", true); updateRef.SetForceUpdate(true); updateRef.SetNewObjectId(ppid); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.NEW, update); NUnit.Framework.Assert.AreEqual(ppid, db.Resolve("HEAD")); Ref @ref = db.GetRef("HEAD"); NUnit.Framework.Assert.AreEqual("HEAD", @ref.GetName()); NUnit.Framework.Assert.IsTrue([email protected](), "is detached"); // the branch HEAD referred to is left untouched NUnit.Framework.Assert.IsNull(db.Resolve("refs/heads/unborn")); ReflogReader reflogReader = new ReflogReader(db, "HEAD"); ReflogEntry e = reflogReader.GetReverseEntries()[0]; NUnit.Framework.Assert.AreEqual(ObjectId.ZeroId, e.GetOldId()); NUnit.Framework.Assert.AreEqual(ppid, e.GetNewId()); NUnit.Framework.Assert.AreEqual("GIT_COMMITTER_EMAIL", e.GetWho().GetEmailAddress ()); NUnit.Framework.Assert.AreEqual("GIT_COMMITTER_NAME", e.GetWho().GetName()); NUnit.Framework.Assert.AreEqual(1250379778000L, e.GetWho().GetWhen().GetTime()); }
public void testNoCacheObjectIdSubclass() { string newRef = "refs/heads/abc"; RefUpdate ru = updateRef(newRef); RevCommit newid = new RevCommit(ru.NewObjectId) { // empty }; ru.NewObjectId = newid; RefUpdate.RefUpdateResult update = ru.Update(); Assert.AreEqual(RefUpdate.RefUpdateResult.New, update); Core.Ref r = db.getAllRefs()[newRef]; Assert.IsNotNull(r); Assert.AreEqual(newRef, r.Name); Assert.IsNotNull(r.ObjectId); Assert.AreNotSame(newid, r.ObjectId); Assert.AreSame(typeof(ObjectId), r.ObjectId.GetType()); Assert.AreEqual(newid.Copy(), r.ObjectId); IList <ReflogReader.Entry> reverseEntries1 = db.ReflogReader("refs/heads/abc").getReverseEntries(); ReflogReader.Entry entry1 = reverseEntries1[0]; Assert.AreEqual(1, reverseEntries1.Count); Assert.AreEqual(ObjectId.ZeroId, entry1.getOldId()); Assert.AreEqual(r.ObjectId, entry1.getNewId()); Assert.AreEqual(new PersonIdent(db).ToString(), entry1.getWho().ToString()); Assert.AreEqual("", entry1.getComment()); IList <ReflogReader.Entry> reverseEntries2 = db.ReflogReader("HEAD").getReverseEntries(); Assert.AreEqual(0, reverseEntries2.Count); }
/// <exception cref="System.IO.IOException"></exception> /// <exception cref="NGit.Api.Errors.JGitInternalException"></exception> private RevCommit TryFastForward(string headName, RevCommit oldCommit, RevCommit newCommit) { bool tryRebase = false; foreach (RevCommit parentCommit in newCommit.Parents) { if (parentCommit.Equals(oldCommit)) { tryRebase = true; } } if (!tryRebase) { return(null); } CheckoutCommand co = new CheckoutCommand(repo); try { co.SetName(newCommit.Name).Call(); if (headName.StartsWith(Constants.R_HEADS)) { RefUpdate rup = repo.UpdateRef(headName); rup.SetExpectedOldObjectId(oldCommit); rup.SetNewObjectId(newCommit); rup.SetRefLogMessage("Fast-foward from " + oldCommit.Name + " to " + newCommit.Name , false); RefUpdate.Result res = rup.Update(walk); switch (res) { case RefUpdate.Result.FAST_FORWARD: case RefUpdate.Result.NO_CHANGE: case RefUpdate.Result.FORCED: { break; } default: { throw new IOException("Could not fast-forward"); } } } return(newCommit); } catch (RefAlreadyExistsException e) { throw new JGitInternalException(e.Message, e); } catch (RefNotFoundException e) { throw new JGitInternalException(e.Message, e); } catch (InvalidRefNameException e) { throw new JGitInternalException(e.Message, e); } }
public void testLooseDelete() { string newRef = "refs/heads/abc"; RefUpdate @ref = updateRef(newRef); @ref.Update(); // create loose ref @ref = updateRef(newRef); // refresh delete(@ref, RefUpdate.RefUpdateResult.NoChange); Assert.IsNull(db.ReflogReader("refs/heads/abc")); }
public virtual void TestUpdateRefNoChange() { ObjectId pid = db.Resolve("refs/heads/master"); RefUpdate updateRef = db.UpdateRef("refs/heads/master"); updateRef.SetNewObjectId(pid); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.NO_CHANGE, update); NUnit.Framework.Assert.AreEqual(pid, db.Resolve("refs/heads/master")); }
public void testUpdateRefNoChange() { ObjectId pid = db.Resolve("refs/heads/master"); RefUpdate updateRef = db.UpdateRef("refs/heads/master"); updateRef.NewObjectId = pid; RefUpdate.RefUpdateResult update = updateRef.Update(); Assert.AreEqual(RefUpdate.RefUpdateResult.NoChange, update); Assert.AreEqual(pid, db.Resolve("refs/heads/master")); }
public void testReadLooseRef() { RefUpdate updateRef = db.UpdateRef("ref/heads/new"); updateRef.NewObjectId = db.Resolve("refs/heads/master"); RefUpdate.RefUpdateResult update = updateRef.Update(); Assert.AreEqual(RefUpdate.RefUpdateResult.New, update); Core.Ref @ref = db.getRef("ref/heads/new"); Assert.AreEqual(Core.Ref.Storage.Loose, @ref.StorageFormat); }
public virtual void TestUpdateRefLockFailureWrongOldValue() { ObjectId pid = db.Resolve("refs/heads/master"); RefUpdate updateRef = db.UpdateRef("refs/heads/master"); updateRef.SetNewObjectId(pid); updateRef.SetExpectedOldObjectId(db.Resolve("refs/heads/master^")); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.LOCK_FAILURE, update); NUnit.Framework.Assert.AreEqual(pid, db.Resolve("refs/heads/master")); }
public virtual void TestNewNamespaceConflictWithPackedPrefixOfExisting() { string newRef = "refs/heads/prefix"; RefUpdate ru = UpdateRef(newRef); RefUpdate.Result update = ru.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.LOCK_FAILURE, update); NUnit.Framework.Assert.IsNull(db.GetReflogReader("refs/heads/prefix")); NUnit.Framework.Assert.AreEqual(0, db.GetReflogReader("HEAD").GetReverseEntries() .Count); }
public virtual void TestDeleteLoosePackedRejected() { ObjectId pid = db.Resolve("refs/heads/c^"); ObjectId oldpid = db.Resolve("refs/heads/c"); RefUpdate updateRef = db.UpdateRef("refs/heads/c"); updateRef.SetNewObjectId(pid); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.REJECTED, update); NUnit.Framework.Assert.AreEqual(oldpid, db.Resolve("refs/heads/c")); }
/// <summary>Update locally stored tracking branch with the new object.</summary> /// <remarks>Update locally stored tracking branch with the new object.</remarks> /// <param name="walk">walker used for checking update properties.</param> /// <exception cref="System.IO.IOException">when I/O error occurred during update</exception> protected internal virtual void UpdateTrackingRef(RevWalk walk) { if (IsDelete()) { trackingRefUpdate.SetResult(localUpdate.Delete(walk)); } else { trackingRefUpdate.SetResult(localUpdate.Update(walk)); } }
public void testUpdateRefLockFailureWrongOldValue() { ObjectId pid = db.Resolve("refs/heads/master"); RefUpdate updateRef = db.UpdateRef("refs/heads/master"); updateRef.NewObjectId = pid; updateRef.ExpectedOldObjectId = db.Resolve("refs/heads/master^"); RefUpdate.RefUpdateResult update = updateRef.Update(); Assert.AreEqual(RefUpdate.RefUpdateResult.LockFailure, update); Assert.AreEqual(pid, db.Resolve("refs/heads/master")); }
public void testDeleteLoosePackedRejected() { ObjectId pid = db.Resolve("refs/heads/c^"); ObjectId oldpid = db.Resolve("refs/heads/c"); RefUpdate updateRef = db.UpdateRef("refs/heads/c"); updateRef.NewObjectId = pid; RefUpdate.RefUpdateResult update = updateRef.Update(); Assert.AreEqual(RefUpdate.RefUpdateResult.Rejected, update); Assert.AreEqual(oldpid, db.Resolve("refs/heads/c")); }
public virtual void TestLooseDelete() { string newRef = "refs/heads/abc"; RefUpdate @ref = UpdateRef(newRef); @ref.Update(); // create loose ref @ref = UpdateRef(newRef); // refresh Delete(@ref, RefUpdate.Result.NO_CHANGE); NUnit.Framework.Assert.IsNull(db.GetReflogReader("refs/heads/abc")); }
public virtual void TestCreateFromLightweightTag() { RefUpdate rup = db.UpdateRef("refs/tags/V10"); rup.SetNewObjectId(initialCommit); rup.SetExpectedOldObjectId(ObjectId.ZeroId); rup.Update(); Ref branch = git.BranchCreate().SetName("FromLightweightTag").SetStartPoint("refs/tags/V10" ).Call(); NUnit.Framework.Assert.AreEqual(initialCommit.Id, branch.GetObjectId()); }