public virtual void TestNoDF_NoGap()
{
DirCache tree0 = db.ReadDirCache();
DirCache tree1 = db.ReadDirCache();
{
DirCacheBuilder b0 = tree0.Builder();
DirCacheBuilder b1 = tree1.Builder();
b0.Add(CreateEntry("a", REGULAR_FILE));
b0.Add(CreateEntry("a.b", EXECUTABLE_FILE));
b1.Add(CreateEntry("a/b", REGULAR_FILE));
b0.Add(CreateEntry("a0b", SYMLINK));
b0.Finish();
b1.Finish();
NUnit.Framework.Assert.AreEqual(3, tree0.GetEntryCount());
NUnit.Framework.Assert.AreEqual(1, tree1.GetEntryCount());
}
TreeWalk tw = new TreeWalk(db);
tw.AddTree(new DirCacheIterator(tree0));
tw.AddTree(new DirCacheIterator(tree1));
AssertModes("a", REGULAR_FILE, MISSING, tw);
AssertModes("a.b", EXECUTABLE_FILE, MISSING, tw);
AssertModes("a", MISSING, TREE, tw);
tw.EnterSubtree();
AssertModes("a/b", MISSING, REGULAR_FILE, tw);
AssertModes("a0b", SYMLINK, MISSING, tw);
}
/// <summary>Open a tree walk and filter to exactly one path.</summary>
/// <remarks>
/// Open a tree walk and filter to exactly one path.
/// <p>
/// The returned tree walk is already positioned on the requested path, so
/// the caller should not need to invoke
/// <see cref="Next()">Next()</see>
/// unless they are
/// looking for a possible directory/file name conflict.
/// </remarks>
/// <param name="reader">the reader the walker will obtain tree data from.</param>
/// <param name="path">single path to advance the tree walk instance into.</param>
/// <param name="trees">one or more trees to walk through, all with the same root.</param>
/// <returns>
/// a new tree walk configured for exactly this one path; null if no
/// path was found in any of the trees.
/// </returns>
/// <exception cref="System.IO.IOException">reading a pack file or loose object failed.
/// </exception>
/// <exception cref="NGit.Errors.CorruptObjectException">
/// an tree object could not be read as its data stream did not
/// appear to be a tree, or could not be inflated.
/// </exception>
/// <exception cref="NGit.Errors.IncorrectObjectTypeException">an object we expected to be a tree was not a tree.
/// </exception>
/// <exception cref="NGit.Errors.MissingObjectException">a tree object was not found.
/// </exception>
public static NGit.Treewalk.TreeWalk ForPath(NGit.ObjectReader reader, string path
, params AnyObjectId[] trees)
{
NGit.Treewalk.TreeWalk tw = new NGit.Treewalk.TreeWalk(reader);
PathFilter f = PathFilter.Create(path);
tw.Filter = f;
tw.Reset(trees);
tw.Recursive = false;
while (tw.Next())
{
if (f.IsDone(tw))
{
return(tw);
}
else
{
if (tw.IsSubtree)
{
tw.EnterSubtree();
}
}
}
return(null);
}
public virtual void TestNoPostOrder()
{
DirCache tree = db.ReadDirCache();
{
DirCacheBuilder b = tree.Builder();
b.Add(MakeFile("a"));
b.Add(MakeFile("b/c"));
b.Add(MakeFile("b/d"));
b.Add(MakeFile("q"));
b.Finish();
NUnit.Framework.Assert.AreEqual(4, tree.GetEntryCount());
}
TreeWalk tw = new TreeWalk(db);
tw.PostOrderTraversal = false;
tw.AddTree(new DirCacheIterator(tree));
AssertModes("a", FileMode.REGULAR_FILE, tw);
AssertModes("b", FileMode.TREE, tw);
NUnit.Framework.Assert.IsTrue(tw.IsSubtree);
NUnit.Framework.Assert.IsFalse(tw.IsPostChildren);
tw.EnterSubtree();
AssertModes("b/c", FileMode.REGULAR_FILE, tw);
AssertModes("b/d", FileMode.REGULAR_FILE, tw);
AssertModes("q", FileMode.REGULAR_FILE, tw);
}
public virtual void TestFindObjects()
{
DirCache tree0 = DirCache.NewInCore();
DirCacheBuilder b0 = tree0.Builder();
ObjectReader or = db.NewObjectReader();
ObjectInserter oi = db.NewObjectInserter();
DirCacheEntry aDotB = MakeEntry("a.b", EXECUTABLE_FILE);
b0.Add(aDotB);
DirCacheEntry aSlashB = MakeEntry("a/b", REGULAR_FILE);
b0.Add(aSlashB);
DirCacheEntry aSlashCSlashD = MakeEntry("a/c/d", REGULAR_FILE);
b0.Add(aSlashCSlashD);
DirCacheEntry aZeroB = MakeEntry("a0b", SYMLINK);
b0.Add(aZeroB);
b0.Finish();
NUnit.Framework.Assert.AreEqual(4, tree0.GetEntryCount());
ObjectId tree = tree0.WriteTree(oi);
// Find the directories that were implicitly created above.
TreeWalk tw = new TreeWalk(or);
tw.AddTree(tree);
ObjectId a = null;
ObjectId aSlashC = null;
while (tw.Next())
{
if (tw.PathString.Equals("a"))
{
a = tw.GetObjectId(0);
tw.EnterSubtree();
while (tw.Next())
{
if (tw.PathString.Equals("a/c"))
{
aSlashC = tw.GetObjectId(0);
break;
}
}
break;
}
}
NUnit.Framework.Assert.AreEqual(a, TreeWalk.ForPath(or, "a", tree).GetObjectId(0)
);
NUnit.Framework.Assert.AreEqual(a, TreeWalk.ForPath(or, "a/", tree).GetObjectId(0
));
NUnit.Framework.Assert.AreEqual(null, TreeWalk.ForPath(or, "/a", tree));
NUnit.Framework.Assert.AreEqual(null, TreeWalk.ForPath(or, "/a/", tree));
NUnit.Framework.Assert.AreEqual(aDotB.GetObjectId(), TreeWalk.ForPath(or, "a.b",
tree).GetObjectId(0));
NUnit.Framework.Assert.AreEqual(null, TreeWalk.ForPath(or, "/a.b", tree));
NUnit.Framework.Assert.AreEqual(null, TreeWalk.ForPath(or, "/a.b/", tree));
NUnit.Framework.Assert.AreEqual(aDotB.GetObjectId(), TreeWalk.ForPath(or, "a.b/",
tree).GetObjectId(0));
NUnit.Framework.Assert.AreEqual(aZeroB.GetObjectId(), TreeWalk.ForPath(or, "a0b",
tree).GetObjectId(0));
NUnit.Framework.Assert.AreEqual(aSlashB.GetObjectId(), TreeWalk.ForPath(or, "a/b"
, tree).GetObjectId(0));
NUnit.Framework.Assert.AreEqual(aSlashB.GetObjectId(), TreeWalk.ForPath(or, "b",
a).GetObjectId(0));
NUnit.Framework.Assert.AreEqual(aSlashC, TreeWalk.ForPath(or, "a/c", tree).GetObjectId
(0));
NUnit.Framework.Assert.AreEqual(aSlashC, TreeWalk.ForPath(or, "c", a).GetObjectId
(0));
NUnit.Framework.Assert.AreEqual(aSlashCSlashD.GetObjectId(), TreeWalk.ForPath(or,
"a/c/d", tree).GetObjectId(0));
NUnit.Framework.Assert.AreEqual(aSlashCSlashD.GetObjectId(), TreeWalk.ForPath(or,
"c/d", a).GetObjectId(0));
or.Release();
oi.Release();
}
