View Javadoc
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    *      https://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.text.matcher;
18  
19  import static org.junit.jupiter.api.Assertions.assertEquals;
20  import static org.junit.jupiter.api.Assertions.assertInstanceOf;
21  import static org.junit.jupiter.api.Assertions.assertSame;
22  
23  import org.junit.jupiter.api.Test;
24  
25  /**
26   * Tests {@link StringMatcher}.
27   */
28  class StringMatcherOnCharSequenceStringTest {
29  
30      private static final String INPUT1 = "0,1\t2 3\n\r\f\u0000'\"";
31  
32      private static final String INPUT2 = "abcdef";
33  
34      private static final int INPUT2_LENGTH = INPUT2.length();
35  
36      private void checkAndMatcher_char(final StringMatcher matcher) {
37          assertEquals(0, matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH));
38          assertEquals(0, matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH));
39          assertEquals(3, matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH));
40          assertEquals(0, matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH));
41          assertEquals(0, matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH));
42          assertEquals(0, matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH));
43          //
44          assertEquals(0, matcher.isMatch(INPUT2, 0));
45          assertEquals(0, matcher.isMatch(INPUT2, 1));
46          assertEquals(3, matcher.isMatch(INPUT2, 2));
47          assertEquals(0, matcher.isMatch(INPUT2, 3));
48          assertEquals(0, matcher.isMatch(INPUT2, 4));
49          assertEquals(0, matcher.isMatch(INPUT2, 5));
50      }
51  
52      @Test
53      void testAndMatcher_char() {
54          final StringMatcher matcher1 = StringMatcherFactory.INSTANCE.andMatcher(StringMatcherFactory.INSTANCE.charMatcher('c'),
55                  StringMatcherFactory.INSTANCE.stringMatcher("de"));
56          assertEquals(3, matcher1.size());
57          checkAndMatcher_char(matcher1);
58          //
59          final StringMatcher matcher2 = StringMatcherFactory.INSTANCE.andMatcher(null, StringMatcherFactory.INSTANCE.charMatcher('c'), null,
60                  StringMatcherFactory.INSTANCE.stringMatcher("de"), null);
61          assertEquals(3, matcher2.size());
62          checkAndMatcher_char(matcher2);
63      }
64  
65      @Test
66      void testCharMatcher_char() {
67          final StringMatcher matcher = StringMatcherFactory.INSTANCE.charMatcher('c');
68          assertEquals(1, matcher.size());
69          //
70          assertEquals(0, matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH));
71          assertEquals(0, matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH));
72          assertEquals(1, matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH));
73          assertEquals(0, matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH));
74          assertEquals(0, matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH));
75          assertEquals(0, matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH));
76          //
77          assertEquals(0, matcher.isMatch(INPUT2, 0));
78          assertEquals(0, matcher.isMatch(INPUT2, 1));
79          assertEquals(1, matcher.isMatch(INPUT2, 2));
80          assertEquals(0, matcher.isMatch(INPUT2, 3));
81          assertEquals(0, matcher.isMatch(INPUT2, 4));
82          assertEquals(0, matcher.isMatch(INPUT2, 5));
83      }
84  
85      @Test
86      void testCharSetMatcher_charArray() {
87          final StringMatcher matcher = StringMatcherFactory.INSTANCE.charSetMatcher("ace".toCharArray());
88          assertEquals(1, matcher.size());
89          //
90          assertEquals(1, matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH));
91          assertEquals(0, matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH));
92          assertEquals(1, matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH));
93          assertEquals(0, matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH));
94          assertEquals(1, matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH));
95          assertEquals(0, matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH));
96          //
97          assertEquals(1, matcher.isMatch(INPUT2, 0));
98          assertEquals(0, matcher.isMatch(INPUT2, 1));
99          assertEquals(1, matcher.isMatch(INPUT2, 2));
100         assertEquals(0, matcher.isMatch(INPUT2, 3));
101         assertEquals(1, matcher.isMatch(INPUT2, 4));
102         assertEquals(0, matcher.isMatch(INPUT2, 5));
103         //
104         assertSame(StringMatcherFactory.INSTANCE.charSetMatcher(), StringMatcherFactory.INSTANCE.noneMatcher());
105         assertSame(StringMatcherFactory.INSTANCE.charSetMatcher((char[]) null), StringMatcherFactory.INSTANCE.noneMatcher());
106         assertInstanceOf(AbstractStringMatcher.CharMatcher.class, StringMatcherFactory.INSTANCE.charSetMatcher("a".toCharArray()));
107     }
108 
109     @Test
110     void testCharSetMatcher_String() {
111         final StringMatcher matcher = StringMatcherFactory.INSTANCE.charSetMatcher("ace");
112         assertEquals(1, matcher.size());
113         //
114         assertEquals(1, matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH));
115         assertEquals(0, matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH));
116         assertEquals(1, matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH));
117         assertEquals(0, matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH));
118         assertEquals(1, matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH));
119         assertEquals(0, matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH));
120         //
121         assertEquals(1, matcher.isMatch(INPUT2, 0));
122         assertEquals(0, matcher.isMatch(INPUT2, 1));
123         assertEquals(1, matcher.isMatch(INPUT2, 2));
124         assertEquals(0, matcher.isMatch(INPUT2, 3));
125         assertEquals(1, matcher.isMatch(INPUT2, 4));
126         assertEquals(0, matcher.isMatch(INPUT2, 5));
127         //
128         assertSame(StringMatcherFactory.INSTANCE.charSetMatcher(""), StringMatcherFactory.INSTANCE.noneMatcher());
129         assertSame(StringMatcherFactory.INSTANCE.charSetMatcher((String) null), StringMatcherFactory.INSTANCE.noneMatcher());
130         assertInstanceOf(AbstractStringMatcher.CharMatcher.class, StringMatcherFactory.INSTANCE.charSetMatcher("a"));
131     }
132 
133     @Test
134     void testCommaMatcher() {
135         final StringMatcher matcher = StringMatcherFactory.INSTANCE.commaMatcher();
136         assertEquals(1, matcher.size());
137         assertSame(StringMatcherFactory.INSTANCE.commaMatcher(), matcher);
138         //
139         assertEquals(0, matcher.isMatch(INPUT1, 0, 0, INPUT1.length()));
140         assertEquals(1, matcher.isMatch(INPUT1, 1, 0, INPUT1.length()));
141         assertEquals(0, matcher.isMatch(INPUT1, 2, 0, INPUT1.length()));
142         //
143         assertEquals(0, matcher.isMatch(INPUT1, 0));
144         assertEquals(1, matcher.isMatch(INPUT1, 1));
145         assertEquals(0, matcher.isMatch(INPUT1, 2));
146     }
147 
148     @Test
149     void testDoubleQuoteMatcher() {
150         final StringMatcher matcher = StringMatcherFactory.INSTANCE.doubleQuoteMatcher();
151         assertEquals(1, matcher.size());
152         assertSame(StringMatcherFactory.INSTANCE.doubleQuoteMatcher(), matcher);
153         //
154         assertEquals(0, matcher.isMatch(INPUT1, 11, 0, INPUT1.length()));
155         assertEquals(1, matcher.isMatch(INPUT1, 12, 0, INPUT1.length()));
156         //
157         assertEquals(0, matcher.isMatch(INPUT1, 11));
158         assertEquals(1, matcher.isMatch(INPUT1, 12));
159     }
160 
161     @Test
162     void testMatcherIndices() {
163         // remember that the API contract is tight for the isMatch() method
164         // all the onus is on the caller, so invalid inputs are not
165         // the concern of StringMatcher, and are not bugs
166         final StringMatcher matcher = StringMatcherFactory.INSTANCE.stringMatcher("bc");
167         assertEquals(2, matcher.size());
168         assertEquals(2, matcher.isMatch(INPUT2, 1, 1, INPUT2_LENGTH));
169         assertEquals(2, matcher.isMatch(INPUT2, 1, 0, 3));
170         assertEquals(0, matcher.isMatch(INPUT2, 1, 0, 2));
171     }
172 
173     @Test
174     void testNoneMatcher() {
175         final StringMatcher matcher = StringMatcherFactory.INSTANCE.noneMatcher();
176         assertEquals(0, matcher.size());
177         assertSame(StringMatcherFactory.INSTANCE.noneMatcher(), matcher);
178         //
179         assertEquals(0, matcher.isMatch(INPUT1, 0, 0, INPUT1.length()));
180         assertEquals(0, matcher.isMatch(INPUT1, 1, 0, INPUT1.length()));
181         assertEquals(0, matcher.isMatch(INPUT1, 2, 0, INPUT1.length()));
182         assertEquals(0, matcher.isMatch(INPUT1, 3, 0, INPUT1.length()));
183         assertEquals(0, matcher.isMatch(INPUT1, 4, 0, INPUT1.length()));
184         assertEquals(0, matcher.isMatch(INPUT1, 5, 0, INPUT1.length()));
185         assertEquals(0, matcher.isMatch(INPUT1, 6, 0, INPUT1.length()));
186         assertEquals(0, matcher.isMatch(INPUT1, 7, 0, INPUT1.length()));
187         assertEquals(0, matcher.isMatch(INPUT1, 8, 0, INPUT1.length()));
188         assertEquals(0, matcher.isMatch(INPUT1, 9, 0, INPUT1.length()));
189         assertEquals(0, matcher.isMatch(INPUT1, 10, 0, INPUT1.length()));
190         assertEquals(0, matcher.isMatch(INPUT1, 11, 0, INPUT1.length()));
191         assertEquals(0, matcher.isMatch(INPUT1, 12, 0, INPUT1.length()));
192         //
193         assertEquals(0, matcher.isMatch(INPUT1, 0));
194         assertEquals(0, matcher.isMatch(INPUT1, 1));
195         assertEquals(0, matcher.isMatch(INPUT1, 2));
196         assertEquals(0, matcher.isMatch(INPUT1, 3));
197         assertEquals(0, matcher.isMatch(INPUT1, 4));
198         assertEquals(0, matcher.isMatch(INPUT1, 5));
199         assertEquals(0, matcher.isMatch(INPUT1, 6));
200         assertEquals(0, matcher.isMatch(INPUT1, 7));
201         assertEquals(0, matcher.isMatch(INPUT1, 8));
202         assertEquals(0, matcher.isMatch(INPUT1, 9));
203         assertEquals(0, matcher.isMatch(INPUT1, 10));
204         assertEquals(0, matcher.isMatch(INPUT1, 11));
205         assertEquals(0, matcher.isMatch(INPUT1, 12));
206     }
207 
208     @Test
209     void testQuoteMatcher() {
210         final StringMatcher matcher = StringMatcherFactory.INSTANCE.quoteMatcher();
211         assertEquals(1, matcher.size());
212         assertSame(StringMatcherFactory.INSTANCE.quoteMatcher(), matcher);
213         //
214         assertEquals(0, matcher.isMatch(INPUT1, 10, 0, INPUT1.length()));
215         assertEquals(1, matcher.isMatch(INPUT1, 11, 0, INPUT1.length()));
216         assertEquals(1, matcher.isMatch(INPUT1, 12, 0, INPUT1.length()));
217         //
218         assertEquals(0, matcher.isMatch(INPUT1, 10));
219         assertEquals(1, matcher.isMatch(INPUT1, 11));
220         assertEquals(1, matcher.isMatch(INPUT1, 12));
221     }
222 
223     @Test
224     void testSingleQuoteMatcher() {
225         final StringMatcher matcher = StringMatcherFactory.INSTANCE.singleQuoteMatcher();
226         assertEquals(1, matcher.size());
227         assertSame(StringMatcherFactory.INSTANCE.singleQuoteMatcher(), matcher);
228         //
229         assertEquals(0, matcher.isMatch(INPUT1, 10, 0, INPUT1.length()));
230         assertEquals(1, matcher.isMatch(INPUT1, 11, 0, INPUT1.length()));
231         assertEquals(0, matcher.isMatch(INPUT1, 12, 0, INPUT1.length()));
232         //
233         assertEquals(0, matcher.isMatch(INPUT1, 10));
234         assertEquals(1, matcher.isMatch(INPUT1, 11));
235         assertEquals(0, matcher.isMatch(INPUT1, 12));
236     }
237 
238     @Test
239     void testSpaceMatcher() {
240         final StringMatcher matcher = StringMatcherFactory.INSTANCE.spaceMatcher();
241         assertEquals(1, matcher.size());
242         assertSame(StringMatcherFactory.INSTANCE.spaceMatcher(), matcher);
243         //
244         assertEquals(0, matcher.isMatch(INPUT1, 4, 0, INPUT1.length()));
245         assertEquals(1, matcher.isMatch(INPUT1, 5, 0, INPUT1.length()));
246         assertEquals(0, matcher.isMatch(INPUT1, 6, 0, INPUT1.length()));
247         //
248         assertEquals(0, matcher.isMatch(INPUT1, 4));
249         assertEquals(1, matcher.isMatch(INPUT1, 5));
250         assertEquals(0, matcher.isMatch(INPUT1, 6));
251     }
252 
253     @Test
254     void testSplitMatcher() {
255         final StringMatcher matcher = StringMatcherFactory.INSTANCE.splitMatcher();
256         assertEquals(1, matcher.size());
257         assertSame(StringMatcherFactory.INSTANCE.splitMatcher(), matcher);
258         //
259         assertEquals(0, matcher.isMatch(INPUT1, 2, 0, INPUT1.length()));
260         assertEquals(1, matcher.isMatch(INPUT1, 3, 0, INPUT1.length()));
261         assertEquals(0, matcher.isMatch(INPUT1, 4, 0, INPUT1.length()));
262         assertEquals(1, matcher.isMatch(INPUT1, 5, 0, INPUT1.length()));
263         assertEquals(0, matcher.isMatch(INPUT1, 6, 0, INPUT1.length()));
264         assertEquals(1, matcher.isMatch(INPUT1, 7, 0, INPUT1.length()));
265         assertEquals(1, matcher.isMatch(INPUT1, 8, 0, INPUT1.length()));
266         assertEquals(1, matcher.isMatch(INPUT1, 9, 0, INPUT1.length()));
267         assertEquals(0, matcher.isMatch(INPUT1, 10, 0, INPUT1.length()));
268         //
269         assertEquals(0, matcher.isMatch(INPUT1, 2));
270         assertEquals(1, matcher.isMatch(INPUT1, 3));
271         assertEquals(0, matcher.isMatch(INPUT1, 4));
272         assertEquals(1, matcher.isMatch(INPUT1, 5));
273         assertEquals(0, matcher.isMatch(INPUT1, 6));
274         assertEquals(1, matcher.isMatch(INPUT1, 7));
275         assertEquals(1, matcher.isMatch(INPUT1, 8));
276         assertEquals(1, matcher.isMatch(INPUT1, 9));
277         assertEquals(0, matcher.isMatch(INPUT1, 10));
278     }
279 
280     @Test
281     void testStringMatcher_String() {
282         final StringMatcher matcher = StringMatcherFactory.INSTANCE.stringMatcher("bc");
283         assertEquals(2, matcher.size());
284         //
285         assertEquals(0, matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH));
286         assertEquals(2, matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH));
287         assertEquals(0, matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH));
288         assertEquals(0, matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH));
289         assertEquals(0, matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH));
290         assertEquals(0, matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH));
291         //
292         assertEquals(0, matcher.isMatch(INPUT2, 0));
293         assertEquals(2, matcher.isMatch(INPUT2, 1));
294         assertEquals(0, matcher.isMatch(INPUT2, 2));
295         assertEquals(0, matcher.isMatch(INPUT2, 3));
296         assertEquals(0, matcher.isMatch(INPUT2, 4));
297         assertEquals(0, matcher.isMatch(INPUT2, 5));
298         //
299         assertSame(StringMatcherFactory.INSTANCE.stringMatcher(""), StringMatcherFactory.INSTANCE.noneMatcher());
300         assertSame(StringMatcherFactory.INSTANCE.stringMatcher((String) null), StringMatcherFactory.INSTANCE.noneMatcher());
301     }
302 
303     @Test
304     void testTabMatcher() {
305         final StringMatcher matcher = StringMatcherFactory.INSTANCE.tabMatcher();
306         assertEquals(1, matcher.size());
307         assertSame(StringMatcherFactory.INSTANCE.tabMatcher(), matcher);
308         //
309         assertEquals(0, matcher.isMatch(INPUT1, 2, 0, INPUT1.length()));
310         assertEquals(1, matcher.isMatch(INPUT1, 3, 0, INPUT1.length()));
311         assertEquals(0, matcher.isMatch(INPUT1, 4, 0, INPUT1.length()));
312         //
313         assertEquals(0, matcher.isMatch(INPUT1, 2));
314         assertEquals(1, matcher.isMatch(INPUT1, 3));
315         assertEquals(0, matcher.isMatch(INPUT1, 4));
316     }
317 
318     @Test
319     void testTrimMatcher() {
320         final StringMatcher matcher = StringMatcherFactory.INSTANCE.trimMatcher();
321         assertEquals(1, matcher.size());
322         assertSame(StringMatcherFactory.INSTANCE.trimMatcher(), matcher);
323         //
324         assertEquals(0, matcher.isMatch(INPUT1, 2, 0, INPUT1.length()));
325         assertEquals(1, matcher.isMatch(INPUT1, 3, 0, INPUT1.length()));
326         assertEquals(0, matcher.isMatch(INPUT1, 4, 0, INPUT1.length()));
327         assertEquals(1, matcher.isMatch(INPUT1, 5, 0, INPUT1.length()));
328         assertEquals(0, matcher.isMatch(INPUT1, 6, 0, INPUT1.length()));
329         assertEquals(1, matcher.isMatch(INPUT1, 7, 0, INPUT1.length()));
330         assertEquals(1, matcher.isMatch(INPUT1, 8, 0, INPUT1.length()));
331         assertEquals(1, matcher.isMatch(INPUT1, 9, 0, INPUT1.length()));
332         assertEquals(1, matcher.isMatch(INPUT1, 10, 0, INPUT1.length()));
333         //
334         assertEquals(0, matcher.isMatch(INPUT1, 2));
335         assertEquals(1, matcher.isMatch(INPUT1, 3));
336         assertEquals(0, matcher.isMatch(INPUT1, 4));
337         assertEquals(1, matcher.isMatch(INPUT1, 5));
338         assertEquals(0, matcher.isMatch(INPUT1, 6));
339         assertEquals(1, matcher.isMatch(INPUT1, 7));
340         assertEquals(1, matcher.isMatch(INPUT1, 8));
341         assertEquals(1, matcher.isMatch(INPUT1, 9));
342         assertEquals(1, matcher.isMatch(INPUT1, 10));
343     }
344 
345 }