public void testNoPostOrder()
{
DirCache tree = DirCache.read(db);
{
DirCacheBuilder b = tree.builder();
b.add(makeFile("a"));
b.add(makeFile("b/c"));
b.add(makeFile("b/d"));
b.add(makeFile("q"));
b.finish();
Assert.AreEqual(4, tree.getEntryCount());
}
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
tw.reset();
tw.PostOrderTraversal = false;
tw.addTree(new DirCacheIterator(tree));
assertModes("a", FileMode.RegularFile, tw);
assertModes("b", FileMode.Tree, tw);
Assert.IsTrue(tw.isSubtree());
Assert.IsFalse(tw.isPostChildren());
tw.enterSubtree();
assertModes("b/c", FileMode.RegularFile, tw);
assertModes("b/d", FileMode.RegularFile, tw);
assertModes("q", FileMode.RegularFile, tw);
}
public void testNonRecursiveFiltering()
{
var ow = new ObjectWriter(db);
ObjectId aSth = ow.WriteBlob("a.sth".getBytes());
ObjectId aTxt = ow.WriteBlob("a.txt".getBytes());
DirCache dc = DirCache.read(db);
DirCacheBuilder builder = dc.builder();
var aSthEntry = new DirCacheEntry("a.sth");
aSthEntry.setFileMode(FileMode.RegularFile);
aSthEntry.setObjectId(aSth);
var aTxtEntry = new DirCacheEntry("a.txt");
aTxtEntry.setFileMode(FileMode.RegularFile);
aTxtEntry.setObjectId(aTxt);
builder.add(aSthEntry);
builder.add(aTxtEntry);
builder.finish();
ObjectId treeId = dc.writeTree(ow);
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
tw.setFilter(PathSuffixFilter.create(".txt"));
tw.addTree(treeId);
var paths = new LinkedList<string>();
while (tw.next())
{
paths.AddLast(tw.getPathString());
}
var expected = new LinkedList<string>();
expected.AddLast("a.txt");
Assert.AreEqual(expected, paths);
}
public void testInitialize_TogglePostOrder()
{
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
Assert.IsFalse(tw.PostOrderTraversal);
tw.PostOrderTraversal = true;
Assert.IsTrue(tw.PostOrderTraversal);
tw.PostOrderTraversal = false;
Assert.IsFalse(tw.PostOrderTraversal);
}
public void testTrivialTwoWay_validSubtreeSort()
{
DirCache treeB = DirCache.read(db);
DirCache treeO = DirCache.read(db);
DirCache treeT = DirCache.read(db);
{
DirCacheBuilder b = treeB.builder();
DirCacheBuilder o = treeO.builder();
DirCacheBuilder t = treeT.builder();
b.add(MakeEntry("libelf-po/a", FileMode.RegularFile));
b.add(MakeEntry("libelf/c", FileMode.RegularFile));
o.add(MakeEntry("Makefile", FileMode.RegularFile));
o.add(MakeEntry("libelf-po/a", FileMode.RegularFile));
o.add(MakeEntry("libelf/c", FileMode.RegularFile));
t.add(MakeEntry("libelf-po/a", FileMode.RegularFile));
t.add(MakeEntry("libelf/c", FileMode.RegularFile, "blah"));
b.finish();
o.finish();
t.finish();
}
var ow = new ObjectWriter(db);
ObjectId B = Commit(ow, treeB, new ObjectId[] { });
ObjectId O = Commit(ow, treeO, new[] { B });
ObjectId T = Commit(ow, treeT, new[] { B });
Merger ourMerger = MergeStrategy.SimpleTwoWayInCore.NewMerger(db);
bool merge = ourMerger.Merge(new[] { O, T });
Assert.IsTrue(merge);
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db)
{
Recursive = true
};
tw.reset(ourMerger.GetResultTreeId());
Assert.IsTrue(tw.next());
Assert.AreEqual("Makefile", tw.getPathString());
AssertCorrectId(treeO, tw);
Assert.IsTrue(tw.next());
Assert.AreEqual("libelf-po/a", tw.getPathString());
AssertCorrectId(treeO, tw);
Assert.IsTrue(tw.next());
Assert.AreEqual("libelf/c", tw.getPathString());
AssertCorrectId(treeT, tw);
Assert.IsFalse(tw.next());
}
public void testInitialize_TogglePostOrder()
{
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
Assert.IsFalse(tw.PostOrderTraversal);
tw.PostOrderTraversal = true;
Assert.IsTrue(tw.PostOrderTraversal);
tw.PostOrderTraversal = false;
Assert.IsFalse(tw.PostOrderTraversal);
}
public void testEmptyTree_WithTreeWalk()
{
DirCache dc = DirCache.read(db);
Assert.AreEqual(0, dc.getEntryCount());
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
tw.reset();
tw.addTree(new DirCacheIterator(dc));
Assert.IsFalse(tw.next());
}
public void testSingleSubtree_NoRecursion()
{
DirCache dc = DirCache.read(db);
string[] paths = { "a.", "a/b", "a/c", "a/d", "a0b" };
var ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].setFileMode(FileMode.RegularFile);
}
DirCacheBuilder b = dc.builder();
for (int i = 0; i < ents.Length; i++)
{
b.add(ents[i]);
}
b.finish();
string[] expPaths = { "a.", "a", "a0b" };
FileMode[] expModes = { FileMode.RegularFile, FileMode.Tree, FileMode.RegularFile };
var expPos = new[] { 0, -1, 4 };
var iter = new DirCacheIterator(dc);
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
tw.reset();
tw.addTree(iter);
tw.Recursive = false;
int pathIdx = 0;
while (tw.next())
{
Assert.AreSame(iter, tw.getTree <DirCacheIterator>(0, typeof(DirCacheIterator)));
Assert.AreEqual(expModes[pathIdx].Bits, tw.getRawMode(0));
Assert.AreSame(expModes[pathIdx], tw.getFileMode(0));
Assert.AreEqual(expPaths[pathIdx], tw.getPathString());
if (expPos[pathIdx] >= 0)
{
Assert.AreEqual(expPos[pathIdx], iter.Pointer);
Assert.AreSame(ents[expPos[pathIdx]], iter.getDirCacheEntry());
}
else
{
Assert.AreSame(FileMode.Tree, tw.getFileMode(0));
}
pathIdx++;
}
Assert.AreEqual(expPaths.Length, pathIdx);
}
public void testResetDoesNotAffectPostOrder()
{
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db) { PostOrderTraversal = true };
Assert.IsTrue(tw.PostOrderTraversal);
tw.reset();
Assert.IsTrue(tw.PostOrderTraversal);
tw.PostOrderTraversal = false;
Assert.IsFalse(tw.PostOrderTraversal);
tw.reset();
Assert.IsFalse(tw.PostOrderTraversal);
}
public void testRecursiveFiltering()
{
var ow = new ObjectWriter(db);
ObjectId aSth = ow.WriteBlob("a.sth".getBytes());
ObjectId aTxt = ow.WriteBlob("a.txt".getBytes());
ObjectId bSth = ow.WriteBlob("b.sth".getBytes());
ObjectId bTxt = ow.WriteBlob("b.txt".getBytes());
DirCache dc = DirCache.read(db);
DirCacheBuilder builder = dc.builder();
var aSthEntry = new DirCacheEntry("a.sth");
aSthEntry.setFileMode(FileMode.RegularFile);
aSthEntry.setObjectId(aSth);
var aTxtEntry = new DirCacheEntry("a.txt");
aTxtEntry.setFileMode(FileMode.RegularFile);
aTxtEntry.setObjectId(aTxt);
builder.add(aSthEntry);
builder.add(aTxtEntry);
var bSthEntry = new DirCacheEntry("sub/b.sth");
bSthEntry.setFileMode(FileMode.RegularFile);
bSthEntry.setObjectId(bSth);
var bTxtEntry = new DirCacheEntry("sub/b.txt");
bTxtEntry.setFileMode(FileMode.RegularFile);
bTxtEntry.setObjectId(bTxt);
builder.add(bSthEntry);
builder.add(bTxtEntry);
builder.finish();
ObjectId treeId = dc.writeTree(ow);
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
tw.Recursive = true;
tw.setFilter(PathSuffixFilter.create(".txt"));
tw.addTree(treeId);
var paths = new LinkedList <string>();
while (tw.next())
{
paths.AddLast(tw.getPathString());
}
var expected = new LinkedList <string>();
expected.AddLast("a.txt");
expected.AddLast("sub/b.txt");
Assert.AreEqual(expected, paths);
}
public void testEmptyTree_WithTreeWalk()
{
DirCache dc = DirCache.read(db);
Assert.AreEqual(0, dc.getEntryCount());
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
tw.reset();
tw.addTree(new DirCacheIterator(dc));
Assert.IsFalse(tw.next());
}
public void testPathFilterGroup_DoesNotSkipTail()
{
DirCache dc = DirCache.read(db);
var mode = FileMode.RegularFile;
string[] paths = { "a.", "a/b", "a/c", "a/d", "a0b" };
var ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].setFileMode(mode);
}
DirCacheBuilder builder = dc.builder();
for (int i = 0; i < ents.Length; i++)
{
builder.add(ents[i]);
}
builder.finish();
const int expIdx = 2;
DirCacheBuilder b = dc.builder();
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
tw.reset();
tw.addTree(new DirCacheBuildIterator(b));
tw.Recursive = true;
tw.setFilter(PathFilterGroup.createFromStrings(new[] { paths[expIdx] }));
Assert.IsTrue(tw.next(), "found " + paths[expIdx]);
var c = tw.getTree <DirCacheIterator>(0, typeof(DirCacheIterator));
Assert.IsNotNull(c);
Assert.AreEqual(expIdx, c.Pointer);
Assert.AreSame(ents[expIdx], c.getDirCacheEntry());
Assert.AreEqual(paths[expIdx], tw.getPathString());
Assert.AreEqual(mode.Bits, tw.getRawMode(0));
Assert.AreSame(mode, tw.getFileMode(0));
b.add(c.getDirCacheEntry());
Assert.IsFalse(tw.next(), "no more entries");
b.finish();
Assert.AreEqual(ents.Length, dc.getEntryCount());
for (int i = 0; i < ents.Length; i++)
{
Assert.AreSame(ents[i], dc.getEntry(i));
}
}
public void testResetDoesNotAffectPostOrder()
{
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db)
{
PostOrderTraversal = true
};
Assert.IsTrue(tw.PostOrderTraversal);
tw.reset();
Assert.IsTrue(tw.PostOrderTraversal);
tw.PostOrderTraversal = false;
Assert.IsFalse(tw.PostOrderTraversal);
tw.reset();
Assert.IsFalse(tw.PostOrderTraversal);
}
public void testPathFilterGroup_DoesNotSkipTail()
{
DirCache dc = DirCache.read(db);
var mode = FileMode.RegularFile;
string[] paths = { "a.", "a/b", "a/c", "a/d", "a0b" };
var ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].setFileMode(mode);
}
DirCacheBuilder builder = dc.builder();
for (int i = 0; i < ents.Length; i++)
{
builder.add(ents[i]);
}
builder.finish();
const int expIdx = 2;
DirCacheBuilder b = dc.builder();
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
tw.reset();
tw.addTree(new DirCacheBuildIterator(b));
tw.Recursive = true;
tw.setFilter(PathFilterGroup.createFromStrings(new[] { paths[expIdx] }));
Assert.IsTrue(tw.next(), "found " + paths[expIdx]);
var c = tw.getTree<DirCacheIterator>(0, typeof(DirCacheIterator));
Assert.IsNotNull(c);
Assert.AreEqual(expIdx, c.Pointer);
Assert.AreSame(ents[expIdx], c.getDirCacheEntry());
Assert.AreEqual(paths[expIdx], tw.getPathString());
Assert.AreEqual(mode.Bits, tw.getRawMode(0));
Assert.AreSame(mode, tw.getFileMode(0));
b.add(c.getDirCacheEntry());
Assert.IsFalse(tw.next(), "no more entries");
b.finish();
Assert.AreEqual(ents.Length, dc.getEntryCount());
for (int i = 0; i < ents.Length; i++)
{
Assert.AreSame(ents[i], dc.getEntry(i));
}
}
public void testSingleSubtree_Recursive()
{
DirCache dc = DirCache.read(db);
FileMode mode = FileMode.RegularFile;
string[] paths = { "a.", "a/b", "a/c", "a/d", "a0b" };
var ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].setFileMode(mode);
}
DirCacheBuilder b = dc.builder();
for (int i = 0; i < ents.Length; i++)
{
b.add(ents[i]);
}
b.finish();
var iter = new DirCacheIterator(dc);
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
tw.reset();
tw.addTree(iter);
tw.Recursive = true;
int pathIdx = 0;
while (tw.next())
{
var c = tw.getTree <DirCacheIterator>(0, typeof(DirCacheIterator));
Assert.IsNotNull(c);
Assert.AreEqual(pathIdx, c.Pointer);
Assert.AreSame(ents[pathIdx], c.getDirCacheEntry());
Assert.AreEqual(paths[pathIdx], tw.getPathString());
Assert.AreEqual(mode.Bits, tw.getRawMode(0));
Assert.AreSame(mode, tw.getFileMode(0));
pathIdx++;
}
Assert.AreEqual(paths.Length, pathIdx);
}
public void testTwoLevelSubtree_FilterPath()
{
DirCache dc = DirCache.read(db);
FileMode mode = FileMode.RegularFile;
string[] paths = { "a.", "a/b", "a/c/e", "a/c/f", "a/d", "a0b" };
var ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].setFileMode(mode);
}
DirCacheBuilder b = dc.builder();
for (int i = 0; i < ents.Length; i++)
{
b.add(ents[i]);
}
b.finish();
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
for (int victimIdx = 0; victimIdx < paths.Length; victimIdx++)
{
tw.reset();
tw.addTree(new DirCacheIterator(dc));
tw.setFilter(PathFilterGroup.createFromStrings(new[] { paths[victimIdx] }));
tw.Recursive = tw.getFilter().shouldBeRecursive();
Assert.IsTrue(tw.next());
var c = tw.getTree <DirCacheIterator>(0, typeof(DirCacheIterator));
Assert.IsNotNull(c);
Assert.AreEqual(victimIdx, c.Pointer);
Assert.AreSame(ents[victimIdx], c.getDirCacheEntry());
Assert.AreEqual(paths[victimIdx], tw.getPathString());
Assert.AreEqual(mode.Bits, tw.getRawMode(0));
Assert.AreSame(mode, tw.getFileMode(0));
Assert.IsFalse(tw.next());
}
}
public void testNoSubtree_WithTreeWalk()
{
DirCache dc = DirCache.read(db);
string[] paths = { "a.", "a0b" };
FileMode[] modes = { FileMode.ExecutableFile, FileMode.GitLink };
var ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].setFileMode(modes[i]);
}
DirCacheBuilder b = dc.builder();
for (int i = 0; i < ents.Length; i++)
{
b.add(ents[i]);
}
b.finish();
var iter = new DirCacheIterator(dc);
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
tw.reset();
tw.addTree(iter);
int pathIdx = 0;
while (tw.next())
{
Assert.AreSame(iter, tw.getTree <DirCacheIterator>(0, typeof(DirCacheIterator)));
Assert.AreEqual(pathIdx, iter.Pointer);
Assert.AreSame(ents[pathIdx], iter.getDirCacheEntry());
Assert.AreEqual(paths[pathIdx], tw.getPathString());
Assert.AreEqual(modes[pathIdx].Bits, tw.getRawMode(0));
Assert.AreSame(modes[pathIdx], tw.getFileMode(0));
pathIdx++;
}
Assert.AreEqual(paths.Length, pathIdx);
}
protected RevObject get(RevTree tree, string path)
{
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
tw.setFilter(PathFilterGroup.createFromStrings(new[] { path }));
tw.reset(tree);
while (tw.next())
{
if (tw.isSubtree() && !path.Equals(tw.getPathString()))
{
tw.enterSubtree();
continue;
}
ObjectId entid = tw.getObjectId(0);
FileMode entmode = tw.getFileMode(0);
return(rw.lookupAny(entid, (int)entmode.ObjectType));
}
Assert.Fail("Can't find " + path + " in tree " + tree.Name);
return(null); // never reached.
}
public void testTreeWalk_LsFiles()
{
List <CGitIndexRecord> ls = ReadLsFiles();
var dc = new DirCache(_index);
Assert.AreEqual(0, dc.getEntryCount());
dc.read();
Assert.AreEqual(ls.Count, dc.getEntryCount());
var rItr = ls.GetEnumerator();
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
tw.reset();
tw.Recursive = true;
tw.addTree(new DirCacheIterator(dc));
while (rItr.MoveNext())
{
Assert.IsTrue(tw.next());
var dcItr = tw.getTree <DirCacheIterator>(0, typeof(DirCacheIterator));
Assert.IsNotNull(dcItr);
AssertAreEqual(rItr.Current, dcItr.getDirCacheEntry());
}
}
public void testTrivialTwoWay_concurrentSubtreeChange()
{
DirCache treeB = DirCache.read(db);
DirCache treeO = DirCache.read(db);
DirCache treeT = DirCache.read(db);
{
DirCacheBuilder b = treeB.builder();
DirCacheBuilder o = treeO.builder();
DirCacheBuilder t = treeT.builder();
b.add(MakeEntry("d/o", FileMode.RegularFile));
b.add(MakeEntry("d/t", FileMode.RegularFile));
o.add(MakeEntry("d/o", FileMode.RegularFile, "o !"));
o.add(MakeEntry("d/t", FileMode.RegularFile));
t.add(MakeEntry("d/o", FileMode.RegularFile));
t.add(MakeEntry("d/t", FileMode.RegularFile, "t !"));
b.finish();
o.finish();
t.finish();
}
var ow = new ObjectWriter(db);
ObjectId B = Commit(ow, treeB, new ObjectId[] { });
ObjectId O = Commit(ow, treeO, new[] { B });
ObjectId T = Commit(ow, treeT, new[] { B });
Merger ourMerger = MergeStrategy.SimpleTwoWayInCore.NewMerger(db);
bool merge = ourMerger.Merge(new[] { O, T });
Assert.IsTrue(merge);
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db) { Recursive = true };
tw.reset(ourMerger.GetResultTreeId());
Assert.IsTrue(tw.next());
Assert.AreEqual("d/o", tw.getPathString());
AssertCorrectId(treeO, tw);
Assert.IsTrue(tw.next());
Assert.AreEqual("d/t", tw.getPathString());
AssertCorrectId(treeT, tw);
Assert.IsFalse(tw.next());
}
private static void AssertCorrectId(DirCache treeT, GitSharp.Core.TreeWalk.TreeWalk tw)
{
Assert.AreEqual(treeT.getEntry(tw.getPathString()).getObjectId(), tw.getObjectId(0));
}
public void testMissingSubtree_DetectFileAdded_FileModified()
{
var ow = new ObjectWriter(db);
ObjectId aFileId = ow.WriteBlob(Constants.CHARSET.GetBytes("a"));
ObjectId bFileId = ow.WriteBlob(Constants.CHARSET.GetBytes("b"));
ObjectId cFileId1 = ow.WriteBlob(Constants.CHARSET.GetBytes("c-1"));
ObjectId cFileId2 = ow.WriteBlob(Constants.CHARSET.GetBytes("c-2"));
// Create sub-a/empty, sub-c/empty = hello.
Func <ObjectId> oldTree = () =>
{
var root = new Core.Tree(db);
Core.Tree subA = root.AddTree("sub-a");
subA.AddFile("empty").Id = aFileId;
subA.Id = ow.WriteTree(subA);
Core.Tree subC = root.AddTree("sub-c");
subC.AddFile("empty").Id = cFileId1;
subC.Id = ow.WriteTree(subC);
return(ow.WriteTree(root));
};
// Create sub-a/empty, sub-b/empty, sub-c/empty.
Func <ObjectId> newTree = () =>
{
var root = new Core.Tree(db);
Core.Tree subA = root.AddTree("sub-a");
subA.AddFile("empty").Id = aFileId;
subA.Id = ow.WriteTree(subA);
Core.Tree subB = root.AddTree("sub-b");
subB.AddFile("empty").Id = bFileId;
subB.Id = ow.WriteTree(subB);
Core.Tree subC = root.AddTree("sub-c");
subC.AddFile("empty").Id = cFileId2;
subC.Id = ow.WriteTree(subC);
return(ow.WriteTree(root));
};
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
tw.reset(new[] { oldTree.Invoke(), newTree.Invoke() });
tw.Recursive = true;
tw.setFilter(TreeFilter.ANY_DIFF);
Assert.IsTrue(tw.next());
Assert.AreEqual("sub-b/empty", tw.getPathString());
Assert.AreEqual(FileMode.Missing, tw.getFileMode(0));
Assert.AreEqual(FileMode.RegularFile, tw.getFileMode(1));
Assert.AreEqual(ObjectId.ZeroId, tw.getObjectId(0));
Assert.AreEqual(bFileId, tw.getObjectId(1));
Assert.IsTrue(tw.next());
Assert.AreEqual("sub-c/empty", tw.getPathString());
Assert.AreEqual(FileMode.RegularFile, tw.getFileMode(0));
Assert.AreEqual(FileMode.RegularFile, tw.getFileMode(1));
Assert.AreEqual(cFileId1, tw.getObjectId(0));
Assert.AreEqual(cFileId2, tw.getObjectId(1));
Assert.IsFalse(tw.next());
}
public void testTwoLevelSubtree_Recursive()
{
DirCache dc = DirCache.read(db);
FileMode mode = FileMode.RegularFile;
string[] paths = { "a.", "a/b", "a/c/e", "a/c/f", "a/d", "a0b" };
var ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].setFileMode(mode);
}
DirCacheBuilder b = dc.builder();
for (int i = 0; i < ents.Length; i++)
{
b.add(ents[i]);
}
b.finish();
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
tw.reset();
tw.addTree(new DirCacheIterator(dc));
tw.Recursive = true;
int pathIdx = 0;
while (tw.next())
{
var c = tw.getTree<DirCacheIterator>(0, typeof(DirCacheIterator));
Assert.IsNotNull(c);
Assert.AreEqual(pathIdx, c.Pointer);
Assert.AreSame(ents[pathIdx], c.getDirCacheEntry());
Assert.AreEqual(paths[pathIdx], tw.getPathString());
Assert.AreEqual(mode.Bits, tw.getRawMode(0));
Assert.AreSame(mode, tw.getFileMode(0));
pathIdx++;
}
Assert.AreEqual(paths.Length, pathIdx);
}
public void testTwoLevelSubtree_FilterPath()
{
DirCache dc = DirCache.read(db);
FileMode mode = FileMode.RegularFile;
string[] paths = { "a.", "a/b", "a/c/e", "a/c/f", "a/d", "a0b" };
var ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].setFileMode(mode);
}
DirCacheBuilder b = dc.builder();
for (int i = 0; i < ents.Length; i++)
{
b.add(ents[i]);
}
b.finish();
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
for (int victimIdx = 0; victimIdx < paths.Length; victimIdx++)
{
tw.reset();
tw.addTree(new DirCacheIterator(dc));
tw.setFilter(PathFilterGroup.createFromStrings(new[] { paths[victimIdx] }));
tw.Recursive = tw.getFilter().shouldBeRecursive();
Assert.IsTrue(tw.next());
var c = tw.getTree<DirCacheIterator>(0, typeof(DirCacheIterator));
Assert.IsNotNull(c);
Assert.AreEqual(victimIdx, c.Pointer);
Assert.AreSame(ents[victimIdx], c.getDirCacheEntry());
Assert.AreEqual(paths[victimIdx], tw.getPathString());
Assert.AreEqual(mode.Bits, tw.getRawMode(0));
Assert.AreSame(mode, tw.getFileMode(0));
Assert.IsFalse(tw.next());
}
}
public void testNoPostOrder()
{
DirCache tree = DirCache.read(db);
{
DirCacheBuilder b = tree.builder();
b.add(makeFile("a"));
b.add(makeFile("b/c"));
b.add(makeFile("b/d"));
b.add(makeFile("q"));
b.finish();
Assert.AreEqual(4, tree.getEntryCount());
}
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
tw.reset();
tw.PostOrderTraversal = false;
tw.addTree(new DirCacheIterator(tree));
assertModes("a", FileMode.RegularFile, tw);
assertModes("b", FileMode.Tree, tw);
Assert.IsTrue(tw.isSubtree());
Assert.IsFalse(tw.isPostChildren());
tw.enterSubtree();
assertModes("b/c", FileMode.RegularFile, tw);
assertModes("b/d", FileMode.RegularFile, tw);
assertModes("q", FileMode.RegularFile, tw);
}
public void testNoSubtree_WithTreeWalk()
{
DirCache dc = DirCache.read(db);
string[] paths = { "a.", "a0b" };
FileMode[] modes = { FileMode.ExecutableFile, FileMode.GitLink };
var ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].setFileMode(modes[i]);
}
DirCacheBuilder b = dc.builder();
for (int i = 0; i < ents.Length; i++)
{
b.add(ents[i]);
}
b.finish();
var iter = new DirCacheIterator(dc);
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
tw.reset();
tw.addTree(iter);
int pathIdx = 0;
while (tw.next())
{
Assert.AreSame(iter, tw.getTree<DirCacheIterator>(0, typeof(DirCacheIterator)));
Assert.AreEqual(pathIdx, iter.Pointer);
Assert.AreSame(ents[pathIdx], iter.getDirCacheEntry());
Assert.AreEqual(paths[pathIdx], tw.getPathString());
Assert.AreEqual(modes[pathIdx].Bits, tw.getRawMode(0));
Assert.AreSame(modes[pathIdx], tw.getFileMode(0));
pathIdx++;
}
Assert.AreEqual(paths.Length, pathIdx);
}
public void testTreeWalk_LsFiles()
{
List<CGitIndexRecord> ls = ReadLsFiles();
var dc = new DirCache(_index);
Assert.AreEqual(0, dc.getEntryCount());
dc.read();
Assert.AreEqual(ls.Count, dc.getEntryCount());
var rItr = ls.GetEnumerator();
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
tw.reset();
tw.Recursive = true;
tw.addTree(new DirCacheIterator(dc));
while (rItr.MoveNext())
{
Assert.IsTrue(tw.next());
var dcItr = tw.getTree<DirCacheIterator>(0, typeof(DirCacheIterator));
Assert.IsNotNull(dcItr);
AssertAreEqual(rItr.Current, dcItr.getDirCacheEntry());
}
}
public void TestPick()
{
// B---O
// \----P---T
//
// Cherry-pick "T" onto "O". This shouldn't introduce "p-fail", which
// was created by "P", nor should it modify "a", which was done by "P".
//
DirCache treeB = DirCache.read(db);
DirCache treeO = DirCache.read(db);
DirCache treeP = DirCache.read(db);
DirCache treeT = DirCache.read(db);
{
DirCacheBuilder b = treeB.builder();
DirCacheBuilder o = treeO.builder();
DirCacheBuilder p = treeP.builder();
DirCacheBuilder t = treeT.builder();
b.add(MakeEntry("a", FileMode.RegularFile));
o.add(MakeEntry("a", FileMode.RegularFile));
o.add(MakeEntry("o", FileMode.RegularFile));
p.add(MakeEntry("a", FileMode.RegularFile, "q"));
p.add(MakeEntry("p-fail", FileMode.RegularFile));
t.add(MakeEntry("a", FileMode.RegularFile));
t.add(MakeEntry("t", FileMode.RegularFile));
b.finish();
o.finish();
p.finish();
t.finish();
}
var ow = new ObjectWriter(db);
ObjectId B = Commit(ow, treeB, new ObjectId[] { });
ObjectId O = Commit(ow, treeO, new[] { B });
ObjectId P = Commit(ow, treeP, new[] { B });
ObjectId T = Commit(ow, treeT, new[] { P });
var twm = (ThreeWayMerger)MergeStrategy.SimpleTwoWayInCore.NewMerger(db);
twm.SetBase(P);
bool merge = twm.Merge(new[] { O, T });
Assert.IsTrue(merge);
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db) { Recursive = true };
tw.reset(twm.GetResultTreeId());
Assert.IsTrue(tw.next());
Assert.AreEqual("a", tw.getPathString());
AssertCorrectId(treeO, tw);
Assert.IsTrue(tw.next());
Assert.AreEqual("o", tw.getPathString());
AssertCorrectId(treeO, tw);
Assert.IsTrue(tw.next());
Assert.AreEqual("t", tw.getPathString());
AssertCorrectId(treeT, tw);
Assert.IsFalse(tw.next());
}
public void TestPick()
{
// B---O
// \----P---T
//
// Cherry-pick "T" onto "O". This shouldn't introduce "p-fail", which
// was created by "P", nor should it modify "a", which was done by "P".
//
DirCache treeB = DirCache.read(db);
DirCache treeO = DirCache.read(db);
DirCache treeP = DirCache.read(db);
DirCache treeT = DirCache.read(db);
{
DirCacheBuilder b = treeB.builder();
DirCacheBuilder o = treeO.builder();
DirCacheBuilder p = treeP.builder();
DirCacheBuilder t = treeT.builder();
b.add(MakeEntry("a", FileMode.RegularFile));
o.add(MakeEntry("a", FileMode.RegularFile));
o.add(MakeEntry("o", FileMode.RegularFile));
p.add(MakeEntry("a", FileMode.RegularFile, "q"));
p.add(MakeEntry("p-fail", FileMode.RegularFile));
t.add(MakeEntry("a", FileMode.RegularFile));
t.add(MakeEntry("t", FileMode.RegularFile));
b.finish();
o.finish();
p.finish();
t.finish();
}
var ow = new ObjectWriter(db);
ObjectId B = Commit(ow, treeB, new ObjectId[] { });
ObjectId O = Commit(ow, treeO, new[] { B });
ObjectId P = Commit(ow, treeP, new[] { B });
ObjectId T = Commit(ow, treeT, new[] { P });
var twm = (ThreeWayMerger)MergeStrategy.SimpleTwoWayInCore.NewMerger(db);
twm.SetBase(P);
bool merge = twm.Merge(new[] { O, T });
Assert.IsTrue(merge);
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db)
{
Recursive = true
};
tw.reset(twm.GetResultTreeId());
Assert.IsTrue(tw.next());
Assert.AreEqual("a", tw.getPathString());
AssertCorrectId(treeO, tw);
Assert.IsTrue(tw.next());
Assert.AreEqual("o", tw.getPathString());
AssertCorrectId(treeO, tw);
Assert.IsTrue(tw.next());
Assert.AreEqual("t", tw.getPathString());
AssertCorrectId(treeT, tw);
Assert.IsFalse(tw.next());
}
public void testInitialize_NoPostOrder()
{
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
Assert.IsFalse(tw.PostOrderTraversal);
}
public void testMissingSubtree_DetectFileAdded_FileModified()
{
var ow = new ObjectWriter(db);
ObjectId aFileId = ow.WriteBlob(Constants.CHARSET.GetBytes("a"));
ObjectId bFileId = ow.WriteBlob(Constants.CHARSET.GetBytes("b"));
ObjectId cFileId1 = ow.WriteBlob(Constants.CHARSET.GetBytes("c-1"));
ObjectId cFileId2 = ow.WriteBlob(Constants.CHARSET.GetBytes("c-2"));
// Create sub-a/empty, sub-c/empty = hello.
Func<ObjectId> oldTree = () =>
{
var root = new Core.Tree(db);
Core.Tree subA = root.AddTree("sub-a");
subA.AddFile("empty").Id = aFileId;
subA.Id = ow.WriteTree(subA);
Core.Tree subC = root.AddTree("sub-c");
subC.AddFile("empty").Id = cFileId1;
subC.Id = ow.WriteTree(subC);
return ow.WriteTree(root);
};
// Create sub-a/empty, sub-b/empty, sub-c/empty.
Func<ObjectId> newTree = () =>
{
var root = new Core.Tree(db);
Core.Tree subA = root.AddTree("sub-a");
subA.AddFile("empty").Id = aFileId;
subA.Id = ow.WriteTree(subA);
Core.Tree subB = root.AddTree("sub-b");
subB.AddFile("empty").Id = bFileId;
subB.Id = ow.WriteTree(subB);
Core.Tree subC = root.AddTree("sub-c");
subC.AddFile("empty").Id = cFileId2;
subC.Id = ow.WriteTree(subC);
return ow.WriteTree(root);
};
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
tw.reset(new[] { oldTree.Invoke(), newTree.Invoke() });
tw.Recursive = true;
tw.setFilter(TreeFilter.ANY_DIFF);
Assert.IsTrue(tw.next());
Assert.AreEqual("sub-b/empty", tw.getPathString());
Assert.AreEqual(FileMode.Missing, tw.getFileMode(0));
Assert.AreEqual(FileMode.RegularFile, tw.getFileMode(1));
Assert.AreEqual(ObjectId.ZeroId, tw.getObjectId(0));
Assert.AreEqual(bFileId, tw.getObjectId(1));
Assert.IsTrue(tw.next());
Assert.AreEqual("sub-c/empty", tw.getPathString());
Assert.AreEqual(FileMode.RegularFile, tw.getFileMode(0));
Assert.AreEqual(FileMode.RegularFile, tw.getFileMode(1));
Assert.AreEqual(cFileId1, tw.getObjectId(0));
Assert.AreEqual(cFileId2, tw.getObjectId(1));
Assert.IsFalse(tw.next());
}
public void testSingleSubtree_NoRecursion()
{
DirCache dc = DirCache.read(db);
string[] paths = { "a.", "a/b", "a/c", "a/d", "a0b" };
var ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].setFileMode(FileMode.RegularFile);
}
DirCacheBuilder b = dc.builder();
for (int i = 0; i < ents.Length; i++)
{
b.add(ents[i]);
}
b.finish();
string[] expPaths = { "a.", "a", "a0b" };
FileMode[] expModes = { FileMode.RegularFile, FileMode.Tree, FileMode.RegularFile };
var expPos = new[] { 0, -1, 4 };
var iter = new DirCacheIterator(dc);
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
tw.reset();
tw.addTree(iter);
tw.Recursive = false;
int pathIdx = 0;
while (tw.next())
{
Assert.AreSame(iter, tw.getTree<DirCacheIterator>(0, typeof(DirCacheIterator)));
Assert.AreEqual(expModes[pathIdx].Bits, tw.getRawMode(0));
Assert.AreSame(expModes[pathIdx], tw.getFileMode(0));
Assert.AreEqual(expPaths[pathIdx], tw.getPathString());
if (expPos[pathIdx] >= 0)
{
Assert.AreEqual(expPos[pathIdx], iter.Pointer);
Assert.AreSame(ents[expPos[pathIdx]], iter.getDirCacheEntry());
}
else
{
Assert.AreSame(FileMode.Tree, tw.getFileMode(0));
}
pathIdx++;
}
Assert.AreEqual(expPaths.Length, pathIdx);
}
public void testInitialize_NoPostOrder()
{
var tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
Assert.IsFalse(tw.PostOrderTraversal);
}
private static void assertModes(string path, FileMode mode0, GitSharp.Core.TreeWalk.TreeWalk tw)
{
Assert.IsTrue(tw.next(), "has " + path);
Assert.AreEqual(path, tw.getPathString());
Assert.AreEqual(mode0, tw.getFileMode(0));
}
