private void checkoutTwoTrees() throws FileNotFoundException, IOException {
for (String path : removed) {
index.remove(root, new File(root, path));
}
for (java.util.Map.Entry<String, ObjectId> entry : updated.entrySet()) {
Entry newEntry = index.addEntry(merge.findBlobMember(entry.getKey()));
index.checkoutEntry(root, newEntry);
}
}
public void testCreateEmptyIndex() throws Exception {
GitIndex index = new GitIndex(db);
index.write();
// native git doesn't like an empty index
// assertEquals(0,system(trash,"git status"));
GitIndex indexr = new GitIndex(db);
indexr.read();
assertEquals(0, indexr.getMembers().length);
}
private GitIndex buildIndex(HashMap<String, String> indexEntries) throws IOException {
GitIndex index = new GitIndex(db);
if (indexEntries == null) return index;
for (java.util.Map.Entry<String, String> e : indexEntries.entrySet()) {
index.add(trash, writeTrashFile(e.getKey(), e.getValue())).forceRecheck();
}
return index;
}
public void testCheckout() throws Exception {
// Prepare tree, remote it and checkout
GitIndex index = new GitIndex(db);
File aslashb = writeTrashFile("a/b", "data:a/b");
File acolonb = writeTrashFile("a:b", "data:a:b");
File adotb = writeTrashFile("a.b", "data:a.b");
index.add(trash, aslashb);
index.add(trash, acolonb);
index.add(trash, adotb);
index.write();
index.writeTree();
delete(aslashb);
delete(acolonb);
delete(adotb);
delete(aslashb.getParentFile());
GitIndex index2 = new GitIndex(db);
assertEquals(0, index2.getMembers().length);
index2.readTree(db.mapTree(ObjectId.fromString("c696abc3ab8e091c665f49d00eb8919690b3aec3")));
index2.checkout(trash);
assertEquals("data:a/b", content(aslashb));
assertEquals("data:a:b", content(acolonb));
assertEquals("data:a.b", content(adotb));
if (canrungitstatus) assertEquals(0, system(trash, "git status"));
}
public void testUpdateSimpleSortTestIndex() throws Exception {
GitIndex index = new GitIndex(db);
writeTrashFile("a/b", "data:a/b");
writeTrashFile("a:b", "data:a:b");
writeTrashFile("a.b", "data:a.b");
index.add(trash, new File(trash, "a/b"));
index.add(trash, new File(trash, "a:b"));
index.add(trash, new File(trash, "a.b"));
writeTrashFile("a/b", "data:a/b modified");
index.add(trash, new File(trash, "a/b"));
index.write();
if (canrungitstatus) assertEquals(0, system(trash, "git status"));
}
WorkDirCheckout(Repository repo, File workDir, GitIndex oldIndex, GitIndex newIndex)
throws IOException {
this.repo = repo;
this.root = workDir;
this.index = oldIndex;
this.merge = repo.mapTree(newIndex.writeTree());
}
public void testDirectoryFileSimple() throws IOException {
theIndex = new GitIndex(db);
theIndex.add(trash, writeTrashFile("DF", "DF"));
Tree treeDF = db.mapTree(theIndex.writeTree());
recursiveDelete(new File(trash, "DF"));
theIndex = new GitIndex(db);
theIndex.add(trash, writeTrashFile("DF/DF", "DF/DF"));
Tree treeDFDF = db.mapTree(theIndex.writeTree());
theIndex = new GitIndex(db);
recursiveDelete(new File(trash, "DF"));
theIndex.add(trash, writeTrashFile("DF", "DF"));
theReadTree = getCheckoutImpl(treeDF, theIndex, treeDFDF);
theReadTree.prescanTwoTrees();
assertTrue(theReadTree.removed().contains("DF"));
assertTrue(theReadTree.updated().containsKey("DF/DF"));
recursiveDelete(new File(trash, "DF"));
theIndex = new GitIndex(db);
theIndex.add(trash, writeTrashFile("DF/DF", "DF/DF"));
theReadTree = getCheckoutImpl(treeDFDF, theIndex, treeDF);
theReadTree.prescanTwoTrees();
assertTrue(theReadTree.removed().contains("DF/DF"));
assertTrue(theReadTree.updated().containsKey("DF"));
}
void prescanTwoTrees() throws IOException {
new IndexTreeWalker(
index,
head,
merge,
root,
new AbstractIndexTreeVisitor() {
public void visitEntry(
TreeEntry treeEntry, TreeEntry auxEntry, Entry indexEntry, File file)
throws IOException {
if (treeEntry instanceof Tree || auxEntry instanceof Tree) {
throw new IllegalArgumentException(JGitText.get().cantPassMeATree);
}
processEntry(treeEntry, auxEntry, indexEntry);
}
@Override
public void finishVisitTree(Tree tree, Tree auxTree, String curDir)
throws IOException {
if (curDir.length() == 0) return;
if (auxTree != null) {
if (index.getEntry(curDir) != null) removed.add(curDir);
}
}
})
.walk();
// if there's a conflict, don't list it under
// to-be-removed, since that messed up our next
// section
removed.removeAll(conflicts);
for (String path : updated.keySet()) {
if (index.getEntry(path) == null) {
File file = new File(root, path);
if (file.isFile()) conflicts.add(path);
else if (file.isDirectory()) {
checkConflictsWithFile(file);
}
}
}
conflicts.removeAll(removed);
}
public void testWriteTree() throws Exception {
GitIndex index = new GitIndex(db);
writeTrashFile("a/b", "data:a/b");
writeTrashFile("a:b", "data:a:b");
writeTrashFile("a.b", "data:a.b");
index.add(trash, new File(trash, "a/b"));
index.add(trash, new File(trash, "a:b"));
index.add(trash, new File(trash, "a.b"));
index.write();
ObjectId id = index.writeTree();
assertEquals("c696abc3ab8e091c665f49d00eb8919690b3aec3", id.name());
writeTrashFile("a/b", "data:a/b");
index.add(trash, new File(trash, "a/b"));
if (canrungitstatus) assertEquals(0, system(trash, "git status"));
}
public void test031_executeBit_coreModeFalse()
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, Error,
Exception {
try {
// coremode true is the default, typically set to false
// by git init (but not jgit!)
Method canExecute = File.class.getMethod("canExecute", (Class[]) null);
Method setExecute = File.class.getMethod("setExecutable", new Class[] {Boolean.TYPE});
File execFile = writeTrashFile("exec", "exec");
if (!((Boolean) setExecute.invoke(execFile, new Object[] {Boolean.TRUE})).booleanValue())
throw new Error("could not set execute bit on " + execFile.getAbsolutePath() + "for test");
File nonexecFile = writeTrashFile("nonexec", "nonexec");
if (!((Boolean) setExecute.invoke(nonexecFile, new Object[] {Boolean.FALSE})).booleanValue())
throw new Error(
"could not clear execute bit on " + nonexecFile.getAbsolutePath() + "for test");
GitIndex index = new GitIndex(db);
index.filemode = Boolean.FALSE; // TODO: we need a way to set this using config
index.add(trash, execFile);
index.add(trash, nonexecFile);
Tree tree = db.mapTree(index.writeTree());
assertEquals(FileMode.REGULAR_FILE, tree.findBlobMember(execFile.getName()).getMode());
assertEquals(FileMode.REGULAR_FILE, tree.findBlobMember(nonexecFile.getName()).getMode());
index.write();
if (!execFile.delete())
throw new Error("Problem in test, cannot delete test file " + execFile.getAbsolutePath());
if (!nonexecFile.delete())
throw new Error(
"Problem in test, cannot delete test file " + nonexecFile.getAbsolutePath());
GitIndex index2 = new GitIndex(db);
index2.filemode = Boolean.FALSE; // TODO: we need a way to set this using config
index2.read();
index2.checkout(trash);
assertFalse(((Boolean) canExecute.invoke(execFile, (Object[]) null)).booleanValue());
assertFalse(((Boolean) canExecute.invoke(nonexecFile, (Object[]) null)).booleanValue());
assertFalse(index2.getEntry(execFile.getName()).isModified(trash));
assertFalse(index2.getEntry(nonexecFile.getName()).isModified(trash));
if (!((Boolean) setExecute.invoke(execFile, new Object[] {Boolean.FALSE})).booleanValue())
throw new Error(
"could not clear set execute bit on " + execFile.getAbsolutePath() + "for test");
if (!((Boolean) setExecute.invoke(nonexecFile, new Object[] {Boolean.TRUE})).booleanValue())
throw new Error("could set execute bit on " + nonexecFile.getAbsolutePath() + "for test");
// no change since we ignore the execute bit
assertFalse(index2.getEntry(execFile.getName()).isModified(trash));
assertFalse(index2.getEntry(nonexecFile.getName()).isModified(trash));
} catch (NoSuchMethodException e) {
System.err.println("Test ignored when running under JDK < 1.6");
return;
}
}
public void testDelete() throws Exception {
GitIndex index = new GitIndex(db);
writeTrashFile("a/b", "data:a/b");
writeTrashFile("a:b", "data:a:b");
writeTrashFile("a.b", "data:a.b");
index.add(trash, new File(trash, "a/b"));
index.add(trash, new File(trash, "a:b"));
index.add(trash, new File(trash, "a.b"));
index.write();
index.writeTree();
index.remove(trash, new File(trash, "a:b"));
index.write();
assertEquals("a.b", index.getMembers()[0].getName());
assertEquals("a/b", index.getMembers()[1].getName());
GitIndex indexr = new GitIndex(db);
indexr.read();
assertEquals("a.b", indexr.getMembers()[0].getName());
assertEquals("a/b", indexr.getMembers()[1].getName());
if (canrungitstatus) assertEquals(0, system(trash, "git status"));
}
public void testReadTree2() throws Exception {
// Prepare a larger tree to test some odd cases in tree writing
GitIndex index = new GitIndex(db);
File f1 = writeTrashFile("a/a/a/a", "data:a/a/a/a");
File f2 = writeTrashFile("a/c/c", "data:a/c/c");
File f3 = writeTrashFile("a/b", "data:a/b");
File f4 = writeTrashFile("a:b", "data:a:b");
File f5 = writeTrashFile("a/d", "data:a/d");
File f6 = writeTrashFile("a.b", "data:a.b");
index.add(trash, f1);
index.add(trash, f2);
index.add(trash, f3);
index.add(trash, f4);
index.add(trash, f5);
index.add(trash, f6);
index.write();
ObjectId id = index.writeTree();
System.out.println("wrote id " + id);
assertEquals("ba78e065e2c261d4f7b8f42107588051e87e18e9", id.name());
GitIndex index2 = new GitIndex(db);
index2.readTree(db.mapTree(ObjectId.fromString("ba78e065e2c261d4f7b8f42107588051e87e18e9")));
Entry[] members = index2.getMembers();
assertEquals(6, members.length);
assertEquals("a.b", members[0].getName());
assertEquals("a/a/a/a", members[1].getName());
assertEquals("a/b", members[2].getName());
assertEquals("a/c/c", members[3].getName());
assertEquals("a/d", members[4].getName());
assertEquals("a:b", members[5].getName());
// reread and test
GitIndex indexr = new GitIndex(db);
indexr.read();
Entry[] membersr = indexr.getMembers();
assertEquals(6, membersr.length);
assertEquals("a.b", membersr[0].getName());
assertEquals("a/a/a/a", membersr[1].getName());
assertEquals("a/b", membersr[2].getName());
assertEquals("a/c/c", membersr[3].getName());
assertEquals("a/d", membersr[4].getName());
assertEquals("a:b", membersr[5].getName());
}
public void testReadTree() throws Exception {
// Prepare tree
GitIndex index = new GitIndex(db);
writeTrashFile("a/b", "data:a/b");
writeTrashFile("a:b", "data:a:b");
writeTrashFile("a.b", "data:a.b");
index.add(trash, new File(trash, "a/b"));
index.add(trash, new File(trash, "a:b"));
index.add(trash, new File(trash, "a.b"));
index.write();
ObjectId id = index.writeTree();
System.out.println("wrote id " + id);
assertEquals("c696abc3ab8e091c665f49d00eb8919690b3aec3", id.name());
GitIndex index2 = new GitIndex(db);
index2.readTree(db.mapTree(ObjectId.fromString("c696abc3ab8e091c665f49d00eb8919690b3aec3")));
Entry[] members = index2.getMembers();
assertEquals(3, members.length);
assertEquals("a.b", members[0].getName());
assertEquals("a/b", members[1].getName());
assertEquals("a:b", members[2].getName());
assertEquals(3, members.length);
GitIndex indexr = new GitIndex(db);
indexr.read();
Entry[] membersr = indexr.getMembers();
assertEquals(3, membersr.length);
assertEquals("a.b", membersr[0].getName());
assertEquals("a/b", membersr[1].getName());
assertEquals("a:b", membersr[2].getName());
assertEquals(3, membersr.length);
if (canrungitstatus) assertEquals(0, system(trash, "git status"));
}
public void testCreateSimpleSortTestIndex() throws Exception {
GitIndex index = new GitIndex(db);
writeTrashFile("a/b", "data:a/b");
writeTrashFile("a:b", "data:a:b");
writeTrashFile("a.b", "data:a.b");
index.add(trash, new File(trash, "a/b"));
index.add(trash, new File(trash, "a:b"));
index.add(trash, new File(trash, "a.b"));
index.write();
assertEquals("a/b", index.getEntry("a/b").getName());
assertEquals("a:b", index.getEntry("a:b").getName());
assertEquals("a.b", index.getEntry("a.b").getName());
assertNull(index.getEntry("a*b"));
// Repeat test for re-read index
GitIndex indexr = new GitIndex(db);
indexr.read();
assertEquals("a/b", indexr.getEntry("a/b").getName());
assertEquals("a:b", indexr.getEntry("a:b").getName());
assertEquals("a.b", indexr.getEntry("a.b").getName());
assertNull(indexr.getEntry("a*b"));
if (canrungitstatus) assertEquals(0, system(trash, "git status"));
}
public void testReadWithNoIndex() throws Exception {
GitIndex index = new GitIndex(db);
index.read();
assertEquals(0, index.getMembers().length);
}
// for these rules, they all have clean yes/no options
// but it doesn't matter if the entry is clean or not
// so we can just ignore the state in the filesystem entirely
public void testRules4thru13_IndexEntryNotInHead() throws IOException {
// rules 4 and 5
HashMap<String, String> idxMap;
idxMap = new HashMap<String, String>();
idxMap.put("foo", "foo");
setupCase(null, null, idxMap);
theReadTree = go();
assertTrue(theReadTree.updated().isEmpty());
assertTrue(theReadTree.removed().isEmpty());
assertTrue(theReadTree.conflicts().isEmpty());
// rules 6 and 7
idxMap = new HashMap<String, String>();
idxMap.put("foo", "foo");
setupCase(null, idxMap, idxMap);
theReadTree = go();
assertAllEmpty();
// rules 8 and 9
HashMap<String, String> mergeMap;
mergeMap = new HashMap<String, String>();
mergeMap.put("foo", "merge");
setupCase(null, mergeMap, idxMap);
go();
assertTrue(theReadTree.updated().isEmpty());
assertTrue(theReadTree.removed().isEmpty());
assertTrue(theReadTree.conflicts().contains("foo"));
// rule 10
HashMap<String, String> headMap = new HashMap<String, String>();
headMap.put("foo", "foo");
setupCase(headMap, null, idxMap);
go();
assertTrue(theReadTree.removed().contains("foo"));
assertTrue(theReadTree.updated().isEmpty());
assertTrue(theReadTree.conflicts().isEmpty());
// rule 11
setupCase(headMap, null, idxMap);
new File(trash, "foo").delete();
writeTrashFile("foo", "bar");
theIndex.getMembers()[0].forceRecheck();
go();
assertTrue(theReadTree.removed().isEmpty());
assertTrue(theReadTree.updated().isEmpty());
assertTrue(theReadTree.conflicts().contains("foo"));
// rule 12 & 13
headMap.put("foo", "head");
setupCase(headMap, null, idxMap);
go();
assertTrue(theReadTree.removed().isEmpty());
assertTrue(theReadTree.updated().isEmpty());
assertTrue(theReadTree.conflicts().contains("foo"));
// rules 14 & 15
setupCase(headMap, headMap, idxMap);
go();
assertAllEmpty();
// rules 16 & 17
setupCase(headMap, mergeMap, idxMap);
go();
assertTrue(theReadTree.conflicts().contains("foo"));
// rules 18 & 19
setupCase(headMap, idxMap, idxMap);
go();
assertAllEmpty();
// rule 20
setupCase(idxMap, mergeMap, idxMap);
go();
assertTrue(theReadTree.updated().containsKey("foo"));
// rules 21
setupCase(idxMap, mergeMap, idxMap);
new File(trash, "foo").delete();
writeTrashFile("foo", "bar");
theIndex.getMembers()[0].forceRecheck();
go();
assertTrue(theReadTree.conflicts().contains("foo"));
}
