motiejus
/
jgit
1
Fork 0
Code Releases Activity

Merge changes I6e022e4a,If1b9d808 

* changes:
  Close TreeWalks in tests
  Close SubmoduleWalks in tests
This commit is contained in:
David Pursehouse 2019-10-15 20:11:35 -04:00 committed by Gerrit Code Review @ Eclipse.org
parent 101b8ea58f 563ec9ecb6
commit 51b24ea17c
20 changed files with 1033 additions and 908 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CloneCommandTest.java
View File

@ -646,25 +646,27 @@ public void testCloneRepositoryWithNestedSubmodules() throws Exception {
assertEquals(sub1Head, pathStatus.getHeadId());
assertEquals(sub1Head, pathStatus.getIndexId());
SubmoduleWalk walk = SubmoduleWalk.forIndex(git2.getRepository());
assertTrue(walk.next());
try (Repository clonedSub1 = walk.getRepository()) {
assertNotNull(clonedSub1);
assertEquals(new File(git2.getRepository().getWorkTree(),
walk.getPath()), clonedSub1.getWorkTree());
assertEquals(
new File(new File(git2.getRepository().getDirectory(),
"modules"), walk.getPath()),
clonedSub1.getDirectory());
status = new SubmoduleStatusCommand(clonedSub1);
statuses = status.call();
try (SubmoduleWalk walk = SubmoduleWalk
.forIndex(git2.getRepository())) {
assertTrue(walk.next());
try (Repository clonedSub1 = walk.getRepository()) {
assertNotNull(clonedSub1);
assertEquals(new File(git2.getRepository().getWorkTree(),
walk.getPath()), clonedSub1.getWorkTree());
assertEquals(
new File(new File(git2.getRepository().getDirectory(),
"modules"), walk.getPath()),
clonedSub1.getDirectory());
status = new SubmoduleStatusCommand(clonedSub1);
statuses = status.call();
}
assertFalse(walk.next());
}
pathStatus = statuses.get(path);
assertNotNull(pathStatus);
assertEquals(SubmoduleStatusType.INITIALIZED, pathStatus.getType());
assertEquals(sub2Head, pathStatus.getHeadId());
assertEquals(sub2Head, pathStatus.getIndexId());
assertFalse(walk.next());
}
@Test

52
org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CommitCommandTest.java
View File

@ -148,9 +148,10 @@ public boolean isCaseSensitive() {
writeTrashFile(path, "content");
git.add().addFilepattern(path).call();
RevCommit commit1 = git.commit().setMessage("commit").call();
TreeWalk walk = TreeWalk.forPath(db, path, commit1.getTree());
assertNotNull(walk);
assertEquals(FileMode.EXECUTABLE_FILE, walk.getFileMode(0));
try (TreeWalk walk = TreeWalk.forPath(db, path, commit1.getTree())) {
assertNotNull(walk);
assertEquals(FileMode.EXECUTABLE_FILE, walk.getFileMode(0));
}
FS nonExecutableFs = new FS() {
@ -204,9 +205,10 @@ public boolean isCaseSensitive() {
writeTrashFile(path, "content2");
RevCommit commit2 = git2.commit().setOnly(path).setMessage("commit2")
.call();
walk = TreeWalk.forPath(db, path, commit2.getTree());
assertNotNull(walk);
assertEquals(FileMode.EXECUTABLE_FILE, walk.getFileMode(0));
try (TreeWalk walk = TreeWalk.forPath(db, path, commit2.getTree())) {
assertNotNull(walk);
assertEquals(FileMode.EXECUTABLE_FILE, walk.getFileMode(0));
}
}
@Test
@ -225,15 +227,16 @@ public void commitNewSubmodule() throws Exception {
assertNotNull(repo);
addRepoToClose(repo);
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
assertEquals(path, generator.getPath());
assertEquals(commit, generator.getObjectId());
assertEquals(uri, generator.getModulesUrl());
assertEquals(path, generator.getModulesPath());
assertEquals(uri, generator.getConfigUrl());
try (Repository subModRepo = generator.getRepository()) {
assertNotNull(subModRepo);
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
assertEquals(path, generator.getPath());
assertEquals(commit, generator.getObjectId());
assertEquals(uri, generator.getModulesUrl());
assertEquals(path, generator.getModulesPath());
assertEquals(uri, generator.getConfigUrl());
try (Repository subModRepo = generator.getRepository()) {
assertNotNull(subModRepo);
}
}
assertEquals(commit, repo.resolve(Constants.HEAD));
@ -275,15 +278,16 @@ public void commitSubmoduleUpdate() throws Exception {
assertNotNull(repo);
addRepoToClose(repo);
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
assertEquals(path, generator.getPath());
assertEquals(commit2, generator.getObjectId());
assertEquals(uri, generator.getModulesUrl());
assertEquals(path, generator.getModulesPath());
assertEquals(uri, generator.getConfigUrl());
try (Repository subModRepo = generator.getRepository()) {
assertNotNull(subModRepo);
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
assertEquals(path, generator.getPath());
assertEquals(commit2, generator.getObjectId());
assertEquals(uri, generator.getModulesUrl());
assertEquals(path, generator.getModulesPath());
assertEquals(uri, generator.getConfigUrl());
try (Repository subModRepo = generator.getRepository()) {
assertNotNull(subModRepo);
}
}
assertEquals(commit2, repo.resolve(Constants.HEAD));

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

@ -142,8 +142,6 @@ public EolRepositoryTest(String[] testContent, boolean smudgeEntries) {
protected String CONTENT_MIXED;
private TreeWalk walk;
/** work tree root .gitattributes */
private File dotGitattributes;
@ -689,27 +687,25 @@ private File createAndAddFile(Git git, String path, String content)
private void collectRepositoryState() throws Exception {
dirCache = db.readDirCache();
walk = beginWalk();
if (dotGitattributes != null)
collectEntryContentAndAttributes(F, ".gitattributes", null);
collectEntryContentAndAttributes(F, fileCRLF.getName(), entryCRLF);
collectEntryContentAndAttributes(F, fileLF.getName(), entryLF);
collectEntryContentAndAttributes(F, fileMixed.getName(), entryMixed);
endWalk();
try (TreeWalk walk = new TreeWalk(db)) {
walk.addTree(new FileTreeIterator(db));
walk.addTree(new DirCacheIterator(db.readDirCache()));
if (dotGitattributes != null) {
collectEntryContentAndAttributes(walk, F, ".gitattributes",
null);
}
collectEntryContentAndAttributes(walk, F, fileCRLF.getName(),
entryCRLF);
collectEntryContentAndAttributes(walk, F, fileLF.getName(),
entryLF);
collectEntryContentAndAttributes(walk, F, fileMixed.getName(),
entryMixed);
assertFalse("Not all files tested", walk.next());
}
}
private TreeWalk beginWalk() throws Exception {
TreeWalk newWalk = new TreeWalk(db);
newWalk.addTree(new FileTreeIterator(db));
newWalk.addTree(new DirCacheIterator(db.readDirCache()));
return newWalk;
}
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 {
assertTrue("walk has entry", walk.next());

21
org.eclipse.jgit.test/tst/org/eclipse/jgit/api/FetchAndPullCommandsRecurseSubmodulesTest.java
View File

@ -343,19 +343,22 @@ private FetchResult execute(FetchRecurseSubmodulesMode mode, boolean fetch)
private void assertSubmoduleFetchHeads(ObjectId expectedHead1,
ObjectId expectedHead2) throws Exception {
Object newHead1 = null;
ObjectId newHead2 = null;
try (SubmoduleWalk walk = SubmoduleWalk
.forIndex(git2.getRepository())) {
assertTrue(walk.next());
Repository r = walk.getRepository();
ObjectId newHead1 = r.resolve(Constants.FETCH_HEAD);
ObjectId newHead2;
try (SubmoduleWalk walk2 = SubmoduleWalk.forIndex(r)) {
assertTrue(walk2.next());
newHead2 = walk2.getRepository().resolve(Constants.FETCH_HEAD);
try (Repository r = walk.getRepository()) {
newHead1 = r.resolve(Constants.FETCH_HEAD);
try (SubmoduleWalk walk2 = SubmoduleWalk.forIndex(r)) {
assertTrue(walk2.next());
try (Repository r2 = walk2.getRepository()) {
newHead2 = r2.resolve(Constants.FETCH_HEAD);
}
}
}
assertEquals(expectedHead1, newHead1);
assertEquals(expectedHead2, newHead2);
}
assertEquals(expectedHead1, newHead1);
assertEquals(expectedHead2, newHead2);
}
}

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

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

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

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

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

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

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

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

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

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

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

89
org.eclipse.jgit.test/tst/org/eclipse/jgit/submodule/SubmoduleAddTest.java
View File

@ -135,20 +135,20 @@ public void addSubmodule() throws Exception {
subCommit = repo.resolve(Constants.HEAD);
}
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
generator.loadModulesConfig();
assertTrue(generator.next());
assertEquals(path, generator.getModuleName());
assertEquals(path, generator.getPath());
assertEquals(commit, generator.getObjectId());
assertEquals(uri, generator.getModulesUrl());
assertEquals(path, generator.getModulesPath());
assertEquals(uri, generator.getConfigUrl());
try (Repository subModRepo = generator.getRepository()) {
assertNotNull(subModRepo);
assertEquals(subCommit, commit);
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
generator.loadModulesConfig();
assertTrue(generator.next());
assertEquals(path, generator.getModuleName());
assertEquals(path, generator.getPath());
assertEquals(commit, generator.getObjectId());
assertEquals(uri, generator.getModulesUrl());
assertEquals(path, generator.getModulesPath());
assertEquals(uri, generator.getConfigUrl());
try (Repository subModRepo = generator.getRepository()) {
assertNotNull(subModRepo);
assertEquals(subCommit, commit);
}
}
Status status = Git.wrap(db).status().call();
assertTrue(status.getAdded().contains(Constants.DOT_GIT_MODULES));
assertTrue(status.getAdded().contains(path));
@ -175,20 +175,20 @@ public void addSubmoduleWithName() throws Exception {
subCommit = repo.resolve(Constants.HEAD);
}
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
generator.loadModulesConfig();
assertTrue(generator.next());
assertEquals(name, generator.getModuleName());
assertEquals(path, generator.getPath());
assertEquals(commit, generator.getObjectId());
assertEquals(uri, generator.getModulesUrl());
assertEquals(path, generator.getModulesPath());
assertEquals(uri, generator.getConfigUrl());
try (Repository subModRepo = generator.getRepository()) {
assertNotNull(subModRepo);
assertEquals(subCommit, commit);
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
generator.loadModulesConfig();
assertTrue(generator.next());
assertEquals(name, generator.getModuleName());
assertEquals(path, generator.getPath());
assertEquals(commit, generator.getObjectId());
assertEquals(uri, generator.getModulesUrl());
assertEquals(path, generator.getModulesPath());
assertEquals(uri, generator.getConfigUrl());
try (Repository subModRepo = generator.getRepository()) {
assertNotNull(subModRepo);
assertEquals(subCommit, commit);
}
}
Status status = Git.wrap(db).status().call();
assertTrue(status.getAdded().contains(Constants.DOT_GIT_MODULES));
assertTrue(status.getAdded().contains(path));
@ -269,24 +269,25 @@ public void addSubmoduleWithRelativeUri() throws Exception {
assertNotNull(repo);
addRepoToClose(repo);
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
assertEquals(path, generator.getPath());
assertEquals(commit, generator.getObjectId());
assertEquals(uri, generator.getModulesUrl());
assertEquals(path, generator.getModulesPath());
String fullUri = db.getDirectory().getAbsolutePath();
if (File.separatorChar == '\\') {
fullUri = fullUri.replace('\\', '/');
}
assertEquals(fullUri, generator.getConfigUrl());
try (Repository subModRepo = generator.getRepository()) {
assertNotNull(subModRepo);
assertEquals(fullUri,
subModRepo.getConfig().getString(
ConfigConstants.CONFIG_REMOTE_SECTION,
Constants.DEFAULT_REMOTE_NAME,
ConfigConstants.CONFIG_KEY_URL));
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
assertEquals(path, generator.getPath());
assertEquals(commit, generator.getObjectId());
assertEquals(uri, generator.getModulesUrl());
assertEquals(path, generator.getModulesPath());
String fullUri = db.getDirectory().getAbsolutePath();
if (File.separatorChar == '\\') {
fullUri = fullUri.replace('\\', '/');
}
assertEquals(fullUri, generator.getConfigUrl());
try (Repository subModRepo = generator.getRepository()) {
assertNotNull(subModRepo);
assertEquals(fullUri,
subModRepo.getConfig().getString(
ConfigConstants.CONFIG_REMOTE_SECTION,
Constants.DEFAULT_REMOTE_NAME,
ConfigConstants.CONFIG_KEY_URL));
}
}
assertEquals(commit, repo.resolve(Constants.HEAD));

51
org.eclipse.jgit.test/tst/org/eclipse/jgit/submodule/SubmoduleDeinitTest.java
View File

@ -107,7 +107,6 @@ public void dirtySubmoduleBecauseUntracked() throws Exception {
assertEquals(1, updated.size());
File submoduleDir = assertSubmoduleIsInitialized();
SubmoduleWalk generator;
write(new File(submoduleDir, "untracked"), "untracked");
@ -115,8 +114,9 @@ public void dirtySubmoduleBecauseUntracked() throws Exception {
assertEquals(path, result.getPath());
assertEquals(SubmoduleDeinitCommand.SubmoduleDeinitStatus.DIRTY, result.getStatus());
generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
}
assertTrue(submoduleDir.isDirectory());
assertNotEquals(0, submoduleDir.list().length);
}
@ -132,33 +132,36 @@ public void dirtySubmoduleBecauseNewCommit() throws Exception {
assertEquals(1, updated.size());
File submoduleDir = assertSubmoduleIsInitialized();
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
generator.next();
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
generator.next();
//want to create a commit inside the repo...
try (Repository submoduleLocalRepo = generator.getRepository()) {
JGitTestUtil.writeTrashFile(submoduleLocalRepo, "file.txt",
"new data");
Git.wrap(submoduleLocalRepo).commit().setAll(true)
.setMessage("local commit").call();
// want to create a commit inside the repo...
try (Repository submoduleLocalRepo = generator.getRepository()) {
JGitTestUtil.writeTrashFile(submoduleLocalRepo, "file.txt",
"new data");
Git.wrap(submoduleLocalRepo).commit().setAll(true)
.setMessage("local commit").call();
}
}
SubmoduleDeinitResult result = runDeinit(new SubmoduleDeinitCommand(db).addPath("sub"));
assertEquals(path, result.getPath());
assertEquals(SubmoduleDeinitCommand.SubmoduleDeinitStatus.DIRTY, result.getStatus());
generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
}
assertTrue(submoduleDir.isDirectory());
assertNotEquals(0, submoduleDir.list().length);
}
private File assertSubmoduleIsInitialized() throws IOException {
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
File submoduleDir = new File(db.getWorkTree(), generator.getPath());
assertTrue(submoduleDir.isDirectory());
assertNotEquals(0, submoduleDir.list().length);
return submoduleDir;
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
File submoduleDir = new File(db.getWorkTree(), generator.getPath());
assertTrue(submoduleDir.isDirectory());
assertNotEquals(0, submoduleDir.list().length);
return submoduleDir;
}
}
@Test
@ -180,8 +183,9 @@ public void dirtySubmoduleWithForce() throws Exception {
assertEquals(path, result.getPath());
assertEquals(SubmoduleDeinitCommand.SubmoduleDeinitStatus.FORCED, result.getStatus());
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
}
assertTrue(submoduleDir.isDirectory());
assertEquals(0, submoduleDir.list().length);
}
@ -202,8 +206,9 @@ public void cleanSubmodule() throws Exception {
assertEquals(path, result.getPath());
assertEquals(SubmoduleDeinitCommand.SubmoduleDeinitStatus.SUCCESS, result.getStatus());
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
}
assertTrue(submoduleDir.isDirectory());
assertEquals(0, submoduleDir.list().length);
}

106
org.eclipse.jgit.test/tst/org/eclipse/jgit/submodule/SubmoduleInitTest.java
View File

@ -86,11 +86,11 @@ public void repositoryWithUninitializedModule() throws IOException,
ConfigInvalidException, GitAPIException {
final String path = addSubmoduleToIndex();
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
assertNull(generator.getConfigUrl());
assertNull(generator.getConfigUpdate());
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
assertNull(generator.getConfigUrl());
assertNull(generator.getConfigUpdate());
}
FileBasedConfig modulesConfig = new FileBasedConfig(new File(
db.getWorkTree(), Constants.DOT_GIT_MODULES), db.getFS());
modulesConfig.setString(ConfigConstants.CONFIG_SUBMODULE_SECTION, path,
@ -109,10 +109,11 @@ public void repositoryWithUninitializedModule() throws IOException,
assertEquals(1, modules.size());
assertEquals(path, modules.iterator().next());
generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
assertEquals(url, generator.getConfigUrl());
assertEquals(update, generator.getConfigUpdate());
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
assertEquals(url, generator.getConfigUrl());
assertEquals(update, generator.getConfigUpdate());
}
}
@Test
@ -126,11 +127,11 @@ public void resolveSameLevelRelativeUrl() throws Exception {
base);
config.save();
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
assertNull(generator.getConfigUrl());
assertNull(generator.getConfigUpdate());
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
assertNull(generator.getConfigUrl());
assertNull(generator.getConfigUpdate());
}
FileBasedConfig modulesConfig = new FileBasedConfig(new File(
db.getWorkTree(), Constants.DOT_GIT_MODULES), db.getFS());
modulesConfig.setString(ConfigConstants.CONFIG_SUBMODULE_SECTION, path,
@ -149,10 +150,12 @@ public void resolveSameLevelRelativeUrl() throws Exception {
assertEquals(1, modules.size());
assertEquals(path, modules.iterator().next());
generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
assertEquals("git://server/repo.git/sub.git", generator.getConfigUrl());
assertEquals(update, generator.getConfigUpdate());
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
assertEquals("git://server/repo.git/sub.git",
generator.getConfigUrl());
assertEquals(update, generator.getConfigUpdate());
}
}
@Test
@ -167,11 +170,11 @@ public void resolveOneLevelHigherRelativeUrl() throws IOException,
base);
config.save();
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
assertNull(generator.getConfigUrl());
assertNull(generator.getConfigUpdate());
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
assertNull(generator.getConfigUrl());
assertNull(generator.getConfigUpdate());
}
FileBasedConfig modulesConfig = new FileBasedConfig(new File(
db.getWorkTree(), Constants.DOT_GIT_MODULES), db.getFS());
modulesConfig.setString(ConfigConstants.CONFIG_SUBMODULE_SECTION, path,
@ -190,10 +193,11 @@ public void resolveOneLevelHigherRelativeUrl() throws IOException,
assertEquals(1, modules.size());
assertEquals(path, modules.iterator().next());
generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
assertEquals("git://server/sub.git", generator.getConfigUrl());
assertEquals(update, generator.getConfigUpdate());
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
assertEquals("git://server/sub.git", generator.getConfigUrl());
assertEquals(update, generator.getConfigUpdate());
}
}
@Test
@ -208,11 +212,11 @@ public void resolveTwoLevelHigherRelativeUrl() throws IOException,
base);
config.save();
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
assertNull(generator.getConfigUrl());
assertNull(generator.getConfigUpdate());
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
assertNull(generator.getConfigUrl());
assertNull(generator.getConfigUpdate());
}
FileBasedConfig modulesConfig = new FileBasedConfig(new File(
db.getWorkTree(), Constants.DOT_GIT_MODULES), db.getFS());
modulesConfig.setString(ConfigConstants.CONFIG_SUBMODULE_SECTION, path,
@ -231,10 +235,11 @@ public void resolveTwoLevelHigherRelativeUrl() throws IOException,
assertEquals(1, modules.size());
assertEquals(path, modules.iterator().next());
generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
assertEquals("git://server2/sub.git", generator.getConfigUrl());
assertEquals(update, generator.getConfigUpdate());
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
assertEquals("git://server2/sub.git", generator.getConfigUrl());
assertEquals(update, generator.getConfigUpdate());
}
}
@Test
@ -250,11 +255,11 @@ public void resolveWorkingDirectoryRelativeUrl() throws IOException,
Constants.DEFAULT_REMOTE_NAME, ConfigConstants.CONFIG_KEY_URL);
config.save();
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
assertNull(generator.getConfigUrl());
assertNull(generator.getConfigUpdate());
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
assertNull(generator.getConfigUrl());
assertNull(generator.getConfigUpdate());
}
FileBasedConfig modulesConfig = new FileBasedConfig(new File(
db.getWorkTree(), Constants.DOT_GIT_MODULES), db.getFS());
modulesConfig.setString(ConfigConstants.CONFIG_SUBMODULE_SECTION, path,
@ -273,10 +278,11 @@ public void resolveWorkingDirectoryRelativeUrl() throws IOException,
assertEquals(1, modules.size());
assertEquals(path, modules.iterator().next());
generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
assertEquals(base + "/sub.git", generator.getConfigUrl());
assertEquals(update, generator.getConfigUpdate());
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
assertEquals(base + "/sub.git", generator.getConfigUrl());
assertEquals(update, generator.getConfigUpdate());
}
}
@Test
@ -291,11 +297,11 @@ public void resolveInvalidParentUrl() throws IOException,
base);
config.save();
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
assertNull(generator.getConfigUrl());
assertNull(generator.getConfigUpdate());
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
assertNull(generator.getConfigUrl());
assertNull(generator.getConfigUpdate());
}
FileBasedConfig modulesConfig = new FileBasedConfig(new File(
db.getWorkTree(), Constants.DOT_GIT_MODULES), db.getFS());
modulesConfig.setString(ConfigConstants.CONFIG_SUBMODULE_SECTION, path,

62
org.eclipse.jgit.test/tst/org/eclipse/jgit/submodule/SubmoduleSyncTest.java
View File

@ -119,11 +119,11 @@ public void apply(DirCacheEntry ent) {
addRepoToClose(subRepo);
assertNotNull(subRepo);
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
assertNull(generator.getConfigUrl());
assertEquals(url, generator.getModulesUrl());
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
assertNull(generator.getConfigUrl());
assertEquals(url, generator.getModulesUrl());
}
SubmoduleSyncCommand command = new SubmoduleSyncCommand(db);
Map<String, String> synced = command.call();
assertNotNull(synced);
@ -132,16 +132,17 @@ public void apply(DirCacheEntry ent) {
assertEquals(path, module.getKey());
assertEquals(url, module.getValue());
generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
assertEquals(url, generator.getConfigUrl());
try (Repository subModRepository = generator.getRepository()) {
StoredConfig submoduleConfig = subModRepository.getConfig();
assertEquals(url,
submoduleConfig.getString(
ConfigConstants.CONFIG_REMOTE_SECTION,
Constants.DEFAULT_REMOTE_NAME,
ConfigConstants.CONFIG_KEY_URL));
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
assertEquals(url, generator.getConfigUrl());
try (Repository subModRepository = generator.getRepository()) {
StoredConfig submoduleConfig = subModRepository.getConfig();
assertEquals(url,
submoduleConfig.getString(
ConfigConstants.CONFIG_REMOTE_SECTION,
Constants.DEFAULT_REMOTE_NAME,
ConfigConstants.CONFIG_KEY_URL));
}
}
}
@ -190,11 +191,11 @@ public void apply(DirCacheEntry ent) {
assertNotNull(subRepo);
addRepoToClose(subRepo);
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
assertNull(generator.getConfigUrl());
assertEquals(current, generator.getModulesUrl());
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
assertNull(generator.getConfigUrl());
assertEquals(current, generator.getModulesUrl());
}
modulesConfig.setString(ConfigConstants.CONFIG_SUBMODULE_SECTION, path,
ConfigConstants.CONFIG_KEY_URL, "../sub.git");
modulesConfig.save();
@ -207,16 +208,17 @@ public void apply(DirCacheEntry ent) {
assertEquals(path, module.getKey());
assertEquals("git://server/sub.git", module.getValue());
generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
assertEquals("git://server/sub.git", generator.getConfigUrl());
try (Repository subModRepository1 = generator.getRepository()) {
StoredConfig submoduleConfig = subModRepository1.getConfig();
assertEquals("git://server/sub.git",
submoduleConfig.getString(
ConfigConstants.CONFIG_REMOTE_SECTION,
Constants.DEFAULT_REMOTE_NAME,
ConfigConstants.CONFIG_KEY_URL));
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
assertEquals("git://server/sub.git", generator.getConfigUrl());
try (Repository subModRepository1 = generator.getRepository()) {
StoredConfig submoduleConfig = subModRepository1.getConfig();
assertEquals("git://server/sub.git",
submoduleConfig.getString(
ConfigConstants.CONFIG_REMOTE_SECTION,
Constants.DEFAULT_REMOTE_NAME,
ConfigConstants.CONFIG_KEY_URL));
}
}
}
}

