[LANG-1238] Add RegexUtils class instead of overloadinh methods in

StringUtils that take a regex to take precompiled Pattern. Sort methods.

1 files changed, 124 insertions, 124 deletions

diff --git a/src/test/java/org/apache/commons/lang3/RegExUtilsTest.java b/src/test/java/org/apache/commons/lang3/RegExUtilsTest.java
index ab89f5eff..7ceadfe59 100644
--- a/src/test/java/org/apache/commons/lang3/RegExUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/RegExUtilsTest.java
@@ -32,73 +32,104 @@ import org.junit.Test;
 public class RegExUtilsTest {
 
     @Test
-    public void testReplacePattern_StringStringString() {
-        assertNull(RegExUtils.replacePattern(null, "", ""));
-        assertEquals("any", RegExUtils.replacePattern("any", (String) null, ""));
-        assertEquals("any", RegExUtils.replacePattern("any", "", null));
+    public void testRemoveAll_StringPattern() {
+        assertNull(RegExUtils.removeAll(null, Pattern.compile("")));
+        assertEquals("any", RegExUtils.removeAll("any", (Pattern) null));
 
-        assertEquals("zzz", RegExUtils.replacePattern("", "", "zzz"));
-        assertEquals("zzz", RegExUtils.replacePattern("", ".*", "zzz"));
-        assertEquals("", RegExUtils.replacePattern("", ".+", "zzz"));
+        assertEquals("any", RegExUtils.removeAll("any", Pattern.compile("")));
+        assertEquals("", RegExUtils.removeAll("any", Pattern.compile(".*")));
+        assertEquals("", RegExUtils.removeAll("any", Pattern.compile(".+")));
+        assertEquals("", RegExUtils.removeAll("any", Pattern.compile(".?")));
 
-        assertEquals("z", RegExUtils.replacePattern("<__>\n<__>", "<.*>", "z"));
-        assertEquals("z", RegExUtils.replacePattern("<__>\\n<__>", "<.*>", "z"));
-        assertEquals("X", RegExUtils.replacePattern("<A>\nxy\n</A>", "<A>.*</A>", "X"));
+        assertEquals("A\nB", RegExUtils.removeAll("A<__>\n<__>B", Pattern.compile("<.*>")));
+        assertEquals("AB", RegExUtils.removeAll("A<__>\n<__>B", Pattern.compile("(?s)<.*>")));
+        assertEquals("ABC123", RegExUtils.removeAll("ABCabc123abc", Pattern.compile("[a-z]")));
 
-        assertEquals("ABC___123", RegExUtils.replacePattern("ABCabc123", "[a-z]", "_"));
-        assertEquals("ABC_123", RegExUtils.replacePattern("ABCabc123", "[^A-Z0-9]+", "_"));
-        assertEquals("ABC123", RegExUtils.replacePattern("ABCabc123", "[^A-Z0-9]+", ""));
-        assertEquals("Lorem_ipsum_dolor_sit",
-                RegExUtils.replacePattern("Lorem ipsum  dolor   sit", "( +)([a-z]+)", "_$2"));
+        assertEquals("AB", RegExUtils.removeAll("A<__>\n<__>B", Pattern.compile("<.*>", Pattern.DOTALL)));
+        assertEquals("AB", RegExUtils.removeAll("A<__>\\n<__>B", Pattern.compile("<.*>")));
+        assertEquals("", RegExUtils.removeAll("<A>x\\ny</A>", Pattern.compile("<A>.*</A>")));
+        assertEquals("", RegExUtils.removeAll("<A>\nxy\n</A>", Pattern.compile("<A>.*</A>", Pattern.DOTALL)));
     }
 
     @Test
-    public void testRemovePattern_StringString() {
-        assertNull(RegExUtils.removePattern(null, ""));
-        assertEquals("any", RegExUtils.removePattern("any", (String) null));
+    public void testRemoveAll_StringString() {
+        assertNull(RegExUtils.removeAll(null, ""));
+        assertEquals("any", RegExUtils.removeAll("any", (String) null));
 
-        assertEquals("", RegExUtils.removePattern("", ""));
-        assertEquals("", RegExUtils.removePattern("", ".*"));
-        assertEquals("", RegExUtils.removePattern("", ".+"));
+        assertEquals("any", RegExUtils.removeAll("any", ""));
+        assertEquals("", RegExUtils.removeAll("any", ".*"));
+        assertEquals("", RegExUtils.removeAll("any", ".+"));
+        assertEquals("", RegExUtils.removeAll("any", ".?"));
 
-        assertEquals("AB", RegExUtils.removePattern("A<__>\n<__>B", "<.*>"));
-        assertEquals("AB", RegExUtils.removePattern("A<__>\\n<__>B", "<.*>"));
-        assertEquals("", RegExUtils.removePattern("<A>x\\ny</A>", "<A>.*</A>"));
-        assertEquals("", RegExUtils.removePattern("<A>\nxy\n</A>", "<A>.*</A>"));
+        assertEquals("A\nB", RegExUtils.removeAll("A<__>\n<__>B", "<.*>"));
+        assertEquals("AB", RegExUtils.removeAll("A<__>\n<__>B", "(?s)<.*>"));
+        assertEquals("ABC123", RegExUtils.removeAll("ABCabc123abc", "[a-z]"));
 
-        assertEquals("ABC123", RegExUtils.removePattern("ABCabc123", "[a-z]"));
+        try {
+            RegExUtils.removeAll("any", "{badRegexSyntax}");
+            fail("RegExUtils.removeAll expecting PatternSyntaxException");
+        } catch (final PatternSyntaxException ex) {
+            // empty
+        }
     }
 
     @Test
-    public void testReplaceAll_StringStringString() {
-        assertNull(RegExUtils.replaceAll(null, "", ""));
+    public void testRemoveFirst_StringPattern() {
+        assertNull(RegExUtils.removeFirst(null, Pattern.compile("")));
+        assertEquals("any", RegExUtils.removeFirst("any", (Pattern) null));
 
-        assertEquals("any", RegExUtils.replaceAll("any", (String) null, ""));
-        assertEquals("any", RegExUtils.replaceAll("any", "", null));
+        assertEquals("any", RegExUtils.removeFirst("any", Pattern.compile("")));
+        assertEquals("", RegExUtils.removeFirst("any", Pattern.compile(".*")));
+        assertEquals("", RegExUtils.removeFirst("any", Pattern.compile(".+")));
+        assertEquals("bc", RegExUtils.removeFirst("abc", Pattern.compile(".?")));
 
-        assertEquals("zzz", RegExUtils.replaceAll("", "", "zzz"));
-        assertEquals("zzz", RegExUtils.replaceAll("", ".*", "zzz"));
-        assertEquals("", RegExUtils.replaceAll("", ".+", "zzz"));
-        assertEquals("ZZaZZbZZcZZ", RegExUtils.replaceAll("abc", "", "ZZ"));
+        assertEquals("A\n<__>B", RegExUtils.removeFirst("A<__>\n<__>B", Pattern.compile("<.*>")));
+        assertEquals("AB", RegExUtils.removeFirst("A<__>\n<__>B", Pattern.compile("(?s)<.*>")));
+        assertEquals("ABCbc123", RegExUtils.removeFirst("ABCabc123", Pattern.compile("[a-z]")));
+        assertEquals("ABC123abc", RegExUtils.removeFirst("ABCabc123abc", Pattern.compile("[a-z]+")));
+    }
 
-        assertEquals("z\nz", RegExUtils.replaceAll("<__>\n<__>", "<.*>", "z"));
-        assertEquals("z", RegExUtils.replaceAll("<__>\n<__>", "(?s)<.*>", "z"));
+    @Test
+    public void testRemoveFirst_StringString() {
+        assertNull(RegExUtils.removeFirst(null, ""));
+        assertEquals("any", RegExUtils.removeFirst("any", (String) null));
 
-        assertEquals("ABC___123", RegExUtils.replaceAll("ABCabc123", "[a-z]", "_"));
-        assertEquals("ABC_123", RegExUtils.replaceAll("ABCabc123", "[^A-Z0-9]+", "_"));
-        assertEquals("ABC123", RegExUtils.replaceAll("ABCabc123", "[^A-Z0-9]+", ""));
-        assertEquals("Lorem_ipsum_dolor_sit",
-                RegExUtils.replaceAll("Lorem ipsum  dolor   sit", "( +)([a-z]+)", "_$2"));
+        assertEquals("any", RegExUtils.removeFirst("any", ""));
+        assertEquals("", RegExUtils.removeFirst("any", ".*"));
+        assertEquals("", RegExUtils.removeFirst("any", ".+"));
+        assertEquals("bc", RegExUtils.removeFirst("abc", ".?"));
+
+        assertEquals("A\n<__>B", RegExUtils.removeFirst("A<__>\n<__>B", "<.*>"));
+        assertEquals("AB", RegExUtils.removeFirst("A<__>\n<__>B", "(?s)<.*>"));
+        assertEquals("ABCbc123", RegExUtils.removeFirst("ABCabc123", "[a-z]"));
+        assertEquals("ABC123abc", RegExUtils.removeFirst("ABCabc123abc", "[a-z]+"));
 
         try {
-            RegExUtils.replaceAll("any", "{badRegexSyntax}", "");
-            fail("RegExUtils.replaceAll expecting PatternSyntaxException");
+            RegExUtils.removeFirst("any", "{badRegexSyntax}");
+            fail("RegExUtils.removeFirst expecting PatternSyntaxException");
         } catch (final PatternSyntaxException ex) {
             // empty
         }
     }
 
     @Test
+    public void testRemovePattern_StringString() {
+        assertNull(RegExUtils.removePattern(null, ""));
+        assertEquals("any", RegExUtils.removePattern("any", (String) null));
+
+        assertEquals("", RegExUtils.removePattern("", ""));
+        assertEquals("", RegExUtils.removePattern("", ".*"));
+        assertEquals("", RegExUtils.removePattern("", ".+"));
+
+        assertEquals("AB", RegExUtils.removePattern("A<__>\n<__>B", "<.*>"));
+        assertEquals("AB", RegExUtils.removePattern("A<__>\\n<__>B", "<.*>"));
+        assertEquals("", RegExUtils.removePattern("<A>x\\ny</A>", "<A>.*</A>"));
+        assertEquals("", RegExUtils.removePattern("<A>\nxy\n</A>", "<A>.*</A>"));
+
+        assertEquals("ABC123", RegExUtils.removePattern("ABCabc123", "[a-z]"));
+    }
+
+    @Test
     public void testReplaceAll_StringPatternString() {
         assertNull(RegExUtils.replaceAll(null, Pattern.compile(""), ""));
 
@@ -125,29 +156,29 @@ public class RegExUtilsTest {
     }
 
     @Test
-    public void testReplaceFirst_StringStringString() {
-        assertNull(RegExUtils.replaceFirst(null, "", ""));
+    public void testReplaceAll_StringStringString() {
+        assertNull(RegExUtils.replaceAll(null, "", ""));
 
-        assertEquals("any", RegExUtils.replaceFirst("any", (String) null, ""));
-        assertEquals("any", RegExUtils.replaceFirst("any", "", null));
+        assertEquals("any", RegExUtils.replaceAll("any", (String) null, ""));
+        assertEquals("any", RegExUtils.replaceAll("any", "", null));
 
-        assertEquals("zzz", RegExUtils.replaceFirst("", "", "zzz"));
-        assertEquals("zzz", RegExUtils.replaceFirst("", ".*", "zzz"));
-        assertEquals("", RegExUtils.replaceFirst("", ".+", "zzz"));
-        assertEquals("ZZabc", RegExUtils.replaceFirst("abc", "", "ZZ"));
+        assertEquals("zzz", RegExUtils.replaceAll("", "", "zzz"));
+        assertEquals("zzz", RegExUtils.replaceAll("", ".*", "zzz"));
+        assertEquals("", RegExUtils.replaceAll("", ".+", "zzz"));
+        assertEquals("ZZaZZbZZcZZ", RegExUtils.replaceAll("abc", "", "ZZ"));
 
-        assertEquals("z\n<__>", RegExUtils.replaceFirst("<__>\n<__>", "<.*>", "z"));
-        assertEquals("z", RegExUtils.replaceFirst("<__>\n<__>", "(?s)<.*>", "z"));
+        assertEquals("z\nz", RegExUtils.replaceAll("<__>\n<__>", "<.*>", "z"));
+        assertEquals("z", RegExUtils.replaceAll("<__>\n<__>", "(?s)<.*>", "z"));
 
-        assertEquals("ABC_bc123", RegExUtils.replaceFirst("ABCabc123", "[a-z]", "_"));
-        assertEquals("ABC_123abc", RegExUtils.replaceFirst("ABCabc123abc", "[^A-Z0-9]+", "_"));
-        assertEquals("ABC123abc", RegExUtils.replaceFirst("ABCabc123abc", "[^A-Z0-9]+", ""));
-        assertEquals("Lorem_ipsum  dolor   sit",
-                RegExUtils.replaceFirst("Lorem ipsum  dolor   sit", "( +)([a-z]+)", "_$2"));
+        assertEquals("ABC___123", RegExUtils.replaceAll("ABCabc123", "[a-z]", "_"));
+        assertEquals("ABC_123", RegExUtils.replaceAll("ABCabc123", "[^A-Z0-9]+", "_"));
+        assertEquals("ABC123", RegExUtils.replaceAll("ABCabc123", "[^A-Z0-9]+", ""));
+        assertEquals("Lorem_ipsum_dolor_sit",
+                RegExUtils.replaceAll("Lorem ipsum  dolor   sit", "( +)([a-z]+)", "_$2"));
 
         try {
-            RegExUtils.replaceFirst("any", "{badRegexSyntax}", "");
-            fail("RegExUtils.replaceFirst expecting PatternSyntaxException");
+            RegExUtils.replaceAll("any", "{badRegexSyntax}", "");
+            fail("RegExUtils.replaceAll expecting PatternSyntaxException");
         } catch (final PatternSyntaxException ex) {
             // empty
         }
@@ -176,84 +207,53 @@ public class RegExUtilsTest {
     }
 
     @Test
-    public void testRemoveAll_StringString() {
-        assertNull(RegExUtils.removeAll(null, ""));
-        assertEquals("any", RegExUtils.removeAll("any", (String) null));
-
-        assertEquals("any", RegExUtils.removeAll("any", ""));
-        assertEquals("", RegExUtils.removeAll("any", ".*"));
-        assertEquals("", RegExUtils.removeAll("any", ".+"));
-        assertEquals("", RegExUtils.removeAll("any", ".?"));
-
-        assertEquals("A\nB", RegExUtils.removeAll("A<__>\n<__>B", "<.*>"));
-        assertEquals("AB", RegExUtils.removeAll("A<__>\n<__>B", "(?s)<.*>"));
-        assertEquals("ABC123", RegExUtils.removeAll("ABCabc123abc", "[a-z]"));
-
-        try {
-            RegExUtils.removeAll("any", "{badRegexSyntax}");
-            fail("RegExUtils.removeAll expecting PatternSyntaxException");
-        } catch (final PatternSyntaxException ex) {
-            // empty
-        }
-    }
-
-    @Test
-    public void testRemoveAll_StringPattern() {
-        assertNull(RegExUtils.removeAll(null, Pattern.compile("")));
-        assertEquals("any", RegExUtils.removeAll("any", (Pattern) null));
-
-        assertEquals("any", RegExUtils.removeAll("any", Pattern.compile("")));
-        assertEquals("", RegExUtils.removeAll("any", Pattern.compile(".*")));
-        assertEquals("", RegExUtils.removeAll("any", Pattern.compile(".+")));
-        assertEquals("", RegExUtils.removeAll("any", Pattern.compile(".?")));
-
-        assertEquals("A\nB", RegExUtils.removeAll("A<__>\n<__>B", Pattern.compile("<.*>")));
-        assertEquals("AB", RegExUtils.removeAll("A<__>\n<__>B", Pattern.compile("(?s)<.*>")));
-        assertEquals("ABC123", RegExUtils.removeAll("ABCabc123abc", Pattern.compile("[a-z]")));
+    public void testReplaceFirst_StringStringString() {
+        assertNull(RegExUtils.replaceFirst(null, "", ""));
 
-        assertEquals("AB", RegExUtils.removeAll("A<__>\n<__>B", Pattern.compile("<.*>", Pattern.DOTALL)));
-        assertEquals("AB", RegExUtils.removeAll("A<__>\\n<__>B", Pattern.compile("<.*>")));
-        assertEquals("", RegExUtils.removeAll("<A>x\\ny</A>", Pattern.compile("<A>.*</A>")));
-        assertEquals("", RegExUtils.removeAll("<A>\nxy\n</A>", Pattern.compile("<A>.*</A>", Pattern.DOTALL)));
-    }
+        assertEquals("any", RegExUtils.replaceFirst("any", (String) null, ""));
+        assertEquals("any", RegExUtils.replaceFirst("any", "", null));
 
-    @Test
-    public void testRemoveFirst_StringString() {
-        assertNull(RegExUtils.removeFirst(null, ""));
-        assertEquals("any", RegExUtils.removeFirst("any", (String) null));
+        assertEquals("zzz", RegExUtils.replaceFirst("", "", "zzz"));
+        assertEquals("zzz", RegExUtils.replaceFirst("", ".*", "zzz"));
+        assertEquals("", RegExUtils.replaceFirst("", ".+", "zzz"));
+        assertEquals("ZZabc", RegExUtils.replaceFirst("abc", "", "ZZ"));
 
-        assertEquals("any", RegExUtils.removeFirst("any", ""));
-        assertEquals("", RegExUtils.removeFirst("any", ".*"));
-        assertEquals("", RegExUtils.removeFirst("any", ".+"));
-        assertEquals("bc", RegExUtils.removeFirst("abc", ".?"));
+        assertEquals("z\n<__>", RegExUtils.replaceFirst("<__>\n<__>", "<.*>", "z"));
+        assertEquals("z", RegExUtils.replaceFirst("<__>\n<__>", "(?s)<.*>", "z"));
 
-        assertEquals("A\n<__>B", RegExUtils.removeFirst("A<__>\n<__>B", "<.*>"));
-        assertEquals("AB", RegExUtils.removeFirst("A<__>\n<__>B", "(?s)<.*>"));
-        assertEquals("ABCbc123", RegExUtils.removeFirst("ABCabc123", "[a-z]"));
-        assertEquals("ABC123abc", RegExUtils.removeFirst("ABCabc123abc", "[a-z]+"));
+        assertEquals("ABC_bc123", RegExUtils.replaceFirst("ABCabc123", "[a-z]", "_"));
+        assertEquals("ABC_123abc", RegExUtils.replaceFirst("ABCabc123abc", "[^A-Z0-9]+", "_"));
+        assertEquals("ABC123abc", RegExUtils.replaceFirst("ABCabc123abc", "[^A-Z0-9]+", ""));
+        assertEquals("Lorem_ipsum  dolor   sit",
+                RegExUtils.replaceFirst("Lorem ipsum  dolor   sit", "( +)([a-z]+)", "_$2"));
 
         try {
-            RegExUtils.removeFirst("any", "{badRegexSyntax}");
-            fail("RegExUtils.removeFirst expecting PatternSyntaxException");
+            RegExUtils.replaceFirst("any", "{badRegexSyntax}", "");
+            fail("RegExUtils.replaceFirst expecting PatternSyntaxException");
         } catch (final PatternSyntaxException ex) {
             // empty
         }
     }
 
     @Test
-    public void testRemoveFirst_StringPattern() {
-        assertNull(RegExUtils.removeFirst(null, Pattern.compile("")));
-        assertEquals("any", RegExUtils.removeFirst("any", (Pattern) null));
+    public void testReplacePattern_StringStringString() {
+        assertNull(RegExUtils.replacePattern(null, "", ""));
+        assertEquals("any", RegExUtils.replacePattern("any", (String) null, ""));
+        assertEquals("any", RegExUtils.replacePattern("any", "", null));
 
-        assertEquals("any", RegExUtils.removeFirst("any", Pattern.compile("")));
-        assertEquals("", RegExUtils.removeFirst("any", Pattern.compile(".*")));
-        assertEquals("", RegExUtils.removeFirst("any", Pattern.compile(".+")));
-        assertEquals("bc", RegExUtils.removeFirst("abc", Pattern.compile(".?")));
+        assertEquals("zzz", RegExUtils.replacePattern("", "", "zzz"));
+        assertEquals("zzz", RegExUtils.replacePattern("", ".*", "zzz"));
+        assertEquals("", RegExUtils.replacePattern("", ".+", "zzz"));
 
-        assertEquals("A\n<__>B", RegExUtils.removeFirst("A<__>\n<__>B", Pattern.compile("<.*>")));
-        assertEquals("AB", RegExUtils.removeFirst("A<__>\n<__>B", Pattern.compile("(?s)<.*>")));
-        assertEquals("ABCbc123", RegExUtils.removeFirst("ABCabc123", Pattern.compile("[a-z]")));
-        assertEquals("ABC123abc", RegExUtils.removeFirst("ABCabc123abc", Pattern.compile("[a-z]+")));
+        assertEquals("z", RegExUtils.replacePattern("<__>\n<__>", "<.*>", "z"));
+        assertEquals("z", RegExUtils.replacePattern("<__>\\n<__>", "<.*>", "z"));
+        assertEquals("X", RegExUtils.replacePattern("<A>\nxy\n</A>", "<A>.*</A>", "X"));
+
+        assertEquals("ABC___123", RegExUtils.replacePattern("ABCabc123", "[a-z]", "_"));
+        assertEquals("ABC_123", RegExUtils.replacePattern("ABCabc123", "[^A-Z0-9]+", "_"));
+        assertEquals("ABC123", RegExUtils.replacePattern("ABCabc123", "[^A-Z0-9]+", ""));
+        assertEquals("Lorem_ipsum_dolor_sit",
+                RegExUtils.replacePattern("Lorem ipsum  dolor   sit", "( +)([a-z]+)", "_$2"));
     }
 
 }