/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.commons.lang3;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.lang.reflect.Modifier;
import java.util.Iterator;
import java.util.NoSuchElementException;
import org.junit.Test;
/**
* Unit tests {@link org.apache.commons.lang3.CharRange}.
*
* @version $Id$
*/
public class CharRangeTest {
//-----------------------------------------------------------------------
@Test
public void testClass() {
// class changed to non-public in 3.0
assertFalse(Modifier.isPublic(CharRange.class.getModifiers()));
assertTrue(Modifier.isFinal(CharRange.class.getModifiers()));
}
//-----------------------------------------------------------------------
@Test
public void testConstructorAccessors_is() {
final CharRange rangea = CharRange.is('a');
assertEquals('a', rangea.getStart());
assertEquals('a', rangea.getEnd());
assertFalse(rangea.isNegated());
assertEquals("a", rangea.toString());
}
@Test
public void testConstructorAccessors_isNot() {
final CharRange rangea = CharRange.isNot('a');
assertEquals('a', rangea.getStart());
assertEquals('a', rangea.getEnd());
assertTrue(rangea.isNegated());
assertEquals("^a", rangea.toString());
}
@Test
public void testConstructorAccessors_isIn_Same() {
final CharRange rangea = CharRange.isIn('a', 'a');
assertEquals('a', rangea.getStart());
assertEquals('a', rangea.getEnd());
assertFalse(rangea.isNegated());
assertEquals("a", rangea.toString());
}
@Test
public void testConstructorAccessors_isIn_Normal() {
final CharRange rangea = CharRange.isIn('a', 'e');
assertEquals('a', rangea.getStart());
assertEquals('e', rangea.getEnd());
assertFalse(rangea.isNegated());
assertEquals("a-e", rangea.toString());
}
@Test
public void testConstructorAccessors_isIn_Reversed() {
final CharRange rangea = CharRange.isIn('e', 'a');
assertEquals('a', rangea.getStart());
assertEquals('e', rangea.getEnd());
assertFalse(rangea.isNegated());
assertEquals("a-e", rangea.toString());
}
@Test
public void testConstructorAccessors_isNotIn_Same() {
final CharRange rangea = CharRange.isNotIn('a', 'a');
assertEquals('a', rangea.getStart());
assertEquals('a', rangea.getEnd());
assertTrue(rangea.isNegated());
assertEquals("^a", rangea.toString());
}
@Test
public void testConstructorAccessors_isNotIn_Normal() {
final CharRange rangea = CharRange.isNotIn('a', 'e');
assertEquals('a', rangea.getStart());
assertEquals('e', rangea.getEnd());
assertTrue(rangea.isNegated());
assertEquals("^a-e", rangea.toString());
}
@Test
public void testConstructorAccessors_isNotIn_Reversed() {
final CharRange rangea = CharRange.isNotIn('e', 'a');
assertEquals('a', rangea.getStart());
assertEquals('e', rangea.getEnd());
assertTrue(rangea.isNegated());
assertEquals("^a-e", rangea.toString());
}
//-----------------------------------------------------------------------
@Test
public void testEquals_Object() {
final CharRange rangea = CharRange.is('a');
final CharRange rangeae = CharRange.isIn('a', 'e');
final CharRange rangenotbf = CharRange.isIn('b', 'f');
assertFalse(rangea.equals(null));
assertTrue(rangea.equals(rangea));
assertTrue(rangea.equals(CharRange.is('a')));
assertTrue(rangeae.equals(rangeae));
assertTrue(rangeae.equals(CharRange.isIn('a', 'e')));
assertTrue(rangenotbf.equals(rangenotbf));
assertTrue(rangenotbf.equals(CharRange.isIn('b', 'f')));
assertFalse(rangea.equals(rangeae));
assertFalse(rangea.equals(rangenotbf));
assertFalse(rangeae.equals(rangea));
assertFalse(rangeae.equals(rangenotbf));
assertFalse(rangenotbf.equals(rangea));
assertFalse(rangenotbf.equals(rangeae));
}
@Test
public void testHashCode() {
final CharRange rangea = CharRange.is('a');
final CharRange rangeae = CharRange.isIn('a', 'e');
final CharRange rangenotbf = CharRange.isIn('b', 'f');
assertTrue(rangea.hashCode() == rangea.hashCode());
assertTrue(rangea.hashCode() == CharRange.is('a').hashCode());
assertTrue(rangeae.hashCode() == rangeae.hashCode());
assertTrue(rangeae.hashCode() == CharRange.isIn('a', 'e').hashCode());
assertTrue(rangenotbf.hashCode() == rangenotbf.hashCode());
assertTrue(rangenotbf.hashCode() == CharRange.isIn('b', 'f').hashCode());
assertFalse(rangea.hashCode() == rangeae.hashCode());
assertFalse(rangea.hashCode() == rangenotbf.hashCode());
assertFalse(rangeae.hashCode() == rangea.hashCode());
assertFalse(rangeae.hashCode() == rangenotbf.hashCode());
assertFalse(rangenotbf.hashCode() == rangea.hashCode());
assertFalse(rangenotbf.hashCode() == rangeae.hashCode());
}
//-----------------------------------------------------------------------
@Test
public void testContains_Char() {
CharRange range = CharRange.is('c');
assertFalse(range.contains('b'));
assertTrue(range.contains('c'));
assertFalse(range.contains('d'));
assertFalse(range.contains('e'));
range = CharRange.isIn('c', 'd');
assertFalse(range.contains('b'));
assertTrue(range.contains('c'));
assertTrue(range.contains('d'));
assertFalse(range.contains('e'));
range = CharRange.isIn('d', 'c');
assertFalse(range.contains('b'));
assertTrue(range.contains('c'));
assertTrue(range.contains('d'));
assertFalse(range.contains('e'));
range = CharRange.isNotIn('c', 'd');
assertTrue(range.contains('b'));
assertFalse(range.contains('c'));
assertFalse(range.contains('d'));
assertTrue(range.contains('e'));
assertTrue(range.contains((char) 0));
assertTrue(range.contains(Character.MAX_VALUE));
}
//-----------------------------------------------------------------------
@Test
public void testContains_Charrange() {
final CharRange a = CharRange.is('a');
final CharRange b = CharRange.is('b');
final CharRange c = CharRange.is('c');
final CharRange c2 = CharRange.is('c');
final CharRange d = CharRange.is('d');
final CharRange e = CharRange.is('e');
final CharRange cd = CharRange.isIn('c', 'd');
final CharRange bd = CharRange.isIn('b', 'd');
final CharRange bc = CharRange.isIn('b', 'c');
final CharRange ab = CharRange.isIn('a', 'b');
final CharRange de = CharRange.isIn('d', 'e');
final CharRange ef = CharRange.isIn('e', 'f');
final CharRange ae = CharRange.isIn('a', 'e');
// normal/normal
assertFalse(c.contains(b));
assertTrue(c.contains(c));
assertTrue(c.contains(c2));
assertFalse(c.contains(d));
assertFalse(c.contains(cd));
assertFalse(c.contains(bd));
assertFalse(c.contains(bc));
assertFalse(c.contains(ab));
assertFalse(c.contains(de));
assertTrue(cd.contains(c));
assertTrue(bd.contains(c));
assertTrue(bc.contains(c));
assertFalse(ab.contains(c));
assertFalse(de.contains(c));
assertTrue(ae.contains(b));
assertTrue(ae.contains(ab));
assertTrue(ae.contains(bc));
assertTrue(ae.contains(cd));
assertTrue(ae.contains(de));
final CharRange notb = CharRange.isNot('b');
final CharRange notc = CharRange.isNot('c');
final CharRange notd = CharRange.isNot('d');
final CharRange notab = CharRange.isNotIn('a', 'b');
final CharRange notbc = CharRange.isNotIn('b', 'c');
final CharRange notbd = CharRange.isNotIn('b', 'd');
final CharRange notcd = CharRange.isNotIn('c', 'd');
final CharRange notde = CharRange.isNotIn('d', 'e');
final CharRange notae = CharRange.isNotIn('a', 'e');
final CharRange all = CharRange.isIn((char) 0, Character.MAX_VALUE);
final CharRange allbutfirst = CharRange.isIn((char) 1, Character.MAX_VALUE);
// normal/negated
assertFalse(c.contains(notc));
assertFalse(c.contains(notbd));
assertTrue(all.contains(notc));
assertTrue(all.contains(notbd));
assertFalse(allbutfirst.contains(notc));
assertFalse(allbutfirst.contains(notbd));
// negated/normal
assertTrue(notc.contains(a));
assertTrue(notc.contains(b));
assertFalse(notc.contains(c));
assertTrue(notc.contains(d));
assertTrue(notc.contains(e));
assertTrue(notc.contains(ab));
assertFalse(notc.contains(bc));
assertFalse(notc.contains(bd));
assertFalse(notc.contains(cd));
assertTrue(notc.contains(de));
assertFalse(notc.contains(ae));
assertFalse(notc.contains(all));
assertFalse(notc.contains(allbutfirst));
assertTrue(notbd.contains(a));
assertFalse(notbd.contains(b));
assertFalse(notbd.contains(c));
assertFalse(notbd.contains(d));
assertTrue(notbd.contains(e));
assertTrue(notcd.contains(ab));
assertFalse(notcd.contains(bc));
assertFalse(notcd.contains(bd));
assertFalse(notcd.contains(cd));
assertFalse(notcd.contains(de));
assertFalse(notcd.contains(ae));
assertTrue(notcd.contains(ef));
assertFalse(notcd.contains(all));
assertFalse(notcd.contains(allbutfirst));
// negated/negated
assertFalse(notc.contains(notb));
assertTrue(notc.contains(notc));
assertFalse(notc.contains(notd));
assertFalse(notc.contains(notab));
assertTrue(notc.contains(notbc));
assertTrue(notc.contains(notbd));
assertTrue(notc.contains(notcd));
assertFalse(notc.contains(notde));
assertFalse(notbd.contains(notb));
assertFalse(notbd.contains(notc));
assertFalse(notbd.contains(notd));
assertFalse(notbd.contains(notab));
assertFalse(notbd.contains(notbc));
assertTrue(notbd.contains(notbd));
assertFalse(notbd.contains(notcd));
assertFalse(notbd.contains(notde));
assertTrue(notbd.contains(notae));
}
@Test
public void testContainsNullArg() {
final CharRange range = CharRange.is('a');
try {
@SuppressWarnings("unused")
final
boolean contains = range.contains(null);
} catch(final IllegalArgumentException e) {
assertEquals("The Range must not be null", e.getMessage());
}
}
@Test
public void testIterator() {
final CharRange a = CharRange.is('a');
final CharRange ad = CharRange.isIn('a', 'd');
final CharRange nota = CharRange.isNot('a');
final CharRange emptySet = CharRange.isNotIn((char) 0, Character.MAX_VALUE);
final CharRange notFirst = CharRange.isNotIn((char) 1, Character.MAX_VALUE);
final CharRange notLast = CharRange.isNotIn((char) 0, (char) (Character.MAX_VALUE - 1));
final Iterator<Character> aIt = a.iterator();
assertNotNull(aIt);
assertTrue(aIt.hasNext());
assertEquals(Character.valueOf('a'), aIt.next());
assertFalse(aIt.hasNext());
final Iterator<Character> adIt = ad.iterator();
assertNotNull(adIt);
assertTrue(adIt.hasNext());
assertEquals(Character.valueOf('a'), adIt.next());
assertEquals(Character.valueOf('b'), adIt.next());
assertEquals(Character.valueOf('c'), adIt.next());
assertEquals(Character.valueOf('d'), adIt.next());
assertFalse(adIt.hasNext());
final Iterator<Character> notaIt = nota.iterator();
assertNotNull(notaIt);
assertTrue(notaIt.hasNext());
while (notaIt.hasNext()) {
final Character c = notaIt.next();
assertFalse('a' == c.charValue());
}
final Iterator<Character> emptySetIt = emptySet.iterator();
assertNotNull(emptySetIt);
assertFalse(emptySetIt.hasNext());
try {
emptySetIt.next();
fail("Should throw NoSuchElementException");
} catch (final NoSuchElementException e) {
assertTrue(true);
}
final Iterator<Character> notFirstIt = notFirst.iterator();
assertNotNull(notFirstIt);
assertTrue(notFirstIt.hasNext());
assertEquals(Character.valueOf((char) 0), notFirstIt.next());
assertFalse(notFirstIt.hasNext());
try {
notFirstIt.next();
fail("Should throw NoSuchElementException");
} catch (final NoSuchElementException e) {
assertTrue(true);
}
final Iterator<Character> notLastIt = notLast.iterator();
assertNotNull(notLastIt);
assertTrue(notLastIt.hasNext());
assertEquals(Character.valueOf(Character.MAX_VALUE), notLastIt.next());
assertFalse(notLastIt.hasNext());
try {
notLastIt.next();
fail("Should throw NoSuchElementException");
} catch (final NoSuchElementException e) {
assertTrue(true);
}
}
//-----------------------------------------------------------------------
@Test
public void testSerialization() {
CharRange range = CharRange.is('a');
assertEquals(range, SerializationUtils.clone(range));
range = CharRange.isIn('a', 'e');
assertEquals(range, SerializationUtils.clone(range));
range = CharRange.isNotIn('a', 'e');
assertEquals(range, SerializationUtils.clone(range));
}
}