diff options
Diffstat (limited to 'org.eclipse.jgit.test')
6 files changed, 1918 insertions, 5 deletions
diff --git a/org.eclipse.jgit.test/META-INF/MANIFEST.MF b/org.eclipse.jgit.test/META-INF/MANIFEST.MF index d493ae4e10..7b9bd64bc1 100644 --- a/org.eclipse.jgit.test/META-INF/MANIFEST.MF +++ b/org.eclipse.jgit.test/META-INF/MANIFEST.MF @@ -20,6 +20,7 @@ Import-Package: com.googlecode.javaewah;version="[0.7.9,0.8.0)", org.eclipse.jgit.fnmatch;version="[3.6.0,3.7.0)", org.eclipse.jgit.gitrepo;version="[3.6.0,3.7.0)", org.eclipse.jgit.ignore;version="[3.6.0,3.7.0)", + org.eclipse.jgit.ignore.internal;version="[3.6.0,3.7.0)", org.eclipse.jgit.internal;version="[3.6.0,3.7.0)", org.eclipse.jgit.internal.storage.dfs;version="[3.6.0,3.7.0)", org.eclipse.jgit.internal.storage.file;version="[3.6.0,3.7.0)", @@ -47,5 +48,6 @@ Import-Package: com.googlecode.javaewah;version="[0.7.9,0.8.0)", org.hamcrest;version="[1.1.0,2.0.0)", org.junit;version="[4.4.0,5.0.0)", org.junit.experimental.theories;version="[4.4.0,5.0.0)", - org.junit.runner;version="[4.4.0,5.0.0)" + org.junit.runner;version="[4.4.0,5.0.0)", + org.junit.runners;version="[4.11.0,5.0.0)" Require-Bundle: org.hamcrest.core;bundle-version="[1.1.0,2.0.0)" diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/BasicRuleTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/BasicRuleTest.java new file mode 100644 index 0000000000..2349b55c64 --- /dev/null +++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/BasicRuleTest.java @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2014, Andrey Loskutov <loskutov@gmx.de> + * and other copyright owners as documented in the project's IP log. + * + * This program and the accompanying materials are made available + * under the terms of the Eclipse Distribution License v1.0 which + * accompanies this distribution, is reproduced below, and is + * available at http://www.eclipse.org/org/documents/edl-v10.php + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or + * without modification, are permitted provided that the following + * conditions are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * - Neither the name of the Eclipse Foundation, Inc. nor the + * names of its contributors may be used to endorse or promote + * products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.eclipse.jgit.ignore; + +import static org.junit.Assert.*; + +import org.eclipse.jgit.ignore.FastIgnoreRule; +import org.junit.Test; + +public class BasicRuleTest { + + @Test + public void test() { + FastIgnoreRule rule1 = new FastIgnoreRule("/hello/[a]/"); + FastIgnoreRule rule2 = new FastIgnoreRule("/hello/[a]/"); + FastIgnoreRule rule3 = new FastIgnoreRule("!/hello/[a]/"); + FastIgnoreRule rule4 = new FastIgnoreRule("/hello/[a]"); + assertTrue(rule1.dirOnly()); + assertTrue(rule3.dirOnly()); + assertFalse(rule4.dirOnly()); + assertFalse(rule1.getNegation()); + assertTrue(rule3.getNegation()); + assertNotEquals(rule1, null); + assertEquals(rule1, rule1); + assertEquals(rule1, rule2); + assertNotEquals(rule1, rule3); + assertNotEquals(rule1, rule4); + assertEquals(rule1.hashCode(), rule2.hashCode()); + assertNotEquals(rule1.hashCode(), rule3.hashCode()); + assertEquals(rule1.toString(), rule2.toString()); + assertNotEquals(rule1.toString(), rule3.toString()); + } + +} diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/FastIgnoreRuleTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/FastIgnoreRuleTest.java new file mode 100644 index 0000000000..dab4e351a3 --- /dev/null +++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/FastIgnoreRuleTest.java @@ -0,0 +1,561 @@ +/* + * Copyright (C) 2014, Andrey Loskutov <loskutov@gmx.de> + * and other copyright owners as documented in the project's IP log. + * + * This program and the accompanying materials are made available + * under the terms of the Eclipse Distribution License v1.0 which + * accompanies this distribution, is reproduced below, and is + * available at http://www.eclipse.org/org/documents/edl-v10.php + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or + * without modification, are permitted provided that the following + * conditions are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * - Neither the name of the Eclipse Foundation, Inc. nor the + * names of its contributors may be used to endorse or promote + * products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.eclipse.jgit.ignore; + +import static org.eclipse.jgit.ignore.internal.Strings.split; +import static org.junit.Assert.*; +import static org.junit.Assume.*; + +import java.util.Arrays; + +import org.eclipse.jgit.ignore.FastIgnoreRule; +import org.eclipse.jgit.ignore.IgnoreRule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.*; +import org.junit.runners.Parameterized.Parameter; +import org.junit.runners.Parameterized.Parameters; + +@SuppressWarnings("deprecation") +@RunWith(Parameterized.class) +public class FastIgnoreRuleTest { + + @Parameters(name = "JGit? {0}") + public static Iterable<Boolean[]> data() { + return Arrays.asList(new Boolean[][] { { Boolean.FALSE }, + { Boolean.TRUE } }); + } + + @Parameter + public Boolean useJGitRule; + + @Test + public void testSimpleCharClass() { + assertMatched("[a]", "a"); + assertMatched("[a]", "a/"); + assertMatched("[a]", "a/b"); + + assertMatched("[a]", "b/a"); + assertMatched("[a]", "b/a/"); + assertMatched("[a]", "b/a/b"); + + assertMatched("[a]", "/a/"); + assertMatched("[a]", "/a/b"); + + assertMatched("[a]", "c/a/b"); + assertMatched("[a]", "c/b/a"); + + assertMatched("/[a]", "a"); + assertMatched("/[a]", "a/"); + assertMatched("/[a]", "a/b"); + assertMatched("/[a]", "/a"); + assertMatched("/[a]", "/a/"); + assertMatched("/[a]", "/a/b"); + + assertMatched("[a]/", "a/"); + assertMatched("[a]/", "a/b"); + assertMatched("[a]/", "/a/"); + assertMatched("[a]/", "/a/b"); + + assertMatched("/[a]/", "a/"); + assertMatched("/[a]/", "a/b"); + assertMatched("/[a]/", "/a/"); + assertMatched("/[a]/", "/a/b"); + } + + @Test + public void testCharClass() { + assertMatched("[v-z]", "x"); + assertMatched("[v-z]", "x/"); + assertMatched("[v-z]", "x/b"); + + assertMatched("[v-z]", "b/x"); + assertMatched("[v-z]", "b/x/"); + assertMatched("[v-z]", "b/x/b"); + + assertMatched("[v-z]", "/x/"); + assertMatched("[v-z]", "/x/b"); + + assertMatched("[v-z]", "c/x/b"); + assertMatched("[v-z]", "c/b/x"); + + assertMatched("/[v-z]", "x"); + assertMatched("/[v-z]", "x/"); + assertMatched("/[v-z]", "x/b"); + assertMatched("/[v-z]", "/x"); + assertMatched("/[v-z]", "/x/"); + assertMatched("/[v-z]", "/x/b"); + + assertMatched("[v-z]/", "x/"); + assertMatched("[v-z]/", "x/b"); + assertMatched("[v-z]/", "/x/"); + assertMatched("[v-z]/", "/x/b"); + + assertMatched("/[v-z]/", "x/"); + assertMatched("/[v-z]/", "x/b"); + assertMatched("/[v-z]/", "/x/"); + assertMatched("/[v-z]/", "/x/b"); + } + + @Test + public void testAsteriskDot() { + assertMatched("*.a", ".a"); + assertMatched("*.a", "/.a"); + assertMatched("*.a", "a.a"); + assertMatched("*.a", "/b.a"); + assertMatched("*.a", "b.a"); + assertMatched("*.a", "/a/b.a"); + assertMatched("*.a", "/b/.a"); + } + + @Test + public void testAsteriskDotDoNotMatch() { + assertNotMatched("*.a", ".ab"); + assertNotMatched("*.a", "/.ab"); + assertNotMatched("*.a", "/b.ba"); + assertNotMatched("*.a", "a.ab"); + assertNotMatched("*.a", "/b.ab"); + assertNotMatched("*.a", "b.ab"); + assertNotMatched("*.a", "/a/b.ab"); + assertNotMatched("*.a", "/b/.ab"); + } + + @Test + public void testDotAsteriskMatch() { + assertMatched("a.*", "a."); + assertMatched("a.*", "a./"); + assertMatched("a.*", "a.b"); + + assertMatched("a.*", "b/a.b"); + assertMatched("a.*", "b/a.b/"); + assertMatched("a.*", "b/a.b/b"); + + assertMatched("a.*", "/a.b/"); + assertMatched("a.*", "/a.b/b"); + + assertMatched("a.*", "c/a.b/b"); + assertMatched("a.*", "c/b/a.b"); + + assertMatched("/a.*", "a.b"); + assertMatched("/a.*", "a.b/"); + assertMatched("/a.*", "a.b/b"); + assertMatched("/a.*", "/a.b"); + assertMatched("/a.*", "/a.b/"); + assertMatched("/a.*", "/a.b/b"); + + assertMatched("/a.*/b", "a.b/b"); + assertMatched("/a.*/b", "/a.b/b"); + assertMatched("/a.*/b", "/a.bc/b"); + assertMatched("/a.*/b", "/a./b"); + } + + @Test + public void testAsterisk() { + assertMatched("a*", "a"); + assertMatched("a*", "a/"); + assertMatched("a*", "ab"); + + assertMatched("a*", "b/ab"); + assertMatched("a*", "b/ab/"); + assertMatched("a*", "b/ab/b"); + + assertMatched("a*", "b/abc"); + assertMatched("a*", "b/abc/"); + assertMatched("a*", "b/abc/b"); + + assertMatched("a*", "/abc/"); + assertMatched("a*", "/abc/b"); + + assertMatched("a*", "c/abc/b"); + assertMatched("a*", "c/b/abc"); + + assertMatched("/a*", "abc"); + assertMatched("/a*", "abc/"); + assertMatched("/a*", "abc/b"); + assertMatched("/a*", "/abc"); + assertMatched("/a*", "/abc/"); + assertMatched("/a*", "/abc/b"); + + assertMatched("/a*/b", "abc/b"); + assertMatched("/a*/b", "/abc/b"); + assertMatched("/a*/b", "/abcd/b"); + assertMatched("/a*/b", "/a/b"); + } + + @Test + public void testQuestionmark() { + assertMatched("a?", "ab"); + assertMatched("a?", "ab/"); + + assertMatched("a?", "b/ab"); + assertMatched("a?", "b/ab/"); + assertMatched("a?", "b/ab/b"); + + assertMatched("a?", "/ab/"); + assertMatched("a?", "/ab/b"); + + assertMatched("a?", "c/ab/b"); + assertMatched("a?", "c/b/ab"); + + assertMatched("/a?", "ab"); + assertMatched("/a?", "ab/"); + assertMatched("/a?", "ab/b"); + assertMatched("/a?", "/ab"); + assertMatched("/a?", "/ab/"); + assertMatched("/a?", "/ab/b"); + + assertMatched("/a?/b", "ab/b"); + assertMatched("/a?/b", "/ab/b"); + } + + @Test + public void testQuestionmarkDoNotMatch() { + assertNotMatched("a?", "a/"); + assertNotMatched("a?", "abc"); + assertNotMatched("a?", "abc/"); + + assertNotMatched("a?", "b/abc"); + assertNotMatched("a?", "b/abc/"); + + assertNotMatched("a?", "/abc/"); + assertNotMatched("a?", "/abc/b"); + + assertNotMatched("a?", "c/abc/b"); + assertNotMatched("a?", "c/b/abc"); + + assertNotMatched("/a?", "abc"); + assertNotMatched("/a?", "abc/"); + assertNotMatched("/a?", "abc/b"); + assertNotMatched("/a?", "/abc"); + assertNotMatched("/a?", "/abc/"); + assertNotMatched("/a?", "/abc/b"); + + assertNotMatched("/a?/b", "abc/b"); + assertNotMatched("/a?/b", "/abc/b"); + assertNotMatched("/a?/b", "/a/b"); + } + + @Test + public void testSimplePatterns() { + assertMatched("a", "a"); + assertMatched("a", "a/"); + assertMatched("a", "a/b"); + + assertMatched("a", "b/a"); + assertMatched("a", "b/a/"); + assertMatched("a", "b/a/b"); + + assertMatched("a", "/a/"); + assertMatched("a", "/a/b"); + + assertMatched("a", "c/a/b"); + assertMatched("a", "c/b/a"); + + assertMatched("/a", "a"); + assertMatched("/a", "a/"); + assertMatched("/a", "a/b"); + assertMatched("/a", "/a"); + assertMatched("/a", "/a/"); + assertMatched("/a", "/a/b"); + + assertMatched("a/", "a/"); + assertMatched("a/", "a/b"); + assertMatched("a/", "/a/"); + assertMatched("a/", "/a/b"); + + assertMatched("/a/", "a/"); + assertMatched("/a/", "a/b"); + assertMatched("/a/", "/a/"); + assertMatched("/a/", "/a/b"); + + } + + @Test + public void testSimplePatternsDoNotMatch() { + assertNotMatched("ab", "a"); + assertNotMatched("abc", "a/"); + assertNotMatched("abc", "a/b"); + + assertNotMatched("a", "ab"); + assertNotMatched("a", "ba"); + assertNotMatched("a", "aa"); + + assertNotMatched("a", "b/ab"); + assertNotMatched("a", "b/ba"); + + assertNotMatched("a", "b/ba"); + assertNotMatched("a", "b/ab"); + + assertNotMatched("a", "b/ba/"); + assertNotMatched("a", "b/ba/b"); + + assertNotMatched("a", "/aa"); + assertNotMatched("a", "aa/"); + assertNotMatched("a", "/aa/"); + + assertNotMatched("/a", "b/a"); + assertNotMatched("/a", "/b/a/"); + + assertNotMatched("a/", "a"); + assertNotMatched("a/", "b/a"); + + assertNotMatched("/a/", "a"); + assertNotMatched("/a/", "/a"); + assertNotMatched("/a/", "b/a"); + } + + @Test + public void testSegments() { + assertMatched("/a/b", "a/b"); + assertMatched("/a/b", "/a/b"); + assertMatched("/a/b", "/a/b/"); + assertMatched("/a/b", "/a/b/c"); + + assertMatched("a/b", "a/b"); + assertMatched("a/b", "/a/b"); + assertMatched("a/b", "/a/b/"); + assertMatched("a/b", "/a/b/c"); + + assertMatched("a/b/", "a/b/"); + assertMatched("a/b/", "/a/b/"); + assertMatched("a/b/", "/a/b/c"); + } + + @Test + public void testSegmentsDoNotMatch() { + assertNotMatched("a/b", "/a/bb"); + assertNotMatched("a/b", "/aa/b"); + assertNotMatched("a/b", "a/bb"); + assertNotMatched("a/b", "aa/b"); + assertNotMatched("a/b", "c/aa/b"); + assertNotMatched("a/b", "c/a/bb"); + assertNotMatched("a/b/", "/a/b"); + assertNotMatched("/a/b/", "/a/b"); + assertNotMatched("/a/b", "c/a/b"); + assertNotMatched("/a/b/", "c/a/b"); + assertNotMatched("/a/b/", "c/a/b/"); + + // XXX why is it like this???? + assertNotMatched("a/b", "c/a/b"); + assertNotMatched("a/b", "c/a/b/"); + assertNotMatched("a/b", "c/a/b/c"); + assertNotMatched("a/b/", "c/a/b/"); + assertNotMatched("a/b/", "c/a/b/c"); + } + + @SuppressWarnings("boxing") + @Test + public void testWildmatch() { + if (useJGitRule) + System.err + .println("IgnoreRule can't understand wildmatch rules, skipping testWildmatch!"); + + Boolean assume = useJGitRule; + assertMatched("**/a/b", "a/b", assume); + assertMatched("**/a/b", "c/a/b", assume); + assertMatched("**/a/b", "c/d/a/b", assume); + assertMatched("**/**/a/b", "c/d/a/b", assume); + + assertMatched("/**/a/b", "a/b", assume); + assertMatched("/**/a/b", "c/a/b", assume); + assertMatched("/**/a/b", "c/d/a/b", assume); + assertMatched("/**/**/a/b", "c/d/a/b", assume); + + assertMatched("a/b/**", "a/b", assume); + assertMatched("a/b/**", "a/b/c", assume); + assertMatched("a/b/**", "a/b/c/d/", assume); + assertMatched("a/b/**/**", "a/b/c/d", assume); + + assertMatched("**/a/**/b", "c/d/a/b", assume); + assertMatched("**/a/**/b", "c/d/a/e/b", assume); + assertMatched("**/**/a/**/**/b", "c/d/a/e/b", assume); + + assertMatched("/**/a/**/b", "c/d/a/b", assume); + assertMatched("/**/a/**/b", "c/d/a/e/b", assume); + assertMatched("/**/**/a/**/**/b", "c/d/a/e/b", assume); + + assertMatched("a/**/b", "a/b", assume); + assertMatched("a/**/b", "a/c/b", assume); + assertMatched("a/**/b", "a/c/d/b", assume); + assertMatched("a/**/**/b", "a/c/d/b", assume); + + assertMatched("a/**/b/**/c", "a/c/b/d/c", assume); + assertMatched("a/**/**/b/**/**/c", "a/c/b/d/c", assume); + } + + @SuppressWarnings("boxing") + @Test + public void testWildmatchDoNotMatch() { + if (useJGitRule) + System.err + .println("IgnoreRule can't understand wildmatch rules, skipping testWildmatchDoNotMatch!"); + + Boolean assume = useJGitRule; + assertNotMatched("**/a/b", "a/c/b", assume); + assertNotMatched("!/**/*.zip", "c/a/b.zip", assume); + assertNotMatched("!**/*.zip", "c/a/b.zip", assume); + assertNotMatched("a/**/b", "a/c/bb", assume); + } + + @SuppressWarnings("unused") + @Test + public void testSimpleRules() { + try { + new FastIgnoreRule(null); + fail("Illegal input allowed!"); + } catch (IllegalArgumentException e) { + // expected + } + assertFalse(new FastIgnoreRule("/").isMatch("/", false)); + assertFalse(new FastIgnoreRule("//").isMatch("//", false)); + assertFalse(new FastIgnoreRule("#").isMatch("#", false)); + assertFalse(new FastIgnoreRule("").isMatch("", false)); + assertFalse(new FastIgnoreRule(" ").isMatch(" ", false)); + } + + @Test + public void testSplit() { + try { + split("/", '/').toArray(); + fail("should not allow single slash"); + } catch (IllegalStateException e) { + // expected + } + + assertArrayEquals(new String[] { "a", "b" }, split("a/b", '/') + .toArray()); + assertArrayEquals(new String[] { "a", "b/" }, split("a/b/", '/') + .toArray()); + assertArrayEquals(new String[] { "/a", "b" }, split("/a/b", '/') + .toArray()); + assertArrayEquals(new String[] { "/a", "b/" }, split("/a/b/", '/') + .toArray()); + assertArrayEquals(new String[] { "/a", "b", "c" }, split("/a/b/c", '/') + .toArray()); + assertArrayEquals(new String[] { "/a", "b", "c/" }, + split("/a/b/c/", '/').toArray()); + } + + public void assertMatched(String pattern, String path, Boolean... assume) { + boolean match = match(pattern, path); + String result = path + " is " + (match ? "ignored" : "not ignored") + + " via '" + pattern + "' rule"; + if (!match) + System.err.println(result); + if (assume.length == 0 || !assume[0].booleanValue()) + assertTrue("Expected a match for: " + pattern + " with: " + path, + match); + else + assumeTrue("Expected a match for: " + pattern + " with: " + path, + match); + + if (pattern.startsWith("!")) + pattern = pattern.substring(1); + else + pattern = "!" + pattern; + match = match(pattern, path); + if (assume.length == 0 || !assume[0].booleanValue()) + assertFalse("Expected no match for: " + pattern + " with: " + path, + match); + else + assumeFalse("Expected no match for: " + pattern + " with: " + path, + match); + } + + public void assertNotMatched(String pattern, String path, Boolean... assume) { + boolean match = match(pattern, path); + String result = path + " is " + (match ? "ignored" : "not ignored") + + " via '" + pattern + "' rule"; + if (match) + System.err.println(result); + if (assume.length == 0 || !assume[0].booleanValue()) + assertFalse("Expected no match for: " + pattern + " with: " + path, + match); + else + assumeFalse("Expected no match for: " + pattern + " with: " + path, + match); + + if (pattern.startsWith("!")) + pattern = pattern.substring(1); + else + pattern = "!" + pattern; + match = match(pattern, path); + if (assume.length == 0 || !assume[0].booleanValue()) + assertTrue("Expected a match for: " + pattern + " with: " + path, + match); + else + assumeTrue("Expected a match for: " + pattern + " with: " + path, + match); + } + + /** + * Check for a match. If target ends with "/", match will assume that the + * target is meant to be a directory. + * + * @param pattern + * Pattern as it would appear in a .gitignore file + * @param target + * Target file path relative to repository's GIT_DIR + * @return Result of {@link FastIgnoreRule#isMatch(String, boolean)} + */ + private boolean match(String pattern, String target) { + boolean isDirectory = target.endsWith("/"); + if (useJGitRule.booleanValue()) { + IgnoreRule r = new IgnoreRule(pattern); + // If speed of this test is ever an issue, we can use a presetRule + // field + // to avoid recompiling a pattern each time. + boolean match = r.isMatch(target, isDirectory); + if (r.getNegation()) + match = !match; + return match; + } + FastIgnoreRule r = new FastIgnoreRule(pattern); + // If speed of this test is ever an issue, we can use a presetRule field + // to avoid recompiling a pattern each time. + boolean match = r.isMatch(target, isDirectory); + if (r.getNegation()) + match = !match; + return match; + } +} diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreMatcherParametrizedTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreMatcherParametrizedTest.java new file mode 100644 index 0000000000..a51582ab3d --- /dev/null +++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreMatcherParametrizedTest.java @@ -0,0 +1,371 @@ +/* + * Copyright (C) 2010, Red Hat Inc. + * and other copyright owners as documented in the project's IP log. + * + * This program and the accompanying materials are made available + * under the terms of the Eclipse Distribution License v1.0 which + * accompanies this distribution, is reproduced below, and is + * available at http://www.eclipse.org/org/documents/edl-v10.php + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or + * without modification, are permitted provided that the following + * conditions are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * - Neither the name of the Eclipse Foundation, Inc. nor the + * names of its contributors may be used to endorse or promote + * products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.eclipse.jgit.ignore; + +import static org.junit.Assert.*; + +import java.util.Arrays; + +import org.eclipse.jgit.ignore.FastIgnoreRule; +import org.eclipse.jgit.ignore.IgnoreRule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.*; +import org.junit.runners.Parameterized.Parameter; +import org.junit.runners.Parameterized.Parameters; + +/** + * Tests ignore pattern matches + */ +@SuppressWarnings("deprecation") +@RunWith(Parameterized.class) +public class IgnoreMatcherParametrizedTest { + + @Parameters(name = "JGit? {0}") + public static Iterable<Boolean[]> data() { + return Arrays.asList(new Boolean[][] { { Boolean.FALSE }, + { Boolean.TRUE } }); + } + + @Parameter + public Boolean useJGitRule; + + @Test + public void testBasic() { + String pattern = "/test.stp"; + assertMatched(pattern, "/test.stp"); + + pattern = "#/test.stp"; + assertNotMatched(pattern, "/test.stp"); + } + + @Test + public void testFileNameWildcards() { + // Test basic * and ? for any pattern + any character + String pattern = "*.st?"; + assertMatched(pattern, "/test.stp"); + assertMatched(pattern, "/anothertest.stg"); + assertMatched(pattern, "/anothertest.st0"); + assertNotMatched(pattern, "/anothertest.sta1"); + // Check that asterisk does not expand to "/" + assertNotMatched(pattern, "/another/test.sta1"); + + // Same as above, with a leading slash to ensure that doesn't cause + // problems + pattern = "/*.st?"; + assertMatched(pattern, "/test.stp"); + assertMatched(pattern, "/anothertest.stg"); + assertMatched(pattern, "/anothertest.st0"); + assertNotMatched(pattern, "/anothertest.sta1"); + // Check that asterisk does not expand to "/" + assertNotMatched(pattern, "/another/test.sta1"); + + // Test for numbers + pattern = "*.sta[0-5]"; + assertMatched(pattern, "/test.sta5"); + assertMatched(pattern, "/test.sta4"); + assertMatched(pattern, "/test.sta3"); + assertMatched(pattern, "/test.sta2"); + assertMatched(pattern, "/test.sta1"); + assertMatched(pattern, "/test.sta0"); + assertMatched(pattern, "/anothertest.sta2"); + assertNotMatched(pattern, "test.stag"); + assertNotMatched(pattern, "test.sta6"); + + // Test for letters + pattern = "/[tv]est.sta[a-d]"; + assertMatched(pattern, "/test.staa"); + assertMatched(pattern, "/test.stab"); + assertMatched(pattern, "/test.stac"); + assertMatched(pattern, "/test.stad"); + assertMatched(pattern, "/vest.stac"); + assertNotMatched(pattern, "test.stae"); + assertNotMatched(pattern, "test.sta9"); + + // Test child directory/file is matched + pattern = "/src/ne?"; + assertMatched(pattern, "/src/new/"); + assertMatched(pattern, "/src/new"); + assertMatched(pattern, "/src/new/a.c"); + assertMatched(pattern, "/src/new/a/a.c"); + assertNotMatched(pattern, "/src/new.c"); + + // Test name-only fnmatcher matches + pattern = "ne?"; + assertMatched(pattern, "/src/new/"); + assertMatched(pattern, "/src/new"); + assertMatched(pattern, "/src/new/a.c"); + assertMatched(pattern, "/src/new/a/a.c"); + assertMatched(pattern, "/neb"); + assertNotMatched(pattern, "/src/new.c"); + } + + @Test + public void testTargetWithoutLeadingSlash() { + // Test basic * and ? for any pattern + any character + String pattern = "/*.st?"; + assertMatched(pattern, "test.stp"); + assertMatched(pattern, "anothertest.stg"); + assertMatched(pattern, "anothertest.st0"); + assertNotMatched(pattern, "anothertest.sta1"); + // Check that asterisk does not expand to "" + assertNotMatched(pattern, "another/test.sta1"); + + // Same as above, with a leading slash to ensure that doesn't cause + // problems + pattern = "/*.st?"; + assertMatched(pattern, "test.stp"); + assertMatched(pattern, "anothertest.stg"); + assertMatched(pattern, "anothertest.st0"); + assertNotMatched(pattern, "anothertest.sta1"); + // Check that asterisk does not expand to "" + assertNotMatched(pattern, "another/test.sta1"); + + // Test for numbers + pattern = "/*.sta[0-5]"; + assertMatched(pattern, "test.sta5"); + assertMatched(pattern, "test.sta4"); + assertMatched(pattern, "test.sta3"); + assertMatched(pattern, "test.sta2"); + assertMatched(pattern, "test.sta1"); + assertMatched(pattern, "test.sta0"); + assertMatched(pattern, "anothertest.sta2"); + assertNotMatched(pattern, "test.stag"); + assertNotMatched(pattern, "test.sta6"); + + // Test for letters + pattern = "/[tv]est.sta[a-d]"; + assertMatched(pattern, "test.staa"); + assertMatched(pattern, "test.stab"); + assertMatched(pattern, "test.stac"); + assertMatched(pattern, "test.stad"); + assertMatched(pattern, "vest.stac"); + assertNotMatched(pattern, "test.stae"); + assertNotMatched(pattern, "test.sta9"); + + // Test child directory/file is matched + pattern = "/src/ne?"; + assertMatched(pattern, "src/new/"); + assertMatched(pattern, "src/new"); + assertMatched(pattern, "src/new/a.c"); + assertMatched(pattern, "src/new/a/a.c"); + assertNotMatched(pattern, "src/new.c"); + + // Test name-only fnmatcher matches + pattern = "ne?"; + assertMatched(pattern, "src/new/"); + assertMatched(pattern, "src/new"); + assertMatched(pattern, "src/new/a.c"); + assertMatched(pattern, "src/new/a/a.c"); + assertMatched(pattern, "neb"); + assertNotMatched(pattern, "src/new.c"); + } + + @Test + public void testParentDirectoryGitIgnores() { + // Contains git ignore patterns such as might be seen in a parent + // directory + + // Test for wildcards + String pattern = "/*/*.c"; + assertMatched(pattern, "/file/a.c"); + assertMatched(pattern, "/src/a.c"); + assertNotMatched(pattern, "/src/new/a.c"); + + // Test child directory/file is matched + pattern = "/src/new"; + assertMatched(pattern, "/src/new/"); + assertMatched(pattern, "/src/new"); + assertMatched(pattern, "/src/new/a.c"); + assertMatched(pattern, "/src/new/a/a.c"); + assertNotMatched(pattern, "/src/new.c"); + + // Test child directory is matched, slash after name + pattern = "/src/new/"; + assertMatched(pattern, "/src/new/"); + assertMatched(pattern, "/src/new/a.c"); + assertMatched(pattern, "/src/new/a/a.c"); + assertNotMatched(pattern, "/src/new"); + assertNotMatched(pattern, "/src/new.c"); + + // Test directory is matched by name only + pattern = "b1"; + assertMatched(pattern, "/src/new/a/b1/a.c"); + assertNotMatched(pattern, "/src/new/a/b2/file.c"); + assertNotMatched(pattern, "/src/new/a/bb1/file.c"); + assertNotMatched(pattern, "/src/new/a/file.c"); + } + + @Test + public void testTrailingSlash() { + String pattern = "/src/"; + assertMatched(pattern, "/src/"); + assertMatched(pattern, "/src/new"); + assertMatched(pattern, "/src/new/a.c"); + assertMatched(pattern, "/src/a.c"); + assertNotMatched(pattern, "/src"); + assertNotMatched(pattern, "/srcA/"); + } + + @Test + public void testNameOnlyMatches() { + /* + * Name-only matches do not contain any path separators + */ + // Test matches for file extension + String pattern = "*.stp"; + assertMatched(pattern, "/test.stp"); + assertMatched(pattern, "/src/test.stp"); + assertNotMatched(pattern, "/test.stp1"); + assertNotMatched(pattern, "/test.astp"); + + // Test matches for name-only, applies to file name or folder name + pattern = "src"; + assertMatched(pattern, "/src"); + assertMatched(pattern, "/src/"); + assertMatched(pattern, "/src/a.c"); + assertMatched(pattern, "/src/new/a.c"); + assertMatched(pattern, "/new/src/a.c"); + assertMatched(pattern, "/file/src"); + + // Test matches for name-only, applies only to folder names + pattern = "src/"; + assertMatched(pattern, "/src/"); + assertMatched(pattern, "/src/a.c"); + assertMatched(pattern, "/src/new/a.c"); + assertMatched(pattern, "/new/src/a.c"); + assertNotMatched(pattern, "/src"); + assertNotMatched(pattern, "/file/src"); + + // Test matches for name-only, applies to file name or folder name + // With a small wildcard + pattern = "?rc"; + assertMatched(pattern, "/src/a.c"); + assertMatched(pattern, "/src/new/a.c"); + assertMatched(pattern, "/new/src/a.c"); + assertMatched(pattern, "/file/src"); + assertMatched(pattern, "/src/"); + + // Test matches for name-only, applies to file name or folder name + // With a small wildcard + pattern = "?r[a-c]"; + assertMatched(pattern, "/src/a.c"); + assertMatched(pattern, "/src/new/a.c"); + assertMatched(pattern, "/new/src/a.c"); + assertMatched(pattern, "/file/src"); + assertMatched(pattern, "/src/"); + assertMatched(pattern, "/srb/a.c"); + assertMatched(pattern, "/grb/new/a.c"); + assertMatched(pattern, "/new/crb/a.c"); + assertMatched(pattern, "/file/3rb"); + assertMatched(pattern, "/xrb/"); + assertMatched(pattern, "/3ra/a.c"); + assertMatched(pattern, "/5ra/new/a.c"); + assertMatched(pattern, "/new/1ra/a.c"); + assertMatched(pattern, "/file/dra"); + assertMatched(pattern, "/era/"); + assertNotMatched(pattern, "/crg"); + assertNotMatched(pattern, "/cr3"); + } + + @Test + public void testNegation() { + String pattern = "!/test.stp"; + assertMatched(pattern, "/test.stp"); + } + + /** + * Check for a match. If target ends with "/", match will assume that the + * target is meant to be a directory. + * + * @param pattern + * Pattern as it would appear in a .gitignore file + * @param target + * Target file path relative to repository's GIT_DIR + */ + public void assertMatched(String pattern, String target) { + boolean value = match(pattern, target); + assertTrue("Expected a match for: " + pattern + " with: " + target, + value); + } + + /** + * Check for a match. If target ends with "/", match will assume that the + * target is meant to be a directory. + * + * @param pattern + * Pattern as it would appear in a .gitignore file + * @param target + * Target file path relative to repository's GIT_DIR + */ + public void assertNotMatched(String pattern, String target) { + boolean value = match(pattern, target); + assertFalse("Expected no match for: " + pattern + " with: " + target, + value); + } + + /** + * Check for a match. If target ends with "/", match will assume that the + * target is meant to be a directory. + * + * @param pattern + * Pattern as it would appear in a .gitignore file + * @param target + * Target file path relative to repository's GIT_DIR + * @return Result of {@link FastIgnoreRule#isMatch(String, boolean)} + */ + private boolean match(String pattern, String target) { + boolean isDirectory = target.endsWith("/"); + if (useJGitRule.booleanValue()) { + IgnoreRule r = new IgnoreRule(pattern); + // If speed of this test is ever an issue, we can use a presetRule + // field + // to avoid recompiling a pattern each time. + return r.isMatch(target, isDirectory); + } + FastIgnoreRule r = new FastIgnoreRule(pattern); + // If speed of this test is ever an issue, we can use a presetRule field + // to avoid recompiling a pattern each time. + return r.isMatch(target, isDirectory); + } +} diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreMatcherTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreMatcherTest.java index aa98696b24..0713b1ad16 100644 --- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreMatcherTest.java +++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreMatcherTest.java @@ -52,6 +52,7 @@ import org.junit.Test; /** * Tests ignore pattern matches */ +@SuppressWarnings("deprecation") public class IgnoreMatcherTest { @Test @@ -383,12 +384,12 @@ public class IgnoreMatcherTest { /** * Check for a match. If target ends with "/", match will assume that the * target is meant to be a directory. + * * @param pattern - * Pattern as it would appear in a .gitignore file + * Pattern as it would appear in a .gitignore file * @param target - * Target file path relative to repository's GIT_DIR - * @return - * Result of {@link IgnoreRule#isMatch(String, boolean)} + * Target file path relative to repository's GIT_DIR + * @return Result of IgnoreRule.isMatch(String, boolean) */ private static boolean match(String pattern, String target) { IgnoreRule r = new IgnoreRule(pattern); diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreRuleSpecialCasesTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreRuleSpecialCasesTest.java new file mode 100644 index 0000000000..41180e70c2 --- /dev/null +++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreRuleSpecialCasesTest.java @@ -0,0 +1,904 @@ +/* + * Copyright (C) 2008, Florian Koeberle <florianskarten@web.de> + * Copyright (C) 2008, Florian Köberle <florianskarten@web.de> + * and other copyright owners as documented in the project's IP log. + * + * This program and the accompanying materials are made available + * under the terms of the Eclipse Distribution License v1.0 which + * accompanies this distribution, is reproduced below, and is + * available at http://www.eclipse.org/org/documents/edl-v10.php + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or + * without modification, are permitted provided that the following + * conditions are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * - Neither the name of the Eclipse Foundation, Inc. nor the + * names of its contributors may be used to endorse or promote + * products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.eclipse.jgit.ignore; + +import static org.junit.Assert.*; +import static org.junit.Assume.*; + +import java.util.Arrays; + +import org.eclipse.jgit.ignore.FastIgnoreRule; +import org.eclipse.jgit.ignore.IgnoreRule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.*; +import org.junit.runners.Parameterized.Parameter; +import org.junit.runners.Parameterized.Parameters; + +@RunWith(Parameterized.class) +@SuppressWarnings({ "deprecation", "boxing" }) +public class IgnoreRuleSpecialCasesTest { + + @Parameters(name = "JGit? {0}") + public static Iterable<Boolean[]> data() { + return Arrays.asList(new Boolean[][] { { Boolean.FALSE }, + { Boolean.TRUE } }); + } + + @Parameter + public Boolean useJGitRule; + + private void assertMatch(final String pattern, final String input, + final boolean matchExpected, Boolean... assume) { + boolean assumeDir = input.endsWith("/"); + if (useJGitRule.booleanValue()) { + final IgnoreRule matcher = new IgnoreRule(pattern); + if (assume.length == 0 || !assume[0].booleanValue()) + assertEquals(matchExpected, matcher.isMatch(input, assumeDir)); + else + assumeTrue(matchExpected == matcher.isMatch(input, assumeDir)); + } else { + FastIgnoreRule matcher = new FastIgnoreRule(pattern); + if (assume.length == 0 || !assume[0].booleanValue()) + assertEquals(matchExpected, matcher.isMatch(input, assumeDir)); + else + assumeTrue(matchExpected == matcher.isMatch(input, assumeDir)); + } + } + + private void assertFileNameMatch(final String pattern, final String input, + final boolean matchExpected) { + boolean assumeDir = input.endsWith("/"); + if (useJGitRule.booleanValue()) { + final IgnoreRule matcher = new IgnoreRule(pattern); + assertEquals(matchExpected, matcher.isMatch(input, assumeDir)); + } else { + FastIgnoreRule matcher = new FastIgnoreRule(pattern); + assertEquals(matchExpected, matcher.isMatch(input, assumeDir)); + } + } + + @Test + public void testVerySimplePatternCase0() throws Exception { + if (useJGitRule) + System.err + .println("IgnoreRule can't understand blank lines, skipping"); + Boolean assume = useJGitRule; + assertMatch("", "", false, assume); + } + + @Test + public void testVerySimplePatternCase1() throws Exception { + assertMatch("ab", "a", false); + } + + @Test + public void testVerySimplePatternCase2() throws Exception { + assertMatch("ab", "ab", true); + } + + @Test + public void testVerySimplePatternCase3() throws Exception { + assertMatch("ab", "ac", false); + } + + @Test + public void testVerySimplePatternCase4() throws Exception { + assertMatch("ab", "abc", false); + } + + @Test + public void testVerySimpleWildcardCase0() throws Exception { + assertMatch("?", "a", true); + } + + @Test + public void testVerySimpleWildCardCase1() throws Exception { + assertMatch("??", "a", false); + } + + @Test + public void testVerySimpleWildCardCase2() throws Exception { + assertMatch("??", "ab", true); + } + + @Test + public void testVerySimpleWildCardCase3() throws Exception { + assertMatch("??", "abc", false); + } + + @Test + public void testVerySimpleStarCase0() throws Exception { + // can't happen, but blank lines should never match + assertMatch("*", "", false); + } + + @Test + public void testVerySimpleStarCase1() throws Exception { + assertMatch("*", "a", true); + } + + @Test + public void testVerySimpleStarCase2() throws Exception { + assertMatch("*", "ab", true); + } + + @Test + public void testSimpleStarCase0() throws Exception { + assertMatch("a*b", "a", false); + } + + @Test + public void testSimpleStarCase1() throws Exception { + assertMatch("a*c", "ac", true); + } + + @Test + public void testSimpleStarCase2() throws Exception { + assertMatch("a*c", "ab", false); + } + + @Test + public void testSimpleStarCase3() throws Exception { + assertMatch("a*c", "abc", true); + } + + @Test + public void testManySolutionsCase0() throws Exception { + assertMatch("a*a*a", "aaa", true); + } + + @Test + public void testManySolutionsCase1() throws Exception { + assertMatch("a*a*a", "aaaa", true); + } + + @Test + public void testManySolutionsCase2() throws Exception { + assertMatch("a*a*a", "ababa", true); + } + + @Test + public void testManySolutionsCase3() throws Exception { + assertMatch("a*a*a", "aaaaaaaa", true); + } + + @Test + public void testManySolutionsCase4() throws Exception { + assertMatch("a*a*a", "aaaaaaab", false); + } + + @Test + public void testVerySimpleGroupCase0() throws Exception { + assertMatch("[ab]", "a", true); + } + + @Test + public void testVerySimpleGroupCase1() throws Exception { + assertMatch("[ab]", "b", true); + } + + @Test + public void testVerySimpleGroupCase2() throws Exception { + assertMatch("[ab]", "ab", false); + } + + @Test + public void testVerySimpleGroupRangeCase0() throws Exception { + assertMatch("[b-d]", "a", false); + } + + @Test + public void testVerySimpleGroupRangeCase1() throws Exception { + assertMatch("[b-d]", "b", true); + } + + @Test + public void testVerySimpleGroupRangeCase2() throws Exception { + assertMatch("[b-d]", "c", true); + } + + @Test + public void testVerySimpleGroupRangeCase3() throws Exception { + assertMatch("[b-d]", "d", true); + } + + @Test + public void testVerySimpleGroupRangeCase4() throws Exception { + assertMatch("[b-d]", "e", false); + } + + @Test + public void testVerySimpleGroupRangeCase5() throws Exception { + assertMatch("[b-d]", "-", false); + } + + @Test + public void testTwoGroupsCase0() throws Exception { + assertMatch("[b-d][ab]", "bb", true); + } + + @Test + public void testTwoGroupsCase1() throws Exception { + assertMatch("[b-d][ab]", "ca", true); + } + + @Test + public void testTwoGroupsCase2() throws Exception { + assertMatch("[b-d][ab]", "fa", false); + } + + @Test + public void testTwoGroupsCase3() throws Exception { + assertMatch("[b-d][ab]", "bc", false); + } + + @Test + public void testTwoRangesInOneGroupCase0() throws Exception { + assertMatch("[b-ce-e]", "a", false); + } + + @Test + public void testTwoRangesInOneGroupCase1() throws Exception { + assertMatch("[b-ce-e]", "b", true); + } + + @Test + public void testTwoRangesInOneGroupCase2() throws Exception { + assertMatch("[b-ce-e]", "c", true); + } + + @Test + public void testTwoRangesInOneGroupCase3() throws Exception { + assertMatch("[b-ce-e]", "d", false); + } + + @Test + public void testTwoRangesInOneGroupCase4() throws Exception { + assertMatch("[b-ce-e]", "e", true); + } + + @Test + public void testTwoRangesInOneGroupCase5() throws Exception { + assertMatch("[b-ce-e]", "f", false); + } + + @Test + public void testIncompleteRangesInOneGroupCase0() throws Exception { + assertMatch("a[b-]", "ab", true); + } + + @Test + public void testIncompleteRangesInOneGroupCase1() throws Exception { + assertMatch("a[b-]", "ac", false); + } + + @Test + public void testIncompleteRangesInOneGroupCase2() throws Exception { + assertMatch("a[b-]", "a-", true); + } + + @Test + public void testCombinedRangesInOneGroupCase0() throws Exception { + assertMatch("[a-c-e]", "b", true); + } + + /** + * The c belongs to the range a-c. "-e" is no valid range so d should not + * match. + * + * @throws Exception + * for some reasons + */ + @Test + public void testCombinedRangesInOneGroupCase1() throws Exception { + assertMatch("[a-c-e]", "d", false); + } + + @Test + public void testCombinedRangesInOneGroupCase2() throws Exception { + assertMatch("[a-c-e]", "e", true); + } + + @Test + public void testInversedGroupCase0() throws Exception { + assertMatch("[!b-c]", "a", true); + } + + @Test + public void testInversedGroupCase1() throws Exception { + assertMatch("[!b-c]", "b", false); + } + + @Test + public void testInversedGroupCase2() throws Exception { + assertMatch("[!b-c]", "c", false); + } + + @Test + public void testInversedGroupCase3() throws Exception { + assertMatch("[!b-c]", "d", true); + } + + @Test + public void testAlphaGroupCase0() throws Exception { + assertMatch("[[:alpha:]]", "d", true); + } + + @Test + public void testAlphaGroupCase1() throws Exception { + assertMatch("[[:alpha:]]", ":", false); + } + + @Test + public void testAlphaGroupCase2() throws Exception { + // \u00f6 = 'o' with dots on it + assertMatch("[[:alpha:]]", "\u00f6", true); + } + + @Test + public void test2AlphaGroupsCase0() throws Exception { + // \u00f6 = 'o' with dots on it + assertMatch("[[:alpha:]][[:alpha:]]", "a\u00f6", true); + assertMatch("[[:alpha:]][[:alpha:]]", "a1", false); + } + + @Test + public void testAlnumGroupCase0() throws Exception { + assertMatch("[[:alnum:]]", "a", true); + } + + @Test + public void testAlnumGroupCase1() throws Exception { + assertMatch("[[:alnum:]]", "1", true); + } + + @Test + public void testAlnumGroupCase2() throws Exception { + assertMatch("[[:alnum:]]", ":", false); + } + + @Test + public void testBlankGroupCase0() throws Exception { + assertMatch("[[:blank:]]", " ", true); + } + + @Test + public void testBlankGroupCase1() throws Exception { + assertMatch("[[:blank:]]", "\t", true); + } + + @Test + public void testBlankGroupCase2() throws Exception { + assertMatch("[[:blank:]]", "\r", false); + } + + @Test + public void testBlankGroupCase3() throws Exception { + assertMatch("[[:blank:]]", "\n", false); + } + + @Test + public void testBlankGroupCase4() throws Exception { + assertMatch("[[:blank:]]", "a", false); + } + + @Test + public void testCntrlGroupCase0() throws Exception { + assertMatch("[[:cntrl:]]", "a", false); + } + + @Test + public void testCntrlGroupCase1() throws Exception { + assertMatch("[[:cntrl:]]", String.valueOf((char) 7), true); + } + + @Test + public void testDigitGroupCase0() throws Exception { + assertMatch("[[:digit:]]", "0", true); + } + + @Test + public void testDigitGroupCase1() throws Exception { + assertMatch("[[:digit:]]", "5", true); + } + + @Test + public void testDigitGroupCase2() throws Exception { + assertMatch("[[:digit:]]", "9", true); + } + + @Test + public void testDigitGroupCase3() throws Exception { + // \u06f9 = EXTENDED ARABIC-INDIC DIGIT NINE + assertMatch("[[:digit:]]", "\u06f9", true); + } + + @Test + public void testDigitGroupCase4() throws Exception { + assertMatch("[[:digit:]]", "a", false); + } + + @Test + public void testDigitGroupCase5() throws Exception { + assertMatch("[[:digit:]]", "]", false); + } + + @Test + public void testGraphGroupCase0() throws Exception { + assertMatch("[[:graph:]]", "]", true); + } + + @Test + public void testGraphGroupCase1() throws Exception { + assertMatch("[[:graph:]]", "a", true); + } + + @Test + public void testGraphGroupCase2() throws Exception { + assertMatch("[[:graph:]]", ".", true); + } + + @Test + public void testGraphGroupCase3() throws Exception { + assertMatch("[[:graph:]]", "0", true); + } + + @Test + public void testGraphGroupCase4() throws Exception { + assertMatch("[[:graph:]]", " ", false); + } + + @Test + public void testGraphGroupCase5() throws Exception { + // \u00f6 = 'o' with dots on it + assertMatch("[[:graph:]]", "\u00f6", true); + } + + @Test + public void testLowerGroupCase0() throws Exception { + assertMatch("[[:lower:]]", "a", true); + } + + @Test + public void testLowerGroupCase1() throws Exception { + assertMatch("[[:lower:]]", "h", true); + } + + @Test + public void testLowerGroupCase2() throws Exception { + assertMatch("[[:lower:]]", "A", false); + } + + @Test + public void testLowerGroupCase3() throws Exception { + assertMatch("[[:lower:]]", "H", false); + } + + @Test + public void testLowerGroupCase4() throws Exception { + // \u00e4 = small 'a' with dots on it + assertMatch("[[:lower:]]", "\u00e4", true); + } + + @Test + public void testLowerGroupCase5() throws Exception { + assertMatch("[[:lower:]]", ".", false); + } + + @Test + public void testPrintGroupCase0() throws Exception { + assertMatch("[[:print:]]", "]", true); + } + + @Test + public void testPrintGroupCase1() throws Exception { + assertMatch("[[:print:]]", "a", true); + } + + @Test + public void testPrintGroupCase2() throws Exception { + assertMatch("[[:print:]]", ".", true); + } + + @Test + public void testPrintGroupCase3() throws Exception { + assertMatch("[[:print:]]", "0", true); + } + + @Test + public void testPrintGroupCase4() throws Exception { + assertMatch("[[:print:]]", " ", true); + } + + @Test + public void testPrintGroupCase5() throws Exception { + // \u00f6 = 'o' with dots on it + assertMatch("[[:print:]]", "\u00f6", true); + } + + @Test + public void testPunctGroupCase0() throws Exception { + assertMatch("[[:punct:]]", ".", true); + } + + @Test + public void testPunctGroupCase1() throws Exception { + assertMatch("[[:punct:]]", "@", true); + } + + @Test + public void testPunctGroupCase2() throws Exception { + assertMatch("[[:punct:]]", " ", false); + } + + @Test + public void testPunctGroupCase3() throws Exception { + assertMatch("[[:punct:]]", "a", false); + } + + @Test + public void testSpaceGroupCase0() throws Exception { + assertMatch("[[:space:]]", " ", true); + } + + @Test + public void testSpaceGroupCase1() throws Exception { + assertMatch("[[:space:]]", "\t", true); + } + + @Test + public void testSpaceGroupCase2() throws Exception { + assertMatch("[[:space:]]", "\r", true); + } + + @Test + public void testSpaceGroupCase3() throws Exception { + assertMatch("[[:space:]]", "\n", true); + } + + @Test + public void testSpaceGroupCase4() throws Exception { + assertMatch("[[:space:]]", "a", false); + } + + @Test + public void testUpperGroupCase0() throws Exception { + assertMatch("[[:upper:]]", "a", false); + } + + @Test + public void testUpperGroupCase1() throws Exception { + assertMatch("[[:upper:]]", "h", false); + } + + @Test + public void testUpperGroupCase2() throws Exception { + assertMatch("[[:upper:]]", "A", true); + } + + @Test + public void testUpperGroupCase3() throws Exception { + assertMatch("[[:upper:]]", "H", true); + } + + @Test + public void testUpperGroupCase4() throws Exception { + // \u00c4 = 'A' with dots on it + assertMatch("[[:upper:]]", "\u00c4", true); + } + + @Test + public void testUpperGroupCase5() throws Exception { + assertMatch("[[:upper:]]", ".", false); + } + + @Test + public void testXDigitGroupCase0() throws Exception { + assertMatch("[[:xdigit:]]", "a", true); + } + + @Test + public void testXDigitGroupCase1() throws Exception { + assertMatch("[[:xdigit:]]", "d", true); + } + + @Test + public void testXDigitGroupCase2() throws Exception { + assertMatch("[[:xdigit:]]", "f", true); + } + + @Test + public void testXDigitGroupCase3() throws Exception { + assertMatch("[[:xdigit:]]", "0", true); + } + + @Test + public void testXDigitGroupCase4() throws Exception { + assertMatch("[[:xdigit:]]", "5", true); + } + + @Test + public void testXDigitGroupCase5() throws Exception { + assertMatch("[[:xdigit:]]", "9", true); + } + + @Test + public void testXDigitGroupCase6() throws Exception { + assertMatch("[[:xdigit:]]", "۹", false); + } + + @Test + public void testXDigitGroupCase7() throws Exception { + assertMatch("[[:xdigit:]]", ".", false); + } + + @Test + public void testWordGroupCase0() throws Exception { + assertMatch("[[:word:]]", "g", true); + } + + @Test + public void testWordGroupCase1() throws Exception { + // \u00f6 = 'o' with dots on it + assertMatch("[[:word:]]", "\u00f6", true); + } + + @Test + public void testWordGroupCase2() throws Exception { + assertMatch("[[:word:]]", "5", true); + } + + @Test + public void testWordGroupCase3() throws Exception { + assertMatch("[[:word:]]", "_", true); + } + + @Test + public void testWordGroupCase4() throws Exception { + assertMatch("[[:word:]]", " ", false); + } + + @Test + public void testWordGroupCase5() throws Exception { + assertMatch("[[:word:]]", ".", false); + } + + @Test + public void testMixedGroupCase0() throws Exception { + assertMatch("[A[:lower:]C3-5]", "A", true); + } + + @Test + public void testMixedGroupCase1() throws Exception { + assertMatch("[A[:lower:]C3-5]", "C", true); + } + + @Test + public void testMixedGroupCase2() throws Exception { + assertMatch("[A[:lower:]C3-5]", "e", true); + } + + @Test + public void testMixedGroupCase3() throws Exception { + assertMatch("[A[:lower:]C3-5]", "3", true); + } + + @Test + public void testMixedGroupCase4() throws Exception { + assertMatch("[A[:lower:]C3-5]", "4", true); + } + + @Test + public void testMixedGroupCase5() throws Exception { + assertMatch("[A[:lower:]C3-5]", "5", true); + } + + @Test + public void testMixedGroupCase6() throws Exception { + assertMatch("[A[:lower:]C3-5]", "B", false); + } + + @Test + public void testMixedGroupCase7() throws Exception { + assertMatch("[A[:lower:]C3-5]", "2", false); + } + + @Test + public void testMixedGroupCase8() throws Exception { + assertMatch("[A[:lower:]C3-5]", "6", false); + } + + @Test + public void testMixedGroupCase9() throws Exception { + assertMatch("[A[:lower:]C3-5]", ".", false); + } + + @Test + public void testSpecialGroupCase0() throws Exception { + assertMatch("[[]", "[", true); + } + + @Test + public void testSpecialGroupCase1() throws Exception { + assertMatch("[]]", "]", true); + } + + @Test + public void testSpecialGroupCase2() throws Exception { + assertMatch("[]a]", "]", true); + } + + @Test + public void testSpecialGroupCase3() throws Exception { + assertMatch("[a[]", "[", true); + } + + @Test + public void testSpecialGroupCase4() throws Exception { + assertMatch("[a[]", "a", true); + } + + @Test + public void testSpecialGroupCase5() throws Exception { + assertMatch("[!]]", "]", false); + } + + @Test + public void testSpecialGroupCase6() throws Exception { + assertMatch("[!]]", "x", true); + } + + @Test + public void testSpecialGroupCase7() throws Exception { + assertMatch("[:]]", ":]", true); + } + + @Test + public void testSpecialGroupCase8() throws Exception { + assertMatch("[:]]", ":", false); + } + + @Test + public void testSpecialGroupCase9() throws Exception { + if (useJGitRule) + System.err.println("IgnoreRule can't understand [[:], skipping"); + Boolean assume = useJGitRule; + // Second bracket is threated literally, so both [ and : should match + assertMatch("[[:]", ":", true, assume); + assertMatch("[[:]", "[", true, assume); + } + + @Test + public void testUnsupportedGroupCase0() throws Exception { + assertMatch("[[=a=]]", "a", false); + assertMatch("[[=a=]]", "=", false); + assertMatch("[=a=]", "a", true); + assertMatch("[=a=]", "=", true); + } + + @Test + public void testUnsupportedGroupCase01() throws Exception { + assertMatch("[.a.]*[.a.]", "aha", true); + } + + @Test + public void testUnsupportedGroupCase1() throws Exception { + assertMatch("[[.a.]]", "a", false); + assertMatch("[[.a.]]", ".", false); + assertMatch("[.a.]", "a", true); + assertMatch("[.a.]", ".", true); + } + + @Test + public void testEscapedBracket1() throws Exception { + assertMatch("\\[", "[", true); + } + + @Test + public void testEscapedBracket2() throws Exception { + assertMatch("\\[[a]", "[", false); + } + + @Test + public void testEscapedBracket3() throws Exception { + assertMatch("\\[[a]", "a", false); + } + + @Test + public void testEscapedBracket4() throws Exception { + assertMatch("\\[[a]", "[a", true); + } + + @Test + public void testEscapedBracket5() throws Exception { + assertMatch("[a\\]]", "]", true); + } + + @Test + public void testEscapedBracket6() throws Exception { + assertMatch("[a\\]]", "a", true); + } + + @Test + public void testEscapedBackslash() throws Exception { + if (useJGitRule) + System.err + .println("IgnoreRule can't understand escaped backslashes, skipping"); + Boolean assume = useJGitRule; + // In Git CLI a\\b matches a\b file + assertMatch("a\\\\b", "a\\b", true, assume); + } + + @Test + public void testMultipleEscapedCharacters1() throws Exception { + assertMatch("\\]a?c\\*\\[d\\?\\]", "]abc*[d?]", true); + } + + @Test + public void testFilePathSimpleCase() throws Exception { + assertFileNameMatch("a/b", "a/b", true); + } + + @Test + public void testFilePathCase0() throws Exception { + assertFileNameMatch("a*b", "a/b", false); + } + + @Test + public void testFilePathCase1() throws Exception { + assertFileNameMatch("a?b", "a/b", false); + } + + @Test + public void testFilePathCase2() throws Exception { + assertFileNameMatch("a*b", "a\\b", true); + } + + @Test + public void testFilePathCase3() throws Exception { + assertFileNameMatch("a?b", "a\\b", true); + } + +}
\ No newline at end of file |