18
org.eclipse.jgit.test/tst/org/eclipse/jgit/submodule/SubmoduleUpdateTest.java
View File

@ -119,11 +119,12 @@ public void apply(DirCacheEntry ent) {
assertEquals(1, updated.size());
assertEquals(path, updated.iterator().next());
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
assertTrue(generator.next());
try (Repository subRepo = generator.getRepository()) {
assertNotNull(subRepo);
assertEquals(commit, subRepo.resolve(Constants.HEAD));
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(db)) {
assertTrue(generator.next());
try (Repository subRepo = generator.getRepository()) {
assertNotNull(subRepo);
assertEquals(commit, subRepo.resolve(Constants.HEAD));
}
}
}
@ -181,10 +182,11 @@ public void apply(DirCacheEntry ent) {
});
editor.commit();
Repository subRepo = Git.init().setBare(false)
try (Repository subRepo = Git.init().setBare(false)
.setDirectory(new File(db.getWorkTree(), path)).call()
.getRepository();
assertNotNull(subRepo);
.getRepository()) {
assertNotNull(subRepo);
}
SubmoduleUpdateCommand command = new SubmoduleUpdateCommand(db);
Collection<String> updated = command.call();

239
org.eclipse.jgit.test/tst/org/eclipse/jgit/submodule/SubmoduleWalkTest.java
View File

