Delete deprecated class IgnoreRule

Was replaced by FastIgnoreRule in 3.6

Change-Id: Ia9c3d1231a5d97f3f5bddc81113954c9f9d8ee1e
Signed-off-by: Matthias Sohn <matthias.sohn@sap.com>

5 files changed, 72 insertions, 602 deletions

diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/attributes/AttributesMatcherTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/attributes/AttributesMatcherTest.java
index 6865406927..9f82b8a1e9 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/attributes/AttributesMatcherTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/attributes/AttributesMatcherTest.java
@@ -51,9 +51,6 @@ import org.junit.Test;
 
 /**
  * Tests git attributes pattern matches
- * <p>
- * Inspired by {@link org.eclipse.jgit.ignore.IgnoreMatcherTest}
- * </p>
  */
 public class AttributesMatcherTest {
 
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
index 007bdcc5fc..a4b799a72e 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/FastIgnoreRuleTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/FastIgnoreRuleTest.java
@@ -47,30 +47,11 @@ 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 static org.junit.Assume.assumeFalse;
-import static org.junit.Assume.assumeTrue;
-
-import java.util.Arrays;
 
 import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameter;
-import org.junit.runners.Parameterized.Parameters;
 
-@SuppressWarnings("deprecation")
-@RunWith(Parameterized.class)
 public class FastIgnoreRuleTest {
 
-	@Parameters(name = "OldRule? {0}")
-	public static Iterable<Boolean[]> data() {
-		return Arrays.asList(new Boolean[][] { { Boolean.FALSE },
-				{ Boolean.TRUE } });
-	}
-
-	@Parameter
-	public Boolean useOldRule;
-
 	@Test
 	public void testSimpleCharClass() {
 		assertMatched("[a]", "a");
@@ -385,58 +366,46 @@ public class FastIgnoreRuleTest {
 		assertNotMatched("a/b/", "c/a/b/c");
 	}
 
-	@SuppressWarnings("boxing")
 	@Test
 	public void testWildmatch() {
-		if (useOldRule)
-			System.err
-					.println("IgnoreRule can't understand wildmatch rules, skipping testWildmatch!");
-
-		Boolean assume = useOldRule;
-		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);
+		assertMatched("**/a/b", "a/b");
+		assertMatched("**/a/b", "c/a/b");
+		assertMatched("**/a/b", "c/d/a/b");
+		assertMatched("**/**/a/b", "c/d/a/b");
+
+		assertMatched("/**/a/b", "a/b");
+		assertMatched("/**/a/b", "c/a/b");
+		assertMatched("/**/a/b", "c/d/a/b");
+		assertMatched("/**/**/a/b", "c/d/a/b");
+
+		assertMatched("a/b/**", "a/b");
+		assertMatched("a/b/**", "a/b/c");
+		assertMatched("a/b/**", "a/b/c/d/");
+		assertMatched("a/b/**/**", "a/b/c/d");
+
+		assertMatched("**/a/**/b", "c/d/a/b");
+		assertMatched("**/a/**/b", "c/d/a/e/b");
+		assertMatched("**/**/a/**/**/b", "c/d/a/e/b");
+
+		assertMatched("/**/a/**/b", "c/d/a/b");
+		assertMatched("/**/a/**/b", "c/d/a/e/b");
+		assertMatched("/**/**/a/**/**/b", "c/d/a/e/b");
+
+		assertMatched("a/**/b", "a/b");
+		assertMatched("a/**/b", "a/c/b");
+		assertMatched("a/**/b", "a/c/d/b");
+		assertMatched("a/**/**/b", "a/c/d/b");
+
+		assertMatched("a/**/b/**/c", "a/c/b/d/c");
+		assertMatched("a/**/**/b/**/**/c", "a/c/b/d/c");
 	}
 
-	@SuppressWarnings("boxing")
 	@Test
 	public void testWildmatchDoNotMatch() {
-		if (useOldRule)
-			System.err
-					.println("IgnoreRule can't understand wildmatch rules, skipping testWildmatchDoNotMatch!");
-
-		Boolean assume = useOldRule;
-		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);
+		assertNotMatched("**/a/b", "a/c/b");
+		assertNotMatched("!/**/*.zip", "c/a/b.zip");
+		assertNotMatched("!**/*.zip", "c/a/b.zip");
+		assertNotMatched("a/**/b", "a/c/bb");
 	}
 
 	@SuppressWarnings("unused")
@@ -478,55 +447,43 @@ public class FastIgnoreRuleTest {
 				split("/a/b/c/", '/').toArray());
 	}
 
