• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements.  See the NOTICE file distributed with
4  * this work for additional information regarding copyright ownership.
5  * The ASF licenses this file to You under the Apache License, Version 2.0
6  * (the "License"); you may not use this file except in compliance with
7  * the License.  You may obtain a copy of the License at
8  *
9  *      http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 package org.apache.commons.lang3;
18 
19 import static org.junit.jupiter.api.Assertions.assertEquals;
20 import static org.junit.jupiter.api.Assertions.assertNull;
21 import static org.junit.jupiter.api.Assertions.assertThrows;
22 
23 import java.util.regex.Pattern;
24 import java.util.regex.PatternSyntaxException;
25 
26 import org.junit.jupiter.api.Test;
27 
28 /**
29  * Unit tests for methods of {@link org.apache.commons.lang3.RegExUtils} which been moved to their own test classes.
30  */
31 public class RegExUtilsTest extends AbstractLangTest {
32 
33     @Test
testRemoveAll_StringPattern()34     public void testRemoveAll_StringPattern() {
35         assertNull(RegExUtils.removeAll(null, Pattern.compile("")));
36         assertEquals("any", RegExUtils.removeAll("any", (Pattern) null));
37 
38         assertEquals("any", RegExUtils.removeAll("any", Pattern.compile("")));
39         assertEquals("", RegExUtils.removeAll("any", Pattern.compile(".*")));
40         assertEquals("", RegExUtils.removeAll("any", Pattern.compile(".+")));
41         assertEquals("", RegExUtils.removeAll("any", Pattern.compile(".?")));
42 
43         assertEquals("A\nB", RegExUtils.removeAll("A<__>\n<__>B", Pattern.compile("<.*>")));
44         assertEquals("AB", RegExUtils.removeAll("A<__>\n<__>B", Pattern.compile("(?s)<.*>")));
45         assertEquals("ABC123", RegExUtils.removeAll("ABCabc123abc", Pattern.compile("[a-z]")));
46 
47         assertEquals("AB", RegExUtils.removeAll("A<__>\n<__>B", Pattern.compile("<.*>", Pattern.DOTALL)));
48         assertEquals("AB", RegExUtils.removeAll("A<__>\\n<__>B", Pattern.compile("<.*>")));
49         assertEquals("", RegExUtils.removeAll("<A>x\\ny</A>", Pattern.compile("<A>.*</A>")));
50         assertEquals("", RegExUtils.removeAll("<A>\nxy\n</A>", Pattern.compile("<A>.*</A>", Pattern.DOTALL)));
51     }
52 
53     @Test
testRemoveAll_StringString()54     public void testRemoveAll_StringString() {
55         assertNull(RegExUtils.removeAll(null, ""));
56         assertEquals("any", RegExUtils.removeAll("any", (String) null));
57 
58         assertEquals("any", RegExUtils.removeAll("any", ""));
59         assertEquals("", RegExUtils.removeAll("any", ".*"));
60         assertEquals("", RegExUtils.removeAll("any", ".+"));
61         assertEquals("", RegExUtils.removeAll("any", ".?"));
62 
63         assertEquals("A\nB", RegExUtils.removeAll("A<__>\n<__>B", "<.*>"));
64         assertEquals("AB", RegExUtils.removeAll("A<__>\n<__>B", "(?s)<.*>"));
65         assertEquals("ABC123", RegExUtils.removeAll("ABCabc123abc", "[a-z]"));
66 
67         assertThrows(
68                 PatternSyntaxException.class,
69                 () -> RegExUtils.removeAll("any", "{badRegexSyntax}"),
70                 "RegExUtils.removeAll expecting PatternSyntaxException");
71     }
72 
73     @Test
testRemoveFirst_StringPattern()74     public void testRemoveFirst_StringPattern() {
75         assertNull(RegExUtils.removeFirst(null, Pattern.compile("")));
76         assertEquals("any", RegExUtils.removeFirst("any", (Pattern) null));
77 
78         assertEquals("any", RegExUtils.removeFirst("any", Pattern.compile("")));
79         assertEquals("", RegExUtils.removeFirst("any", Pattern.compile(".*")));
80         assertEquals("", RegExUtils.removeFirst("any", Pattern.compile(".+")));
81         assertEquals("bc", RegExUtils.removeFirst("abc", Pattern.compile(".?")));
82 
83         assertEquals("A\n<__>B", RegExUtils.removeFirst("A<__>\n<__>B", Pattern.compile("<.*>")));
84         assertEquals("AB", RegExUtils.removeFirst("A<__>\n<__>B", Pattern.compile("(?s)<.*>")));
85         assertEquals("ABCbc123", RegExUtils.removeFirst("ABCabc123", Pattern.compile("[a-z]")));
86         assertEquals("ABC123abc", RegExUtils.removeFirst("ABCabc123abc", Pattern.compile("[a-z]+")));
87     }
88 
89     @Test
testRemoveFirst_StringString()90     public void testRemoveFirst_StringString() {
91         assertNull(RegExUtils.removeFirst(null, ""));
92         assertEquals("any", RegExUtils.removeFirst("any", (String) null));
93 
94         assertEquals("any", RegExUtils.removeFirst("any", ""));
95         assertEquals("", RegExUtils.removeFirst("any", ".*"));
96         assertEquals("", RegExUtils.removeFirst("any", ".+"));
97         assertEquals("bc", RegExUtils.removeFirst("abc", ".?"));
98 
99         assertEquals("A\n<__>B", RegExUtils.removeFirst("A<__>\n<__>B", "<.*>"));
100         assertEquals("AB", RegExUtils.removeFirst("A<__>\n<__>B", "(?s)<.*>"));
101         assertEquals("ABCbc123", RegExUtils.removeFirst("ABCabc123", "[a-z]"));
102         assertEquals("ABC123abc", RegExUtils.removeFirst("ABCabc123abc", "[a-z]+"));
103 
104         assertThrows(
105                 PatternSyntaxException.class,
106                 () -> RegExUtils.removeFirst("any", "{badRegexSyntax}"),
107                 "RegExUtils.removeFirst expecting PatternSyntaxException");
108     }
109 
110     @Test
testRemovePattern_StringString()111     public void testRemovePattern_StringString() {
112         assertNull(RegExUtils.removePattern(null, ""));
113         assertEquals("any", RegExUtils.removePattern("any", (String) null));
114 
115         assertEquals("", RegExUtils.removePattern("", ""));
116         assertEquals("", RegExUtils.removePattern("", ".*"));
117         assertEquals("", RegExUtils.removePattern("", ".+"));
118 
119         assertEquals("AB", RegExUtils.removePattern("A<__>\n<__>B", "<.*>"));
120         assertEquals("AB", RegExUtils.removePattern("A<__>\\n<__>B", "<.*>"));
121         assertEquals("", RegExUtils.removePattern("<A>x\\ny</A>", "<A>.*</A>"));
122         assertEquals("", RegExUtils.removePattern("<A>\nxy\n</A>", "<A>.*</A>"));
123 
124         assertEquals("ABC123", RegExUtils.removePattern("ABCabc123", "[a-z]"));
125     }
126 
127     @Test
testReplaceAll_StringPatternString()128     public void testReplaceAll_StringPatternString() {
129         assertNull(RegExUtils.replaceAll(null, Pattern.compile(""), ""));
130 
131         assertEquals("any", RegExUtils.replaceAll("any", (Pattern) null, ""));
132         assertEquals("any", RegExUtils.replaceAll("any", Pattern.compile(""), null));
133 
134         assertEquals("zzz", RegExUtils.replaceAll("", Pattern.compile(""), "zzz"));
135         assertEquals("zzz", RegExUtils.replaceAll("", Pattern.compile(".*"), "zzz"));
136         assertEquals("", RegExUtils.replaceAll("", Pattern.compile(".+"), "zzz"));
137         assertEquals("ZZaZZbZZcZZ", RegExUtils.replaceAll("abc", Pattern.compile(""), "ZZ"));
138 
139         assertEquals("z\nz", RegExUtils.replaceAll("<__>\n<__>", Pattern.compile("<.*>"), "z"));
140         assertEquals("z", RegExUtils.replaceAll("<__>\n<__>", Pattern.compile("(?s)<.*>"), "z"));
141 
142         assertEquals("z", RegExUtils.replaceAll("<__>\n<__>", Pattern.compile("<.*>", Pattern.DOTALL), "z"));
143         assertEquals("z", RegExUtils.replaceAll("<__>\\n<__>", Pattern.compile("<.*>"), "z"));
144         assertEquals("X", RegExUtils.replaceAll("<A>\nxy\n</A>", Pattern.compile("<A>.*</A>", Pattern.DOTALL), "X"));
145 
146         assertEquals("ABC___123", RegExUtils.replaceAll("ABCabc123", Pattern.compile("[a-z]"), "_"));
147         assertEquals("ABC_123", RegExUtils.replaceAll("ABCabc123", Pattern.compile("[^A-Z0-9]+"), "_"));
148         assertEquals("ABC123", RegExUtils.replaceAll("ABCabc123", Pattern.compile("[^A-Z0-9]+"), ""));
149         assertEquals("Lorem_ipsum_dolor_sit",
150                 RegExUtils.replaceAll("Lorem ipsum  dolor   sit", Pattern.compile("( +)([a-z]+)"), "_$2"));
151     }
152 
153     @Test
testReplaceAll_StringStringString()154     public void testReplaceAll_StringStringString() {
155         assertNull(RegExUtils.replaceAll(null, "", ""));
156 
157         assertEquals("any", RegExUtils.replaceAll("any", (String) null, ""));
158         assertEquals("any", RegExUtils.replaceAll("any", "", null));
159 
160         assertEquals("zzz", RegExUtils.replaceAll("", "", "zzz"));
161         assertEquals("zzz", RegExUtils.replaceAll("", ".*", "zzz"));
162         assertEquals("", RegExUtils.replaceAll("", ".+", "zzz"));
163         assertEquals("ZZaZZbZZcZZ", RegExUtils.replaceAll("abc", "", "ZZ"));
164 
165         assertEquals("z\nz", RegExUtils.replaceAll("<__>\n<__>", "<.*>", "z"));
166         assertEquals("z", RegExUtils.replaceAll("<__>\n<__>", "(?s)<.*>", "z"));
167 
168         assertEquals("ABC___123", RegExUtils.replaceAll("ABCabc123", "[a-z]", "_"));
169         assertEquals("ABC_123", RegExUtils.replaceAll("ABCabc123", "[^A-Z0-9]+", "_"));
170         assertEquals("ABC123", RegExUtils.replaceAll("ABCabc123", "[^A-Z0-9]+", ""));
171         assertEquals("Lorem_ipsum_dolor_sit", RegExUtils.replaceAll("Lorem ipsum  dolor   sit", "( +)([a-z]+)", "_$2"));
172 
173         assertThrows(
174                 PatternSyntaxException.class,
175                 () -> RegExUtils.replaceAll("any", "{badRegexSyntax}", ""),
176                 "RegExUtils.replaceAll expecting PatternSyntaxException");
177     }
178 
179     @Test
testReplaceFirst_StringPatternString()180     public void testReplaceFirst_StringPatternString() {
181         assertNull(RegExUtils.replaceFirst(null, Pattern.compile(""), ""));
182 
183         assertEquals("any", RegExUtils.replaceFirst("any", (Pattern) null, ""));
184         assertEquals("any", RegExUtils.replaceFirst("any", Pattern.compile(""), null));
185 
186         assertEquals("zzz", RegExUtils.replaceFirst("", Pattern.compile(""), "zzz"));
187         assertEquals("zzz", RegExUtils.replaceFirst("", Pattern.compile(".*"), "zzz"));
188         assertEquals("", RegExUtils.replaceFirst("", Pattern.compile(".+"), "zzz"));
189         assertEquals("ZZabc", RegExUtils.replaceFirst("abc", Pattern.compile(""), "ZZ"));
190 
191         assertEquals("z\n<__>", RegExUtils.replaceFirst("<__>\n<__>", Pattern.compile("<.*>"), "z"));
192         assertEquals("z", RegExUtils.replaceFirst("<__>\n<__>", Pattern.compile("(?s)<.*>"), "z"));
193 
194         assertEquals("ABC_bc123", RegExUtils.replaceFirst("ABCabc123", Pattern.compile("[a-z]"), "_"));
195         assertEquals("ABC_123abc", RegExUtils.replaceFirst("ABCabc123abc", Pattern.compile("[^A-Z0-9]+"), "_"));
196         assertEquals("ABC123abc", RegExUtils.replaceFirst("ABCabc123abc", Pattern.compile("[^A-Z0-9]+"), ""));
197         assertEquals("Lorem_ipsum  dolor   sit",
198                 RegExUtils.replaceFirst("Lorem ipsum  dolor   sit", Pattern.compile("( +)([a-z]+)"), "_$2"));
199     }
200 
201     @Test
testReplaceFirst_StringStringString()202     public void testReplaceFirst_StringStringString() {
203         assertNull(RegExUtils.replaceFirst(null, "", ""));
204 
205         assertEquals("any", RegExUtils.replaceFirst("any", (String) null, ""));
206         assertEquals("any", RegExUtils.replaceFirst("any", "", null));
207 
208         assertEquals("zzz", RegExUtils.replaceFirst("", "", "zzz"));
209         assertEquals("zzz", RegExUtils.replaceFirst("", ".*", "zzz"));
210         assertEquals("", RegExUtils.replaceFirst("", ".+", "zzz"));
211         assertEquals("ZZabc", RegExUtils.replaceFirst("abc", "", "ZZ"));
212 
213         assertEquals("z\n<__>", RegExUtils.replaceFirst("<__>\n<__>", "<.*>", "z"));
214         assertEquals("z", RegExUtils.replaceFirst("<__>\n<__>", "(?s)<.*>", "z"));
215 
216         assertEquals("ABC_bc123", RegExUtils.replaceFirst("ABCabc123", "[a-z]", "_"));
217         assertEquals("ABC_123abc", RegExUtils.replaceFirst("ABCabc123abc", "[^A-Z0-9]+", "_"));
218         assertEquals("ABC123abc", RegExUtils.replaceFirst("ABCabc123abc", "[^A-Z0-9]+", ""));
219         assertEquals("Lorem_ipsum  dolor   sit",
220                 RegExUtils.replaceFirst("Lorem ipsum  dolor   sit", "( +)([a-z]+)", "_$2"));
221 
222         assertThrows(
223                 PatternSyntaxException.class,
224                 () -> RegExUtils.replaceFirst("any", "{badRegexSyntax}", ""),
225                 "RegExUtils.replaceFirst expecting PatternSyntaxException");
226     }
227 
228     @Test
testReplacePattern_StringStringString()229     public void testReplacePattern_StringStringString() {
230         assertNull(RegExUtils.replacePattern(null, "", ""));
231         assertEquals("any", RegExUtils.replacePattern("any", (String) null, ""));
232         assertEquals("any", RegExUtils.replacePattern("any", "", null));
233 
234         assertEquals("zzz", RegExUtils.replacePattern("", "", "zzz"));
235         assertEquals("zzz", RegExUtils.replacePattern("", ".*", "zzz"));
236         assertEquals("", RegExUtils.replacePattern("", ".+", "zzz"));
237 
238         assertEquals("z", RegExUtils.replacePattern("<__>\n<__>", "<.*>", "z"));
239         assertEquals("z", RegExUtils.replacePattern("<__>\\n<__>", "<.*>", "z"));
240         assertEquals("X", RegExUtils.replacePattern("<A>\nxy\n</A>", "<A>.*</A>", "X"));
241 
242         assertEquals("ABC___123", RegExUtils.replacePattern("ABCabc123", "[a-z]", "_"));
243         assertEquals("ABC_123", RegExUtils.replacePattern("ABCabc123", "[^A-Z0-9]+", "_"));
244         assertEquals("ABC123", RegExUtils.replacePattern("ABCabc123", "[^A-Z0-9]+", ""));
245         assertEquals("Lorem_ipsum_dolor_sit",
246                 RegExUtils.replacePattern("Lorem ipsum  dolor   sit", "( +)([a-z]+)", "_$2"));
247     }
248 
249 }
250