@ -98,10 +98,11 @@ public void setUp() throws Exception {
@Test
public void repositoryWithNoSubmodules() throws IOException {
SubmoduleWalk gen = SubmoduleWalk.forIndex(db);
assertFalse(gen.next());
assertNull(gen.getPath());
assertEquals(ObjectId.zeroId(), gen.getObjectId());
try (SubmoduleWalk gen = SubmoduleWalk.forIndex(db)) {
assertFalse(gen.next());
assertNull(gen.getPath());
assertEquals(ObjectId.zeroId(), gen.getObjectId());
}
}
@Test
@ -129,20 +130,21 @@ public void apply(DirCacheEntry ent) {
});
editor.commit();
SubmoduleWalk gen = SubmoduleWalk.forIndex(db);
assertTrue(gen.next());
assertEquals(path, gen.getPath());
assertEquals(id, gen.getObjectId());
assertEquals(new File(db.getWorkTree(), path), gen.getDirectory());
assertNull(gen.getConfigUpdate());
assertNull(gen.getConfigUrl());
assertNull(gen.getModulesPath());
assertNull(gen.getModulesUpdate());
assertNull(gen.getModulesUrl());
assertNull(gen.getRepository());
try (SubmoduleWalk gen = SubmoduleWalk.forIndex(db)) {
assertTrue(gen.next());
assertEquals(path, gen.getPath());
assertEquals(id, gen.getObjectId());
assertEquals(new File(db.getWorkTree(), path), gen.getDirectory());
assertNull(gen.getConfigUpdate());
assertNull(gen.getConfigUrl());
assertNull(gen.getModulesPath());
assertNull(gen.getModulesUpdate());
assertNull(gen.getModulesUrl());
assertNull(gen.getRepository());
assertFalse(gen.next());
}
Status status = Git.wrap(db).status().call();
assertTrue(!status.isClean());
assertFalse(gen.next());
assertFalse(status.isClean());
}
@Test
@ -178,24 +180,25 @@ public void apply(DirCacheEntry ent) {
});
editor.commit();
SubmoduleWalk gen = SubmoduleWalk.forIndex(db);
assertTrue(gen.next());
assertEquals(path, gen.getPath());
assertEquals(id, gen.getObjectId());
assertEquals(new File(db.getWorkTree(), path), gen.getDirectory());
assertNull(gen.getConfigUpdate());
assertNull(gen.getConfigUrl());
assertNull(gen.getModulesPath());
assertNull(gen.getModulesUpdate());
assertNull(gen.getModulesUrl());
try (Repository subRepo = gen.getRepository()) {
assertNotNull(subRepo);
assertEquals(modulesGitDir.getAbsolutePath(),
subRepo.getDirectory().getAbsolutePath());
assertEquals(new File(db.getWorkTree(), path).getAbsolutePath(),
subRepo.getWorkTree().getAbsolutePath());
try (SubmoduleWalk gen = SubmoduleWalk.forIndex(db)) {
assertTrue(gen.next());
assertEquals(path, gen.getPath());
assertEquals(id, gen.getObjectId());
assertEquals(new File(db.getWorkTree(), path), gen.getDirectory());
assertNull(gen.getConfigUpdate());
assertNull(gen.getConfigUrl());
assertNull(gen.getModulesPath());
assertNull(gen.getModulesUpdate());
assertNull(gen.getModulesUrl());
try (Repository subRepo = gen.getRepository()) {
assertNotNull(subRepo);
assertEquals(modulesGitDir.getAbsolutePath(),
subRepo.getDirectory().getAbsolutePath());
assertEquals(new File(db.getWorkTree(), path).getAbsolutePath(),
subRepo.getWorkTree().getAbsolutePath());
}
assertFalse(gen.next());
}
assertFalse(gen.next());
}
@Test
@ -232,23 +235,24 @@ public void apply(DirCacheEntry ent) {
});
editor.commit();
SubmoduleWalk gen = SubmoduleWalk.forIndex(db);
assertTrue(gen.next());
assertEquals(path, gen.getPath());
assertEquals(id, gen.getObjectId());
assertEquals(new File(db.getWorkTree(), path), gen.getDirectory());
assertNull(gen.getConfigUpdate());
assertNull(gen.getConfigUrl());
assertNull(gen.getModulesPath());
assertNull(gen.getModulesUpdate());
assertNull(gen.getModulesUrl());
try (Repository subRepo = gen.getRepository()) {
assertNotNull(subRepo);
assertEqualsFile(modulesGitDir, subRepo.getDirectory());
assertEqualsFile(new File(db.getWorkTree(), path),
subRepo.getWorkTree());
subRepo.close();
assertFalse(gen.next());
try (SubmoduleWalk gen = SubmoduleWalk.forIndex(db)) {
assertTrue(gen.next());
assertEquals(path, gen.getPath());
assertEquals(id, gen.getObjectId());
assertEquals(new File(db.getWorkTree(), path), gen.getDirectory());
assertNull(gen.getConfigUpdate());
assertNull(gen.getConfigUrl());
assertNull(gen.getModulesPath());
assertNull(gen.getModulesUpdate());
assertNull(gen.getModulesUrl());
try (Repository subRepo = gen.getRepository()) {
assertNotNull(subRepo);
assertEqualsFile(modulesGitDir, subRepo.getDirectory());
assertEqualsFile(new File(db.getWorkTree(), path),
subRepo.getWorkTree());
subRepo.close();
assertFalse(gen.next());
}
}
}
@ -270,18 +274,19 @@ public void apply(DirCacheEntry ent) {
});
editor.commit();
SubmoduleWalk gen = SubmoduleWalk.forIndex(db);
assertTrue(gen.next());
assertEquals(path, gen.getPath());
assertEquals(id, gen.getObjectId());
assertEquals(new File(db.getWorkTree(), path), gen.getDirectory());
assertNull(gen.getConfigUpdate());
assertNull(gen.getConfigUrl());
assertNull(gen.getModulesPath());
assertNull(gen.getModulesUpdate());
assertNull(gen.getModulesUrl());
assertNull(gen.getRepository());
assertFalse(gen.next());
try (SubmoduleWalk gen = SubmoduleWalk.forIndex(db)) {
assertTrue(gen.next());
assertEquals(path, gen.getPath());
assertEquals(id, gen.getObjectId());
assertEquals(new File(db.getWorkTree(), path), gen.getDirectory());
assertNull(gen.getConfigUpdate());
assertNull(gen.getConfigUrl());
assertNull(gen.getModulesPath());
assertNull(gen.getModulesUpdate());
assertNull(gen.getModulesUrl());
assertNull(gen.getRepository());
assertFalse(gen.next());
}
}
@Test
@ -312,12 +317,13 @@ public void apply(DirCacheEntry ent) {
});
editor.commit();
SubmoduleWalk gen = SubmoduleWalk.forIndex(db);
gen.setFilter(PathFilter.create(path1));
assertTrue(gen.next());
assertEquals(path1, gen.getPath());
assertEquals(id1, gen.getObjectId());
assertFalse(gen.next());
try (SubmoduleWalk gen = SubmoduleWalk.forIndex(db)) {
gen.setFilter(PathFilter.create(path1));
assertTrue(gen.next());
assertEquals(path1, gen.getPath());
assertEquals(id1, gen.getObjectId());
assertFalse(gen.next());
}
}
@Test
@ -358,18 +364,19 @@ public void apply(DirCacheEntry ent) {
});
editor.commit();
SubmoduleWalk gen = SubmoduleWalk.forIndex(db);
assertTrue(gen.next());
assertEquals(path, gen.getPath());
assertEquals(subId, gen.getObjectId());
assertEquals(new File(db.getWorkTree(), path), gen.getDirectory());
assertNull(gen.getConfigUpdate());
assertNull(gen.getConfigUrl());
assertEquals("sub", gen.getModulesPath());
assertNull(gen.getModulesUpdate());
assertEquals("git://example.com/sub", gen.getModulesUrl());
assertNull(gen.getRepository());
assertFalse(gen.next());
try (SubmoduleWalk gen = SubmoduleWalk.forIndex(db)) {
assertTrue(gen.next());
assertEquals(path, gen.getPath());
assertEquals(subId, gen.getObjectId());
assertEquals(new File(db.getWorkTree(), path), gen.getDirectory());
assertNull(gen.getConfigUpdate());
assertNull(gen.getConfigUrl());
assertEquals("sub", gen.getModulesPath());
assertNull(gen.getModulesUpdate());
assertEquals("git://example.com/sub", gen.getModulesUrl());
assertNull(gen.getRepository());
assertFalse(gen.next());
}
}
@Test
@ -397,17 +404,19 @@ public void apply(DirCacheEntry ent) {
})
.create());
SubmoduleWalk gen = SubmoduleWalk.forPath(db, commit.getTree(), "sub");
assertEquals(path, gen.getPath());
assertEquals(subId, gen.getObjectId());
assertEquals(new File(db.getWorkTree(), path), gen.getDirectory());
assertNull(gen.getConfigUpdate());
assertNull(gen.getConfigUrl());
assertEquals("sub", gen.getModulesPath());
assertNull(gen.getModulesUpdate());
assertEquals("git://example.com/sub", gen.getModulesUrl());
assertNull(gen.getRepository());
assertFalse(gen.next());
try (SubmoduleWalk gen = SubmoduleWalk.forPath(db, commit.getTree(),
"sub")) {
assertEquals(path, gen.getPath());
assertEquals(subId, gen.getObjectId());
assertEquals(new File(db.getWorkTree(), path), gen.getDirectory());
assertNull(gen.getConfigUpdate());
assertNull(gen.getConfigUrl());
assertEquals("sub", gen.getModulesPath());
assertNull(gen.getModulesUpdate());
assertEquals("git://example.com/sub", gen.getModulesUrl());
assertNull(gen.getRepository());
assertFalse(gen.next());
}
}
@Test
@ -437,17 +446,18 @@ public void apply(DirCacheEntry ent) {
final CanonicalTreeParser p = new CanonicalTreeParser();
p.reset(testDb.getRevWalk().getObjectReader(), commit.getTree());
SubmoduleWalk gen = SubmoduleWalk.forPath(db, p, "sub");
assertEquals(path, gen.getPath());
assertEquals(subId, gen.getObjectId());
assertEquals(new File(db.getWorkTree(), path), gen.getDirectory());
assertNull(gen.getConfigUpdate());
assertNull(gen.getConfigUrl());
assertEquals("sub", gen.getModulesPath());
assertNull(gen.getModulesUpdate());
assertEquals("git://example.com/sub", gen.getModulesUrl());
assertNull(gen.getRepository());
assertFalse(gen.next());
try (SubmoduleWalk gen = SubmoduleWalk.forPath(db, p, "sub")) {
assertEquals(path, gen.getPath());
assertEquals(subId, gen.getObjectId());
assertEquals(new File(db.getWorkTree(), path), gen.getDirectory());
assertNull(gen.getConfigUpdate());
assertNull(gen.getConfigUrl());
assertEquals("sub", gen.getModulesPath());
assertNull(gen.getModulesUpdate());
assertEquals("git://example.com/sub", gen.getModulesUrl());
assertNull(gen.getRepository());
assertFalse(gen.next());
}
}
@Test
@ -477,16 +487,17 @@ public void apply(DirCacheEntry ent) {
final CanonicalTreeParser p = new CanonicalTreeParser();
p.reset(testDb.getRevWalk().getObjectReader(), commit.getTree());
SubmoduleWalk gen = SubmoduleWalk.forPath(db, p, "sub");
assertEquals(path, gen.getPath());
assertEquals(subId, gen.getObjectId());
assertEquals(new File(db.getWorkTree(), path), gen.getDirectory());
assertNull(gen.getConfigUpdate());
assertNull(gen.getConfigUrl());
assertEquals("sub", gen.getModulesPath());
assertNull(gen.getModulesUpdate());
assertEquals("git://example.com/sub", gen.getModulesUrl());
assertNull(gen.getRepository());
assertFalse(gen.next());
try (SubmoduleWalk gen = SubmoduleWalk.forPath(db, p, "sub")) {
assertEquals(path, gen.getPath());
assertEquals(subId, gen.getObjectId());
assertEquals(new File(db.getWorkTree(), path), gen.getDirectory());
assertNull(gen.getConfigUpdate());
assertNull(gen.getConfigUrl());
assertEquals("sub", gen.getModulesPath());
assertNull(gen.getModulesUpdate());
assertEquals("git://example.com/sub", gen.getModulesUrl());
assertNull(gen.getRepository());
assertFalse(gen.next());
}
}
}

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

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

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

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

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

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