github
/
jgit
mirror of https://gitee.com/github-mirror-repo/jgit.git
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

Close TreeWalks in tests 

Note that TreeWalk.forPath() needs not be closed; the ObjectReader
_is_ closed when that method returns.

Change-Id: I6e022e4a2fde0c88d610a82de092ea541b33f75c
Signed-off-by: Thomas Wolf <thomas.wolf@paranor.ch>
next
Thomas Wolf 5 years ago
parent
5e0eca6943
commit
563ec9ecb6
11 changed files with 689 additions and 600 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 38
      org.eclipse.jgit.test/tst/org/eclipse/jgit/api/EolRepositoryTest.java
  2. 529
      org.eclipse.jgit.test/tst/org/eclipse/jgit/attributes/AttributesHandlerTest.java
  3. 109
      org.eclipse.jgit.test/tst/org/eclipse/jgit/attributes/AttributesNodeDirCacheIteratorTest.java
  4. 99
      org.eclipse.jgit.test/tst/org/eclipse/jgit/attributes/AttributesNodeWorkingTreeIteratorTest.java
  5. 6
      org.eclipse.jgit.test/tst/org/eclipse/jgit/attributes/TreeWalkAttributeTest.java
  6. 8
      org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreNodeTest.java
  7. 48
      org.eclipse.jgit.test/tst/org/eclipse/jgit/merge/CherryPickTest.java
  8. 48
      org.eclipse.jgit.test/tst/org/eclipse/jgit/merge/SimpleMergeTest.java
  9. 33
      org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/FileTreeIteratorTest.java
  10. 149
      org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/NameConflictTreeWalkTest.java
  11. 222
      org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/filter/IndexDiffFilterTest.java

38
org.eclipse.jgit.test/tst/org/eclipse/jgit/api/EolRepositoryTest.java
Unescape View File

