Add tests for PathFilterGroup.Single

Expand the existing PathFilterGroup tests to check which paths the
tree entry matches.  This expands test coverage by ensuring that
PathFilterGroup's simpler code path to match against a single
PathFilter works correctly.

While at it, move the check on tree entry d/e/f/g.y into two separate
tests: one to check that it doesn't match any of the configured paths,
and another to check that it does not throw StopWalkException to end
the walk early.

Change-Id: I55bd512cd049fc2018659e2f86a4b8650f171fda

org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/filter/PathFilterGroupTest.java

@@ -43,11 +43,18 @@
 
 package org.eclipse.jgit.treewalk.filter;
 
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 import org.eclipse.jgit.dircache.DirCache;
 import org.eclipse.jgit.dircache.DirCacheEditor;
@@ -58,6 +65,7 @@ import org.eclipse.jgit.errors.MissingObjectException;
 import org.eclipse.jgit.errors.StopWalkException;
 import org.eclipse.jgit.lib.FileMode;
 import org.eclipse.jgit.lib.ObjectReader;
+import org.eclipse.jgit.lib.Sets;
 import org.eclipse.jgit.treewalk.TreeWalk;
 import org.junit.Before;
 import org.junit.Test;
@@ -66,6 +74,8 @@ public class PathFilterGroupTest {
 
 	private TreeFilter filter;
 
+	private Map<String, TreeFilter> singles;
+
 	@Before
 	public void setup() {
 		// @formatter:off
@@ -81,64 +91,65 @@ public class PathFilterGroupTest {
 				};
 		// @formatter:on
 		filter = PathFilterGroup.createFromStrings(paths);
+		singles = new HashMap<>();
+		for (String path : paths) {
+			singles.put(path, PathFilterGroup.createFromStrings(path));
+		}
 	}
 
 	@Test
 	public void testExact() throws MissingObjectException,
 			IncorrectObjectTypeException, IOException {
-		assertTrue(filter.include(fakeWalk("a")));
+		assertMatches(Sets.of("a"), fakeWalk("a"));
-		assertTrue(filter.include(fakeWalk("b/c")));
+		assertMatches(Sets.of("b/c"), fakeWalk("b/c"));
-		assertTrue(filter.include(fakeWalk("c/d/e")));
+		assertMatches(Sets.of("c/d/e"), fakeWalk("c/d/e"));
-		assertTrue(filter.include(fakeWalk("c/d/f")));
+		assertMatches(Sets.of("c/d/f"), fakeWalk("c/d/f"));
-		assertTrue(filter.include(fakeWalk("d/e/f/g")));
+		assertMatches(Sets.of("d/e/f/g"), fakeWalk("d/e/f/g"));
-		assertTrue(filter.include(fakeWalk("d/e/f/g.x")));
+		assertMatches(Sets.of("d/e/f/g.x"), fakeWalk("d/e/f/g.x"));
 	}
 
 	@Test
 	public void testNoMatchButClose() throws MissingObjectException,
 			IncorrectObjectTypeException, IOException {
-		assertFalse(filter.include(fakeWalk("a+")));
+		assertNoMatches(fakeWalk("a+"));
-		assertFalse(filter.include(fakeWalk("b+/c")));
+		assertNoMatches(fakeWalk("b+/c"));
-		assertFalse(filter.include(fakeWalk("c+/d/e")));
+		assertNoMatches(fakeWalk("c+/d/e"));
-		assertFalse(filter.include(fakeWalk("c+/d/f")));
+		assertNoMatches(fakeWalk("c+/d/f"));
-		assertFalse(filter.include(fakeWalk("c/d.a")));
+		assertNoMatches(fakeWalk("c/d.a"));
-		assertFalse(filter.include(fakeWalk("d+/e/f/g")));
+		assertNoMatches(fakeWalk("d+/e/f/g"));
 	}
 
 	@Test
 	public void testJustCommonPrefixIsNotMatch() throws MissingObjectException,
 			IncorrectObjectTypeException, IOException {
-		assertFalse(filter.include(fakeWalk("b/a")));
+		assertNoMatches(fakeWalk("b/a"));
-		assertFalse(filter.include(fakeWalk("b/d")));
+		assertNoMatches(fakeWalk("b/d"));
-		assertFalse(filter.include(fakeWalk("c/d/a")));
+		assertNoMatches(fakeWalk("c/d/a"));
-		assertFalse(filter.include(fakeWalk("d/e/e")));
+		assertNoMatches(fakeWalk("d/e/e"));
+		assertNoMatches(fakeWalk("d/e/f/g.y"));
 	}
 
 	@Test
 	public void testKeyIsPrefixOfFilter() throws MissingObjectException,
 			IncorrectObjectTypeException, IOException {
-		assertTrue(filter.include(fakeWalk("b")));
+		assertMatches(Sets.of("b/c"), fakeWalk("b"));
-		assertTrue(filter.include(fakeWalk("c/d")));
+		assertMatches(Sets.of("c/d/e", "c/d/f"), fakeWalk("c/d"));
-		assertTrue(filter.include(fakeWalk("c/d")));
+		assertMatches(Sets.of("c/d/e", "c/d/f"), fakeWalk("c"));
-		assertTrue(filter.include(fakeWalk("c")));
+		assertMatches(Sets.of("d/e/f/g", "d/e/f/g.x"), fakeWalk("d/e/f"));
-		assertTrue(filter.include(fakeWalk("d/e/f")));
+		assertMatches(Sets.of("d/e/f/g", "d/e/f/g.x"), fakeWalk("d/e"));
-		assertTrue(filter.include(fakeWalk("d/e")));
+		assertMatches(Sets.of("d/e/f/g", "d/e/f/g.x"), fakeWalk("d"));
-		assertTrue(filter.include(fakeWalk("d")));
 	}
 
 	@Test
 	public void testFilterIsPrefixOfKey() throws MissingObjectException,
 			IncorrectObjectTypeException, IOException {
-		assertTrue(filter.include(fakeWalk("a/b")));
+		assertMatches(Sets.of("a"), fakeWalk("a/b"));
-		assertTrue(filter.include(fakeWalk("b/c/d")));
+		assertMatches(Sets.of("b/c"), fakeWalk("b/c/d"));
-		assertTrue(filter.include(fakeWalk("c/d/e/f")));
+		assertMatches(Sets.of("c/d/e"), fakeWalk("c/d/e/f"));
-		assertTrue(filter.include(fakeWalk("c/d/f/g")));
+		assertMatches(Sets.of("c/d/f"), fakeWalk("c/d/f/g"));
-		assertTrue(filter.include(fakeWalk("d/e/f/g/h")));
+		assertMatches(Sets.of("d/e/f/g"), fakeWalk("d/e/f/g/h"));
-		assertTrue(filter.include(fakeWalk("d/e/f/g/y")));
+		assertMatches(Sets.of("d/e/f/g"), fakeWalk("d/e/f/g/y"));
-		assertTrue(filter.include(fakeWalk("d/e/f/g.x/h")));
+		assertMatches(Sets.of("d/e/f/g.x"), fakeWalk("d/e/f/g.x/h"));
-		// listed before g/y, so can't StopWalk here, but it's not included
-		// either
-		assertFalse(filter.include(fakeWalk("d/e/f/g.y")));
 	}
 
 	@Test
@@ -182,6 +193,10 @@ public class PathFilterGroupTest {
 		// less obvious #2 due to git sorting order
 		filter.include(fakeWalk("d/e/f/g/h.txt"));
 
+		// listed before g/y, so can't StopWalk here
+		filter.include(fakeWalk("d/e/f/g.y"));
+		singles.get("d/e/f/g").include(fakeWalk("d/e/f/g.y"));
+
 		// non-ascii
 		try {
 			filter.include(fakeWalk("\u00C0"));
@@ -191,6 +206,44 @@ public class PathFilterGroupTest {
 		}
 	}
 
+	private void assertNoMatches(TreeWalk tw) throws MissingObjectException,
+			IncorrectObjectTypeException, IOException {
+		assertMatches(Sets.<String> of(), tw);
+	}
+
+	private void assertMatches(Set<String> expect, TreeWalk tw)
+			throws MissingObjectException, IncorrectObjectTypeException,
+			IOException {
+		List<String> actual = new ArrayList<>();
+		for (String path : singles.keySet()) {
+			if (includes(singles.get(path), tw)) {
+				actual.add(path);
+			}
+		}
+
+		String[] e = expect.toArray(new String[expect.size()]);
+		String[] a = actual.toArray(new String[actual.size()]);
+		Arrays.sort(e);
+		Arrays.sort(a);
+		assertArrayEquals(e, a);
+
+		if (expect.isEmpty()) {
+			assertFalse(includes(filter, tw));
+		} else {
+			assertTrue(includes(filter, tw));
+		}
+	}
+
+	private static boolean includes(TreeFilter f, TreeWalk tw)
+			throws MissingObjectException, IncorrectObjectTypeException,
+			IOException {
+		try {
+			return f.include(tw);
+		} catch (StopWalkException e) {
+			return false;
+		}
+	}
+
 	TreeWalk fakeWalk(final String path) throws IOException {
 		DirCache dc = DirCache.newInCore();
 		DirCacheEditor dce = dc.editor();