public void testWriteReadTree()
{
DirCache dc = DirCache.Lock(db);
string A = string.Format("a%2000s", "a");
string B = string.Format("b%2000s", "b");
string[] paths = { A + ".", A + "." + B, A + "/" + B, A + "0" + B };
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.commit();
DirCache read = DirCache.read(db);
Assert.AreEqual(paths.Length, read.getEntryCount());
Assert.AreEqual(1, read.getCacheTree(true).getChildCount());
}
public virtual void TestTrivialTwoWay_rightDFconflict2()
{
DirCache treeB = db.ReadDirCache();
DirCache treeO = db.ReadDirCache();
DirCache treeT = db.ReadDirCache();
{
DirCacheBuilder b = treeB.Builder();
DirCacheBuilder o = treeO.Builder();
DirCacheBuilder t = treeT.Builder();
b.Add(CreateEntry("d", FileMode.REGULAR_FILE));
o.Add(CreateEntry("d/o", FileMode.REGULAR_FILE));
t.Add(CreateEntry("d", FileMode.REGULAR_FILE, "t !"));
b.Finish();
o.Finish();
t.Finish();
}
ObjectInserter ow = db.NewObjectInserter();
ObjectId b_1 = Commit(ow, treeB, new ObjectId[] { });
ObjectId o_1 = Commit(ow, treeO, new ObjectId[] { b_1 });
ObjectId t_1 = Commit(ow, treeT, new ObjectId[] { b_1 });
Merger ourMerger = ((ThreeWayMerger)MergeStrategy.SIMPLE_TWO_WAY_IN_CORE.NewMerger
(db));
bool merge = ourMerger.Merge(new ObjectId[] { o_1, t_1 });
NUnit.Framework.Assert.IsFalse(merge);
}
public void testNoSubtree_NoTreeWalk()
{
DirCache dc = DirCache.read(db);
string[] paths = { "a.", "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();
var iter = new DirCacheIterator(dc);
int pathIdx = 0;
for (; !iter.eof(); iter.next(1))
{
Assert.AreEqual(pathIdx, iter.Pointer);
Assert.AreSame(ents[pathIdx], iter.getDirCacheEntry());
pathIdx++;
}
Assert.AreEqual(paths.Length, pathIdx);
}
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 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 void testTrivialTwoWay_rightDFconflict2()
{
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", FileMode.RegularFile));
o.add(MakeEntry("d/o", FileMode.RegularFile));
t.add(MakeEntry("d", 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.IsFalse(merge);
}
public void testAdd_ReverseGitSortOrder()
{
DirCache dc = DirCache.read(db);
string[] paths = { "a.", "a.b", "a/b", "a0b" };
DirCacheEntry[] 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 = ents.Length - 1; i >= 0; i--)
{
b.add(ents[i]);
}
b.finish();
Assert.AreEqual(paths.Length, dc.getEntryCount());
for (int i = 0; i < paths.Length; i++)
{
Assert.AreSame(ents[i], dc.getEntry(i));
Assert.AreEqual(paths[i], dc.getEntry(i).getPathString());
Assert.AreEqual(i, dc.findEntry(paths[i]));
Assert.AreSame(ents[i], dc.getEntry(paths[i]));
}
}
public void testBuilderClear()
{
DirCache dc = DirCache.read(db);
string[] paths = { "a.", "a.b", "a/b", "a0b" };
DirCacheEntry[] 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();
}
Assert.AreEqual(paths.Length, dc.getEntryCount());
{
DirCacheBuilder b = dc.builder();
b.finish();
}
Assert.AreEqual(0, dc.getEntryCount());
}
public void testBuildThenClear()
{
DirCache dc = DirCache.read(db);
string[] paths = { "a.", "a.b", "a/b", "a0b" };
var ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
}
DirCacheBuilder b = dc.builder();
for (int i = 0; i < ents.Length; i++)
{
b.add(ents[i]);
}
b.finish();
Assert.AreEqual(paths.Length, dc.getEntryCount());
dc.clear();
Assert.AreEqual(0, dc.getEntryCount());
}
public void testFindSingleFile()
{
string path = "a-File-path";
DirCache dc = DirCache.read(db);
DirCacheBuilder b = dc.builder();
Assert.IsNotNull(b);
DirCacheEntry entOrig = new DirCacheEntry(path);
entOrig.setFileMode(FileMode.RegularFile);
Assert.AreNotSame(path, entOrig.getPathString());
Assert.AreEqual(path, entOrig.getPathString());
b.add(entOrig);
b.finish();
Assert.AreEqual(1, dc.getEntryCount());
Assert.AreSame(entOrig, dc.getEntry(0));
Assert.AreEqual(0, dc.findEntry(path));
Assert.AreEqual(-1, dc.findEntry("@@-before"));
Assert.AreEqual(0, real(dc.findEntry("@@-before")));
Assert.AreEqual(-2, dc.findEntry("a-zoo"));
Assert.AreEqual(1, real(dc.findEntry("a-zoo")));
Assert.AreSame(entOrig, dc.getEntry(path));
}
public virtual void testDF_NoGap()
{
DirCache tree0 = DirCache.read(db);
DirCache tree1 = DirCache.read(db);
{
DirCacheBuilder b0 = tree0.builder();
DirCacheBuilder b1 = tree1.builder();
b0.add(makeEntry("a", REGULAR_FILE));
b0.add(makeEntry("a.b", EXECUTABLE_FILE));
b1.add(makeEntry("a/b", REGULAR_FILE));
b0.add(makeEntry("a0b", SYMLINK));
b0.finish();
b1.finish();
Assert.AreEqual(3, tree0.getEntryCount());
Assert.AreEqual(1, tree1.getEntryCount());
}
NameConflictTreeWalk tw = new NameConflictTreeWalk(db);
tw.reset();
tw.addTree(new DirCacheIterator(tree0));
tw.addTree(new DirCacheIterator(tree1));
assertModes("a", REGULAR_FILE, TREE, tw);
Assert.IsTrue(tw.isSubtree());
tw.enterSubtree();
assertModes("a/b", MISSING, REGULAR_FILE, tw);
assertModes("a.b", EXECUTABLE_FILE, MISSING, tw);
assertModes("a0b", SYMLINK, MISSING, tw);
}
private void testLongPath(int len)
{
string longPath = makeLongPath(len);
string shortPath = "~~~ shorter-path";
DirCacheEntry longEnt = new DirCacheEntry(longPath);
DirCacheEntry shortEnt = new DirCacheEntry(shortPath);
Assert.AreEqual(longPath, longEnt.getPathString());
Assert.AreEqual(shortPath, shortEnt.getPathString());
DirCache dc1 = DirCache.Lock(db);
DirCacheBuilder b = dc1.builder();
b.add(longEnt);
b.add(shortEnt);
Assert.IsTrue(b.commit());
Assert.AreEqual(2, dc1.getEntryCount());
Assert.AreSame(longEnt, dc1.getEntry(0));
Assert.AreSame(shortEnt, dc1.getEntry(1));
DirCache dc2 = DirCache.read(db);
Assert.AreEqual(2, dc2.getEntryCount());
Assert.AreNotSame(longEnt, dc2.getEntry(0));
Assert.AreEqual(longPath, dc2.getEntry(0).getPathString());
Assert.AreNotSame(shortEnt, dc2.getEntry(1));
Assert.AreEqual(shortPath, dc2.getEntry(1).getPathString());
}
public virtual void TestDF_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());
}
NameConflictTreeWalk tw = new NameConflictTreeWalk(db);
tw.AddTree(new DirCacheIterator(tree0));
tw.AddTree(new DirCacheIterator(tree1));
AssertModes("a", REGULAR_FILE, TREE, tw);
NUnit.Framework.Assert.IsTrue(tw.IsDirectoryFileConflict());
NUnit.Framework.Assert.IsTrue(tw.IsSubtree);
tw.EnterSubtree();
AssertModes("a/b", MISSING, REGULAR_FILE, tw);
NUnit.Framework.Assert.IsTrue(tw.IsDirectoryFileConflict());
AssertModes("a.b", EXECUTABLE_FILE, MISSING, tw);
NUnit.Framework.Assert.IsFalse(tw.IsDirectoryFileConflict());
AssertModes("a0b", SYMLINK, MISSING, tw);
NUnit.Framework.Assert.IsFalse(tw.IsDirectoryFileConflict());
}
ObjectId WriteWorkingDirectoryTree(RevTree headTree, DirCache index)
{
DirCache dc = DirCache.NewInCore();
DirCacheBuilder cb = dc.Builder();
ObjectInserter oi = _repo.NewObjectInserter();
try {
TreeWalk tw = new TreeWalk(_repo);
tw.Reset();
tw.AddTree(new FileTreeIterator(_repo));
tw.AddTree(headTree);
tw.AddTree(new DirCacheIterator(index));
while (tw.Next())
{
// Ignore untracked files
if (tw.IsSubtree)
{
tw.EnterSubtree();
}
else if (tw.GetFileMode(0) != NGit.FileMode.MISSING && (tw.GetFileMode(1) != NGit.FileMode.MISSING || tw.GetFileMode(2) != NGit.FileMode.MISSING))
{
WorkingTreeIterator f = tw.GetTree <WorkingTreeIterator>(0);
DirCacheIterator dcIter = tw.GetTree <DirCacheIterator>(2);
DirCacheEntry currentEntry = dcIter.GetDirCacheEntry();
DirCacheEntry ce = new DirCacheEntry(tw.PathString);
if (!f.IsModified(currentEntry, true))
{
ce.SetLength(currentEntry.Length);
ce.LastModified = currentEntry.LastModified;
ce.FileMode = currentEntry.FileMode;
ce.SetObjectId(currentEntry.GetObjectId());
}
else
{
long sz = f.GetEntryLength();
ce.SetLength(sz);
ce.LastModified = f.GetEntryLastModified();
ce.FileMode = f.EntryFileMode;
var data = f.OpenEntryStream();
try {
ce.SetObjectId(oi.Insert(Constants.OBJ_BLOB, sz, data));
} finally {
data.Close();
}
}
cb.Add(ce);
}
}
cb.Finish();
return(dc.WriteTree(oi));
} finally {
oi.Release();
}
}
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 virtual 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 = db.ReadDirCache();
DirCache treeO = db.ReadDirCache();
DirCache treeP = db.ReadDirCache();
DirCache treeT = db.ReadDirCache();
{
DirCacheBuilder b = treeB.Builder();
DirCacheBuilder o = treeO.Builder();
DirCacheBuilder p = treeP.Builder();
DirCacheBuilder t = treeT.Builder();
b.Add(MakeEntry("a", FileMode.REGULAR_FILE));
o.Add(MakeEntry("a", FileMode.REGULAR_FILE));
o.Add(MakeEntry("o", FileMode.REGULAR_FILE));
p.Add(MakeEntry("a", FileMode.REGULAR_FILE, "q"));
p.Add(MakeEntry("p-fail", FileMode.REGULAR_FILE));
t.Add(MakeEntry("a", FileMode.REGULAR_FILE));
t.Add(MakeEntry("t", FileMode.REGULAR_FILE));
b.Finish();
o.Finish();
p.Finish();
t.Finish();
}
ObjectInserter ow = db.NewObjectInserter();
ObjectId B = Commit(ow, treeB, new ObjectId[] { });
ObjectId O = Commit(ow, treeO, new ObjectId[] { B });
ObjectId P = Commit(ow, treeP, new ObjectId[] { B });
ObjectId T = Commit(ow, treeT, new ObjectId[] { P });
ThreeWayMerger twm = ((ThreeWayMerger)MergeStrategy.SIMPLE_TWO_WAY_IN_CORE.NewMerger
(db));
twm.SetBase(P);
bool merge = twm.Merge(new ObjectId[] { O, T });
NUnit.Framework.Assert.IsTrue(merge);
TreeWalk tw = new TreeWalk(db);
tw.Recursive = true;
tw.Reset(twm.GetResultTreeId());
NUnit.Framework.Assert.IsTrue(tw.Next());
NUnit.Framework.Assert.AreEqual("a", tw.PathString);
AssertCorrectId(treeO, tw);
NUnit.Framework.Assert.IsTrue(tw.Next());
NUnit.Framework.Assert.AreEqual("o", tw.PathString);
AssertCorrectId(treeO, tw);
NUnit.Framework.Assert.IsTrue(tw.Next());
NUnit.Framework.Assert.AreEqual("t", tw.PathString);
AssertCorrectId(treeT, tw);
NUnit.Framework.Assert.IsFalse(tw.Next());
}
public void testTwoLevelSubtree()
{
DirCache dc = DirCache.read(db);
string[] paths = { "a.", "a/b", "a/c/e", "a/c/f", "a/d", "a0b" };
DirCacheEntry[] ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].setFileMode(FileMode.RegularFile);
}
int aFirst = 1;
int aLast = 4;
int acFirst = 2;
int acLast = 3;
DirCacheBuilder b = dc.builder();
for (int i = 0; i < ents.Length; i++)
{
b.add(ents[i]);
}
b.finish();
Assert.IsNull(dc.getCacheTree(false));
DirCacheTree root = dc.getCacheTree(true);
Assert.IsNotNull(root);
Assert.AreSame(root, dc.getCacheTree(true));
Assert.AreEqual(string.Empty, root.getNameString());
Assert.AreEqual(string.Empty, root.getPathString());
Assert.AreEqual(1, root.getChildCount());
Assert.AreEqual(dc.getEntryCount(), root.getEntrySpan());
Assert.IsFalse(root.isValid());
DirCacheTree aTree = root.getChild(0);
Assert.IsNotNull(aTree);
Assert.AreSame(aTree, root.getChild(0));
Assert.AreEqual("a", aTree.getNameString());
Assert.AreEqual("a/", aTree.getPathString());
Assert.AreEqual(1, aTree.getChildCount());
Assert.AreEqual(aLast - aFirst + 1, aTree.getEntrySpan());
Assert.IsFalse(aTree.isValid());
DirCacheTree acTree = aTree.getChild(0);
Assert.IsNotNull(acTree);
Assert.AreSame(acTree, aTree.getChild(0));
Assert.AreEqual("c", acTree.getNameString());
Assert.AreEqual("a/c/", acTree.getPathString());
Assert.AreEqual(0, acTree.getChildCount());
Assert.AreEqual(acLast - acFirst + 1, acTree.getEntrySpan());
Assert.IsFalse(acTree.isValid());
}
public virtual void TestRecursiveFiltering()
{
ObjectInserter odi = db.NewObjectInserter();
ObjectId aSth = odi.Insert(Constants.OBJ_BLOB, Sharpen.Runtime.GetBytesForString(
"a.sth"));
ObjectId aTxt = odi.Insert(Constants.OBJ_BLOB, Sharpen.Runtime.GetBytesForString(
"a.txt"));
ObjectId bSth = odi.Insert(Constants.OBJ_BLOB, Sharpen.Runtime.GetBytesForString(
"b.sth"));
ObjectId bTxt = odi.Insert(Constants.OBJ_BLOB, Sharpen.Runtime.GetBytesForString(
"b.txt"));
DirCache dc = db.ReadDirCache();
DirCacheBuilder builder = dc.Builder();
DirCacheEntry aSthEntry = new DirCacheEntry("a.sth");
aSthEntry.FileMode = FileMode.REGULAR_FILE;
aSthEntry.SetObjectId(aSth);
DirCacheEntry aTxtEntry = new DirCacheEntry("a.txt");
aTxtEntry.FileMode = FileMode.REGULAR_FILE;
aTxtEntry.SetObjectId(aTxt);
builder.Add(aSthEntry);
builder.Add(aTxtEntry);
DirCacheEntry bSthEntry = new DirCacheEntry("sub/b.sth");
bSthEntry.FileMode = FileMode.REGULAR_FILE;
bSthEntry.SetObjectId(bSth);
DirCacheEntry bTxtEntry = new DirCacheEntry("sub/b.txt");
bTxtEntry.FileMode = FileMode.REGULAR_FILE;
bTxtEntry.SetObjectId(bTxt);
builder.Add(bSthEntry);
builder.Add(bTxtEntry);
builder.Finish();
ObjectId treeId = dc.WriteTree(odi);
odi.Flush();
TreeWalk tw = new TreeWalk(db);
tw.Recursive = true;
tw.Filter = PathSuffixFilter.Create(".txt");
tw.AddTree(treeId);
IList <string> paths = new List <string>();
while (tw.Next())
{
paths.AddItem(tw.PathString);
}
IList <string> expected = new List <string>();
expected.AddItem("a.txt");
expected.AddItem("sub/b.txt");
NUnit.Framework.Assert.AreEqual(expected, paths);
}
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 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 testEntriesWithin()
{
DirCache dc = DirCache.read(db);
string[] paths = { "a.", "a/b", "a/c", "a/d", "a0b" };
DirCacheEntry[] ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].setFileMode(FileMode.RegularFile);
}
int aFirst = 1;
int aLast = 3;
DirCacheBuilder b = dc.builder();
for (int i = 0; i < ents.Length; i++)
{
b.add(ents[i]);
}
b.finish();
Assert.AreEqual(paths.Length, dc.getEntryCount());
for (int i = 0; i < ents.Length; i++)
{
Assert.AreSame(ents[i], dc.getEntry(i));
}
DirCacheEntry[] aContents = dc.getEntriesWithin("a");
Assert.IsNotNull(aContents);
Assert.AreEqual(aLast - aFirst + 1, aContents.Length);
for (int i = aFirst, j = 0; i <= aLast; i++, j++)
{
Assert.AreSame(ents[i], aContents[j]);
}
aContents = dc.getEntriesWithin("a/");
Assert.IsNotNull(aContents);
Assert.AreEqual(aLast - aFirst + 1, aContents.Length);
for (int i = aFirst, j = 0; i <= aLast; i++, j++)
{
Assert.AreSame(ents[i], aContents[j]);
}
Assert.IsNotNull(dc.getEntriesWithin("a."));
Assert.AreEqual(0, dc.getEntriesWithin("a.").Length);
Assert.IsNotNull(dc.getEntriesWithin("a0b"));
Assert.AreEqual(0, dc.getEntriesWithin("a0b.").Length);
Assert.IsNotNull(dc.getEntriesWithin("zoo"));
Assert.AreEqual(0, dc.getEntriesWithin("zoo.").Length);
}
/**
* Construct a tree from a specific listing of file entries.
*
* @param entries
* the files to include in the tree. The collection does not need
* to be sorted properly and may be empty.
* @return reference to the tree specified by the entry list.
* @throws Exception
*/
public RevTree tree(params DirCacheEntry[] entries)
{
DirCache dc = DirCache.newInCore();
DirCacheBuilder b = dc.builder();
foreach (DirCacheEntry e in entries)
{
b.add(e);
}
b.finish();
return(pool.lookupTree(dc.writeTree(writer)));
}
public CommitBuilder parent(RevCommit p)
{
if (parents.isEmpty())
{
DirCacheBuilder b = tree.builder();
_testRepository.parseBody(p);
b.addTree(new byte[0], DirCacheEntry.STAGE_0, _testRepository.db, p.Tree);
b.finish();
}
parents.Add(p);
return(this);
}
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);
}
protected RevTree tree(params DirCacheEntry[] entries)
{
DirCache dc = DirCache.newInCore();
DirCacheBuilder b = dc.builder();
foreach (DirCacheEntry e in entries)
{
b.add(e);
}
b.finish();
return(rw.lookupTree(dc.writeTree(_ow)));
}
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));
}
}
/// <exception cref="System.Exception"></exception>
public virtual CommitBuilder Parent(RevCommit p)
{
if (this.parents.IsEmpty())
{
DirCacheBuilder b = this.tree.Builder();
this._enclosing.ParseBody(p);
b.AddTree(new byte[0], DirCacheEntry.STAGE_0, this._enclosing.pool.GetObjectReader
(), p.Tree);
b.Finish();
}
this.parents.AddItem(p);
return(this);
}
public void testBuildEmpty()
{
DirCache dc = DirCache.Lock(db);
DirCacheBuilder b = dc.builder();
Assert.IsNotNull(b);
b.finish();
dc.write();
Assert.IsTrue(dc.commit());
dc = DirCache.read(db);
Assert.AreEqual(0, dc.getEntryCount());
}
public virtual void TestRevert()
{
// B---P---T
//
// Revert P, this should result in a tree with a
// from B and t from T as the change to a in P
// and addition of t in P is reverted.
//
// We use the standard merge, but change the order
// of the sources.
//
DirCache treeB = db.ReadDirCache();
DirCache treeP = db.ReadDirCache();
DirCache treeT = db.ReadDirCache();
{
DirCacheBuilder b = treeB.Builder();
DirCacheBuilder p = treeP.Builder();
DirCacheBuilder t = treeT.Builder();
b.Add(MakeEntry("a", FileMode.REGULAR_FILE));
p.Add(MakeEntry("a", FileMode.REGULAR_FILE, "q"));
p.Add(MakeEntry("p-fail", FileMode.REGULAR_FILE));
t.Add(MakeEntry("a", FileMode.REGULAR_FILE, "q"));
t.Add(MakeEntry("p-fail", FileMode.REGULAR_FILE));
t.Add(MakeEntry("t", FileMode.REGULAR_FILE));
b.Finish();
p.Finish();
t.Finish();
}
ObjectInserter ow = db.NewObjectInserter();
ObjectId B = Commit(ow, treeB, new ObjectId[] { });
ObjectId P = Commit(ow, treeP, new ObjectId[] { B });
ObjectId T = Commit(ow, treeT, new ObjectId[] { P });
ThreeWayMerger twm = ((ThreeWayMerger)MergeStrategy.SIMPLE_TWO_WAY_IN_CORE.NewMerger
(db));
twm.SetBase(P);
bool merge = twm.Merge(new ObjectId[] { B, T });
NUnit.Framework.Assert.IsTrue(merge);
TreeWalk tw = new TreeWalk(db);
tw.Recursive = true;
tw.Reset(twm.GetResultTreeId());
NUnit.Framework.Assert.IsTrue(tw.Next());
NUnit.Framework.Assert.AreEqual("a", tw.PathString);
AssertCorrectId(treeB, tw);
NUnit.Framework.Assert.IsTrue(tw.Next());
NUnit.Framework.Assert.AreEqual("t", tw.PathString);
AssertCorrectId(treeT, tw);
NUnit.Framework.Assert.IsFalse(tw.Next());
}
/// <exception cref="System.Exception"></exception>
internal CommitBuilder(TestRepository _enclosing, CommitBuilder
prior)
{
this._enclosing = _enclosing;
this.branch = prior.branch;
DirCacheBuilder b = this.tree.Builder();
for (int i = 0; i < prior.tree.GetEntryCount(); i++)
{
b.Add(prior.tree.GetEntry(i));
}
b.Finish();
this.parents.AddItem(prior.Create());
}
public void testBuildOneFile_FinishWriteCommit()
{
string path = "a-File-path";
var mode = FileMode.RegularFile;
long lastModified = 1218123387057L;
int Length = 1342;
DirCacheEntry entOrig;
DirCache dc = DirCache.Lock(db);
DirCacheBuilder b = dc.builder();
Assert.IsNotNull(b);
entOrig = new DirCacheEntry(path);
entOrig.setFileMode(mode);
entOrig.setLastModified(lastModified);
entOrig.setLength(Length);
Assert.AreNotSame(path, entOrig.getPathString());
Assert.AreEqual(path, entOrig.getPathString());
Assert.AreEqual(ObjectId.ZeroId, entOrig.getObjectId());
Assert.AreEqual(mode.Bits, entOrig.getRawMode());
Assert.AreEqual(0, entOrig.getStage());
Assert.AreEqual(lastModified, entOrig.getLastModified());
Assert.AreEqual(Length, entOrig.getLength());
Assert.IsFalse(entOrig.isAssumeValid());
b.add(entOrig);
b.finish();
Assert.AreEqual(1, dc.getEntryCount());
Assert.AreSame(entOrig, dc.getEntry(0));
dc.write();
Assert.IsTrue(dc.commit());
dc = DirCache.read(db);
Assert.AreEqual(1, dc.getEntryCount());
DirCacheEntry entRead = dc.getEntry(0);
Assert.AreNotSame(entOrig, entRead);
Assert.AreEqual(path, entRead.getPathString());
Assert.AreEqual(ObjectId.ZeroId, entOrig.getObjectId());
Assert.AreEqual(mode.Bits, entOrig.getRawMode());
Assert.AreEqual(0, entOrig.getStage());
Assert.AreEqual(lastModified, entOrig.getLastModified());
Assert.AreEqual(Length, entOrig.getLength());
Assert.IsFalse(entOrig.isAssumeValid());
}