-	public void assertMatched(String pattern, String path, Boolean... assume) {
+	public void assertMatched(String pattern, String path) {
 		boolean match = match(pattern, path);
 		String result = path + " is " + (match ? "ignored" : "not ignored")
 				+ " via '" + pattern + "' rule";
-		if (!match)
+		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,
+		}
+		assertTrue("Expected a match for: " + pattern + " with: " + path,
 					match);
 
-		if (pattern.startsWith("!"))
+		if (pattern.startsWith("!")) {
 			pattern = pattern.substring(1);
-		else
+		} 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);
+		assertFalse("Expected no match for: " + pattern + " with: " + path,
+				match);
 	}
 
-	public void assertNotMatched(String pattern, String path, Boolean... assume) {
+	public void assertNotMatched(String pattern, String path) {
 		boolean match = match(pattern, path);
 		String result = path + " is " + (match ? "ignored" : "not ignored")
 				+ " via '" + pattern + "' rule";
-		if (match)
+		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,
+		}
+		assertFalse("Expected no match for: " + pattern + " with: " + path,
 					match);
 
-		if (pattern.startsWith("!"))
+		if (pattern.startsWith("!")) {
 			pattern = pattern.substring(1);
-		else
+		} 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,
+		assertTrue("Expected a match for: " + pattern + " with: " + path,
 					match);
 	}
 