@ -142,8 +142,6 @@ public class EolRepositoryTest extends RepositoryTestCase {
protected String CONTENT_MIXED; protected String CONTENT_MIXED;
private TreeWalk walk;
/** work tree root .gitattributes */ /** work tree root .gitattributes */
private File dotGitattributes; private File dotGitattributes;
@ -689,27 +687,25 @@ public class EolRepositoryTest extends RepositoryTestCase {
private void collectRepositoryState() throws Exception { private void collectRepositoryState() throws Exception {
dirCache = db.readDirCache(); dirCache = db.readDirCache();
walk = beginWalk(); try (TreeWalk walk = new TreeWalk(db)) {
if (dotGitattributes != null) walk.addTree(new FileTreeIterator(db));
collectEntryContentAndAttributes(F, ".gitattributes", null); walk.addTree(new DirCacheIterator(db.readDirCache()));
collectEntryContentAndAttributes(F, fileCRLF.getName(), entryCRLF); if (dotGitattributes != null) {
collectEntryContentAndAttributes(F, fileLF.getName(), entryLF); collectEntryContentAndAttributes(walk, F, ".gitattributes",
collectEntryContentAndAttributes(F, fileMixed.getName(), entryMixed); null);
endWalk(); }
} collectEntryContentAndAttributes(walk, F, fileCRLF.getName(),
entryCRLF);
private TreeWalk beginWalk() throws Exception { collectEntryContentAndAttributes(walk, F, fileLF.getName(),
TreeWalk newWalk = new TreeWalk(db); entryLF);
newWalk.addTree(new FileTreeIterator(db)); collectEntryContentAndAttributes(walk, F, fileMixed.getName(),
newWalk.addTree(new DirCacheIterator(db.readDirCache())); entryMixed);
return newWalk; assertFalse("Not all files tested", walk.next());
} }
private void endWalk() throws IOException {
assertFalse("Not all files tested", walk.next());
} }
private void collectEntryContentAndAttributes(FileMode type, String pathName, private void collectEntryContentAndAttributes(TreeWalk walk, FileMode type,
String pathName,
ActualEntry e) throws IOException { ActualEntry e) throws IOException {
assertTrue("walk has entry", walk.next()); assertTrue("walk has entry", walk.next());

529
org.eclipse.jgit.test/tst/org/eclipse/jgit/attributes/AttributesHandlerTest.java
Unescape View File

@ -69,83 +69,90 @@ public class AttributesHandlerTest extends RepositoryTestCase {
private static final FileMode F = FileMode.REGULAR_FILE; private static final FileMode F = FileMode.REGULAR_FILE;
private TreeWalk walk;
@Test @Test
public void testExpandNonMacro1() throws Exception { public void testExpandNonMacro1() throws Exception {
setupRepo(null, null, null, "*.txt text"); setupRepo(null, null, null, "*.txt text");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/.gitattributes"); assertIteration(walk, F, "sub/.gitattributes");
assertIteration(F, "sub/a.txt", attrs("text")); assertIteration(walk, F, "sub/a.txt", attrs("text"));
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
public void testExpandNonMacro2() throws Exception { public void testExpandNonMacro2() throws Exception {
setupRepo(null, null, null, "*.txt -text"); setupRepo(null, null, null, "*.txt -text");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/.gitattributes"); assertIteration(walk, F, "sub/.gitattributes");
assertIteration(F, "sub/a.txt", attrs("-text")); assertIteration(walk, F, "sub/a.txt", attrs("-text"));
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
public void testExpandNonMacro3() throws Exception { public void testExpandNonMacro3() throws Exception {
setupRepo(null, null, null, "*.txt !text"); setupRepo(null, null, null, "*.txt !text");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/.gitattributes"); assertIteration(walk, F, "sub/.gitattributes");
assertIteration(F, "sub/a.txt", attrs("")); assertIteration(walk, F, "sub/a.txt", attrs(""));
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
public void testExpandNonMacro4() throws Exception { public void testExpandNonMacro4() throws Exception {
setupRepo(null, null, null, "*.txt text=auto"); setupRepo(null, null, null, "*.txt text=auto");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/.gitattributes"); assertIteration(walk, F, "sub/.gitattributes");
assertIteration(F, "sub/a.txt", attrs("text=auto")); assertIteration(walk, F, "sub/a.txt", attrs("text=auto"));
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
public void testExpandBuiltInMacro1() throws Exception { public void testExpandBuiltInMacro1() throws Exception {
setupRepo(null, null, null, "*.txt binary"); setupRepo(null, null, null, "*.txt binary");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/.gitattributes"); assertIteration(walk, F, "sub/.gitattributes");
assertIteration(F, "sub/a.txt", attrs("binary -diff -merge -text")); assertIteration(walk, F, "sub/a.txt",
endWalk(); attrs("binary -diff -merge -text"));
assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
public void testExpandBuiltInMacro2() throws Exception { public void testExpandBuiltInMacro2() throws Exception {
setupRepo(null, null, null, "*.txt -binary"); setupRepo(null, null, null, "*.txt -binary");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/.gitattributes"); assertIteration(walk, F, "sub/.gitattributes");
assertIteration(F, "sub/a.txt", attrs("-binary diff merge text")); assertIteration(walk, F, "sub/a.txt",
endWalk(); attrs("-binary diff merge text"));
assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
public void testExpandBuiltInMacro3() throws Exception { public void testExpandBuiltInMacro3() throws Exception {
setupRepo(null, null, null, "*.txt !binary"); setupRepo(null, null, null, "*.txt !binary");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/.gitattributes"); assertIteration(walk, F, "sub/.gitattributes");
assertIteration(F, "sub/a.txt", attrs("")); assertIteration(walk, F, "sub/a.txt", attrs(""));
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -153,44 +160,48 @@ public class AttributesHandlerTest extends RepositoryTestCase {
setupRepo( setupRepo(
"[attr]foo a -b !c d=e", null, null, "*.txt foo"); "[attr]foo a -b !c d=e", null, null, "*.txt foo");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/.gitattributes"); assertIteration(walk, F, "sub/.gitattributes");
assertIteration(F, "sub/a.txt", attrs("foo a -b d=e")); assertIteration(walk, F, "sub/a.txt", attrs("foo a -b d=e"));
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
public void testCustomGlobalMacro2() throws Exception { public void testCustomGlobalMacro2() throws Exception {
setupRepo("[attr]foo a -b !c d=e", null, null, "*.txt -foo"); setupRepo("[attr]foo a -b !c d=e", null, null, "*.txt -foo");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/.gitattributes"); assertIteration(walk, F, "sub/.gitattributes");
assertIteration(F, "sub/a.txt", attrs("-foo -a b d=e")); assertIteration(walk, F, "sub/a.txt", attrs("-foo -a b d=e"));
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
public void testCustomGlobalMacro3() throws Exception { public void testCustomGlobalMacro3() throws Exception {
setupRepo("[attr]foo a -b !c d=e", null, null, "*.txt !foo"); setupRepo("[attr]foo a -b !c d=e", null, null, "*.txt !foo");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/.gitattributes"); assertIteration(walk, F, "sub/.gitattributes");
assertIteration(F, "sub/a.txt", attrs("")); assertIteration(walk, F, "sub/a.txt", attrs(""));
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
public void testCustomGlobalMacro4() throws Exception { public void testCustomGlobalMacro4() throws Exception {
setupRepo("[attr]foo a -b !c d=e", null, null, "*.txt foo=bar"); setupRepo("[attr]foo a -b !c d=e", null, null, "*.txt foo=bar");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/.gitattributes"); assertIteration(walk, F, "sub/.gitattributes");
assertIteration(F, "sub/a.txt", attrs("foo=bar a -b d=bar")); assertIteration(walk, F, "sub/a.txt", attrs("foo=bar a -b d=bar"));
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -198,11 +209,12 @@ public class AttributesHandlerTest extends RepositoryTestCase {
setupRepo("[attr]foo bar1", setupRepo("[attr]foo bar1",
"[attr]foo bar2", null, "*.txt foo"); "[attr]foo bar2", null, "*.txt foo");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/.gitattributes"); assertIteration(walk, F, "sub/.gitattributes");
assertIteration(F, "sub/a.txt", attrs("foo bar2")); assertIteration(walk, F, "sub/a.txt", attrs("foo bar2"));
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -211,12 +223,13 @@ public class AttributesHandlerTest extends RepositoryTestCase {
null, null,
"[attr]foo bar3", "*.txt foo"); "[attr]foo bar3", "*.txt foo");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(F, ".gitattributes"); assertIteration(walk, F, ".gitattributes");
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/.gitattributes"); assertIteration(walk, F, "sub/.gitattributes");
assertIteration(F, "sub/a.txt", attrs("foo bar3")); assertIteration(walk, F, "sub/a.txt", attrs("foo bar3"));
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -224,12 +237,13 @@ public class AttributesHandlerTest extends RepositoryTestCase {
setupRepo("[attr]foo bar1", setupRepo("[attr]foo bar1",
"[attr]foo bar2", "[attr]foo bar3", "*.txt foo"); "[attr]foo bar2", "[attr]foo bar3", "*.txt foo");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(F, ".gitattributes"); assertIteration(walk, F, ".gitattributes");
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/.gitattributes"); assertIteration(walk, F, "sub/.gitattributes");
assertIteration(F, "sub/a.txt", attrs("foo bar2")); assertIteration(walk, F, "sub/a.txt", attrs("foo bar2"));
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -238,11 +252,12 @@ public class AttributesHandlerTest extends RepositoryTestCase {
"[attr]foo x bar -foo", "[attr]foo x bar -foo",
null, null, "*.txt foo"); null, null, "*.txt foo");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/.gitattributes"); assertIteration(walk, F, "sub/.gitattributes");
assertIteration(F, "sub/a.txt", attrs("foo x bar")); assertIteration(walk, F, "sub/a.txt", attrs("foo x bar"));
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -250,11 +265,12 @@ public class AttributesHandlerTest extends RepositoryTestCase {
setupRepo( setupRepo(
"[attr]foo x -bar\n[attr]bar y -foo", null, null, "*.txt foo"); "[attr]foo x -bar\n[attr]bar y -foo", null, null, "*.txt foo");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/.gitattributes"); assertIteration(walk, F, "sub/.gitattributes");
assertIteration(F, "sub/a.txt", attrs("foo x -bar -y")); assertIteration(walk, F, "sub/a.txt", attrs("foo x -bar -y"));
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -266,23 +282,30 @@ public class AttributesHandlerTest extends RepositoryTestCase {
// apply to any of the files here. It would match for a // apply to any of the files here. It would match for a
// further subdirectory sub/sub. The sub/ rules must match // further subdirectory sub/sub. The sub/ rules must match
// only for directories. // only for directories.
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(F, ".gitattributes"); assertIteration(walk, F, ".gitattributes");
assertIteration(D, "sub", attrs("global")); assertIteration(walk, D, "sub", attrs("global"));
assertIteration(F, "sub/.gitattributes", attrs("init top_sub")); assertIteration(walk, F, "sub/.gitattributes",
assertIteration(F, "sub/a.txt", attrs("init foo top top_sub")); attrs("init top_sub"));
endWalk(); assertIteration(walk, F, "sub/a.txt",
attrs("init foo top top_sub"));
assertFalse("Not all files tested", walk.next());
}
// All right, let's see that they *do* apply in sub/sub: // All right, let's see that they *do* apply in sub/sub:
writeTrashFile("sub/sub/b.txt", "b"); writeTrashFile("sub/sub/b.txt", "b");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(F, ".gitattributes"); assertIteration(walk, F, ".gitattributes");
assertIteration(D, "sub", attrs("global")); assertIteration(walk, D, "sub", attrs("global"));
assertIteration(F, "sub/.gitattributes", attrs("init top_sub")); assertIteration(walk, F, "sub/.gitattributes",
assertIteration(F, "sub/a.txt", attrs("init foo top top_sub")); attrs("init top_sub"));
assertIteration(D, "sub/sub", attrs("init subsub2 top_sub global")); assertIteration(walk, F, "sub/a.txt",
assertIteration(F, "sub/sub/b.txt", attrs("init foo top top_sub"));
attrs("init foo subsub top top_sub")); assertIteration(walk, D, "sub/sub",
endWalk(); attrs("init subsub2 top_sub global"));
assertIteration(walk, F, "sub/sub/b.txt",
attrs("init foo subsub top top_sub"));
assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -293,16 +316,17 @@ public class AttributesHandlerTest extends RepositoryTestCase {
writeTrashFile("sub/b.jar", "bj"); writeTrashFile("sub/b.jar", "bj");
writeTrashFile("sub/b.xml", "bx"); writeTrashFile("sub/b.xml", "bx");
// On foo.xml/bar.jar we must not have 'xml' // On foo.xml/bar.jar we must not have 'xml'
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(F, ".gitattributes"); assertIteration(walk, F, ".gitattributes");
assertIteration(D, "foo.xml", attrs("xml")); assertIteration(walk, D, "foo.xml", attrs("xml"));
assertIteration(F, "foo.xml/bar.jar", attrs("jar")); assertIteration(walk, F, "foo.xml/bar.jar", attrs("jar"));
assertIteration(F, "foo.xml/bar.xml", attrs("xml")); assertIteration(walk, F, "foo.xml/bar.xml", attrs("xml"));
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/a.txt"); assertIteration(walk, F, "sub/a.txt");
assertIteration(F, "sub/b.jar", attrs("jar")); assertIteration(walk, F, "sub/b.jar", attrs("jar"));
assertIteration(F, "sub/b.xml", attrs("xml")); assertIteration(walk, F, "sub/b.xml", attrs("xml"));
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -314,18 +338,19 @@ public class AttributesHandlerTest extends RepositoryTestCase {
writeTrashFile("sub/b.jar", "bj"); writeTrashFile("sub/b.jar", "bj");
writeTrashFile("sub/b.xml", "bx"); writeTrashFile("sub/b.xml", "bx");
writeTrashFile("sub/foo/b.jar", "bf"); writeTrashFile("sub/foo/b.jar", "bf");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(F, ".gitattributes"); assertIteration(walk, F, ".gitattributes");
assertIteration(D, "foo", attrs("xml")); assertIteration(walk, D, "foo", attrs("xml"));
assertIteration(F, "foo/bar.jar", attrs("jar")); assertIteration(walk, F, "foo/bar.jar", attrs("jar"));
assertIteration(F, "foo/bar.xml"); assertIteration(walk, F, "foo/bar.xml");
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/a.txt"); assertIteration(walk, F, "sub/a.txt");
assertIteration(F, "sub/b.jar", attrs("jar")); assertIteration(walk, F, "sub/b.jar", attrs("jar"));
assertIteration(F, "sub/b.xml"); assertIteration(walk, F, "sub/b.xml");
assertIteration(D, "sub/foo", attrs("sub xml")); assertIteration(walk, D, "sub/foo", attrs("sub xml"));
assertIteration(F, "sub/foo/b.jar", attrs("jar")); assertIteration(walk, F, "sub/foo/b.jar", attrs("jar"));
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -337,18 +362,19 @@ public class AttributesHandlerTest extends RepositoryTestCase {
writeTrashFile("sub/b.xml", "bx"); writeTrashFile("sub/b.xml", "bx");
writeTrashFile("sub/foo/b.jar", "bf"); writeTrashFile("sub/foo/b.jar", "bf");
// On foo.xml/bar.jar we must not have 'xml' // On foo.xml/bar.jar we must not have 'xml'
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(F, ".gitattributes"); assertIteration(walk, F, ".gitattributes");
assertIteration(D, "foo"); assertIteration(walk, D, "foo");
assertIteration(F, "foo/bar.jar", attrs("jar xml")); assertIteration(walk, F, "foo/bar.jar", attrs("jar xml"));
assertIteration(F, "foo/bar.xml", attrs("xml")); assertIteration(walk, F, "foo/bar.xml", attrs("xml"));
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/a.txt"); assertIteration(walk, F, "sub/a.txt");
assertIteration(F, "sub/b.jar", attrs("jar")); assertIteration(walk, F, "sub/b.jar", attrs("jar"));
assertIteration(F, "sub/b.xml"); assertIteration(walk, F, "sub/b.xml");
assertIteration(D, "sub/foo"); assertIteration(walk, D, "sub/foo");
assertIteration(F, "sub/foo/b.jar", attrs("jar")); assertIteration(walk, F, "sub/foo/b.jar", attrs("jar"));
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -357,27 +383,29 @@ public class AttributesHandlerTest extends RepositoryTestCase {
writeTrashFile("sub/a.txt", "1"); writeTrashFile("sub/a.txt", "1");
writeTrashFile("foo/sext", "2"); writeTrashFile("foo/sext", "2");
writeTrashFile("foo/s.txt", "3"); writeTrashFile("foo/s.txt", "3");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(F, ".gitattributes"); assertIteration(walk, F, ".gitattributes");
assertIteration(D, "foo"); assertIteration(walk, D, "foo");
assertIteration(F, "foo/s.txt", attrs("bar")); assertIteration(walk, F, "foo/s.txt", attrs("bar"));
assertIteration(F, "foo/sext", attrs("bar")); assertIteration(walk, F, "foo/sext", attrs("bar"));
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/a.txt"); assertIteration(walk, F, "sub/a.txt");
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
public void testPrefixMatchNot() throws Exception { public void testPrefixMatchNot() throws Exception {
setupRepo(null, null, "sub/new bar", null); setupRepo(null, null, "sub/new bar", null);
writeTrashFile("sub/new/foo.txt", "1"); writeTrashFile("sub/new/foo.txt", "1");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(F, ".gitattributes"); assertIteration(walk, F, ".gitattributes");
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/a.txt"); assertIteration(walk, F, "sub/a.txt");
assertIteration(D, "sub/new", attrs("bar")); assertIteration(walk, D, "sub/new", attrs("bar"));
assertIteration(F, "sub/new/foo.txt"); assertIteration(walk, F, "sub/new/foo.txt");
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -385,14 +413,15 @@ public class AttributesHandlerTest extends RepositoryTestCase {
setupRepo(null, null, "s[t-v]b/n[de]w bar", null); setupRepo(null, null, "s[t-v]b/n[de]w bar", null);
writeTrashFile("sub/new/foo.txt", "1"); writeTrashFile("sub/new/foo.txt", "1");
writeTrashFile("sub/ndw", "2"); writeTrashFile("sub/ndw", "2");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(F, ".gitattributes"); assertIteration(walk, F, ".gitattributes");
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/a.txt"); assertIteration(walk, F, "sub/a.txt");
assertIteration(F, "sub/ndw", attrs("bar")); assertIteration(walk, F, "sub/ndw", attrs("bar"));
assertIteration(D, "sub/new", attrs("bar")); assertIteration(walk, D, "sub/new", attrs("bar"));
assertIteration(F, "sub/new/foo.txt"); assertIteration(walk, F, "sub/new/foo.txt");
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -400,15 +429,16 @@ public class AttributesHandlerTest extends RepositoryTestCase {
setupRepo(null, null, "sub/new/* bar", null); setupRepo(null, null, "sub/new/* bar", null);
writeTrashFile("sub/new/foo.txt", "1"); writeTrashFile("sub/new/foo.txt", "1");
writeTrashFile("sub/new/lower/foo.txt", "2"); writeTrashFile("sub/new/lower/foo.txt", "2");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(F, ".gitattributes"); assertIteration(walk, F, ".gitattributes");
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/a.txt"); assertIteration(walk, F, "sub/a.txt");
assertIteration(D, "sub/new"); assertIteration(walk, D, "sub/new");
assertIteration(F, "sub/new/foo.txt", attrs("bar")); assertIteration(walk, F, "sub/new/foo.txt", attrs("bar"));
assertIteration(D, "sub/new/lower", attrs("bar")); assertIteration(walk, D, "sub/new/lower", attrs("bar"));
assertIteration(F, "sub/new/lower/foo.txt"); assertIteration(walk, F, "sub/new/lower/foo.txt");
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -417,20 +447,21 @@ public class AttributesHandlerTest extends RepositoryTestCase {
writeTrashFile("sub/new/foo.txt", "1"); writeTrashFile("sub/new/foo.txt", "1");
writeTrashFile("foo/sub/new/foo.txt", "2"); writeTrashFile("foo/sub/new/foo.txt", "2");
writeTrashFile("sub/sub/new/foo.txt", "3"); writeTrashFile("sub/sub/new/foo.txt", "3");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(F, ".gitattributes"); assertIteration(walk, F, ".gitattributes");
assertIteration(D, "foo"); assertIteration(walk, D, "foo");
assertIteration(D, "foo/sub"); assertIteration(walk, D, "foo/sub");
assertIteration(D, "foo/sub/new"); assertIteration(walk, D, "foo/sub/new");
assertIteration(F, "foo/sub/new/foo.txt"); assertIteration(walk, F, "foo/sub/new/foo.txt");
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/a.txt"); assertIteration(walk, F, "sub/a.txt");
assertIteration(D, "sub/new", attrs("bar")); assertIteration(walk, D, "sub/new", attrs("bar"));
assertIteration(F, "sub/new/foo.txt"); assertIteration(walk, F, "sub/new/foo.txt");
assertIteration(D, "sub/sub"); assertIteration(walk, D, "sub/sub");
assertIteration(D, "sub/sub/new"); assertIteration(walk, D, "sub/sub/new");
assertIteration(F, "sub/sub/new/foo.txt"); assertIteration(walk, F, "sub/sub/new/foo.txt");
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -438,17 +469,18 @@ public class AttributesHandlerTest extends RepositoryTestCase {
setupRepo(null, null, "**/sub/new/ bar", null); setupRepo(null, null, "**/sub/new/ bar", null);
writeTrashFile("sub/new/foo.txt", "1"); writeTrashFile("sub/new/foo.txt", "1");
writeTrashFile("foo/sub/new/foo.txt", "2"); writeTrashFile("foo/sub/new/foo.txt", "2");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(F, ".gitattributes"); assertIteration(walk, F, ".gitattributes");
assertIteration(D, "foo"); assertIteration(walk, D, "foo");
assertIteration(D, "foo/sub"); assertIteration(walk, D, "foo/sub");
assertIteration(D, "foo/sub/new", attrs("bar")); assertIteration(walk, D, "foo/sub/new", attrs("bar"));
assertIteration(F, "foo/sub/new/foo.txt"); assertIteration(walk, F, "foo/sub/new/foo.txt");
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/a.txt"); assertIteration(walk, F, "sub/a.txt");
assertIteration(D, "sub/new", attrs("bar")); assertIteration(walk, D, "sub/new", attrs("bar"));
assertIteration(F, "sub/new/foo.txt"); assertIteration(walk, F, "sub/new/foo.txt");
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -457,20 +489,21 @@ public class AttributesHandlerTest extends RepositoryTestCase {
writeTrashFile("sub/new/foo.txt", "1"); writeTrashFile("sub/new/foo.txt", "1");
writeTrashFile("foo/sub/new/foo.txt", "2"); writeTrashFile("foo/sub/new/foo.txt", "2");
writeTrashFile("sub/sub/new/foo.txt", "3"); writeTrashFile("sub/sub/new/foo.txt", "3");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(F, ".gitattributes"); assertIteration(walk, F, ".gitattributes");
assertIteration(D, "foo"); assertIteration(walk, D, "foo");
assertIteration(D, "foo/sub"); assertIteration(walk, D, "foo/sub");
assertIteration(D, "foo/sub/new", attrs("bar")); assertIteration(walk, D, "foo/sub/new", attrs("bar"));
assertIteration(F, "foo/sub/new/foo.txt"); assertIteration(walk, F, "foo/sub/new/foo.txt");
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/a.txt"); assertIteration(walk, F, "sub/a.txt");
assertIteration(D, "sub/new", attrs("bar")); assertIteration(walk, D, "sub/new", attrs("bar"));
assertIteration(F, "sub/new/foo.txt"); assertIteration(walk, F, "sub/new/foo.txt");
assertIteration(D, "sub/sub"); assertIteration(walk, D, "sub/sub");
assertIteration(D, "sub/sub/new", attrs("bar")); assertIteration(walk, D, "sub/sub/new", attrs("bar"));
assertIteration(F, "sub/sub/new/foo.txt"); assertIteration(walk, F, "sub/sub/new/foo.txt");
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -479,20 +512,21 @@ public class AttributesHandlerTest extends RepositoryTestCase {
writeTrashFile("sub/new/foo.txt", "1"); writeTrashFile("sub/new/foo.txt", "1");
writeTrashFile("foo/sub/new/foo.txt", "2"); writeTrashFile("foo/sub/new/foo.txt", "2");
writeTrashFile("sub/sub/new/foo.txt", "3"); writeTrashFile("sub/sub/new/foo.txt", "3");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(F, ".gitattributes"); assertIteration(walk, F, ".gitattributes");
assertIteration(D, "foo"); assertIteration(walk, D, "foo");
assertIteration(D, "foo/sub"); assertIteration(walk, D, "foo/sub");
assertIteration(D, "foo/sub/new", attrs("bar")); assertIteration(walk, D, "foo/sub/new", attrs("bar"));
assertIteration(F, "foo/sub/new/foo.txt"); assertIteration(walk, F, "foo/sub/new/foo.txt");
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/a.txt"); assertIteration(walk, F, "sub/a.txt");
assertIteration(D, "sub/new", attrs("bar")); assertIteration(walk, D, "sub/new", attrs("bar"));
assertIteration(F, "sub/new/foo.txt"); assertIteration(walk, F, "sub/new/foo.txt");
assertIteration(D, "sub/sub"); assertIteration(walk, D, "sub/sub");
assertIteration(D, "sub/sub/new", attrs("bar")); assertIteration(walk, D, "sub/sub/new", attrs("bar"));
assertIteration(F, "sub/sub/new/foo.txt"); assertIteration(walk, F, "sub/sub/new/foo.txt");
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -500,17 +534,18 @@ public class AttributesHandlerTest extends RepositoryTestCase {
setupRepo(null, null, "s[uv]b/n*/ bar", null); setupRepo(null, null, "s[uv]b/n*/ bar", null);
writeTrashFile("sub/new/foo.txt", "1"); writeTrashFile("sub/new/foo.txt", "1");
writeTrashFile("foo/sub/new/foo.txt", "2"); writeTrashFile("foo/sub/new/foo.txt", "2");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(F, ".gitattributes"); assertIteration(walk, F, ".gitattributes");
assertIteration(D, "foo"); assertIteration(walk, D, "foo");
assertIteration(D, "foo/sub"); assertIteration(walk, D, "foo/sub");
assertIteration(D, "foo/sub/new"); assertIteration(walk, D, "foo/sub/new");
assertIteration(F, "foo/sub/new/foo.txt"); assertIteration(walk, F, "foo/sub/new/foo.txt");
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/a.txt"); assertIteration(walk, F, "sub/a.txt");
assertIteration(D, "sub/new", attrs("bar")); assertIteration(walk, D, "sub/new", attrs("bar"));
assertIteration(F, "sub/new/foo.txt"); assertIteration(walk, F, "sub/new/foo.txt");
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -519,30 +554,32 @@ public class AttributesHandlerTest extends RepositoryTestCase {
writeTrashFile("sub/new/foo.txt", "1"); writeTrashFile("sub/new/foo.txt", "1");
writeTrashFile("foo/sub/new/foo.txt", "2"); writeTrashFile("foo/sub/new/foo.txt", "2");
writeTrashFile("foo/new", "3"); writeTrashFile("foo/new", "3");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(F, ".gitattributes"); assertIteration(walk, F, ".gitattributes");
assertIteration(D, "foo"); assertIteration(walk, D, "foo");
assertIteration(F, "foo/new"); assertIteration(walk, F, "foo/new");
assertIteration(D, "foo/sub"); assertIteration(walk, D, "foo/sub");
assertIteration(D, "foo/sub/new", attrs("bar")); assertIteration(walk, D, "foo/sub/new", attrs("bar"));
assertIteration(F, "foo/sub/new/foo.txt"); assertIteration(walk, F, "foo/sub/new/foo.txt");
assertIteration(D, "sub"); assertIteration(walk, D, "sub");
assertIteration(F, "sub/a.txt"); assertIteration(walk, F, "sub/a.txt");
assertIteration(D, "sub/new", attrs("bar")); assertIteration(walk, D, "sub/new", attrs("bar"));
assertIteration(F, "sub/new/foo.txt"); assertIteration(walk, F, "sub/new/foo.txt");
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
private static Collection<Attribute> attrs(String s) { private static Collection<Attribute> attrs(String s) {
return new AttributesRule("*", s).getAttributes(); return new AttributesRule("*", s).getAttributes();
} }
private void assertIteration(FileMode type, String pathName) private void assertIteration(TreeWalk walk, FileMode type, String pathName)
throws IOException { throws IOException {
assertIteration(type, pathName, Collections.<Attribute> emptyList()); assertIteration(walk, type, pathName,
Collections.<Attribute> emptyList());
} }
private void assertIteration(FileMode type, String pathName, private void assertIteration(TreeWalk walk, FileMode type, String pathName,
Collection<Attribute> expectedAttrs) throws IOException { Collection<Attribute> expectedAttrs) throws IOException {
assertTrue("walk has entry", walk.next()); assertTrue("walk has entry", walk.next());
assertEquals(pathName, walk.getPathString()); assertEquals(pathName, walk.getPathString());
@ -611,8 +648,4 @@ public class AttributesHandlerTest extends RepositoryTestCase {
newWalk.addTree(new FileTreeIterator(db)); newWalk.addTree(new FileTreeIterator(db));
return newWalk; return newWalk;
} }
private void endWalk() throws IOException {
assertFalse("Not all files tested", walk.next());
}
} }

109
org.eclipse.jgit.test/tst/org/eclipse/jgit/attributes/AttributesNodeDirCacheIteratorTest.java
Unescape View File

@ -78,8 +78,6 @@ public class AttributesNodeDirCacheIteratorTest extends RepositoryTestCase {
private Git git; private Git git;
private TreeWalk walk;
@Override @Override
@Before @Before
public void setUp() throws Exception { public void setUp() throws Exception {
@ -105,23 +103,25 @@ public class AttributesNodeDirCacheIteratorTest extends RepositoryTestCase {
// Adds file to index // Adds file to index
git.add().addFilepattern(".").call(); git.add().addFilepattern(".").call();
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(walk, F, ".gitattributes");
assertIteration(F, ".gitattributes"); assertIteration(walk, F, "readme.txt", asList(EOL_LF));
assertIteration(F, "readme.txt", asList(EOL_LF));
assertIteration(D, "src"); assertIteration(walk, D, "src");
assertIteration(D, "src/config"); assertIteration(walk, D, "src/config");
assertIteration(F, "src/config/.gitattributes"); assertIteration(walk, F, "src/config/.gitattributes");
assertIteration(F, "src/config/readme.txt", asList(DELTA_UNSET)); assertIteration(walk, F, "src/config/readme.txt",
assertIteration(F, "src/config/windows.file", null); asList(DELTA_UNSET));
assertIteration(F, "src/config/windows.txt", asList(DELTA_UNSET)); assertIteration(walk, F, "src/config/windows.file", null);
assertIteration(walk, F, "src/config/windows.txt",
asList(DELTA_UNSET));
assertIteration(F, "windows.file", null); assertIteration(walk, F, "windows.file", null);
assertIteration(F, "windows.txt", asList(EOL_LF)); assertIteration(walk, F, "windows.txt", asList(EOL_LF));
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
/** /**
@ -138,17 +138,18 @@ public class AttributesNodeDirCacheIteratorTest extends RepositoryTestCase {
// Adds file to index // Adds file to index
git.add().addFilepattern(".").call(); git.add().addFilepattern(".").call();
walk = beginWalk();
assertIteration(F, "l0.txt"); try (TreeWalk walk = beginWalk()) {
assertIteration(walk, F, "l0.txt");
assertIteration(D, "level1"); assertIteration(walk, D, "level1");
assertIteration(F, "level1/l1.txt"); assertIteration(walk, F, "level1/l1.txt");
assertIteration(D, "level1/level2"); assertIteration(walk, D, "level1/level2");
assertIteration(F, "level1/level2/l2.txt"); assertIteration(walk, F, "level1/level2/l2.txt");
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
/** /**
@ -166,18 +167,19 @@ public class AttributesNodeDirCacheIteratorTest extends RepositoryTestCase {
// Adds file to index // Adds file to index
git.add().addFilepattern(".").call(); git.add().addFilepattern(".").call();
walk = beginWalk();
assertIteration(F, ".gitattributes"); try (TreeWalk walk = beginWalk()) {
assertIteration(F, "l0.txt"); assertIteration(walk, F, ".gitattributes");
assertIteration(walk, F, "l0.txt");
assertIteration(D, "level1"); assertIteration(walk, D, "level1");
assertIteration(F, "level1/l1.txt"); assertIteration(walk, F, "level1/l1.txt");
assertIteration(D, "level1/level2"); assertIteration(walk, D, "level1/level2");
assertIteration(F, "level1/level2/l2.txt"); assertIteration(walk, F, "level1/level2/l2.txt");
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -191,18 +193,19 @@ public class AttributesNodeDirCacheIteratorTest extends RepositoryTestCase {
// Adds file to index // Adds file to index
git.add().addFilepattern(".").call(); git.add().addFilepattern(".").call();
walk = beginWalk();
assertIteration(F, ".gitattributes"); try (TreeWalk walk = beginWalk()) {
assertIteration(walk, F, ".gitattributes");
assertIteration(D, "levelA"); assertIteration(walk, D, "levelA");
assertIteration(F, "levelA/.gitattributes"); assertIteration(walk, F, "levelA/.gitattributes");
assertIteration(F, "levelA/lA.txt"); assertIteration(walk, F, "levelA/lA.txt");
assertIteration(D, "levelB"); assertIteration(walk, D, "levelB");
assertIteration(F, "levelB/.gitattributes"); assertIteration(walk, F, "levelB/.gitattributes");
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -215,25 +218,27 @@ public class AttributesNodeDirCacheIteratorTest extends RepositoryTestCase {
// Adds file to index // Adds file to index
git.add().addFilepattern(".").call(); git.add().addFilepattern(".").call();
walk = beginWalk();
assertIteration(F, "gitattributes"); try (TreeWalk walk = beginWalk()) {
assertIteration(walk, F, "gitattributes");
assertIteration(F, "l0.txt"); assertIteration(walk, F, "l0.txt");
assertIteration(D, "levelA"); assertIteration(walk, D, "levelA");
assertIteration(F, "levelA/file.gitattributes"); assertIteration(walk, F, "levelA/file.gitattributes");
assertIteration(F, "levelA/lA.txt"); assertIteration(walk, F, "levelA/lA.txt");
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
private void assertIteration(FileMode type, String pathName) private void assertIteration(TreeWalk walk, FileMode type, String pathName)
throws IOException { throws IOException {
assertIteration(type, pathName, Collections.<Attribute> emptyList()); assertIteration(walk, type, pathName,
Collections.<Attribute> emptyList());
} }
private void assertIteration(FileMode type, String pathName, private void assertIteration(TreeWalk walk, FileMode type, String pathName,
List<Attribute> nodeAttrs) throws IOException { List<Attribute> nodeAttrs) throws IOException {
assertTrue("walk has entry", walk.next()); assertTrue("walk has entry", walk.next());
assertEquals(pathName, walk.getPathString()); assertEquals(pathName, walk.getPathString());
@ -243,14 +248,14 @@ public class AttributesNodeDirCacheIteratorTest extends RepositoryTestCase {
AttributesNode attributesNode = itr.getEntryAttributesNode(db AttributesNode attributesNode = itr.getEntryAttributesNode(db
.newObjectReader()); .newObjectReader());
assertAttributesNode(pathName, attributesNode, nodeAttrs); assertAttributesNode(walk, pathName, attributesNode, nodeAttrs);
if (D.equals(type)) if (D.equals(type))
walk.enterSubtree(); walk.enterSubtree();
} }
private void assertAttributesNode(String pathName, private void assertAttributesNode(TreeWalk walk, String pathName,
AttributesNode attributesNode, List<Attribute> nodeAttrs) AttributesNode attributesNode, List<Attribute> nodeAttrs)
throws IOException { throws IOException {
if (attributesNode == null) if (attributesNode == null)
@ -292,8 +297,4 @@ public class AttributesNodeDirCacheIteratorTest extends RepositoryTestCase {
newWalk.addTree(new DirCacheIterator(db.readDirCache())); newWalk.addTree(new DirCacheIterator(db.readDirCache()));
return newWalk; return newWalk;
} }
private void endWalk() throws IOException {
assertFalse("Not all files tested", walk.next());
}
} }

99
org.eclipse.jgit.test/tst/org/eclipse/jgit/attributes/AttributesNodeWorkingTreeIteratorTest.java
Unescape View File

@ -77,8 +77,6 @@ public class AttributesNodeWorkingTreeIteratorTest extends RepositoryTestCase {
private static Attribute DELTA_UNSET = new Attribute("delta", State.UNSET); private static Attribute DELTA_UNSET = new Attribute("delta", State.UNSET);
private TreeWalk walk;
@Test @Test
public void testRules() throws Exception { public void testRules() throws Exception {
@ -102,24 +100,26 @@ public class AttributesNodeWorkingTreeIteratorTest extends RepositoryTestCase {
writeTrashFile("src/config/windows.file", ""); writeTrashFile("src/config/windows.file", "");
writeTrashFile("src/config/windows.txt", ""); writeTrashFile("src/config/windows.txt", "");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(walk, F, ".gitattributes");
assertIteration(F, ".gitattributes"); assertIteration(walk, F, "global.txt", asList(EOL_LF));
assertIteration(F, "global.txt", asList(EOL_LF)); assertIteration(walk, F, "readme.txt", asList(EOL_LF));
assertIteration(F, "readme.txt", asList(EOL_LF));
assertIteration(D, "src"); assertIteration(walk, D, "src");
assertIteration(D, "src/config"); assertIteration(walk, D, "src/config");
assertIteration(F, "src/config/.gitattributes"); assertIteration(walk, F, "src/config/.gitattributes");
assertIteration(F, "src/config/readme.txt", asList(DELTA_UNSET)); assertIteration(walk, F, "src/config/readme.txt",
assertIteration(F, "src/config/windows.file", null); asList(DELTA_UNSET));
assertIteration(F, "src/config/windows.txt", asList(DELTA_UNSET)); assertIteration(walk, F, "src/config/windows.file", null);
assertIteration(walk, F, "src/config/windows.txt",
asList(DELTA_UNSET));
assertIteration(F, "windows.file", null); assertIteration(walk, F, "windows.file", null);
assertIteration(F, "windows.txt", asList(EOL_LF)); assertIteration(walk, F, "windows.txt", asList(EOL_LF));
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
/** /**
@ -134,17 +134,17 @@ public class AttributesNodeWorkingTreeIteratorTest extends RepositoryTestCase {
writeTrashFile("level1/l1.txt", ""); writeTrashFile("level1/l1.txt", "");
writeTrashFile("level1/level2/l2.txt", ""); writeTrashFile("level1/level2/l2.txt", "");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(walk, F, "l0.txt");
assertIteration(F, "l0.txt"); assertIteration(walk, D, "level1");
assertIteration(walk, F, "level1/l1.txt");
assertIteration(D, "level1"); assertIteration(walk, D, "level1/level2");
assertIteration(F, "level1/l1.txt"); assertIteration(walk, F, "level1/level2/l2.txt");
assertIteration(D, "level1/level2"); assertFalse("Not all files tested", walk.next());
assertIteration(F, "level1/level2/l2.txt"); }
endWalk();
} }
/** /**
@ -160,18 +160,18 @@ public class AttributesNodeWorkingTreeIteratorTest extends RepositoryTestCase {
writeTrashFile("level1/l1.txt", ""); writeTrashFile("level1/l1.txt", "");
writeTrashFile("level1/level2/l2.txt", ""); writeTrashFile("level1/level2/l2.txt", "");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(walk, F, ".gitattributes");
assertIteration(F, ".gitattributes"); assertIteration(walk, F, "l0.txt");
assertIteration(F, "l0.txt");
assertIteration(D, "level1"); assertIteration(walk, D, "level1");
assertIteration(F, "level1/l1.txt"); assertIteration(walk, F, "level1/l1.txt");
assertIteration(D, "level1/level2"); assertIteration(walk, D, "level1/level2");
assertIteration(F, "level1/level2/l2.txt"); assertIteration(walk, F, "level1/level2/l2.txt");
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
@Test @Test
@ -183,26 +183,27 @@ public class AttributesNodeWorkingTreeIteratorTest extends RepositoryTestCase {
writeTrashFile("levelA/lA.txt", ""); writeTrashFile("levelA/lA.txt", "");
walk = beginWalk(); try (TreeWalk walk = beginWalk()) {
assertIteration(walk, F, ".gitattributes");
assertIteration(F, ".gitattributes");
assertIteration(D, "levelA"); assertIteration(walk, D, "levelA");
assertIteration(F, "levelA/.gitattributes"); assertIteration(walk, F, "levelA/.gitattributes");
assertIteration(F, "levelA/lA.txt"); assertIteration(walk, F, "levelA/lA.txt");
assertIteration(D, "levelB"); assertIteration(walk, D, "levelB");
assertIteration(F, "levelB/.gitattributes"); assertIteration(walk, F, "levelB/.gitattributes");
endWalk(); assertFalse("Not all files tested", walk.next());
}
} }
private void assertIteration(FileMode type, String pathName) private void assertIteration(TreeWalk walk, FileMode type, String pathName)
throws IOException { throws IOException {
assertIteration(type, pathName, Collections.<Attribute> emptyList()); assertIteration(walk, type, pathName,
Collections.<Attribute> emptyList());
} }
private void assertIteration(FileMode type, String pathName, private void assertIteration(TreeWalk walk, FileMode type, String pathName,
List<Attribute> nodeAttrs) List<Attribute> nodeAttrs)
throws IOException { throws IOException {
assertTrue("walk has entry", walk.next()); assertTrue("walk has entry", walk.next());
@ -212,13 +213,13 @@ public class AttributesNodeWorkingTreeIteratorTest extends RepositoryTestCase {
assertNotNull("has tree", itr); assertNotNull("has tree", itr);
AttributesNode attributesNode = itr.getEntryAttributesNode(); AttributesNode attributesNode = itr.getEntryAttributesNode();
assertAttributesNode(pathName, attributesNode, nodeAttrs); assertAttributesNode(walk, pathName, attributesNode, nodeAttrs);
if (D.equals(type)) if (D.equals(type))
walk.enterSubtree(); walk.enterSubtree();
} }
private void assertAttributesNode(String pathName, private void assertAttributesNode(TreeWalk walk, String pathName,
AttributesNode attributesNode, List<Attribute> nodeAttrs) AttributesNode attributesNode, List<Attribute> nodeAttrs)
throws IOException { throws IOException {
if (attributesNode == null) if (attributesNode == null)
@ -259,8 +260,4 @@ public class AttributesNodeWorkingTreeIteratorTest extends RepositoryTestCase {
newWalk.addTree(new FileTreeIterator(db)); newWalk.addTree(new FileTreeIterator(db));
return newWalk; return newWalk;
} }
private void endWalk() throws IOException {
assertFalse("Not all files tested", walk.next());
}
} }

6
org.eclipse.jgit.test/tst/org/eclipse/jgit/attributes/TreeWalkAttributeTest.java
Unescape View File

@ -131,6 +131,12 @@ public class TreeWalkAttributeTest extends RepositoryTestCase {
@Override @Override
@After @After
public void tearDown() throws Exception { public void tearDown() throws Exception {
if (walk != null) {
walk.close();
}
if (ci_walk != null) {
ci_walk.close();
}
super.tearDown(); super.tearDown();
if (customAttributeFile != null) if (customAttributeFile != null)
customAttributeFile.delete(); customAttributeFile.delete();

8
org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreNodeTest.java
Unescape View File

@ -63,6 +63,7 @@ import org.eclipse.jgit.treewalk.TreeWalk;
import org.eclipse.jgit.treewalk.WorkingTreeIterator; import org.eclipse.jgit.treewalk.WorkingTreeIterator;
import org.eclipse.jgit.util.FileUtils; import org.eclipse.jgit.util.FileUtils;
import org.eclipse.jgit.util.SystemReader; import org.eclipse.jgit.util.SystemReader;
import org.junit.After;
import org.junit.Test; import org.junit.Test;
/** /**
@ -79,6 +80,13 @@ public class IgnoreNodeTest extends RepositoryTestCase {
private TreeWalk walk; private TreeWalk walk;
@After
public void closeWalk() {
if (walk != null) {
walk.close();
}
}
@Test @Test
public void testSimpleRootGitIgnoreGlobalIgnore() throws IOException { public void testSimpleRootGitIgnoreGlobalIgnore() throws IOException {
writeIgnoreFile(".gitignore", "x"); writeIgnoreFile(".gitignore", "x");

48
org.eclipse.jgit.test/tst/org/eclipse/jgit/merge/CherryPickTest.java
Unescape View File

@ -106,23 +106,24 @@ public class CherryPickTest extends RepositoryTestCase {
boolean merge = twm.merge(new ObjectId[] { O, T }); boolean merge = twm.merge(new ObjectId[] { O, T });
assertTrue(merge); assertTrue(merge);
final TreeWalk tw = new TreeWalk(db); try (TreeWalk tw = new TreeWalk(db)) {
tw.setRecursive(true); tw.setRecursive(true);
tw.reset(twm.getResultTreeId()); tw.reset(twm.getResultTreeId());
assertTrue(tw.next()); assertTrue(tw.next());
assertEquals("a", tw.getPathString()); assertEquals("a", tw.getPathString());
assertCorrectId(treeO, tw); assertCorrectId(treeO, tw);
assertTrue(tw.next()); assertTrue(tw.next());
assertEquals("o", tw.getPathString()); assertEquals("o", tw.getPathString());
assertCorrectId(treeO, tw); assertCorrectId(treeO, tw);
assertTrue(tw.next()); assertTrue(tw.next());
assertEquals("t", tw.getPathString()); assertEquals("t", tw.getPathString());
assertCorrectId(treeT, tw); assertCorrectId(treeT, tw);
assertFalse(tw.next()); assertFalse(tw.next());
}
} }
@Test @Test
@ -168,19 +169,20 @@ public class CherryPickTest extends RepositoryTestCase {
boolean merge = twm.merge(new ObjectId[] { B, T }); boolean merge = twm.merge(new ObjectId[] { B, T });
assertTrue(merge); assertTrue(merge);
final TreeWalk tw = new TreeWalk(db); try (TreeWalk tw = new TreeWalk(db)) {
tw.setRecursive(true); tw.setRecursive(true);
tw.reset(twm.getResultTreeId()); tw.reset(twm.getResultTreeId());
assertTrue(tw.next()); assertTrue(tw.next());
assertEquals("a", tw.getPathString()); assertEquals("a", tw.getPathString());
assertCorrectId(treeB, tw); assertCorrectId(treeB, tw);
assertTrue(tw.next()); assertTrue(tw.next());
assertEquals("t", tw.getPathString()); assertEquals("t", tw.getPathString());
assertCorrectId(treeT, tw); assertCorrectId(treeT, tw);
assertFalse(tw.next()); assertFalse(tw.next());
}
} }
private static void assertCorrectId(DirCache treeT, TreeWalk tw) { private static void assertCorrectId(DirCache treeT, TreeWalk tw) {

48
org.eclipse.jgit.test/tst/org/eclipse/jgit/merge/SimpleMergeTest.java
Unescape View File

@ -174,23 +174,24 @@ public class SimpleMergeTest extends SampleDataRepositoryTestCase {
boolean merge = ourMerger.merge(new ObjectId[] { o, t }); boolean merge = ourMerger.merge(new ObjectId[] { o, t });
assertTrue(merge); assertTrue(merge);
final TreeWalk tw = new TreeWalk(db); try (TreeWalk tw = new TreeWalk(db)) {
tw.setRecursive(true); tw.setRecursive(true);
tw.reset(ourMerger.getResultTreeId()); tw.reset(ourMerger.getResultTreeId());
assertTrue(tw.next()); assertTrue(tw.next());
assertEquals("Makefile", tw.getPathString()); assertEquals("Makefile", tw.getPathString());
assertCorrectId(treeO, tw); assertCorrectId(treeO, tw);
assertTrue(tw.next()); assertTrue(tw.next());
assertEquals("libelf-po/a", tw.getPathString()); assertEquals("libelf-po/a", tw.getPathString());
assertCorrectId(treeO, tw); assertCorrectId(treeO, tw);
assertTrue(tw.next()); assertTrue(tw.next());
assertEquals("libelf/c", tw.getPathString()); assertEquals("libelf/c", tw.getPathString());
assertCorrectId(treeT, tw); assertCorrectId(treeT, tw);
assertFalse(tw.next()); assertFalse(tw.next());
}
} }
@Test @Test
@ -226,19 +227,20 @@ public class SimpleMergeTest extends SampleDataRepositoryTestCase {
boolean merge = ourMerger.merge(new ObjectId[] { o, t }); boolean merge = ourMerger.merge(new ObjectId[] { o, t });
assertTrue(merge); assertTrue(merge);
final TreeWalk tw = new TreeWalk(db); try (TreeWalk tw = new TreeWalk(db)) {
tw.setRecursive(true); tw.setRecursive(true);
tw.reset(ourMerger.getResultTreeId()); tw.reset(ourMerger.getResultTreeId());
assertTrue(tw.next()); assertTrue(tw.next());
assertEquals("d/o", tw.getPathString()); assertEquals("d/o", tw.getPathString());
assertCorrectId(treeO, tw); assertCorrectId(treeO, tw);
assertTrue(tw.next()); assertTrue(tw.next());
assertEquals("d/t", tw.getPathString()); assertEquals("d/t", tw.getPathString());
assertCorrectId(treeT, tw); assertCorrectId(treeT, tw);
assertFalse(tw.next()); assertFalse(tw.next());
}
} }
@Test @Test

33
org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/FileTreeIteratorTest.java
Unescape View File

@ -272,22 +272,23 @@ public class FileTreeIteratorTest extends RepositoryTestCase {
git.add().addFilepattern("file").call(); git.add().addFilepattern("file").call();
} }
DirCacheEntry dce = db.readDirCache().getEntry("file"); DirCacheEntry dce = db.readDirCache().getEntry("file");
TreeWalk tw = new TreeWalk(db); try (TreeWalk tw = new TreeWalk(db)) {
FileTreeIterator fti = new FileTreeIterator(trash, db.getFS(), db FileTreeIterator fti = new FileTreeIterator(trash, db.getFS(),
.getConfig().get(WorkingTreeOptions.KEY)); db.getConfig().get(WorkingTreeOptions.KEY));
tw.addTree(fti); tw.addTree(fti);
DirCacheIterator dci = new DirCacheIterator(db.readDirCache()); DirCacheIterator dci = new DirCacheIterator(db.readDirCache());
tw.addTree(dci); tw.addTree(dci);
fti.setDirCacheIterator(tw, 1); fti.setDirCacheIterator(tw, 1);
while (tw.next() && !tw.getPathString().equals("file")) { while (tw.next() && !tw.getPathString().equals("file")) {
// //
} }
assertEquals(MetadataDiff.EQUAL, fti.compareMetadata(dce)); assertEquals(MetadataDiff.EQUAL, fti.compareMetadata(dce));
ObjectId fromRaw = ObjectId.fromRaw(fti.idBuffer(), fti.idOffset()); ObjectId fromRaw = ObjectId.fromRaw(fti.idBuffer(), fti.idOffset());
assertEquals("6b584e8ece562ebffc15d38808cd6b98fc3d97ea", assertEquals("6b584e8ece562ebffc15d38808cd6b98fc3d97ea",
fromRaw.getName()); fromRaw.getName());
try (ObjectReader objectReader = db.newObjectReader()) { try (ObjectReader objectReader = db.newObjectReader()) {
assertFalse(fti.isModified(dce, false, objectReader)); assertFalse(fti.isModified(dce, false, objectReader));
}
} }
} }

149
org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/NameConflictTreeWalkTest.java
Unescape View File

@ -84,16 +84,17 @@ public class NameConflictTreeWalkTest extends RepositoryTestCase {
assertEquals(1, tree1.getEntryCount()); assertEquals(1, tree1.getEntryCount());
} }
final TreeWalk tw = new TreeWalk(db); try (TreeWalk tw = new TreeWalk(db)) {
tw.addTree(new DirCacheIterator(tree0)); tw.addTree(new DirCacheIterator(tree0));
tw.addTree(new DirCacheIterator(tree1)); tw.addTree(new DirCacheIterator(tree1));
assertModes("a", REGULAR_FILE, MISSING, tw); assertModes("a", REGULAR_FILE, MISSING, tw);
assertModes("a.b", EXECUTABLE_FILE, MISSING, tw); assertModes("a.b", EXECUTABLE_FILE, MISSING, tw);
assertModes("a", MISSING, TREE, tw); assertModes("a", MISSING, TREE, tw);
tw.enterSubtree(); tw.enterSubtree();
assertModes("a/b", MISSING, REGULAR_FILE, tw); assertModes("a/b", MISSING, REGULAR_FILE, tw);
assertModes("a0b", SYMLINK, MISSING, tw); assertModes("a0b", SYMLINK, MISSING, tw);
}
} }
@Test @Test
@ -115,20 +116,21 @@ public class NameConflictTreeWalkTest extends RepositoryTestCase {
assertEquals(1, tree1.getEntryCount()); assertEquals(1, tree1.getEntryCount());
} }
final NameConflictTreeWalk tw = new NameConflictTreeWalk(db); try (NameConflictTreeWalk tw = new NameConflictTreeWalk(db)) {
tw.addTree(new DirCacheIterator(tree0)); tw.addTree(new DirCacheIterator(tree0));
tw.addTree(new DirCacheIterator(tree1)); tw.addTree(new DirCacheIterator(tree1));
assertModes("a", REGULAR_FILE, TREE, tw); assertModes("a", REGULAR_FILE, TREE, tw);
assertTrue(tw.isDirectoryFileConflict()); assertTrue(tw.isDirectoryFileConflict());
assertTrue(tw.isSubtree()); assertTrue(tw.isSubtree());
tw.enterSubtree(); tw.enterSubtree();
assertModes("a/b", MISSING, REGULAR_FILE, tw); assertModes("a/b", MISSING, REGULAR_FILE, tw);
assertTrue(tw.isDirectoryFileConflict()); assertTrue(tw.isDirectoryFileConflict());
assertModes("a.b", EXECUTABLE_FILE, MISSING, tw); assertModes("a.b", EXECUTABLE_FILE, MISSING, tw);
assertFalse(tw.isDirectoryFileConflict()); assertFalse(tw.isDirectoryFileConflict());
assertModes("a0b", SYMLINK, MISSING, tw); assertModes("a0b", SYMLINK, MISSING, tw);
assertFalse(tw.isDirectoryFileConflict()); assertFalse(tw.isDirectoryFileConflict());
}
} }
@Test @Test
@ -151,20 +153,21 @@ public class NameConflictTreeWalkTest extends RepositoryTestCase {
assertEquals(2, tree1.getEntryCount()); assertEquals(2, tree1.getEntryCount());
} }
final NameConflictTreeWalk tw = new NameConflictTreeWalk(db); try (NameConflictTreeWalk tw = new NameConflictTreeWalk(db)) {
tw.addTree(new DirCacheIterator(tree0)); tw.addTree(new DirCacheIterator(tree0));
tw.addTree(new DirCacheIterator(tree1)); tw.addTree(new DirCacheIterator(tree1));
assertModes("a", REGULAR_FILE, TREE, tw); assertModes("a", REGULAR_FILE, TREE, tw);
assertTrue(tw.isSubtree()); assertTrue(tw.isSubtree());
assertTrue(tw.isDirectoryFileConflict()); assertTrue(tw.isDirectoryFileConflict());
tw.enterSubtree(); tw.enterSubtree();
assertModes("a/b", MISSING, REGULAR_FILE, tw); assertModes("a/b", MISSING, REGULAR_FILE, tw);
assertTrue(tw.isDirectoryFileConflict()); assertTrue(tw.isDirectoryFileConflict());
assertModes("a.b", EXECUTABLE_FILE, EXECUTABLE_FILE, tw); assertModes("a.b", EXECUTABLE_FILE, EXECUTABLE_FILE, tw);
assertFalse(tw.isDirectoryFileConflict()); assertFalse(tw.isDirectoryFileConflict());
assertModes("a0b", SYMLINK, MISSING, tw); assertModes("a0b", SYMLINK, MISSING, tw);
assertFalse(tw.isDirectoryFileConflict()); assertFalse(tw.isDirectoryFileConflict());
}
} }
@Test @Test
@ -187,20 +190,21 @@ public class NameConflictTreeWalkTest extends RepositoryTestCase {
assertEquals(3, tree1.getEntryCount()); assertEquals(3, tree1.getEntryCount());
} }
final NameConflictTreeWalk tw = new NameConflictTreeWalk(db); try (NameConflictTreeWalk tw = new NameConflictTreeWalk(db)) {
tw.addTree(new DirCacheIterator(tree0)); tw.addTree(new DirCacheIterator(tree0));
tw.addTree(new DirCacheIterator(tree1)); tw.addTree(new DirCacheIterator(tree1));
assertModes("a", REGULAR_FILE, TREE, tw); assertModes("a", REGULAR_FILE, TREE, tw);
assertTrue(tw.isSubtree()); assertTrue(tw.isSubtree());
assertTrue(tw.isDirectoryFileConflict()); assertTrue(tw.isDirectoryFileConflict());
tw.enterSubtree(); tw.enterSubtree();
assertModes("a/b", MISSING, REGULAR_FILE, tw); assertModes("a/b", MISSING, REGULAR_FILE, tw);
assertTrue(tw.isDirectoryFileConflict()); assertTrue(tw.isDirectoryFileConflict());
assertModes("a.b", MISSING, EXECUTABLE_FILE, tw); assertModes("a.b", MISSING, EXECUTABLE_FILE, tw);
assertFalse(tw.isDirectoryFileConflict()); assertFalse(tw.isDirectoryFileConflict());
assertModes("a0b", SYMLINK, SYMLINK, tw); assertModes("a0b", SYMLINK, SYMLINK, tw);
assertFalse(tw.isDirectoryFileConflict()); assertFalse(tw.isDirectoryFileConflict());
}
} }
@Test @Test
@ -224,26 +228,27 @@ public class NameConflictTreeWalkTest extends RepositoryTestCase {
assertEquals(4, tree1.getEntryCount()); assertEquals(4, tree1.getEntryCount());
} }
final NameConflictTreeWalk tw = new NameConflictTreeWalk(db); try (NameConflictTreeWalk tw = new NameConflictTreeWalk(db)) {
tw.addTree(new DirCacheIterator(tree0)); tw.addTree(new DirCacheIterator(tree0));
tw.addTree(new DirCacheIterator(tree1)); tw.addTree(new DirCacheIterator(tree1));
assertModes("0", REGULAR_FILE, REGULAR_FILE, tw); assertModes("0", REGULAR_FILE, REGULAR_FILE, tw);
assertFalse(tw.isDirectoryFileConflict()); assertFalse(tw.isDirectoryFileConflict());
assertModes("a", REGULAR_FILE, TREE, tw); assertModes("a", REGULAR_FILE, TREE, tw);
assertTrue(tw.isSubtree()); assertTrue(tw.isSubtree());
assertTrue(tw.isDirectoryFileConflict()); assertTrue(tw.isDirectoryFileConflict());
tw.enterSubtree(); tw.enterSubtree();
assertModes("a/b", MISSING, REGULAR_FILE, tw); assertModes("a/b", MISSING, REGULAR_FILE, tw);
assertTrue(tw.isDirectoryFileConflict()); assertTrue(tw.isDirectoryFileConflict());
assertModes("a/c", MISSING, TREE, tw); assertModes("a/c", MISSING, TREE, tw);
assertTrue(tw.isDirectoryFileConflict()); assertTrue(tw.isDirectoryFileConflict());
tw.enterSubtree(); tw.enterSubtree();
assertModes("a/c/e", MISSING, REGULAR_FILE, tw); assertModes("a/c/e", MISSING, REGULAR_FILE, tw);
assertTrue(tw.isDirectoryFileConflict()); assertTrue(tw.isDirectoryFileConflict());
assertModes("a.b", MISSING, REGULAR_FILE, tw); assertModes("a.b", MISSING, REGULAR_FILE, tw);
assertFalse(tw.isDirectoryFileConflict()); assertFalse(tw.isDirectoryFileConflict());
}
} }
private static void assertModes(final String path, final FileMode mode0, private static void assertModes(final String path, final FileMode mode0,

222
org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/filter/IndexDiffFilterTest.java
Unescape View File

@ -101,13 +101,14 @@ public class IndexDiffFilterTest extends RepositoryTestCase {
RevCommit commit = writeFileInFolderAndCommit(); RevCommit commit = writeFileInFolderAndCommit();
deleteAll(); deleteAll();
writeFileWithFolderName(); writeFileWithFolderName();
TreeWalk treeWalk = createTreeWalk(commit);
assertTrue(treeWalk.next()); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertEquals("folder", treeWalk.getPathString()); assertTrue(treeWalk.next());
assertTrue(treeWalk.next()); assertEquals("folder", treeWalk.getPathString());
assertEquals("folder/file", treeWalk.getPathString()); assertTrue(treeWalk.next());
assertFalse(treeWalk.next()); assertEquals("folder/file", treeWalk.getPathString());
assertFalse(treeWalk.next());
}
} }
@Test @Test
@ -115,24 +116,26 @@ public class IndexDiffFilterTest extends RepositoryTestCase {
RevCommit commit = writeFileInFolderAndCommit(); RevCommit commit = writeFileInFolderAndCommit();
deleteAll(); deleteAll();
writeFileWithFolderName(); writeFileWithFolderName();
TreeWalk treeWalk = createNonRecursiveTreeWalk(commit);
try (TreeWalk treeWalk = createNonRecursiveTreeWalk(commit)) {
assertTrue(treeWalk.next()); assertTrue(treeWalk.next());
assertEquals("folder", treeWalk.getPathString()); assertEquals("folder", treeWalk.getPathString());
assertTrue(treeWalk.next()); assertTrue(treeWalk.next());
assertEquals("folder", treeWalk.getPathString()); assertEquals("folder", treeWalk.getPathString());
assertTrue(treeWalk.isSubtree()); assertTrue(treeWalk.isSubtree());
treeWalk.enterSubtree(); treeWalk.enterSubtree();
assertTrue(treeWalk.next()); assertTrue(treeWalk.next());
assertEquals("folder/file", treeWalk.getPathString()); assertEquals("folder/file", treeWalk.getPathString());
assertFalse(treeWalk.next()); assertFalse(treeWalk.next());
}
} }
@Test @Test
public void testFileCommitted() throws Exception { public void testFileCommitted() throws Exception {
RevCommit commit = writeFileAndCommit(); RevCommit commit = writeFileAndCommit();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertFalse(treeWalk.next()); assertFalse(treeWalk.next());
}
} }
@Test @Test
@ -153,89 +156,100 @@ public class IndexDiffFilterTest extends RepositoryTestCase {
"<<<<<<< HEAD\nside\n=======\nmaster\n>>>>>>> master\n"); "<<<<<<< HEAD\nside\n=======\nmaster\n>>>>>>> master\n");
writeTrashFile(FILE, "master"); writeTrashFile(FILE, "master");
TreeWalk treeWalk = createTreeWalk(side); try (TreeWalk treeWalk = createTreeWalk(side)) {
int count = 0; int count = 0;
while (treeWalk.next()) while (treeWalk.next())
count++; count++;
assertEquals(2, count); assertEquals(2, count);
}
} }
@Test @Test
public void testFileInFolderCommitted() throws Exception { public void testFileInFolderCommitted() throws Exception {
RevCommit commit = writeFileInFolderAndCommit(); RevCommit commit = writeFileInFolderAndCommit();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertFalse(treeWalk.next()); assertFalse(treeWalk.next());
}
} }
@Test @Test
public void testEmptyFolderCommitted() throws Exception { public void testEmptyFolderCommitted() throws Exception {
RevCommit commit = createEmptyFolderAndCommit(); RevCommit commit = createEmptyFolderAndCommit();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertFalse(treeWalk.next()); assertFalse(treeWalk.next());
}
} }
@Test @Test
public void testFileCommittedChangedNotModified() throws Exception { public void testFileCommittedChangedNotModified() throws Exception {
RevCommit commit = writeFileAndCommit(); RevCommit commit = writeFileAndCommit();
writeFile(); writeFile();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertFalse(treeWalk.next()); assertFalse(treeWalk.next());
}
} }
@Test @Test
public void testFileInFolderCommittedChangedNotModified() throws Exception { public void testFileInFolderCommittedChangedNotModified() throws Exception {
RevCommit commit = writeFileInFolderAndCommit(); RevCommit commit = writeFileInFolderAndCommit();
writeFileInFolder(); writeFileInFolder();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertFalse(treeWalk.next()); assertFalse(treeWalk.next());
}
} }
@Test @Test
public void testFileCommittedModified() throws Exception { public void testFileCommittedModified() throws Exception {
RevCommit commit = writeFileAndCommit(); RevCommit commit = writeFileAndCommit();
writeFileModified(); writeFileModified();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertPaths(treeWalk, FILE); assertPaths(treeWalk, FILE);
}
} }
@Test @Test
public void testFileInFolderCommittedModified() throws Exception { public void testFileInFolderCommittedModified() throws Exception {
RevCommit commit = writeFileInFolderAndCommit(); RevCommit commit = writeFileInFolderAndCommit();
writeFileInFolderModified(); writeFileInFolderModified();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertPaths(treeWalk, FILE_IN_FOLDER); assertPaths(treeWalk, FILE_IN_FOLDER);
}
} }
@Test @Test
public void testFileCommittedDeleted() throws Exception { public void testFileCommittedDeleted() throws Exception {
RevCommit commit = writeFileAndCommit(); RevCommit commit = writeFileAndCommit();
deleteFile(); deleteFile();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertPaths(treeWalk, FILE); assertPaths(treeWalk, FILE);
}
} }
@Test @Test
public void testFileInFolderCommittedDeleted() throws Exception { public void testFileInFolderCommittedDeleted() throws Exception {
RevCommit commit = writeFileInFolderAndCommit(); RevCommit commit = writeFileInFolderAndCommit();
deleteFileInFolder(); deleteFileInFolder();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertPaths(treeWalk, FILE_IN_FOLDER); assertPaths(treeWalk, FILE_IN_FOLDER);
}
} }
@Test @Test
public void testFileInFolderCommittedAllDeleted() throws Exception { public void testFileInFolderCommittedAllDeleted() throws Exception {
RevCommit commit = writeFileInFolderAndCommit(); RevCommit commit = writeFileInFolderAndCommit();
deleteAll(); deleteAll();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertPaths(treeWalk, FILE_IN_FOLDER); assertPaths(treeWalk, FILE_IN_FOLDER);
}
} }
@Test @Test
public void testEmptyFolderCommittedDeleted() throws Exception { public void testEmptyFolderCommittedDeleted() throws Exception {
RevCommit commit = createEmptyFolderAndCommit(); RevCommit commit = createEmptyFolderAndCommit();
deleteFolder(); deleteFolder();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertFalse(treeWalk.next()); assertFalse(treeWalk.next());
}
} }
@Test @Test
@ -243,8 +257,9 @@ public class IndexDiffFilterTest extends RepositoryTestCase {
throws Exception { throws Exception {
RevCommit commit = writeFileAndCommit(); RevCommit commit = writeFileAndCommit();
writeFileModifiedAndCommit(); writeFileModifiedAndCommit();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertPaths(treeWalk, FILE); assertPaths(treeWalk, FILE);
}
} }
@Test @Test
@ -252,8 +267,9 @@ public class IndexDiffFilterTest extends RepositoryTestCase {
throws Exception { throws Exception {
RevCommit commit = writeFileInFolderAndCommit(); RevCommit commit = writeFileInFolderAndCommit();
writeFileInFolderModifiedAndCommit(); writeFileInFolderModifiedAndCommit();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertPaths(treeWalk, FILE_IN_FOLDER); assertPaths(treeWalk, FILE_IN_FOLDER);
}
} }
@Test @Test
@ -261,8 +277,9 @@ public class IndexDiffFilterTest extends RepositoryTestCase {
throws Exception { throws Exception {
RevCommit commit = writeFileAndCommit(); RevCommit commit = writeFileAndCommit();
deleteFileAndCommit(); deleteFileAndCommit();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertPaths(treeWalk, FILE); assertPaths(treeWalk, FILE);
}
} }
@Test @Test
@ -270,8 +287,9 @@ public class IndexDiffFilterTest extends RepositoryTestCase {
throws Exception { throws Exception {
RevCommit commit = writeFileInFolderAndCommit(); RevCommit commit = writeFileInFolderAndCommit();
deleteFileInFolderAndCommit(); deleteFileInFolderAndCommit();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertPaths(treeWalk, FILE_IN_FOLDER); assertPaths(treeWalk, FILE_IN_FOLDER);
}
} }
@Test @Test
@ -279,8 +297,9 @@ public class IndexDiffFilterTest extends RepositoryTestCase {
throws Exception { throws Exception {
RevCommit commit = writeFileInFolderAndCommit(); RevCommit commit = writeFileInFolderAndCommit();
deleteAllAndCommit(); deleteAllAndCommit();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertPaths(treeWalk, FILE_IN_FOLDER); assertPaths(treeWalk, FILE_IN_FOLDER);
}
} }
@Test @Test
@ -288,96 +307,108 @@ public class IndexDiffFilterTest extends RepositoryTestCase {
throws Exception { throws Exception {
RevCommit commit = createEmptyFolderAndCommit(); RevCommit commit = createEmptyFolderAndCommit();
deleteFolderAndCommit(); deleteFolderAndCommit();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertFalse(treeWalk.next()); assertFalse(treeWalk.next());
}
} }
@Test @Test
public void testFileUntracked() throws Exception { public void testFileUntracked() throws Exception {
RevCommit commit = writeFileAndCommit(); RevCommit commit = writeFileAndCommit();
writeFileUntracked(); writeFileUntracked();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertPaths(treeWalk, UNTRACKED_FILE); assertPaths(treeWalk, UNTRACKED_FILE);
}
} }
@Test @Test
public void testFileInFolderUntracked() throws Exception { public void testFileInFolderUntracked() throws Exception {
RevCommit commit = writeFileInFolderAndCommit(); RevCommit commit = writeFileInFolderAndCommit();
writeFileInFolderUntracked(); writeFileInFolderUntracked();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertPaths(treeWalk, UNTRACKED_FILE_IN_FOLDER); assertPaths(treeWalk, UNTRACKED_FILE_IN_FOLDER);
}
} }
@Test @Test
public void testEmptyFolderUntracked() throws Exception { public void testEmptyFolderUntracked() throws Exception {
RevCommit commit = createEmptyFolderAndCommit(); RevCommit commit = createEmptyFolderAndCommit();
createEmptyFolderUntracked(); createEmptyFolderUntracked();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertFalse(treeWalk.next()); assertFalse(treeWalk.next());
}
} }
@Test @Test
public void testFileIgnored() throws Exception { public void testFileIgnored() throws Exception {
RevCommit commit = writeFileAndCommit(); RevCommit commit = writeFileAndCommit();
writeFileIgnored(); writeFileIgnored();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertFalse(treeWalk.next()); assertFalse(treeWalk.next());
}
} }
@Test @Test
public void testFileInFolderIgnored() throws Exception { public void testFileInFolderIgnored() throws Exception {
RevCommit commit = writeFileInFolderAndCommit(); RevCommit commit = writeFileInFolderAndCommit();
writeFileInFolderIgnored(); writeFileInFolderIgnored();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertFalse(treeWalk.next()); assertFalse(treeWalk.next());
}
} }
@Test @Test
public void testFileInFolderAllIgnored() throws Exception { public void testFileInFolderAllIgnored() throws Exception {
RevCommit commit = writeFileInFolderAndCommit(); RevCommit commit = writeFileInFolderAndCommit();
writeFileInFolderAllIgnored(); writeFileInFolderAllIgnored();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertFalse(treeWalk.next()); assertFalse(treeWalk.next());
}
} }
@Test @Test
public void testEmptyFolderIgnored() throws Exception { public void testEmptyFolderIgnored() throws Exception {
RevCommit commit = createEmptyFolderAndCommit(); RevCommit commit = createEmptyFolderAndCommit();
createEmptyFolderIgnored(); createEmptyFolderIgnored();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertFalse(treeWalk.next()); assertFalse(treeWalk.next());
}
} }
@Test @Test
public void testFileIgnoredNotHonored() throws Exception { public void testFileIgnoredNotHonored() throws Exception {
RevCommit commit = writeFileAndCommit(); RevCommit commit = writeFileAndCommit();
writeFileIgnored(); writeFileIgnored();
TreeWalk treeWalk = createTreeWalkDishonorIgnores(commit); try (TreeWalk treeWalk = createTreeWalkDishonorIgnores(commit)) {
assertPaths(treeWalk, IGNORED_FILE, GITIGNORE); assertPaths(treeWalk, IGNORED_FILE, GITIGNORE);
}
} }
@Test @Test
public void testFileCommittedModifiedIgnored() throws Exception { public void testFileCommittedModifiedIgnored() throws Exception {
RevCommit commit = writeFileAndCommit(); RevCommit commit = writeFileAndCommit();
writeFileModifiedIgnored(); writeFileModifiedIgnored();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertPaths(treeWalk, FILE); assertPaths(treeWalk, FILE);
}
} }
@Test @Test
public void testFileInFolderCommittedModifiedIgnored() throws Exception { public void testFileInFolderCommittedModifiedIgnored() throws Exception {
RevCommit commit = writeFileInFolderAndCommit(); RevCommit commit = writeFileInFolderAndCommit();
writeFileInFolderModifiedIgnored(); writeFileInFolderModifiedIgnored();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertPaths(treeWalk, FILE_IN_FOLDER); assertPaths(treeWalk, FILE_IN_FOLDER);
}
} }
@Test @Test
public void testFileInFolderCommittedModifiedAllIgnored() throws Exception { public void testFileInFolderCommittedModifiedAllIgnored() throws Exception {
RevCommit commit = writeFileInFolderAndCommit(); RevCommit commit = writeFileInFolderAndCommit();
writeFileInFolderModifiedAllIgnored(); writeFileInFolderModifiedAllIgnored();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertPaths(treeWalk, FILE_IN_FOLDER); assertPaths(treeWalk, FILE_IN_FOLDER);
}
} }
@Test @Test
@ -386,8 +417,9 @@ public class IndexDiffFilterTest extends RepositoryTestCase {
RevCommit commit = writeFileAndCommit(); RevCommit commit = writeFileAndCommit();
deleteFileAndCommit(); deleteFileAndCommit();
rewriteFileIgnored(); rewriteFileIgnored();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertPaths(treeWalk, FILE); assertPaths(treeWalk, FILE);
}
} }
@Test @Test
@ -396,8 +428,9 @@ public class IndexDiffFilterTest extends RepositoryTestCase {
RevCommit commit = writeFileInFolderAndCommit(); RevCommit commit = writeFileInFolderAndCommit();
deleteFileInFolderAndCommit(); deleteFileInFolderAndCommit();
rewriteFileInFolderIgnored(); rewriteFileInFolderIgnored();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertPaths(treeWalk, FILE_IN_FOLDER); assertPaths(treeWalk, FILE_IN_FOLDER);
}
} }
@Test @Test
@ -406,8 +439,9 @@ public class IndexDiffFilterTest extends RepositoryTestCase {
RevCommit commit = writeFileInFolderAndCommit(); RevCommit commit = writeFileInFolderAndCommit();
deleteAllAndCommit(); deleteAllAndCommit();
rewriteFileInFolderAllIgnored(); rewriteFileInFolderAllIgnored();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertPaths(treeWalk, FILE_IN_FOLDER); assertPaths(treeWalk, FILE_IN_FOLDER);
}
} }
@Test @Test
@ -416,15 +450,17 @@ public class IndexDiffFilterTest extends RepositoryTestCase {
RevCommit commit = createEmptyFolderAndCommit(); RevCommit commit = createEmptyFolderAndCommit();
deleteFolderAndCommit(); deleteFolderAndCommit();
recreateEmptyFolderIgnored(); recreateEmptyFolderIgnored();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertFalse(treeWalk.next()); assertFalse(treeWalk.next());
}
} }
@Test @Test
public void testFileInFolderCommittedNonRecursive() throws Exception { public void testFileInFolderCommittedNonRecursive() throws Exception {
RevCommit commit = writeFileInFolderAndCommit(); RevCommit commit = writeFileInFolderAndCommit();
TreeWalk treeWalk = createNonRecursiveTreeWalk(commit); try (TreeWalk treeWalk = createNonRecursiveTreeWalk(commit)) {
assertPaths(treeWalk, FOLDER); assertPaths(treeWalk, FOLDER);
}
} }
@Test @Test
@ -432,8 +468,9 @@ public class IndexDiffFilterTest extends RepositoryTestCase {
RevCommit commit = writeFileInFolderAndCommit(); RevCommit commit = writeFileInFolderAndCommit();
deleteAll(); deleteAll();
writeFileWithFolderName(); writeFileWithFolderName();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertPaths(treeWalk, FOLDER, FILE_IN_FOLDER); assertPaths(treeWalk, FOLDER, FILE_IN_FOLDER);
}
} }
@Test @Test
@ -442,8 +479,9 @@ public class IndexDiffFilterTest extends RepositoryTestCase {
RevCommit commit = writeFileInFolderAndCommit(); RevCommit commit = writeFileInFolderAndCommit();
deleteAll(); deleteAll();
writeFileWithFolderNameAndCommit(); writeFileWithFolderNameAndCommit();
TreeWalk treeWalk = createTreeWalk(commit); try (TreeWalk treeWalk = createTreeWalk(commit)) {
assertPaths(treeWalk, FOLDER, FILE_IN_FOLDER); assertPaths(treeWalk, FOLDER, FILE_IN_FOLDER);
}
} }
private void writeFile() throws Exception { private void writeFile() throws Exception {

Write Preview
Loading…
Cancel
Save