Browse Source

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
stable-4.3
Jonathan Nieder 9 years ago
parent
commit
29dfbd22b7
  1. 119
      org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/filter/PathFilterGroupTest.java

119
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")));
assertTrue(filter.include(fakeWalk("b/c")));
assertTrue(filter.include(fakeWalk("c/d/e")));
assertTrue(filter.include(fakeWalk("c/d/f")));
assertTrue(filter.include(fakeWalk("d/e/f/g")));
assertTrue(filter.include(fakeWalk("d/e/f/g.x")));
assertMatches(Sets.of("a"), fakeWalk("a"));
assertMatches(Sets.of("b/c"), fakeWalk("b/c"));
assertMatches(Sets.of("c/d/e"), fakeWalk("c/d/e"));
assertMatches(Sets.of("c/d/f"), fakeWalk("c/d/f"));
assertMatches(Sets.of("d/e/f/g"), fakeWalk("d/e/f/g"));
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+")));
assertFalse(filter.include(fakeWalk("b+/c")));
assertFalse(filter.include(fakeWalk("c+/d/e")));
assertFalse(filter.include(fakeWalk("c+/d/f")));
assertFalse(filter.include(fakeWalk("c/d.a")));
assertFalse(filter.include(fakeWalk("d+/e/f/g")));
assertNoMatches(fakeWalk("a+"));
assertNoMatches(fakeWalk("b+/c"));
assertNoMatches(fakeWalk("c+/d/e"));
assertNoMatches(fakeWalk("c+/d/f"));
assertNoMatches(fakeWalk("c/d.a"));
assertNoMatches(fakeWalk("d+/e/f/g"));
}
@Test
public void testJustCommonPrefixIsNotMatch() throws MissingObjectException,
IncorrectObjectTypeException, IOException {
assertFalse(filter.include(fakeWalk("b/a")));
assertFalse(filter.include(fakeWalk("b/d")));
assertFalse(filter.include(fakeWalk("c/d/a")));
assertFalse(filter.include(fakeWalk("d/e/e")));
assertNoMatches(fakeWalk("b/a"));
assertNoMatches(fakeWalk("b/d"));
assertNoMatches(fakeWalk("c/d/a"));
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")));
assertTrue(filter.include(fakeWalk("c/d")));
assertTrue(filter.include(fakeWalk("c/d")));
assertTrue(filter.include(fakeWalk("c")));
assertTrue(filter.include(fakeWalk("d/e/f")));
assertTrue(filter.include(fakeWalk("d/e")));
assertTrue(filter.include(fakeWalk("d")));
assertMatches(Sets.of("b/c"), fakeWalk("b"));
assertMatches(Sets.of("c/d/e", "c/d/f"), fakeWalk("c/d"));
assertMatches(Sets.of("c/d/e", "c/d/f"), fakeWalk("c"));
assertMatches(Sets.of("d/e/f/g", "d/e/f/g.x"), fakeWalk("d/e/f"));
assertMatches(Sets.of("d/e/f/g", "d/e/f/g.x"), fakeWalk("d/e"));
assertMatches(Sets.of("d/e/f/g", "d/e/f/g.x"), fakeWalk("d"));
}
@Test
public void testFilterIsPrefixOfKey() throws MissingObjectException,
IncorrectObjectTypeException, IOException {
assertTrue(filter.include(fakeWalk("a/b")));
assertTrue(filter.include(fakeWalk("b/c/d")));
assertTrue(filter.include(fakeWalk("c/d/e/f")));
assertTrue(filter.include(fakeWalk("c/d/f/g")));
assertTrue(filter.include(fakeWalk("d/e/f/g/h")));
assertTrue(filter.include(fakeWalk("d/e/f/g/y")));
assertTrue(filter.include(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")));
assertMatches(Sets.of("a"), fakeWalk("a/b"));
assertMatches(Sets.of("b/c"), fakeWalk("b/c/d"));
assertMatches(Sets.of("c/d/e"), fakeWalk("c/d/e/f"));
assertMatches(Sets.of("c/d/f"), fakeWalk("c/d/f/g"));
assertMatches(Sets.of("d/e/f/g"), fakeWalk("d/e/f/g/h"));
assertMatches(Sets.of("d/e/f/g"), fakeWalk("d/e/f/g/y"));
assertMatches(Sets.of("d/e/f/g.x"), fakeWalk("d/e/f/g.x/h"));
}
@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();

Loading…
Cancel
Save