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 StringMatcherOnCharArrayTest {
29  
30      private static final char[] INPUT1 = "0,1\t2 3\n\r\f\u0000'\"".toCharArray();
31  
32      private static final char[] INPUT2 = "abcdef".toCharArray();
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     private void testStringMatcher_String(final StringMatcher matcher) {
281         assertEquals(2, matcher.size());
282         //
283         assertEquals(0, matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH));
284         assertEquals(2, matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH));
285         assertEquals(0, matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH));
286         assertEquals(0, matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH));
287         assertEquals(0, matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH));
288         assertEquals(0, matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH));
289         //
290         assertEquals(0, matcher.isMatch(INPUT2, 0));
291         assertEquals(2, matcher.isMatch(INPUT2, 1));
292         assertEquals(0, matcher.isMatch(INPUT2, 2));
293         assertEquals(0, matcher.isMatch(INPUT2, 3));
294         assertEquals(0, matcher.isMatch(INPUT2, 4));
295         assertEquals(0, matcher.isMatch(INPUT2, 5));
296         //
297         assertSame(StringMatcherFactory.INSTANCE.stringMatcher(""), StringMatcherFactory.INSTANCE.noneMatcher());
298         assertSame(StringMatcherFactory.INSTANCE.stringMatcher((String) null), StringMatcherFactory.INSTANCE.noneMatcher());
299     }
300 
301     @Test
302     void testStringMatcher_String_fromChars() {
303         testStringMatcher_String(StringMatcherFactory.INSTANCE.stringMatcher('b', 'c'));
304         testStringMatcher_String(StringMatcherFactory.INSTANCE.stringMatcher(new char[] { 'b', 'c' }));
305     }
306 
307     @Test
308     void testStringMatcher_String_fromString() {
309         testStringMatcher_String(StringMatcherFactory.INSTANCE.stringMatcher("bc"));
310     }
311 
312     @Test
313     void testTabMatcher() {
314         final StringMatcher matcher = StringMatcherFactory.INSTANCE.tabMatcher();
315         assertEquals(1, matcher.size());
316         assertSame(StringMatcherFactory.INSTANCE.tabMatcher(), matcher);
317         //
318         assertEquals(0, matcher.isMatch(INPUT1, 2, 0, INPUT1.length));
319         assertEquals(1, matcher.isMatch(INPUT1, 3, 0, INPUT1.length));
320         assertEquals(0, matcher.isMatch(INPUT1, 4, 0, INPUT1.length));
321         //
322         assertEquals(0, matcher.isMatch(INPUT1, 2));
323         assertEquals(1, matcher.isMatch(INPUT1, 3));
324         assertEquals(0, matcher.isMatch(INPUT1, 4));
325     }
326 
327     @Test
328     void testTrimMatcher() {
329         final StringMatcher matcher = StringMatcherFactory.INSTANCE.trimMatcher();
330         assertEquals(1, matcher.size());
331         assertSame(StringMatcherFactory.INSTANCE.trimMatcher(), matcher);
332         //
333         assertEquals(0, matcher.isMatch(INPUT1, 2, 0, INPUT1.length));
334         assertEquals(1, matcher.isMatch(INPUT1, 3, 0, INPUT1.length));
335         assertEquals(0, matcher.isMatch(INPUT1, 4, 0, INPUT1.length));
336         assertEquals(1, matcher.isMatch(INPUT1, 5, 0, INPUT1.length));
337         assertEquals(0, matcher.isMatch(INPUT1, 6, 0, INPUT1.length));
338         assertEquals(1, matcher.isMatch(INPUT1, 7, 0, INPUT1.length));
339         assertEquals(1, matcher.isMatch(INPUT1, 8, 0, INPUT1.length));
340         assertEquals(1, matcher.isMatch(INPUT1, 9, 0, INPUT1.length));
341         assertEquals(1, matcher.isMatch(INPUT1, 10, 0, INPUT1.length));
342         //
343         assertEquals(0, matcher.isMatch(INPUT1, 2));
344         assertEquals(1, matcher.isMatch(INPUT1, 3));
345         assertEquals(0, matcher.isMatch(INPUT1, 4));
346         assertEquals(1, matcher.isMatch(INPUT1, 5));
347         assertEquals(0, matcher.isMatch(INPUT1, 6));
348         assertEquals(1, matcher.isMatch(INPUT1, 7));
349         assertEquals(1, matcher.isMatch(INPUT1, 8));
350         assertEquals(1, matcher.isMatch(INPUT1, 9));
351         assertEquals(1, matcher.isMatch(INPUT1, 10));
352     }
353 
354 }