View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   * https://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
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   * Tests {@link CharRange}.
38   */
39  class CharRangeTest extends AbstractLangTest {
40  
41      @Test
42      void testClass() {
43          // class changed to non-public in 3.0
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          // Subsequent calls reuse the string cached by the first call.
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          // Subsequent calls reuse the string cached by the first call.
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          // Subsequent calls reuse the string cached by the first call.
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          // Subsequent calls reuse the string cached by the first call.
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         // Subsequent calls reuse the string cached by the first call.
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         // Subsequent calls reuse the string cached by the first call.
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         // Subsequent calls reuse the string cached by the first call.
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         // Subsequent calls reuse the string cached by the first call.
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         // normal/normal
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         // normal/negated
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         // negated/normal
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         // negated/negated
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         // A negated argument denotes [0, start - 1] union [end + 1, MAX_VALUE]. When its excluded range touches 0 or
291         // MAX_VALUE that set collapses to the empty set or a single contiguous interval, so a non-full range can contain it.
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         // isNotIn(0, 'a' - 1) denotes ['a', MAX_VALUE]
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         // isNotIn('b', MAX_VALUE) denotes [0, 'a']
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         // A fully interior excluded range is still only contained by the full range.
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         // isNotIn(MIN_VALUE, MAX_VALUE) denotes the empty set: it excludes the entire character space.
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         // The constructor reverses reversed endpoints, so the reversed construction is the same empty set.
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         // It contains no characters, including both extremes of the character space.
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         // It is contained in every range, plain or negated, single character or not.
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         // Iterating over it yields no characters.
351         final Iterator<Character> emptySetIt = emptySet.iterator();
352         assertNotNull(emptySetIt);
353         assertFalse(emptySetIt.hasNext());
354         assertThrows(NoSuchElementException.class, emptySetIt::next);
355 
356         // Ranges that exclude a boundary but not the entire character space are NOT empty ...
357         final CharRange fromB = CharRange.isNotIn(Character.MIN_VALUE, 'a'); // denotes ['b', MAX_VALUE]
358         final CharRange upToA = CharRange.isNotIn('a', Character.MAX_VALUE); // denotes [MIN_VALUE, 'a']
359         assertTrue(fromB.contains(Character.MAX_VALUE));
360         assertTrue(upToA.contains(Character.MIN_VALUE));
361         // ... so, unlike the empty set, they are not contained in every range.
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      * Tests https://issues.apache.org/jira/browse/LANG-1802
413      */
414     @Test
415     void testHashCodeLang1802() {
416         // Test various combinations of different ranges
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         // Previously problematic cases from LANG-1802 should now have different hash codes
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         // Test that negated and non-negated ranges with same bounds have different hash codes
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         // Test that ranges with different start/end produce different hash codes
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         // Test that equal ranges have equal hash codes
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         // Only a negated range over the entire character space is empty.
457         assertTrue(CharRange.isNotIn(Character.MIN_VALUE, Character.MAX_VALUE).isEmpty());
458         // The constructor reverses reversed endpoints, so this is the same empty set.
459         assertTrue(CharRange.isNotIn(Character.MAX_VALUE, Character.MIN_VALUE).isEmpty());
460 
461         // Negated ranges that exclude a boundary or an interior but not the entire character space are not empty.
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         // Plain ranges always contain at least one character, even the full character space.
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 }