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.apache.commons.lang3.LangAssertions.assertNullPointerException;
22 import static org.junit.jupiter.api.Assertions.assertEquals;
23 import static org.junit.jupiter.api.Assertions.assertFalse;
24 import static org.junit.jupiter.api.Assertions.assertNotEquals;
25 import static org.junit.jupiter.api.Assertions.assertNotNull;
26 import static org.junit.jupiter.api.Assertions.assertSame;
27 import static org.junit.jupiter.api.Assertions.assertThrows;
28 import static org.junit.jupiter.api.Assertions.assertTrue;
29
30 import java.lang.reflect.Modifier;
31 import java.util.Iterator;
32 import java.util.NoSuchElementException;
33
34 import org.junit.jupiter.api.Test;
35
36
37
38
39 class CharRangeTest extends AbstractLangTest {
40
41 @Test
42 void testClass() {
43
44 assertFalse(Modifier.isPublic(CharRange.class.getModifiers()));
45 assertTrue(Modifier.isFinal(CharRange.class.getModifiers()));
46 }
47
48 @Test
49 void testConstructorAccessors_is() {
50 final CharRange rangea = CharRange.is('a');
51 assertEquals('a', rangea.getStart());
52 assertEquals('a', rangea.getEnd());
53 assertFalse(rangea.isNegated());
54 final String str = rangea.toString();
55 assertEquals("a", str);
56
57 assertSame(str, rangea.toString());
58 }
59
60 @Test
61 void testConstructorAccessors_isIn_Normal() {
62 final CharRange rangea = CharRange.isIn('a', 'e');
63 assertEquals('a', rangea.getStart());
64 assertEquals('e', rangea.getEnd());
65 assertFalse(rangea.isNegated());
66 final String str = rangea.toString();
67 assertEquals("a-e", str);
68
69 assertSame(str, rangea.toString());
70 }
71
72 @Test
73 void testConstructorAccessors_isIn_Reversed() {
74 final CharRange rangea = CharRange.isIn('e', 'a');
75 assertEquals('a', rangea.getStart());
76 assertEquals('e', rangea.getEnd());
77 assertFalse(rangea.isNegated());
78 final String str = rangea.toString();
79 assertEquals("a-e", str);
80
81 assertSame(str, rangea.toString());
82 }
83
84 @Test
85 void testConstructorAccessors_isIn_Same() {
86 final CharRange rangea = CharRange.isIn('a', 'a');
87 assertEquals('a', rangea.getStart());
88 assertEquals('a', rangea.getEnd());
89 assertFalse(rangea.isNegated());
90 final String str = rangea.toString();
91 assertEquals("a", str);
92
93 assertSame(str, rangea.toString());
94 }
95
96 @Test
97 void testConstructorAccessors_isNot() {
98 final CharRange rangea = CharRange.isNot('a');
99 assertEquals('a', rangea.getStart());
100 assertEquals('a', rangea.getEnd());
101 assertTrue(rangea.isNegated());
102 final String str = rangea.toString();
103 assertEquals("^a", str);
104
105 assertSame(str, rangea.toString());
106 }
107
108 @Test
109 void testConstructorAccessors_isNotIn_Normal() {
110 final CharRange rangea = CharRange.isNotIn('a', 'e');
111 assertEquals('a', rangea.getStart());
112 assertEquals('e', rangea.getEnd());
113 assertTrue(rangea.isNegated());
114 final String str = rangea.toString();
115 assertEquals("^a-e", str);
116
117 assertSame(str, rangea.toString());
118 }
119
120 @Test
121 void testConstructorAccessors_isNotIn_Reversed() {
122 final CharRange rangea = CharRange.isNotIn('e', 'a');
123 assertEquals('a', rangea.getStart());
124 assertEquals('e', rangea.getEnd());
125 assertTrue(rangea.isNegated());
126 final String str = rangea.toString();
127 assertEquals("^a-e", str);
128
129 assertSame(str, rangea.toString());
130 }
131
132 @Test
133 void testConstructorAccessors_isNotIn_Same() {
134 final CharRange rangea = CharRange.isNotIn('a', 'a');
135 assertEquals('a', rangea.getStart());
136 assertEquals('a', rangea.getEnd());
137 assertTrue(rangea.isNegated());
138 final String str = rangea.toString();
139 assertEquals("^a", str);
140
141 assertSame(str, rangea.toString());
142 }
143
144 @Test
145 void testContains_Char() {
146 CharRange range = CharRange.is('c');
147 assertFalse(range.contains('b'));
148 assertTrue(range.contains('c'));
149 assertFalse(range.contains('d'));
150 assertFalse(range.contains('e'));
151
152 range = CharRange.isIn('c', 'd');
153 assertFalse(range.contains('b'));
154 assertTrue(range.contains('c'));
155 assertTrue(range.contains('d'));
156 assertFalse(range.contains('e'));
157
158 range = CharRange.isIn('d', 'c');
159 assertFalse(range.contains('b'));
160 assertTrue(range.contains('c'));
161 assertTrue(range.contains('d'));
162 assertFalse(range.contains('e'));
163
164 range = CharRange.isNotIn('c', 'd');
165 assertTrue(range.contains('b'));
166 assertFalse(range.contains('c'));
167 assertFalse(range.contains('d'));
168 assertTrue(range.contains('e'));
169 assertTrue(range.contains((char) 0));
170 assertTrue(range.contains(Character.MAX_VALUE));
171 }
172
173 @Test
174 void testContains_Charrange() {
175 final CharRange a = CharRange.is('a');
176 final CharRange b = CharRange.is('b');
177 final CharRange c = CharRange.is('c');
178 final CharRange c2 = CharRange.is('c');
179 final CharRange d = CharRange.is('d');
180 final CharRange e = CharRange.is('e');
181 final CharRange cd = CharRange.isIn('c', 'd');
182 final CharRange bd = CharRange.isIn('b', 'd');
183 final CharRange bc = CharRange.isIn('b', 'c');
184 final CharRange ab = CharRange.isIn('a', 'b');
185 final CharRange de = CharRange.isIn('d', 'e');
186 final CharRange ef = CharRange.isIn('e', 'f');
187 final CharRange ae = CharRange.isIn('a', 'e');
188
189
190 assertFalse(c.contains(b));
191 assertTrue(c.contains(c));
192 assertTrue(c.contains(c2));
193 assertFalse(c.contains(d));
194
195 assertFalse(c.contains(cd));
196 assertFalse(c.contains(bd));
197 assertFalse(c.contains(bc));
198 assertFalse(c.contains(ab));
199 assertFalse(c.contains(de));
200
201 assertTrue(cd.contains(c));
202 assertTrue(bd.contains(c));
203 assertTrue(bc.contains(c));
204 assertFalse(ab.contains(c));
205 assertFalse(de.contains(c));
206
207 assertTrue(ae.contains(b));
208 assertTrue(ae.contains(ab));
209 assertTrue(ae.contains(bc));
210 assertTrue(ae.contains(cd));
211 assertTrue(ae.contains(de));
212
213 final CharRange notb = CharRange.isNot('b');
214 final CharRange notc = CharRange.isNot('c');
215 final CharRange notd = CharRange.isNot('d');
216 final CharRange notab = CharRange.isNotIn('a', 'b');
217 final CharRange notbc = CharRange.isNotIn('b', 'c');
218 final CharRange notbd = CharRange.isNotIn('b', 'd');
219 final CharRange notcd = CharRange.isNotIn('c', 'd');
220 final CharRange notde = CharRange.isNotIn('d', 'e');
221 final CharRange notae = CharRange.isNotIn('a', 'e');
222 final CharRange all = CharRange.isIn((char) 0, Character.MAX_VALUE);
223 final CharRange allbutfirst = CharRange.isIn((char) 1, Character.MAX_VALUE);
224
225
226 assertFalse(c.contains(notc));
227 assertFalse(c.contains(notbd));
228 assertTrue(all.contains(notc));
229 assertTrue(all.contains(notbd));
230 assertFalse(allbutfirst.contains(notc));
231 assertFalse(allbutfirst.contains(notbd));
232
233
234 assertTrue(notc.contains(a));
235 assertTrue(notc.contains(b));
236 assertFalse(notc.contains(c));
237 assertTrue(notc.contains(d));
238 assertTrue(notc.contains(e));
239
240 assertTrue(notc.contains(ab));
241 assertFalse(notc.contains(bc));
242 assertFalse(notc.contains(bd));
243 assertFalse(notc.contains(cd));
244 assertTrue(notc.contains(de));
245 assertFalse(notc.contains(ae));
246 assertFalse(notc.contains(all));
247 assertFalse(notc.contains(allbutfirst));
248
249 assertTrue(notbd.contains(a));
250 assertFalse(notbd.contains(b));
251 assertFalse(notbd.contains(c));
252 assertFalse(notbd.contains(d));
253 assertTrue(notbd.contains(e));
254
255 assertTrue(notcd.contains(ab));
256 assertFalse(notcd.contains(bc));
257 assertFalse(notcd.contains(bd));
258 assertFalse(notcd.contains(cd));
259 assertFalse(notcd.contains(de));
260 assertFalse(notcd.contains(ae));
261 assertTrue(notcd.contains(ef));
262 assertFalse(notcd.contains(all));
263 assertFalse(notcd.contains(allbutfirst));
264
265
266 assertFalse(notc.contains(notb));
267 assertTrue(notc.contains(notc));
268 assertFalse(notc.contains(notd));
269
270 assertFalse(notc.contains(notab));
271 assertTrue(notc.contains(notbc));
272 assertTrue(notc.contains(notbd));
273 assertTrue(notc.contains(notcd));
274 assertFalse(notc.contains(notde));
275
276 assertFalse(notbd.contains(notb));
277 assertFalse(notbd.contains(notc));
278 assertFalse(notbd.contains(notd));
279
280 assertFalse(notbd.contains(notab));
281 assertFalse(notbd.contains(notbc));
282 assertTrue(notbd.contains(notbd));
283 assertFalse(notbd.contains(notcd));
284 assertFalse(notbd.contains(notde));
285 assertTrue(notbd.contains(notae));
286 }
287
288 @Test
289 void testContains_Charrange_negatedArgumentTouchingBounds() {
290
291
292 final CharRange emptySet = CharRange.isNotIn((char) 0, Character.MAX_VALUE);
293 assertTrue(CharRange.is('x').contains(emptySet));
294 assertTrue(CharRange.isIn((char) 0, Character.MAX_VALUE).contains(emptySet));
295
296
297 final CharRange fromA = CharRange.isNotIn((char) 0, (char) ('a' - 1));
298 assertTrue(CharRange.isIn('a', Character.MAX_VALUE).contains(fromA));
299 assertTrue(CharRange.isIn('Z', Character.MAX_VALUE).contains(fromA));
300 assertFalse(CharRange.isIn('b', Character.MAX_VALUE).contains(fromA));
301 assertFalse(CharRange.isIn('a', 'z').contains(fromA));
302
303
304 final CharRange upToA = CharRange.isNotIn('b', Character.MAX_VALUE);
305 assertTrue(CharRange.isIn((char) 0, 'a').contains(upToA));
306 assertTrue(CharRange.isIn((char) 0, 'b').contains(upToA));
307 assertFalse(CharRange.isIn((char) 1, 'a').contains(upToA));
308 assertFalse(CharRange.isIn((char) 0, 'Z').contains(upToA));
309
310
311 assertFalse(CharRange.is('c').contains(CharRange.isNot('c')));
312 assertTrue(CharRange.isIn((char) 0, Character.MAX_VALUE).contains(CharRange.isNot('c')));
313 }
314
315 @Test
316 void testContainsNullArg() {
317 final CharRange range = CharRange.is('a');
318 final NullPointerException e = assertNullPointerException(() -> range.contains(null));
319 assertEquals("range", e.getMessage());
320 }
321
322 @Test
323 void testEmptySet() {
324
325 final CharRange emptySet = CharRange.isNotIn(Character.MIN_VALUE, Character.MAX_VALUE);
326 assertTrue(emptySet.isNegated());
327 assertEquals(Character.MIN_VALUE, emptySet.getStart());
328 assertEquals(Character.MAX_VALUE, emptySet.getEnd());
329
330 assertEquals(emptySet, CharRange.isNotIn(Character.MAX_VALUE, Character.MIN_VALUE));
331 assertEquals(emptySet.hashCode(), CharRange.isNotIn(Character.MAX_VALUE, Character.MIN_VALUE).hashCode());
332
333
334 assertFalse(emptySet.contains(Character.MIN_VALUE));
335 assertFalse(emptySet.contains('a'));
336 assertFalse(emptySet.contains('x'));
337 assertFalse(emptySet.contains('z'));
338 assertFalse(emptySet.contains(Character.MAX_VALUE));
339
340
341 assertTrue(CharRange.is('a').contains(emptySet));
342 assertTrue(CharRange.is('x').contains(emptySet));
343 assertTrue(CharRange.isIn('a', 'z').contains(emptySet));
344 assertTrue(CharRange.isIn(Character.MIN_VALUE, Character.MAX_VALUE).contains(emptySet));
345 assertTrue(CharRange.isNot('a').contains(emptySet));
346 assertTrue(CharRange.isNotIn('a', 'z').contains(emptySet));
347 assertTrue(CharRange.isNotIn(Character.MIN_VALUE, 'z').contains(emptySet));
348 assertTrue(CharRange.isNotIn('a', Character.MAX_VALUE).contains(emptySet));
349
350
351 final Iterator<Character> emptySetIt = emptySet.iterator();
352 assertNotNull(emptySetIt);
353 assertFalse(emptySetIt.hasNext());
354 assertThrows(NoSuchElementException.class, emptySetIt::next);
355
356
357 final CharRange fromB = CharRange.isNotIn(Character.MIN_VALUE, 'a');
358 final CharRange upToA = CharRange.isNotIn('a', Character.MAX_VALUE);
359 assertTrue(fromB.contains(Character.MAX_VALUE));
360 assertTrue(upToA.contains(Character.MIN_VALUE));
361
362 assertFalse(CharRange.is('a').contains(fromB));
363 assertFalse(CharRange.is('b').contains(upToA));
364 assertFalse(upToA.contains(fromB));
365 }
366
367 @Test
368 void testEquals_Object() {
369 final CharRange rangea = CharRange.is('a');
370 final CharRange rangeae = CharRange.isIn('a', 'e');
371 final CharRange rangenotbf = CharRange.isIn('b', 'f');
372
373 assertNotEquals(null, rangea);
374
375 assertEquals(rangea, rangea);
376 assertEquals(rangea, CharRange.is('a'));
377 assertEquals(rangeae, rangeae);
378 assertEquals(rangeae, CharRange.isIn('a', 'e'));
379 assertEquals(rangenotbf, rangenotbf);
380 assertEquals(rangenotbf, CharRange.isIn('b', 'f'));
381
382 assertNotEquals(rangea, rangeae);
383 assertNotEquals(rangea, rangenotbf);
384 assertNotEquals(rangeae, rangea);
385 assertNotEquals(rangeae, rangenotbf);
386 assertNotEquals(rangenotbf, rangea);
387 assertNotEquals(rangenotbf, rangeae);
388 }
389
390 @Test
391 void testHashCode() {
392 final CharRange rangea = CharRange.is('a');
393 final CharRange rangeae = CharRange.isIn('a', 'e');
394 final CharRange rangenotbf = CharRange.isIn('b', 'f');
395
396 assertEquals(rangea.hashCode(), rangea.hashCode());
397 assertEquals(rangea.hashCode(), CharRange.is('a').hashCode());
398 assertEquals(rangeae.hashCode(), rangeae.hashCode());
399 assertEquals(rangeae.hashCode(), CharRange.isIn('a', 'e').hashCode());
400 assertEquals(rangenotbf.hashCode(), rangenotbf.hashCode());
401 assertEquals(rangenotbf.hashCode(), CharRange.isIn('b', 'f').hashCode());
402
403 assertNotEquals(rangea.hashCode(), rangeae.hashCode());
404 assertNotEquals(rangea.hashCode(), rangenotbf.hashCode());
405 assertNotEquals(rangeae.hashCode(), rangea.hashCode());
406 assertNotEquals(rangeae.hashCode(), rangenotbf.hashCode());
407 assertNotEquals(rangenotbf.hashCode(), rangea.hashCode());
408 assertNotEquals(rangenotbf.hashCode(), rangeae.hashCode());
409 }
410
411
412
413
414 @Test
415 void testHashCodeLang1802() {
416
417 final CharRange range1 = CharRange.is('a');
418 final CharRange range2 = CharRange.is('b');
419 final CharRange range3 = CharRange.isIn('a', 'z');
420 final CharRange range4 = CharRange.isIn('b', 'z');
421 final CharRange range5 = CharRange.isNot('a');
422 final CharRange range6 = CharRange.isNotIn('a', 'z');
423 final CharRange range7 = CharRange.isNotIn('b', 'z');
424 final CharRange range8 = CharRange.isIn((char) 1, (char) 2);
425 final CharRange range9 = CharRange.isNotIn((char) 1, (char) 2);
426
427 final CharRange a1 = CharRange.isNotIn((char) 1, (char) 2);
428 final CharRange a2 = CharRange.isIn((char) 2, (char) 2);
429 assertNotEquals(a1, a2, "Different ranges should not be equal");
430 assertNotEquals(a1.hashCode(), a2.hashCode(), "Different ranges should have different hash codes");
431 final CharRange b1 = CharRange.isIn((char) 5, (char) 5);
432 final CharRange b2 = CharRange.isNotIn((char) 4, (char) 5);
433 assertNotEquals(b1, b2, "Different ranges should not be equal");
434 assertNotEquals(b1.hashCode(), b2.hashCode(), "Different ranges should have different hash codes");
435
436 final CharRange normal = CharRange.isIn('x', 'y');
437 final CharRange negated = CharRange.isNotIn('x', 'y');
438 assertNotEquals(normal, negated, "Negated and normal ranges should not be equal");
439 assertNotEquals(normal.hashCode(), negated.hashCode(), "Negated and normal ranges should have different hash codes");
440
441 assertNotEquals(range1.hashCode(), range2.hashCode(), "is('a') vs is('b')");
442 assertNotEquals(range1.hashCode(), range3.hashCode(), "is('a') vs isIn('a', 'z')");
443 assertNotEquals(range3.hashCode(), range4.hashCode(), "isIn('a', 'z') vs isIn('b', 'z')");
444 assertNotEquals(range1.hashCode(), range5.hashCode(), "is('a') vs isNot('a')");
445 assertNotEquals(range3.hashCode(), range6.hashCode(), "isIn('a', 'z') vs isNotIn('a', 'z')");
446 assertNotEquals(range6.hashCode(), range7.hashCode(), "isNotIn('a', 'z') vs isNotIn('b', 'z')");
447 assertNotEquals(range8.hashCode(), range9.hashCode(), "isIn(1, 2) vs isNotIn(1, 2)");
448
449 final CharRange sameAsRange1 = CharRange.is('a');
450 assertEquals(range1, sameAsRange1, "Equal ranges should be equal");
451 assertEquals(range1.hashCode(), sameAsRange1.hashCode(), "Equal ranges should have equal hash codes");
452 }
453
454 @Test
455 void testIsEmpty() {
456
457 assertTrue(CharRange.isNotIn(Character.MIN_VALUE, Character.MAX_VALUE).isEmpty());
458
459 assertTrue(CharRange.isNotIn(Character.MAX_VALUE, Character.MIN_VALUE).isEmpty());
460
461
462 assertFalse(CharRange.isNotIn(Character.MIN_VALUE, 'a').isEmpty());
463 assertFalse(CharRange.isNotIn('a', Character.MAX_VALUE).isEmpty());
464 assertFalse(CharRange.isNot('a').isEmpty());
465 assertFalse(CharRange.isNotIn('a', 'z').isEmpty());
466
467
468 assertFalse(CharRange.is('a').isEmpty());
469 assertFalse(CharRange.isIn('a', 'z').isEmpty());
470 assertFalse(CharRange.isIn(Character.MIN_VALUE, Character.MAX_VALUE).isEmpty());
471 }
472
473 @Test
474 void testIterator() {
475 final CharRange a = CharRange.is('a');
476 final CharRange ad = CharRange.isIn('a', 'd');
477 final CharRange nota = CharRange.isNot('a');
478 final CharRange emptySet = CharRange.isNotIn((char) 0, Character.MAX_VALUE);
479 final CharRange notFirst = CharRange.isNotIn((char) 1, Character.MAX_VALUE);
480 final CharRange notLast = CharRange.isNotIn((char) 0, (char) (Character.MAX_VALUE - 1));
481
482 final Iterator<Character> aIt = a.iterator();
483 assertNotNull(aIt);
484 assertTrue(aIt.hasNext());
485 assertEquals(Character.valueOf('a'), aIt.next());
486 assertFalse(aIt.hasNext());
487
488 final Iterator<Character> adIt = ad.iterator();
489 assertNotNull(adIt);
490 assertTrue(adIt.hasNext());
491 assertEquals(Character.valueOf('a'), adIt.next());
492 assertEquals(Character.valueOf('b'), adIt.next());
493 assertEquals(Character.valueOf('c'), adIt.next());
494 assertEquals(Character.valueOf('d'), adIt.next());
495 assertFalse(adIt.hasNext());
496
497 final Iterator<Character> notaIt = nota.iterator();
498 assertNotNull(notaIt);
499 assertTrue(notaIt.hasNext());
500 while (notaIt.hasNext()) {
501 final Character c = notaIt.next();
502 assertNotEquals('a', c.charValue());
503 }
504
505 final Iterator<Character> emptySetIt = emptySet.iterator();
506 assertNotNull(emptySetIt);
507 assertFalse(emptySetIt.hasNext());
508 assertThrows(NoSuchElementException.class, emptySetIt::next);
509
510 final Iterator<Character> notFirstIt = notFirst.iterator();
511 assertNotNull(notFirstIt);
512 assertTrue(notFirstIt.hasNext());
513 assertEquals(Character.valueOf((char) 0), notFirstIt.next());
514 assertFalse(notFirstIt.hasNext());
515 assertThrows(NoSuchElementException.class, notFirstIt::next);
516
517 final Iterator<Character> notLastIt = notLast.iterator();
518 assertNotNull(notLastIt);
519 assertTrue(notLastIt.hasNext());
520 assertEquals(Character.valueOf(Character.MAX_VALUE), notLastIt.next());
521 assertFalse(notLastIt.hasNext());
522 assertThrows(NoSuchElementException.class, notLastIt::next);
523 }
524
525 @Test
526 void testIteratorRemove() {
527 final CharRange a = CharRange.is('a');
528 final Iterator<Character> aIt = a.iterator();
529 assertThrows(UnsupportedOperationException.class, aIt::remove);
530 }
531
532 @Test
533 void testSerialization() {
534 CharRange range = CharRange.is('a');
535 assertEquals(range, SerializationUtils.clone(range));
536 range = CharRange.isIn('a', 'e');
537 assertEquals(range, SerializationUtils.clone(range));
538 range = CharRange.isNotIn('a', 'e');
539 assertEquals(range, SerializationUtils.clone(range));
540 }
541 }