1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.commons.lang3;
20
21 import static org.junit.jupiter.api.Assertions.assertEquals;
22 import static org.junit.jupiter.api.Assertions.assertFalse;
23 import static org.junit.jupiter.api.Assertions.assertNotEquals;
24 import static org.junit.jupiter.api.Assertions.assertNotNull;
25 import static org.junit.jupiter.api.Assertions.assertThrows;
26 import static org.junit.jupiter.api.Assertions.assertTrue;
27
28 import java.lang.reflect.Modifier;
29 import java.util.Iterator;
30 import java.util.NoSuchElementException;
31
32 import org.junit.jupiter.api.Test;
33
34
35
36
37 public class CharRangeTest extends AbstractLangTest {
38
39 @Test
40 public void testClass() {
41
42 assertFalse(Modifier.isPublic(CharRange.class.getModifiers()));
43 assertTrue(Modifier.isFinal(CharRange.class.getModifiers()));
44 }
45
46 @Test
47 public void testConstructorAccessors_is() {
48 final CharRange rangea = CharRange.is('a');
49 assertEquals('a', rangea.getStart());
50 assertEquals('a', rangea.getEnd());
51 assertFalse(rangea.isNegated());
52 assertEquals("a", rangea.toString());
53 }
54
55 @Test
56 public void testConstructorAccessors_isIn_Normal() {
57 final CharRange rangea = CharRange.isIn('a', 'e');
58 assertEquals('a', rangea.getStart());
59 assertEquals('e', rangea.getEnd());
60 assertFalse(rangea.isNegated());
61 assertEquals("a-e", rangea.toString());
62 }
63
64 @Test
65 public void testConstructorAccessors_isIn_Reversed() {
66 final CharRange rangea = CharRange.isIn('e', 'a');
67 assertEquals('a', rangea.getStart());
68 assertEquals('e', rangea.getEnd());
69 assertFalse(rangea.isNegated());
70 assertEquals("a-e", rangea.toString());
71 }
72
73 @Test
74 public void testConstructorAccessors_isIn_Same() {
75 final CharRange rangea = CharRange.isIn('a', 'a');
76 assertEquals('a', rangea.getStart());
77 assertEquals('a', rangea.getEnd());
78 assertFalse(rangea.isNegated());
79 assertEquals("a", rangea.toString());
80 }
81
82 @Test
83 public void testConstructorAccessors_isNot() {
84 final CharRange rangea = CharRange.isNot('a');
85 assertEquals('a', rangea.getStart());
86 assertEquals('a', rangea.getEnd());
87 assertTrue(rangea.isNegated());
88 assertEquals("^a", rangea.toString());
89 }
90
91 @Test
92 public void testConstructorAccessors_isNotIn_Normal() {
93 final CharRange rangea = CharRange.isNotIn('a', 'e');
94 assertEquals('a', rangea.getStart());
95 assertEquals('e', rangea.getEnd());
96 assertTrue(rangea.isNegated());
97 assertEquals("^a-e", rangea.toString());
98 }
99
100 @Test
101 public void testConstructorAccessors_isNotIn_Reversed() {
102 final CharRange rangea = CharRange.isNotIn('e', 'a');
103 assertEquals('a', rangea.getStart());
104 assertEquals('e', rangea.getEnd());
105 assertTrue(rangea.isNegated());
106 assertEquals("^a-e", rangea.toString());
107 }
108
109 @Test
110 public void testConstructorAccessors_isNotIn_Same() {
111 final CharRange rangea = CharRange.isNotIn('a', 'a');
112 assertEquals('a', rangea.getStart());
113 assertEquals('a', rangea.getEnd());
114 assertTrue(rangea.isNegated());
115 assertEquals("^a", rangea.toString());
116 }
117
118 @Test
119 public void testContains_Char() {
120 CharRange range = CharRange.is('c');
121 assertFalse(range.contains('b'));
122 assertTrue(range.contains('c'));
123 assertFalse(range.contains('d'));
124 assertFalse(range.contains('e'));
125
126 range = CharRange.isIn('c', 'd');
127 assertFalse(range.contains('b'));
128 assertTrue(range.contains('c'));
129 assertTrue(range.contains('d'));
130 assertFalse(range.contains('e'));
131
132 range = CharRange.isIn('d', 'c');
133 assertFalse(range.contains('b'));
134 assertTrue(range.contains('c'));
135 assertTrue(range.contains('d'));
136 assertFalse(range.contains('e'));
137
138 range = CharRange.isNotIn('c', 'd');
139 assertTrue(range.contains('b'));
140 assertFalse(range.contains('c'));
141 assertFalse(range.contains('d'));
142 assertTrue(range.contains('e'));
143 assertTrue(range.contains((char) 0));
144 assertTrue(range.contains(Character.MAX_VALUE));
145 }
146
147 @Test
148 public void testContains_Charrange() {
149 final CharRange a = CharRange.is('a');
150 final CharRange b = CharRange.is('b');
151 final CharRange c = CharRange.is('c');
152 final CharRange c2 = CharRange.is('c');
153 final CharRange d = CharRange.is('d');
154 final CharRange e = CharRange.is('e');
155 final CharRange cd = CharRange.isIn('c', 'd');
156 final CharRange bd = CharRange.isIn('b', 'd');
157 final CharRange bc = CharRange.isIn('b', 'c');
158 final CharRange ab = CharRange.isIn('a', 'b');
159 final CharRange de = CharRange.isIn('d', 'e');
160 final CharRange ef = CharRange.isIn('e', 'f');
161 final CharRange ae = CharRange.isIn('a', 'e');
162
163
164 assertFalse(c.contains(b));
165 assertTrue(c.contains(c));
166 assertTrue(c.contains(c2));
167 assertFalse(c.contains(d));
168
169 assertFalse(c.contains(cd));
170 assertFalse(c.contains(bd));
171 assertFalse(c.contains(bc));
172 assertFalse(c.contains(ab));
173 assertFalse(c.contains(de));
174
175 assertTrue(cd.contains(c));
176 assertTrue(bd.contains(c));
177 assertTrue(bc.contains(c));
178 assertFalse(ab.contains(c));
179 assertFalse(de.contains(c));
180
181 assertTrue(ae.contains(b));
182 assertTrue(ae.contains(ab));
183 assertTrue(ae.contains(bc));
184 assertTrue(ae.contains(cd));
185 assertTrue(ae.contains(de));
186
187 final CharRange notb = CharRange.isNot('b');
188 final CharRange notc = CharRange.isNot('c');
189 final CharRange notd = CharRange.isNot('d');
190 final CharRange notab = CharRange.isNotIn('a', 'b');
191 final CharRange notbc = CharRange.isNotIn('b', 'c');
192 final CharRange notbd = CharRange.isNotIn('b', 'd');
193 final CharRange notcd = CharRange.isNotIn('c', 'd');
194 final CharRange notde = CharRange.isNotIn('d', 'e');
195 final CharRange notae = CharRange.isNotIn('a', 'e');
196 final CharRange all = CharRange.isIn((char) 0, Character.MAX_VALUE);
197 final CharRange allbutfirst = CharRange.isIn((char) 1, Character.MAX_VALUE);
198
199
200 assertFalse(c.contains(notc));
201 assertFalse(c.contains(notbd));
202 assertTrue(all.contains(notc));
203 assertTrue(all.contains(notbd));
204 assertFalse(allbutfirst.contains(notc));
205 assertFalse(allbutfirst.contains(notbd));
206
207
208 assertTrue(notc.contains(a));
209 assertTrue(notc.contains(b));
210 assertFalse(notc.contains(c));
211 assertTrue(notc.contains(d));
212 assertTrue(notc.contains(e));
213
214 assertTrue(notc.contains(ab));
215 assertFalse(notc.contains(bc));
216 assertFalse(notc.contains(bd));
217 assertFalse(notc.contains(cd));
218 assertTrue(notc.contains(de));
219 assertFalse(notc.contains(ae));
220 assertFalse(notc.contains(all));
221 assertFalse(notc.contains(allbutfirst));
222
223 assertTrue(notbd.contains(a));
224 assertFalse(notbd.contains(b));
225 assertFalse(notbd.contains(c));
226 assertFalse(notbd.contains(d));
227 assertTrue(notbd.contains(e));
228
229 assertTrue(notcd.contains(ab));
230 assertFalse(notcd.contains(bc));
231 assertFalse(notcd.contains(bd));
232 assertFalse(notcd.contains(cd));
233 assertFalse(notcd.contains(de));
234 assertFalse(notcd.contains(ae));
235 assertTrue(notcd.contains(ef));
236 assertFalse(notcd.contains(all));
237 assertFalse(notcd.contains(allbutfirst));
238
239
240 assertFalse(notc.contains(notb));
241 assertTrue(notc.contains(notc));
242 assertFalse(notc.contains(notd));
243
244 assertFalse(notc.contains(notab));
245 assertTrue(notc.contains(notbc));
246 assertTrue(notc.contains(notbd));
247 assertTrue(notc.contains(notcd));
248 assertFalse(notc.contains(notde));
249
250 assertFalse(notbd.contains(notb));
251 assertFalse(notbd.contains(notc));
252 assertFalse(notbd.contains(notd));
253
254 assertFalse(notbd.contains(notab));
255 assertFalse(notbd.contains(notbc));
256 assertTrue(notbd.contains(notbd));
257 assertFalse(notbd.contains(notcd));
258 assertFalse(notbd.contains(notde));
259 assertTrue(notbd.contains(notae));
260 }
261
262 @Test
263 public void testContainsNullArg() {
264 final CharRange range = CharRange.is('a');
265 final NullPointerException e = assertThrows(NullPointerException.class, () -> range.contains(null));
266 assertEquals("range", e.getMessage());
267 }
268
269 @Test
270 public void testEquals_Object() {
271 final CharRange rangea = CharRange.is('a');
272 final CharRange rangeae = CharRange.isIn('a', 'e');
273 final CharRange rangenotbf = CharRange.isIn('b', 'f');
274
275 assertNotEquals(null, rangea);
276
277 assertEquals(rangea, rangea);
278 assertEquals(rangea, CharRange.is('a'));
279 assertEquals(rangeae, rangeae);
280 assertEquals(rangeae, CharRange.isIn('a', 'e'));
281 assertEquals(rangenotbf, rangenotbf);
282 assertEquals(rangenotbf, CharRange.isIn('b', 'f'));
283
284 assertNotEquals(rangea, rangeae);
285 assertNotEquals(rangea, rangenotbf);
286 assertNotEquals(rangeae, rangea);
287 assertNotEquals(rangeae, rangenotbf);
288 assertNotEquals(rangenotbf, rangea);
289 assertNotEquals(rangenotbf, rangeae);
290 }
291
292 @Test
293 public void testHashCode() {
294 final CharRange rangea = CharRange.is('a');
295 final CharRange rangeae = CharRange.isIn('a', 'e');
296 final CharRange rangenotbf = CharRange.isIn('b', 'f');
297
298 assertEquals(rangea.hashCode(), rangea.hashCode());
299 assertEquals(rangea.hashCode(), CharRange.is('a').hashCode());
300 assertEquals(rangeae.hashCode(), rangeae.hashCode());
301 assertEquals(rangeae.hashCode(), CharRange.isIn('a', 'e').hashCode());
302 assertEquals(rangenotbf.hashCode(), rangenotbf.hashCode());
303 assertEquals(rangenotbf.hashCode(), CharRange.isIn('b', 'f').hashCode());
304
305 assertNotEquals(rangea.hashCode(), rangeae.hashCode());
306 assertNotEquals(rangea.hashCode(), rangenotbf.hashCode());
307 assertNotEquals(rangeae.hashCode(), rangea.hashCode());
308 assertNotEquals(rangeae.hashCode(), rangenotbf.hashCode());
309 assertNotEquals(rangenotbf.hashCode(), rangea.hashCode());
310 assertNotEquals(rangenotbf.hashCode(), rangeae.hashCode());
311 }
312
313 @Test
314 public void testIterator() {
315 final CharRange a = CharRange.is('a');
316 final CharRange ad = CharRange.isIn('a', 'd');
317 final CharRange nota = CharRange.isNot('a');
318 final CharRange emptySet = CharRange.isNotIn((char) 0, Character.MAX_VALUE);
319 final CharRange notFirst = CharRange.isNotIn((char) 1, Character.MAX_VALUE);
320 final CharRange notLast = CharRange.isNotIn((char) 0, (char) (Character.MAX_VALUE - 1));
321
322 final Iterator<Character> aIt = a.iterator();
323 assertNotNull(aIt);
324 assertTrue(aIt.hasNext());
325 assertEquals(Character.valueOf('a'), aIt.next());
326 assertFalse(aIt.hasNext());
327
328 final Iterator<Character> adIt = ad.iterator();
329 assertNotNull(adIt);
330 assertTrue(adIt.hasNext());
331 assertEquals(Character.valueOf('a'), adIt.next());
332 assertEquals(Character.valueOf('b'), adIt.next());
333 assertEquals(Character.valueOf('c'), adIt.next());
334 assertEquals(Character.valueOf('d'), adIt.next());
335 assertFalse(adIt.hasNext());
336
337 final Iterator<Character> notaIt = nota.iterator();
338 assertNotNull(notaIt);
339 assertTrue(notaIt.hasNext());
340 while (notaIt.hasNext()) {
341 final Character c = notaIt.next();
342 assertNotEquals('a', c.charValue());
343 }
344
345 final Iterator<Character> emptySetIt = emptySet.iterator();
346 assertNotNull(emptySetIt);
347 assertFalse(emptySetIt.hasNext());
348 assertThrows(NoSuchElementException.class, emptySetIt::next);
349
350 final Iterator<Character> notFirstIt = notFirst.iterator();
351 assertNotNull(notFirstIt);
352 assertTrue(notFirstIt.hasNext());
353 assertEquals(Character.valueOf((char) 0), notFirstIt.next());
354 assertFalse(notFirstIt.hasNext());
355 assertThrows(NoSuchElementException.class, notFirstIt::next);
356
357 final Iterator<Character> notLastIt = notLast.iterator();
358 assertNotNull(notLastIt);
359 assertTrue(notLastIt.hasNext());
360 assertEquals(Character.valueOf(Character.MAX_VALUE), notLastIt.next());
361 assertFalse(notLastIt.hasNext());
362 assertThrows(NoSuchElementException.class, notLastIt::next);
363 }
364
365 @Test
366 public void testIteratorRemove() {
367 final CharRange a = CharRange.is('a');
368 final Iterator<Character> aIt = a.iterator();
369 assertThrows(UnsupportedOperationException.class, aIt::remove);
370 }
371
372 @Test
373 public void testSerialization() {
374 CharRange range = CharRange.is('a');
375 assertEquals(range, SerializationUtils.clone(range));
376 range = CharRange.isIn('a', 'e');
377 assertEquals(range, SerializationUtils.clone(range));
378 range = CharRange.isNotIn('a', 'e');
379 assertEquals(range, SerializationUtils.clone(range));
380 }
381 }