public virtual void TestModify()
{
Git git = new Git(db);
string path = "file";
WriteTrashFile(path, "content");
git.Add().AddFilepattern(path).Call();
git.Commit().SetMessage("commit").Call();
DirCache dc = db.ReadDirCache();
DirCacheEntry entry = dc.GetEntry(path);
long masterLastMod = entry.LastModified;
git.Checkout().SetCreateBranch(true).SetName("side").Call();
Sharpen.Thread.Sleep(10);
string path2 = "file2";
WriteTrashFile(path2, "side content");
git.Add().AddFilepattern(path2).Call();
git.Commit().SetMessage("commit").Call();
dc = db.ReadDirCache();
entry = dc.GetEntry(path);
long sideLastMode = entry.LastModified;
Sharpen.Thread.Sleep(2000);
WriteTrashFile(path, "uncommitted content");
git.Checkout().SetName("master").Call();
dc = db.ReadDirCache();
entry = dc.GetEntry(path);
NUnit.Framework.Assert.IsTrue(masterLastMod == sideLastMode, "shall have equal mod time!"
);
NUnit.Framework.Assert.IsTrue(entry.LastModified == masterLastMod, "shall not equal master timestamp!"
);
}
public virtual void TestUpdateSmudgedEntries()
{
git.BranchCreate().SetName("test2").Call();
RefUpdate rup = db.UpdateRef(Constants.HEAD);
rup.Link("refs/heads/test2");
FilePath file = new FilePath(db.WorkTree, "Test.txt");
long size = file.Length();
long mTime = file.LastModified() - 5000L;
NUnit.Framework.Assert.IsTrue(file.SetLastModified(mTime));
DirCache cache = DirCache.Lock(db.GetIndexFile(), db.FileSystem);
DirCacheEntry entry = cache.GetEntry("Test.txt");
NUnit.Framework.Assert.IsNotNull(entry);
entry.SetLength(0);
entry.LastModified = 0;
cache.Write();
NUnit.Framework.Assert.IsTrue(cache.Commit());
cache = DirCache.Read(db.GetIndexFile(), db.FileSystem);
entry = cache.GetEntry("Test.txt");
NUnit.Framework.Assert.IsNotNull(entry);
NUnit.Framework.Assert.AreEqual(0, entry.Length);
NUnit.Framework.Assert.AreEqual(0, entry.LastModified);
db.GetIndexFile().SetLastModified(db.GetIndexFile().LastModified() - 5000);
NUnit.Framework.Assert.IsNotNull(git.Checkout().SetName("test").Call());
cache = DirCache.Read(db.GetIndexFile(), db.FileSystem);
entry = cache.GetEntry("Test.txt");
NUnit.Framework.Assert.IsNotNull(entry);
NUnit.Framework.Assert.AreEqual(size, entry.Length);
NUnit.Framework.Assert.AreEqual(mTime, entry.LastModified);
}
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!"
);
}
/// <summary>Represent the state of the index in one String.</summary>
/// <remarks>
/// Represent the state of the index in one String. This representation is
/// useful when writing tests which do assertions on the state of the index.
/// By default information about path, mode, stage (if different from 0) is
/// included. A bitmask controls which additional info about
/// modificationTimes, smudge state and length is included.
/// <p>
/// The format of the returned string is described with this BNF:
/// <pre>
/// result = ( "[" path mode stage? time? smudge? length? sha1? content? "]" )* .
/// mode = ", mode:" number .
/// stage = ", stage:" number .
/// time = ", time:t" timestamp-index .
/// smudge = "" | ", smudged" .
/// length = ", length:" number .
/// sha1 = ", sha1:" hex-sha1 .
/// content = ", content:" blob-data .
/// </pre>
/// 'stage' is only presented when the stage is different from 0. All
/// reported time stamps are mapped to strings like "t0", "t1", ... "tn". The
/// smallest reported time-stamp will be called "t0". This allows to write
/// assertions against the string although the concrete value of the time
/// stamps is unknown.
/// </remarks>
/// <param name="repo">the repository the index state should be determined for</param>
/// <param name="includedOptions">
/// a bitmask constructed out of the constants
/// <see cref="MOD_TIME">MOD_TIME</see>
/// ,
/// <see cref="SMUDGE">SMUDGE</see>
/// ,
/// <see cref="LENGTH">LENGTH</see>
/// ,
/// <see cref="CONTENT_ID">CONTENT_ID</see>
/// and
/// <see cref="CONTENT">CONTENT</see>
/// controlling which info is present in the
/// resulting string.
/// </param>
/// <returns>a string encoding the index state</returns>
/// <exception cref="System.InvalidOperationException">System.InvalidOperationException
/// </exception>
/// <exception cref="System.IO.IOException">System.IO.IOException</exception>
public virtual string IndexState(Repository repo, int includedOptions)
{
DirCache dc = repo.ReadDirCache();
StringBuilder sb = new StringBuilder();
TreeSet <long> timeStamps = null;
// iterate once over the dircache just to collect all time stamps
if (0 != (includedOptions & MOD_TIME))
{
timeStamps = new TreeSet <long>();
for (int i = 0; i < dc.GetEntryCount(); ++i)
{
timeStamps.AddItem(Sharpen.Extensions.ValueOf(dc.GetEntry(i).LastModified));
}
}
// iterate again, now produce the result string
for (int i_1 = 0; i_1 < dc.GetEntryCount(); ++i_1)
{
DirCacheEntry entry = dc.GetEntry(i_1);
sb.Append("[" + entry.PathString + ", mode:" + entry.FileMode);
int stage = entry.Stage;
if (stage != 0)
{
sb.Append(", stage:" + stage);
}
if (0 != (includedOptions & MOD_TIME))
{
sb.Append(", time:t" + timeStamps.HeadSet(Sharpen.Extensions.ValueOf(entry.LastModified
)).Count);
}
if (0 != (includedOptions & SMUDGE))
{
if (entry.IsSmudged)
{
sb.Append(", smudged");
}
}
if (0 != (includedOptions & LENGTH))
{
sb.Append(", length:" + Sharpen.Extensions.ToString(entry.Length));
}
if (0 != (includedOptions & CONTENT_ID))
{
sb.Append(", sha1:" + ObjectId.ToString(entry.GetObjectId()));
}
if (0 != (includedOptions & CONTENT))
{
sb.Append(", content:" + Sharpen.Runtime.GetStringForBytes(db.Open(entry.GetObjectId
(), Constants.OBJ_BLOB).GetCachedBytes(), "UTF-8"));
}
if (0 != (includedOptions & ASSUME_UNCHANGED))
{
sb.Append(", assume-unchanged:" + entry.IsAssumeValid.ToString().ToLower());
}
sb.Append("]");
}
return(sb.ToString());
}
/// <returns>list of files with the flag assume-unchanged</returns>
public virtual ICollection <string> GetAssumeUnchanged()
{
if (assumeUnchanged == null)
{
HashSet <string> unchanged = new HashSet <string>();
for (int i = 0; i < dirCache.GetEntryCount(); i++)
{
if (dirCache.GetEntry(i).IsAssumeValid)
{
unchanged.AddItem(dirCache.GetEntry(i).PathString);
}
}
assumeUnchanged = unchanged;
}
return(assumeUnchanged);
}
public virtual void TestCherryPickOverExecutableChangeOnNonExectuableFileSystem()
{
Git git = new Git(db);
FilePath file = WriteTrashFile("test.txt", "a");
NUnit.Framework.Assert.IsNotNull(git.Add().AddFilepattern("test.txt").Call());
NUnit.Framework.Assert.IsNotNull(git.Commit().SetMessage("commit1").Call());
NUnit.Framework.Assert.IsNotNull(git.Checkout().SetCreateBranch(true).SetName("a"
).Call());
WriteTrashFile("test.txt", "b");
NUnit.Framework.Assert.IsNotNull(git.Add().AddFilepattern("test.txt").Call());
RevCommit commit2 = git.Commit().SetMessage("commit2").Call();
NUnit.Framework.Assert.IsNotNull(commit2);
NUnit.Framework.Assert.IsNotNull(git.Checkout().SetName(Constants.MASTER).Call());
DirCache cache = db.LockDirCache();
cache.GetEntry("test.txt").FileMode = FileMode.EXECUTABLE_FILE;
cache.Write();
NUnit.Framework.Assert.IsTrue(cache.Commit());
cache.Unlock();
NUnit.Framework.Assert.IsNotNull(git.Commit().SetMessage("commit3").Call());
git.GetRepository().GetConfig().SetBoolean(ConfigConstants.CONFIG_CORE_SECTION, null
, ConfigConstants.CONFIG_KEY_FILEMODE, false);
CherryPickResult result = git.CherryPick().Include(commit2).Call();
NUnit.Framework.Assert.IsNotNull(result);
NUnit.Framework.Assert.AreEqual(CherryPickResult.CherryPickStatus.OK, result.GetStatus
());
}
/// <summary>Reverts the worktree after an unsuccessful merge.</summary>
/// <remarks>
/// Reverts the worktree after an unsuccessful merge. We know that for all
/// modified files the old content was in the old index and the index
/// contained only stage 0. In case if inCore operation just clear
/// the history of modified files.
/// </remarks>
/// <exception cref="System.IO.IOException">System.IO.IOException</exception>
/// <exception cref="NGit.Errors.CorruptObjectException">NGit.Errors.CorruptObjectException
/// </exception>
/// <exception cref="NGit.Errors.NoWorkTreeException">NGit.Errors.NoWorkTreeException
/// </exception>
private void CleanUp()
{
if (inCore)
{
modifiedFiles.Clear();
return;
}
DirCache dc = db.ReadDirCache();
ObjectReader or = db.ObjectDatabase.NewReader();
Iterator <string> mpathsIt = modifiedFiles.Iterator();
while (mpathsIt.HasNext())
{
string mpath = mpathsIt.Next();
DirCacheEntry entry = dc.GetEntry(mpath);
FileOutputStream fos = new FileOutputStream(new FilePath(db.WorkTree, mpath));
try
{
or.Open(entry.GetObjectId()).CopyTo(fos);
}
finally
{
fos.Close();
}
mpathsIt.Remove();
}
}
/// <summary>
/// Generate a list of lines with information about when the lines were
/// introduced into the file path.
/// </summary>
/// <remarks>
/// Generate a list of lines with information about when the lines were
/// introduced into the file path.
/// </remarks>
/// <returns>list of lines</returns>
/// <exception cref="NGit.Api.Errors.GitAPIException"></exception>
public override BlameResult Call()
{
CheckCallable();
BlameGenerator gen = new BlameGenerator(repo, path);
try
{
if (diffAlgorithm != null)
{
gen.SetDiffAlgorithm(diffAlgorithm);
}
if (textComparator != null)
{
gen.SetTextComparator(textComparator);
}
if (followFileRenames != null)
{
gen.SetFollowFileRenames(followFileRenames);
}
if (reverseEndCommits != null)
{
gen.Reverse(startCommit, reverseEndCommits);
}
else
{
if (startCommit != null)
{
gen.Push(null, startCommit);
}
else
{
gen.Push(null, repo.Resolve(Constants.HEAD));
if (!repo.IsBare)
{
DirCache dc = repo.ReadDirCache();
int entry = dc.FindEntry(path);
if (0 <= entry)
{
gen.Push(null, dc.GetEntry(entry).GetObjectId());
}
FilePath inTree = new FilePath(repo.WorkTree, path);
if (inTree.IsFile())
{
gen.Push(null, new RawText(inTree));
}
}
}
}
return(gen.ComputeBlameResult());
}
catch (IOException e)
{
throw new JGitInternalException(e.Message, e);
}
finally
{
gen.Release();
}
}
/// <exception cref="NGit.Errors.CorruptObjectException"></exception>
/// <exception cref="System.IO.IOException"></exception>
private void AssertIndex(Dictionary <string, string> i)
{
string expectedValue;
string path;
DirCache read = DirCache.Read(db.GetIndexFile(), db.FileSystem);
NUnit.Framework.Assert.AreEqual(i.Count, read.GetEntryCount(), "Index has not the right size."
);
for (int j = 0; j < read.GetEntryCount(); j++)
{
path = read.GetEntry(j).PathString;
expectedValue = i.Get(path);
NUnit.Framework.Assert.IsNotNull(expectedValue, "found unexpected entry for path "
+ path + " in index");
NUnit.Framework.Assert.IsTrue(Arrays.Equals(db.Open(read.GetEntry(j).GetObjectId(
)).GetCachedBytes(), Sharpen.Runtime.GetBytesForString(i.Get(path))), "unexpected content for path "
+ path + " in index. Expected: <" + expectedValue + ">");
}
}
public GitFileStatus GetFileStatusNoCache(string fileName)
{
if (Directory.Exists(fileName))
{
return(GitFileStatus.Ignored);
}
var fileNameRel = GetRelativeFileNameForGit(fileName);
TreeWalk treeWalk = new TreeWalk(this.repository)
{
Recursive = true
};
RevTree revTree = head == null ? null : new RevWalk(repository).ParseTree(head);
if (revTree != null)
{
treeWalk.AddTree(revTree);
}
else
{
treeWalk.AddTree(new EmptyTreeIterator());
}
treeWalk.AddTree(new DirCacheIterator(dirCache));
treeWalk.AddTree(new FileTreeIterator(this.repository));
var filters = new TreeFilter[] {
PathFilter.Create(fileNameRel),
new SkipWorkTreeFilter(INDEX),
new IndexDiffFilter(INDEX, WORKDIR)
};
treeWalk.Filter = AndTreeFilter.Create(filters);
var status = GitFileStatus.NotControlled;
if (treeWalk.Next())
{
status = GetFileStatus(treeWalk);
}
if (status == GitFileStatus.NotControlled)
{
var dirCacheEntry2 = dirCache.GetEntry(fileNameRel);
if (dirCacheEntry2 != null)
{
var treeEntry2 = TreeWalk.ForPath(repository, fileNameRel, revTree);
if (treeEntry2 != null && treeEntry2.GetObjectId(0).Equals(dirCacheEntry2.GetObjectId()))
{
return(GitFileStatus.Tracked);
}
}
}
return(GitFileStatus.NotControlled);
}
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);
}
/// <exception cref="System.IO.IOException"></exception>
private void AssumeUnchanged(string path)
{
DirCache dirc = db.LockDirCache();
DirCacheEntry ent = dirc.GetEntry(path);
if (ent != null)
{
ent.IsAssumeValid = true;
}
dirc.Write();
if (!dirc.Commit())
{
throw new IOException("could not commit");
}
}
public virtual void CommitIgnoresSmudgedEntryWithDifferentId()
{
Git git = new Git(db);
FilePath file1 = WriteTrashFile("file1.txt", "content1");
NUnit.Framework.Assert.IsTrue(file1.SetLastModified(file1.LastModified() - 5000));
FilePath file2 = WriteTrashFile("file2.txt", "content2");
NUnit.Framework.Assert.IsTrue(file2.SetLastModified(file2.LastModified() - 5000));
NUnit.Framework.Assert.IsNotNull(git.Add().AddFilepattern("file1.txt").AddFilepattern
("file2.txt").Call());
RevCommit commit = git.Commit().SetMessage("add files").Call();
NUnit.Framework.Assert.IsNotNull(commit);
DirCache cache = DirCache.Read(db.GetIndexFile(), db.FileSystem);
int file1Size = cache.GetEntry("file1.txt").Length;
int file2Size = cache.GetEntry("file2.txt").Length;
NUnit.Framework.Assert.IsTrue(file1Size > 0);
NUnit.Framework.Assert.IsTrue(file2Size > 0);
WriteTrashFile("file2.txt", "content3");
NUnit.Framework.Assert.IsNotNull(git.Add().AddFilepattern("file2.txt").Call());
WriteTrashFile("file2.txt", "content4");
// Smudge entries
cache = DirCache.Lock(db.GetIndexFile(), db.FileSystem);
cache.GetEntry("file1.txt").SetLength(0);
cache.GetEntry("file2.txt").SetLength(0);
cache.Write();
NUnit.Framework.Assert.IsTrue(cache.Commit());
// Verify entries smudged
cache = db.ReadDirCache();
NUnit.Framework.Assert.AreEqual(0, cache.GetEntry("file1.txt").Length);
NUnit.Framework.Assert.AreEqual(0, cache.GetEntry("file2.txt").Length);
long indexTime = db.GetIndexFile().LastModified();
db.GetIndexFile().SetLastModified(indexTime - 5000);
Write(file1, "content5");
NUnit.Framework.Assert.IsTrue(file1.SetLastModified(file1.LastModified() + 1000));
NUnit.Framework.Assert.IsNotNull(git.Commit().SetMessage("edit file").SetOnly("file1.txt"
).Call());
cache = db.ReadDirCache();
NUnit.Framework.Assert.AreEqual(file1Size, cache.GetEntry("file1.txt").Length);
NUnit.Framework.Assert.AreEqual(0, cache.GetEntry("file2.txt").Length);
}
public virtual void TestReadIndex_LsFiles()
{
IDictionary<string, DirCacheCGitCompatabilityTest.CGitIndexRecord> ls = ReadLsFiles
();
DirCache dc = new DirCache(index, FS.DETECTED);
NUnit.Framework.Assert.AreEqual(0, dc.GetEntryCount());
dc.Read();
NUnit.Framework.Assert.AreEqual(ls.Count, dc.GetEntryCount());
{
Iterator<DirCacheCGitCompatabilityTest.CGitIndexRecord> rItr = ls.Values.Iterator
();
for (int i = 0; rItr.HasNext(); i++)
{
AssertEqual(rItr.Next(), dc.GetEntry(i));
}
}
}
/// <exception cref="System.IO.IOException"></exception>
private void ApplyChanges(TreeWalk treeWalk, DirCache cache, DirCacheEditor editor
)
{
FilePath workingTree = repo.WorkTree;
while (treeWalk.Next())
{
string path = treeWalk.PathString;
FilePath file = new FilePath(workingTree, path);
// State of the stashed HEAD, index, and working directory
AbstractTreeIterator stashHeadIter = treeWalk.GetTree <AbstractTreeIterator>(0);
AbstractTreeIterator stashIndexIter = treeWalk.GetTree <AbstractTreeIterator>(1);
AbstractTreeIterator stashWorkingIter = treeWalk.GetTree <AbstractTreeIterator>(2);
if (stashWorkingIter != null && stashIndexIter != null)
{
// Checkout index change
DirCacheEntry entry = cache.GetEntry(path);
if (entry == null)
{
entry = new DirCacheEntry(treeWalk.RawPath);
}
entry.FileMode = stashIndexIter.EntryFileMode;
entry.SetObjectId(stashIndexIter.EntryObjectId);
DirCacheCheckout.CheckoutEntry(repo, file, entry, treeWalk.ObjectReader);
DirCacheEntry updatedEntry = entry;
editor.Add(new _PathEdit_270(updatedEntry, path));
// Checkout working directory change
if (!stashWorkingIter.IdEqual(stashIndexIter))
{
entry = new DirCacheEntry(treeWalk.RawPath);
entry.SetObjectId(stashWorkingIter.EntryObjectId);
DirCacheCheckout.CheckoutEntry(repo, file, entry, treeWalk.ObjectReader);
}
}
else
{
if (stashIndexIter == null || (stashHeadIter != null && !stashIndexIter.IdEqual(stashHeadIter
)))
{
editor.Add(new DirCacheEditor.DeletePath(path));
}
FileUtils.Delete(file, FileUtils.RETRY | FileUtils.SKIP_MISSING);
}
}
}
public virtual void TestAddRemovedFile()
{
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();
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 virtual void TestAddExistingSingleFileTwiceWithCommit()
{
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();
git.Commit().SetMessage("commit a.txt").Call();
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));
}
/// <exception cref="NGit.Errors.NoWorkTreeException"></exception>
/// <exception cref="System.IO.IOException"></exception>
public static void ValidateIndex(Git git)
{
DirCache dc = git.GetRepository().LockDirCache();
ObjectReader r = git.GetRepository().ObjectDatabase.NewReader();
try
{
for (int i = 0; i < dc.GetEntryCount(); ++i)
{
DirCacheEntry entry = dc.GetEntry(i);
if (entry.Length > 0)
{
NUnit.Framework.Assert.AreEqual(entry.Length, r.GetObjectSize(entry.GetObjectId()
, ObjectReader.OBJ_ANY));
}
}
}
finally
{
dc.Unlock();
r.Release();
}
}
/// <summary>Checkout paths into index and working directory</summary>
/// <returns>this instance</returns>
/// <exception cref="System.IO.IOException">System.IO.IOException</exception>
/// <exception cref="NGit.Api.Errors.RefNotFoundException">NGit.Api.Errors.RefNotFoundException
/// </exception>
protected internal virtual NGit.Api.CheckoutCommand CheckoutPaths()
{
RevWalk revWalk = new RevWalk(repo);
DirCache dc = repo.LockDirCache();
try
{
TreeWalk treeWalk = new TreeWalk(revWalk.GetObjectReader());
treeWalk.Recursive = true;
treeWalk.AddTree(new DirCacheIterator(dc));
treeWalk.Filter = PathFilterGroup.CreateFromStrings(paths);
IList <string> files = new List <string>();
while (treeWalk.Next())
{
files.AddItem(treeWalk.PathString);
}
if (startCommit != null || startPoint != null)
{
DirCacheEditor editor = dc.Editor();
TreeWalk startWalk = new TreeWalk(revWalk.GetObjectReader());
startWalk.Recursive = true;
startWalk.Filter = treeWalk.Filter;
startWalk.AddTree(revWalk.ParseCommit(GetStartPoint()).Tree);
while (startWalk.Next())
{
ObjectId blobId = startWalk.GetObjectId(0);
editor.Add(new _PathEdit_258(blobId, startWalk.PathString));
}
editor.Commit();
}
FilePath workTree = repo.WorkTree;
foreach (string file in files)
{
DirCacheCheckout.CheckoutEntry(repo, new FilePath(workTree, file), dc.GetEntry(file
));
}
}
finally
{
dc.Unlock();
revWalk.Release();
}
return(this);
}
private void AssertCorrectId(DirCache treeT, TreeWalk tw)
{
NUnit.Framework.Assert.AreEqual(treeT.GetEntry(tw.PathString).GetObjectId(), tw.GetObjectId
(0));
}
//
//
//
//
//
// Assert that every specified index entry has the same last modification
// timestamp as the associated file
/// <exception cref="System.IO.IOException"></exception>
private void CheckConsistentLastModified(params string[] pathes)
{
DirCache dc = db.ReadDirCache();
FilePath workTree = db.WorkTree;
foreach (string path in pathes)
{
NUnit.Framework.Assert.AreEqual(new FilePath(workTree, path).LastModified(), dc.GetEntry
(path).LastModified, "IndexEntry with path " + path + " has lastmodified with is different from the worktree file"
);
}
}
public virtual void TestUnsupportedOptionalExtension()
{
DirCache dc = new DirCache(PathOf("gitgit.index.ZZZZ"), FS.DETECTED);
dc.Read();
NUnit.Framework.Assert.AreEqual(1, dc.GetEntryCount());
NUnit.Framework.Assert.AreEqual("A", dc.GetEntry(0).PathString);
}
private void AssertCorrectId(DirCache treeT, TreeWalk tw)
{
NUnit.Framework.Assert.AreEqual(treeT.GetEntry(tw.PathString).GetObjectId(), tw.GetObjectId
(0));
}
/// <summary>Checks if a file with the given path exists in the index</summary>
/// <param name="path"></param>
/// <returns>true if the file exists</returns>
/// <exception cref="System.IO.IOException">System.IO.IOException</exception>
private bool InIndex(string path)
{
DirCache dc = DirCache.Read(db.GetIndexFile(), db.FileSystem);
return(dc.GetEntry(path) != null);
}
private static void AssertV3TreeEntry(int indexPosition, string path, bool skipWorkTree
, bool intentToAdd, DirCache dc)
{
DirCacheEntry entry = dc.GetEntry(indexPosition);
NUnit.Framework.Assert.AreEqual(path, entry.PathString);
Assert.AreEqual(skipWorkTree, entry.IsSkipWorkTree);
Assert.AreEqual(intentToAdd, entry.IsIntentToAdd);
}