@@ -542,16 +499,6 @@ public class FastIgnoreRuleTest {
 	 */
 	private boolean match(String pattern, String target) {
 		boolean isDirectory = target.endsWith("/");
-		if (useOldRule.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.
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
index 699542c57f..529c75ff39 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreMatcherParametrizedTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreMatcherParametrizedTest.java
@@ -47,31 +47,14 @@ import static org.junit.Assert.assertTrue;
 import static org.junit.Assume.assumeFalse;
 import static org.junit.Assume.assumeTrue;
 
-import java.util.Arrays;
-
 import org.eclipse.jgit.junit.Assert;
 import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-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 = "OldRule? {0}")
-	public static Iterable<Boolean[]> data() {
-		return Arrays.asList(new Boolean[][] { { Boolean.FALSE },
-				{ Boolean.TRUE } });
-	}
-
-	@Parameter
-	public Boolean useOldRule;
-
 	@Test
 	public void testBasic() {
 		String pattern = "/test.stp";
@@ -252,47 +235,38 @@ public class IgnoreMatcherParametrizedTest {
 
 	@Test
 	public void testDirModeAndRegex1() {
-		// IgnoreRule was buggy for some cases below, therefore using "Assume"
-		Boolean assume = useOldRule;
-
 		String pattern = "a/*/src/";
 		assertMatched(pattern, "a/b/src/");
 		assertMatched(pattern, "a/b/src/new");
 		assertMatched(pattern, "a/b/src/new/a.c");
 		assertMatched(pattern, "a/b/src/a.c");
 		// no match as a "file" pattern, because rule is for directories only
-		assertNotMatched(pattern, "a/b/src", assume);
+		assertNotMatched(pattern, "a/b/src");
 		assertNotMatched(pattern, "a/b/srcA/");
 	}
 
 	@Test
 	public void testDirModeAndRegex2() {
-		// IgnoreRule was buggy for some cases below, therefore using "Assume"
-		Boolean assume = useOldRule;
-
 		String pattern = "a/[a-b]/src/";
 		assertMatched(pattern, "a/b/src/");
 		assertMatched(pattern, "a/b/src/new");
 		assertMatched(pattern, "a/b/src/new/a.c");
 		assertMatched(pattern, "a/b/src/a.c");
 		// no match as a "file" pattern, because rule is for directories only
-		assertNotMatched(pattern, "a/b/src", assume);
+		assertNotMatched(pattern, "a/b/src");
 		assertNotMatched(pattern, "a/b/srcA/");
 	}
 
 	@Test
 	public void testDirModeAndRegex3() {
-		// IgnoreRule was buggy for some cases below, therefore using "Assume"
-		Boolean assume = useOldRule;
-
 		String pattern = "**/src/";
-		assertMatched(pattern, "a/b/src/", assume);
-		assertMatched(pattern, "a/b/src/new", assume);
-		assertMatched(pattern, "a/b/src/new/a.c", assume);
-		assertMatched(pattern, "a/b/src/a.c", assume);
+		assertMatched(pattern, "a/b/src/");
+		assertMatched(pattern, "a/b/src/new");
+		assertMatched(pattern, "a/b/src/new/a.c");
+		assertMatched(pattern, "a/b/src/a.c");
 		// no match as a "file" pattern, because rule is for directories only
-		assertNotMatched(pattern, "a/b/src", assume);
-		assertNotMatched(pattern, "a/b/srcA/", assume);
+		assertNotMatched(pattern, "a/b/src");
+		assertNotMatched(pattern, "a/b/srcA/");
 	}
 
 	@Test
@@ -416,13 +390,8 @@ public class IgnoreMatcherParametrizedTest {
 	private boolean match(String pattern, String target) {
 		boolean isDirectory = target.endsWith("/");
 		boolean match;
-		if (useOldRule.booleanValue()) {
-			IgnoreRule r = new IgnoreRule(pattern);
-			match = r.isMatch(target, isDirectory);
-		} else {
-			FastIgnoreRule r = new FastIgnoreRule(pattern);
-			match = r.isMatch(target, isDirectory);
-		}
+		FastIgnoreRule r = new FastIgnoreRule(pattern);
+		match = r.isMatch(target, isDirectory);
 
 		if (isDirectory) {
 			boolean noTrailingSlash = matchAsDir(pattern,
@@ -447,10 +416,6 @@ public class IgnoreMatcherParametrizedTest {
 	 */
 	private boolean matchAsDir(String pattern, String target) {
 		assertFalse(target.endsWith("/"));
-		if (useOldRule.booleanValue()) {
-			IgnoreRule r = new IgnoreRule(pattern);
-			return r.isMatch(target, true);
-		}
 		FastIgnoreRule r = new FastIgnoreRule(pattern);
 		return r.isMatch(target, true);
 	}
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
deleted file mode 100644
index 0713b1ad16..0000000000
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreMatcherTest.java
+++ /dev/null
@@ -1,400 +0,0 @@
-/*
- * 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.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-import org.junit.Test;
-
-
-/**
- * Tests ignore pattern matches
- */
-@SuppressWarnings("deprecation")
-public class IgnoreMatcherTest {
-
-	@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");
-	}
-
-	@Test
-	public void testGetters() {
-		IgnoreRule r = new IgnoreRule("/pattern/");
-		assertFalse(r.getNameOnly());
-		assertTrue(r.dirOnly());
-		assertFalse(r.getNegation());
-		assertEquals(r.getPattern(), "/pattern");
-
-		r = new IgnoreRule("/patter?/");
-		assertFalse(r.getNameOnly());
-		assertTrue(r.dirOnly());
-		assertFalse(r.getNegation());
-		assertEquals(r.getPattern(), "/patter?");
-
-		r = new IgnoreRule("patt*");
-		assertTrue(r.getNameOnly());
-		assertFalse(r.dirOnly());
-		assertFalse(r.getNegation());
-		assertEquals(r.getPattern(), "patt*");
-
-		r = new IgnoreRule("pattern");
-		assertTrue(r.getNameOnly());
-		assertFalse(r.dirOnly());
-		assertFalse(r.getNegation());
-		assertEquals(r.getPattern(), "pattern");
-
-		r = new IgnoreRule("!pattern");
-		assertTrue(r.getNameOnly());
-		assertFalse(r.dirOnly());
-		assertTrue(r.getNegation());
-		assertEquals(r.getPattern(), "pattern");
-
-		r = new IgnoreRule("!/pattern");
-		assertFalse(r.getNameOnly());
-		assertFalse(r.dirOnly());
-		assertTrue(r.getNegation());
-		assertEquals(r.getPattern(), "/pattern");
-
-		r = new IgnoreRule("!/patter?");
-		assertFalse(r.getNameOnly());
-		assertFalse(r.dirOnly());
-		assertTrue(r.getNegation());
-		assertEquals(r.getPattern(), "/patter?");
-	}
-
-	@Test
-	public void testResetState() {
-		String pattern = "/build/*";
-		String target = "/build";
-		// Don't use the assert methods of this class, as we want to test
-		// whether the state in IgnoreRule is reset properly
-		IgnoreRule r = new IgnoreRule(pattern);
-		// Result should be the same for the same inputs
-		assertFalse(r.isMatch(target, true));
-		assertFalse(r.isMatch(target, true));
-	}
-
-	/**
-	 * 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 IgnoreRule.isMatch(String, boolean)
-	 */
-	private static boolean match(String pattern, String target) {
-		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, target.endsWith("/"));
-	}
-}
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
index 7afa69f441..a7a78f841f 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreRuleSpecialCasesTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreRuleSpecialCasesTest.java
@@ -46,64 +46,32 @@ package org.eclipse.jgit.ignore;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assume.assumeTrue;
 
-import java.util.Arrays;
-
 import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameter;
-import org.junit.runners.Parameterized.Parameters;
 
-@RunWith(Parameterized.class)
-@SuppressWarnings({ "deprecation", "boxing" })
+@SuppressWarnings({ "boxing" })
 public class IgnoreRuleSpecialCasesTest {
 
-	@Parameters(name = "OldRule? {0}")
-	public static Iterable<Boolean[]> data() {
-		return Arrays.asList(new Boolean[][] { { Boolean.FALSE },
-				{ Boolean.TRUE } });
-	}
-
-	@Parameter
-	public Boolean useOldRule;
-
 	private void assertMatch(final String pattern, final String input,
 			final boolean matchExpected, Boolean... assume) {
 		boolean assumeDir = input.endsWith("/");
-		if (useOldRule.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));
+		FastIgnoreRule matcher = new FastIgnoreRule(pattern);
+		if (assume.length == 0 || !assume[0].booleanValue()) {
+			assertEquals(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));
+			assumeTrue(matchExpected == matcher.isMatch(input, assumeDir));
 		}
 	}
 
 	private void assertFileNameMatch(final String pattern, final String input,
 			final boolean matchExpected) {
 		boolean assumeDir = input.endsWith("/");
-		if (useOldRule.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));
-		}
+		FastIgnoreRule matcher = new FastIgnoreRule(pattern);
+		assertEquals(matchExpected, matcher.isMatch(input, assumeDir));
 	}
 
 	@Test
 	public void testVerySimplePatternCase0() throws Exception {
-		if (useOldRule)
-			System.err
-					.println("IgnoreRule can't understand blank lines, skipping");
-		Boolean assume = useOldRule;
-		assertMatch("", "", false, assume);
+		assertMatch("", "", false);
 	}
 
 	@Test
@@ -805,12 +773,9 @@ public class IgnoreRuleSpecialCasesTest {
 
 	@Test
 	public void testSpecialGroupCase10() throws Exception {
-		if (useOldRule)
-			System.err.println("IgnoreRule can't understand [[:], skipping");
-		Boolean assume = useOldRule;
 		// Second bracket is threated literally, so both [ and : should match
-		assertMatch("[[:]", ":", true, assume);
-		assertMatch("[[:]", "[", true, assume);
+		assertMatch("[[:]", ":", true);
+		assertMatch("[[:]", "[", true);
 	}
 
 	@Test
@@ -866,12 +831,8 @@ public class IgnoreRuleSpecialCasesTest {
 
 	@Test
 	public void testEscapedBackslash() throws Exception {
-		if (useOldRule)
-			System.err
-					.println("IgnoreRule can't understand escaped backslashes, skipping");
-		Boolean assume = useOldRule;
 		// In Git CLI a\\b matches a\b file
-		assertMatch("a\\\\b", "a\\b", true, assume);
+		assertMatch("a\\\\b", "a\\b", true);
 	}
 
 	@Test