motiejus
/
jgit
1
Fork 0
Code Releases Activity

DiffEntryTest: Open Git and TreeWalk in try-with-resource 

Change-Id: If4a49268b9b7ec3a44ed1508ed78db365b0c9e5b
Signed-off-by: David Pursehouse <david.pursehouse@sonymobile.com>
This commit is contained in:
David Pursehouse 2016-01-25 11:55:46 +09:00
parent 6b66240311
commit 4c128b0764
1 changed files with 240 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

469
org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/DiffEntryTest.java
View File

@ -77,260 +77,268 @@ public class DiffEntryTest extends RepositoryTestCase {
public void shouldListAddedFileInInitialCommit() throws Exception { public void shouldListAddedFileInInitialCommit() throws Exception {
// given // given
writeTrashFile("a.txt", "content"); writeTrashFile("a.txt", "content");
Git git = new Git(db); try (Git git = new Git(db);
git.add().addFilepattern("a.txt").call(); TreeWalk walk = new TreeWalk(db)) {
RevCommit c = git.commit().setMessage("initial commit").call(); git.add().addFilepattern("a.txt").call();
RevCommit c = git.commit().setMessage("initial commit").call();
// when // when
TreeWalk walk = new TreeWalk(db); walk.addTree(new EmptyTreeIterator());
walk.addTree(new EmptyTreeIterator()); walk.addTree(c.getTree());
walk.addTree(c.getTree()); List<DiffEntry> result = DiffEntry.scan(walk);
List<DiffEntry> result = DiffEntry.scan(walk);
// then // then
assertThat(result, notNullValue()); assertThat(result, notNullValue());
assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1))); assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
DiffEntry entry = result.get(0); DiffEntry entry = result.get(0);
assertThat(entry.getChangeType(), is(ChangeType.ADD)); assertThat(entry.getChangeType(), is(ChangeType.ADD));
assertThat(entry.getNewPath(), is("a.txt")); assertThat(entry.getNewPath(), is("a.txt"));
assertThat(entry.getOldPath(), is(DEV_NULL)); assertThat(entry.getOldPath(), is(DEV_NULL));
}
} }
@Test @Test
public void shouldListAddedFileBetweenTwoCommits() throws Exception { public void shouldListAddedFileBetweenTwoCommits() throws Exception {
// given // given
Git git = new Git(db); try (Git git = new Git(db);
RevCommit c1 = git.commit().setMessage("initial commit").call(); TreeWalk walk = new TreeWalk(db)) {
writeTrashFile("a.txt", "content"); RevCommit c1 = git.commit().setMessage("initial commit").call();
git.add().addFilepattern("a.txt").call(); writeTrashFile("a.txt", "content");
RevCommit c2 = git.commit().setMessage("second commit").call(); git.add().addFilepattern("a.txt").call();
RevCommit c2 = git.commit().setMessage("second commit").call();
// when // when
TreeWalk walk = new TreeWalk(db); walk.addTree(c1.getTree());
walk.addTree(c1.getTree()); walk.addTree(c2.getTree());
walk.addTree(c2.getTree()); List<DiffEntry> result = DiffEntry.scan(walk);
List<DiffEntry> result = DiffEntry.scan(walk);
// then // then
assertThat(result, notNullValue()); assertThat(result, notNullValue());
assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1))); assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
DiffEntry entry = result.get(0); DiffEntry entry = result.get(0);
assertThat(entry.getChangeType(), is(ChangeType.ADD)); assertThat(entry.getChangeType(), is(ChangeType.ADD));
assertThat(entry.getNewPath(), is("a.txt")); assertThat(entry.getNewPath(), is("a.txt"));
assertThat(entry.getOldPath(), is(DEV_NULL)); assertThat(entry.getOldPath(), is(DEV_NULL));
}
} }
@Test @Test
public void shouldListModificationBetweenTwoCommits() throws Exception { public void shouldListModificationBetweenTwoCommits() throws Exception {
// given // given
Git git = new Git(db); try (Git git = new Git(db);
File file = writeTrashFile("a.txt", "content"); TreeWalk walk = new TreeWalk(db)) {
git.add().addFilepattern("a.txt").call(); File file = writeTrashFile("a.txt", "content");
RevCommit c1 = git.commit().setMessage("initial commit").call(); git.add().addFilepattern("a.txt").call();
write(file, "new content"); RevCommit c1 = git.commit().setMessage("initial commit").call();
RevCommit c2 = git.commit().setAll(true).setMessage("second commit") write(file, "new content");
.call(); RevCommit c2 = git.commit().setAll(true).setMessage("second commit")
.call();
// when // when
TreeWalk walk = new TreeWalk(db); walk.addTree(c1.getTree());
walk.addTree(c1.getTree()); walk.addTree(c2.getTree());
walk.addTree(c2.getTree()); List<DiffEntry> result = DiffEntry.scan(walk);
List<DiffEntry> result = DiffEntry.scan(walk);
// then // then
assertThat(result, notNullValue()); assertThat(result, notNullValue());
assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1))); assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
DiffEntry entry = result.get(0); DiffEntry entry = result.get(0);
assertThat(entry.getChangeType(), is(ChangeType.MODIFY)); assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
assertThat(entry.getNewPath(), is("a.txt")); assertThat(entry.getNewPath(), is("a.txt"));
}
} }
@Test @Test
public void shouldListDeletionBetweenTwoCommits() throws Exception { public void shouldListDeletionBetweenTwoCommits() throws Exception {
// given // given
Git git = new Git(db); try (Git git = new Git(db);
File file = writeTrashFile("a.txt", "content"); TreeWalk walk = new TreeWalk(db)) {
git.add().addFilepattern("a.txt").call(); File file = writeTrashFile("a.txt", "content");
RevCommit c1 = git.commit().setMessage("initial commit").call(); git.add().addFilepattern("a.txt").call();
delete(file); RevCommit c1 = git.commit().setMessage("initial commit").call();
RevCommit c2 = git.commit().setAll(true).setMessage("delete a.txt") delete(file);
.call(); RevCommit c2 = git.commit().setAll(true).setMessage("delete a.txt")
.call();
// when // when
TreeWalk walk = new TreeWalk(db); walk.addTree(c1.getTree());
walk.addTree(c1.getTree()); walk.addTree(c2.getTree());
walk.addTree(c2.getTree()); List<DiffEntry> result = DiffEntry.scan(walk);
List<DiffEntry> result = DiffEntry.scan(walk);
// then // then
assertThat(result, notNullValue()); assertThat(result, notNullValue());
assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1))); assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
DiffEntry entry = result.get(0); DiffEntry entry = result.get(0);
assertThat(entry.getOldPath(), is("a.txt")); assertThat(entry.getOldPath(), is("a.txt"));
assertThat(entry.getNewPath(), is(DEV_NULL)); assertThat(entry.getNewPath(), is(DEV_NULL));
assertThat(entry.getChangeType(), is(ChangeType.DELETE)); assertThat(entry.getChangeType(), is(ChangeType.DELETE));
}
} }
@Test @Test
public void shouldListModificationInDirWithoutModifiedTrees() public void shouldListModificationInDirWithoutModifiedTrees()
throws Exception { throws Exception {
// given // given
Git git = new Git(db); try (Git git = new Git(db);
File tree = new File(new File(db.getWorkTree(), "a"), "b"); TreeWalk walk = new TreeWalk(db)) {
FileUtils.mkdirs(tree); File tree = new File(new File(db.getWorkTree(), "a"), "b");
File file = new File(tree, "c.txt"); FileUtils.mkdirs(tree);
FileUtils.createNewFile(file); File file = new File(tree, "c.txt");
write(file, "content"); FileUtils.createNewFile(file);
git.add().addFilepattern("a").call(); write(file, "content");
RevCommit c1 = git.commit().setMessage("initial commit").call(); git.add().addFilepattern("a").call();
write(file, "new line"); RevCommit c1 = git.commit().setMessage("initial commit").call();
RevCommit c2 = git.commit().setAll(true).setMessage("second commit") write(file, "new line");
.call(); RevCommit c2 = git.commit().setAll(true).setMessage("second commit")
.call();
// when // when
TreeWalk walk = new TreeWalk(db); walk.addTree(c1.getTree());
walk.addTree(c1.getTree()); walk.addTree(c2.getTree());
walk.addTree(c2.getTree()); walk.setRecursive(true);
walk.setRecursive(true); List<DiffEntry> result = DiffEntry.scan(walk);
List<DiffEntry> result = DiffEntry.scan(walk);
// then // then
assertThat(result, notNullValue()); assertThat(result, notNullValue());
assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1))); assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
DiffEntry entry = result.get(0); DiffEntry entry = result.get(0);
assertThat(entry.getChangeType(), is(ChangeType.MODIFY)); assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
assertThat(entry.getNewPath(), is("a/b/c.txt")); assertThat(entry.getNewPath(), is("a/b/c.txt"));
}
} }
@Test @Test
public void shouldListModificationInDirWithModifiedTrees() throws Exception { public void shouldListModificationInDirWithModifiedTrees() throws Exception {
// given // given
Git git = new Git(db); try (Git git = new Git(db);
File tree = new File(new File(db.getWorkTree(), "a"), "b"); TreeWalk walk = new TreeWalk(db)) {
FileUtils.mkdirs(tree); File tree = new File(new File(db.getWorkTree(), "a"), "b");
File file = new File(tree, "c.txt"); FileUtils.mkdirs(tree);
FileUtils.createNewFile(file); File file = new File(tree, "c.txt");
write(file, "content"); FileUtils.createNewFile(file);
git.add().addFilepattern("a").call(); write(file, "content");
RevCommit c1 = git.commit().setMessage("initial commit").call(); git.add().addFilepattern("a").call();
write(file, "new line"); RevCommit c1 = git.commit().setMessage("initial commit").call();
RevCommit c2 = git.commit().setAll(true).setMessage("second commit") write(file, "new line");
.call(); RevCommit c2 = git.commit().setAll(true).setMessage("second commit")
.call();
// when // when
TreeWalk walk = new TreeWalk(db); walk.addTree(c1.getTree());
walk.addTree(c1.getTree()); walk.addTree(c2.getTree());
walk.addTree(c2.getTree()); List<DiffEntry> result = DiffEntry.scan(walk, true);
List<DiffEntry> result = DiffEntry.scan(walk, true);
// then // then
assertThat(result, notNullValue()); assertThat(result, notNullValue());
assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(3))); assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(3)));
DiffEntry entry = result.get(0); DiffEntry entry = result.get(0);
assertThat(entry.getChangeType(), is(ChangeType.MODIFY)); assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
assertThat(entry.getNewPath(), is("a")); assertThat(entry.getNewPath(), is("a"));
entry = result.get(1); entry = result.get(1);
assertThat(entry.getChangeType(), is(ChangeType.MODIFY)); assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
assertThat(entry.getNewPath(), is("a/b")); assertThat(entry.getNewPath(), is("a/b"));
entry = result.get(2); entry = result.get(2);
assertThat(entry.getChangeType(), is(ChangeType.MODIFY)); assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
assertThat(entry.getNewPath(), is("a/b/c.txt")); assertThat(entry.getNewPath(), is("a/b/c.txt"));
}
} }
@Test @Test
public void shouldListChangesInWorkingTree() throws Exception { public void shouldListChangesInWorkingTree() throws Exception {
// given // given
writeTrashFile("a.txt", "content"); writeTrashFile("a.txt", "content");
Git git = new Git(db); try (Git git = new Git(db);
git.add().addFilepattern("a.txt").call(); TreeWalk walk = new TreeWalk(db)) {
RevCommit c = git.commit().setMessage("initial commit").call(); git.add().addFilepattern("a.txt").call();
writeTrashFile("b.txt", "new line"); RevCommit c = git.commit().setMessage("initial commit").call();
writeTrashFile("b.txt", "new line");
// when // when
TreeWalk walk = new TreeWalk(db); walk.addTree(c.getTree());
walk.addTree(c.getTree()); walk.addTree(new FileTreeIterator(db));
walk.addTree(new FileTreeIterator(db)); List<DiffEntry> result = DiffEntry.scan(walk, true);
List<DiffEntry> result = DiffEntry.scan(walk, true);
// then // then
assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1))); assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
DiffEntry entry = result.get(0); DiffEntry entry = result.get(0);
assertThat(entry.getChangeType(), is(ChangeType.ADD)); assertThat(entry.getChangeType(), is(ChangeType.ADD));
assertThat(entry.getNewPath(), is("b.txt")); assertThat(entry.getNewPath(), is("b.txt"));
}
} }
@Test @Test
public void shouldMarkEntriesWhenGivenMarkTreeFilter() throws Exception { public void shouldMarkEntriesWhenGivenMarkTreeFilter() throws Exception {
// given // given
Git git = new Git(db); try (Git git = new Git(db);
RevCommit c1 = git.commit().setMessage("initial commit").call(); TreeWalk walk = new TreeWalk(db)) {
FileUtils.mkdir(new File(db.getWorkTree(), "b")); RevCommit c1 = git.commit().setMessage("initial commit").call();
writeTrashFile("a.txt", "a"); FileUtils.mkdir(new File(db.getWorkTree(), "b"));
writeTrashFile("b/1.txt", "b1"); writeTrashFile("a.txt", "a");
writeTrashFile("b/2.txt", "b2"); writeTrashFile("b/1.txt", "b1");
writeTrashFile("c.txt", "c"); writeTrashFile("b/2.txt", "b2");
git.add().addFilepattern("a.txt").addFilepattern("b") writeTrashFile("c.txt", "c");
.addFilepattern("c.txt").call(); git.add().addFilepattern("a.txt").addFilepattern("b")
RevCommit c2 = git.commit().setMessage("second commit").call(); .addFilepattern("c.txt").call();
TreeFilter filterA = PathFilterGroup.createFromStrings("a.txt"); RevCommit c2 = git.commit().setMessage("second commit").call();
TreeFilter filterB = PathFilterGroup.createFromStrings("b"); TreeFilter filterA = PathFilterGroup.createFromStrings("a.txt");
TreeFilter filterB2 = PathFilterGroup.createFromStrings("b/2.txt"); TreeFilter filterB = PathFilterGroup.createFromStrings("b");
TreeFilter filterB2 = PathFilterGroup.createFromStrings("b/2.txt");
// when // when
TreeWalk walk = new TreeWalk(db); walk.addTree(c1.getTree());
walk.addTree(c1.getTree()); walk.addTree(c2.getTree());
walk.addTree(c2.getTree()); List<DiffEntry> result = DiffEntry.scan(walk, true, new TreeFilter[] {
List<DiffEntry> result = DiffEntry.scan(walk, true, new TreeFilter[] { filterA, filterB, filterB2 });
filterA, filterB, filterB2 });
// then // then
assertThat(result, notNullValue()); assertThat(result, notNullValue());
assertEquals(5, result.size()); assertEquals(5, result.size());
DiffEntry entryA = result.get(0); DiffEntry entryA = result.get(0);
DiffEntry entryB = result.get(1); DiffEntry entryB = result.get(1);
DiffEntry entryB1 = result.get(2); DiffEntry entryB1 = result.get(2);
DiffEntry entryB2 = result.get(3); DiffEntry entryB2 = result.get(3);
DiffEntry entryC = result.get(4); DiffEntry entryC = result.get(4);
assertThat(entryA.getNewPath(), is("a.txt")); assertThat(entryA.getNewPath(), is("a.txt"));
assertTrue(entryA.isMarked(0)); assertTrue(entryA.isMarked(0));
assertFalse(entryA.isMarked(1)); assertFalse(entryA.isMarked(1));
assertFalse(entryA.isMarked(2)); assertFalse(entryA.isMarked(2));
assertEquals(1, entryA.getTreeFilterMarks()); assertEquals(1, entryA.getTreeFilterMarks());
assertThat(entryB.getNewPath(), is("b")); assertThat(entryB.getNewPath(), is("b"));
assertFalse(entryB.isMarked(0)); assertFalse(entryB.isMarked(0));
assertTrue(entryB.isMarked(1)); assertTrue(entryB.isMarked(1));
assertTrue(entryB.isMarked(2)); assertTrue(entryB.isMarked(2));
assertEquals(6, entryB.getTreeFilterMarks()); assertEquals(6, entryB.getTreeFilterMarks());
assertThat(entryB1.getNewPath(), is("b/1.txt")); assertThat(entryB1.getNewPath(), is("b/1.txt"));
assertFalse(entryB1.isMarked(0)); assertFalse(entryB1.isMarked(0));
assertTrue(entryB1.isMarked(1)); assertTrue(entryB1.isMarked(1));
assertFalse(entryB1.isMarked(2)); assertFalse(entryB1.isMarked(2));
assertEquals(2, entryB1.getTreeFilterMarks()); assertEquals(2, entryB1.getTreeFilterMarks());
assertThat(entryB2.getNewPath(), is("b/2.txt")); assertThat(entryB2.getNewPath(), is("b/2.txt"));
assertFalse(entryB2.isMarked(0)); assertFalse(entryB2.isMarked(0));
assertTrue(entryB2.isMarked(1)); assertTrue(entryB2.isMarked(1));
assertTrue(entryB2.isMarked(2)); assertTrue(entryB2.isMarked(2));
assertEquals(6, entryB2.getTreeFilterMarks()); assertEquals(6, entryB2.getTreeFilterMarks());
assertThat(entryC.getNewPath(), is("c.txt")); assertThat(entryC.getNewPath(), is("c.txt"));
assertFalse(entryC.isMarked(0)); assertFalse(entryC.isMarked(0));
assertFalse(entryC.isMarked(1)); assertFalse(entryC.isMarked(1));
assertFalse(entryC.isMarked(2)); assertFalse(entryC.isMarked(2));
assertEquals(0, entryC.getTreeFilterMarks()); assertEquals(0, entryC.getTreeFilterMarks());
}
} }
@Test(expected = IllegalArgumentException.class) @Test(expected = IllegalArgumentException.class)
@ -339,9 +347,10 @@ public void shouldThrowIAEWhenTreeWalkHasLessThanTwoTrees()
// given - we don't need anything here // given - we don't need anything here
// when // when
TreeWalk walk = new TreeWalk(db); try (TreeWalk walk = new TreeWalk(db)) {
walk.addTree(new EmptyTreeIterator()); walk.addTree(new EmptyTreeIterator());
DiffEntry.scan(walk); DiffEntry.scan(walk);
}
} }
@Test(expected = IllegalArgumentException.class) @Test(expected = IllegalArgumentException.class)
@ -350,11 +359,12 @@ public void shouldThrowIAEWhenTreeWalkHasMoreThanTwoTrees()
// given - we don't need anything here // given - we don't need anything here
// when // when
TreeWalk walk = new TreeWalk(db); try (TreeWalk walk = new TreeWalk(db)) {
walk.addTree(new EmptyTreeIterator()); walk.addTree(new EmptyTreeIterator());
walk.addTree(new EmptyTreeIterator()); walk.addTree(new EmptyTreeIterator());
walk.addTree(new EmptyTreeIterator()); walk.addTree(new EmptyTreeIterator());
DiffEntry.scan(walk); DiffEntry.scan(walk);
}
} }
@Test(expected = IllegalArgumentException.class) @Test(expected = IllegalArgumentException.class)
@ -363,46 +373,47 @@ public void shouldThrowIAEWhenScanShouldIncludeTreesAndWalkIsRecursive()
// given - we don't need anything here // given - we don't need anything here
// when // when
TreeWalk walk = new TreeWalk(db); try (TreeWalk walk = new TreeWalk(db)) {
walk.addTree(new EmptyTreeIterator()); walk.addTree(new EmptyTreeIterator());
walk.addTree(new EmptyTreeIterator()); walk.addTree(new EmptyTreeIterator());
walk.setRecursive(true); walk.setRecursive(true);
DiffEntry.scan(walk, true); DiffEntry.scan(walk, true);
}
} }
@Test @Test
public void shouldReportFileModeChange() throws Exception { public void shouldReportFileModeChange() throws Exception {
writeTrashFile("a.txt", "content"); writeTrashFile("a.txt", "content");
Git git = new Git(db); try (Git git = new Git(db);
git.add().addFilepattern("a.txt").call(); TreeWalk walk = new TreeWalk(db)) {
RevCommit c1 = git.commit().setMessage("initial commit").call(); git.add().addFilepattern("a.txt").call();
DirCache cache = db.lockDirCache(); RevCommit c1 = git.commit().setMessage("initial commit").call();
DirCacheEditor editor = cache.editor(); DirCache cache = db.lockDirCache();
final TreeWalk walk = new TreeWalk(db); DirCacheEditor editor = cache.editor();
walk.addTree(c1.getTree()); walk.addTree(c1.getTree());
walk.setRecursive(true); walk.setRecursive(true);
assertTrue(walk.next()); assertTrue(walk.next());
editor.add(new PathEdit("a.txt") { editor.add(new PathEdit("a.txt") {
public void apply(DirCacheEntry ent) {
public void apply(DirCacheEntry ent) { ent.setFileMode(FileMode.EXECUTABLE_FILE);
ent.setFileMode(FileMode.EXECUTABLE_FILE); ent.setObjectId(walk.getObjectId(0));
ent.setObjectId(walk.getObjectId(0)); }
} });
}); assertTrue(editor.commit());
assertTrue(editor.commit()); RevCommit c2 = git.commit().setMessage("second commit").call();
RevCommit c2 = git.commit().setMessage("second commit").call(); walk.reset();
walk.reset(); walk.addTree(c1.getTree());
walk.addTree(c1.getTree()); walk.addTree(c2.getTree());
walk.addTree(c2.getTree()); List<DiffEntry> diffs = DiffEntry.scan(walk, false);
List<DiffEntry> diffs = DiffEntry.scan(walk, false); assertEquals(1, diffs.size());
assertEquals(1, diffs.size()); DiffEntry diff = diffs.get(0);
DiffEntry diff = diffs.get(0); assertEquals(ChangeType.MODIFY,diff.getChangeType());
assertEquals(ChangeType.MODIFY,diff.getChangeType()); assertEquals(diff.getOldId(), diff.getNewId());
assertEquals(diff.getOldId(), diff.getNewId()); assertEquals("a.txt", diff.getOldPath());
assertEquals("a.txt", diff.getOldPath()); assertEquals(diff.getOldPath(), diff.getNewPath());
assertEquals(diff.getOldPath(), diff.getNewPath()); assertEquals(FileMode.EXECUTABLE_FILE, diff.getNewMode());
assertEquals(FileMode.EXECUTABLE_FILE, diff.getNewMode()); assertEquals(FileMode.REGULAR_FILE, diff.getOldMode());
assertEquals(FileMode.REGULAR_FILE, diff.getOldMode()); }
} }
} }