commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From scolebou...@apache.org
Subject cvs commit: jakarta-commons/lang/src/test/org/apache/commons/lang CharSetTest.java CharRangeTest.java LangTestSuite.java
Date Sat, 02 Aug 2003 18:18:33 GMT
scolebourne    2003/08/02 11:18:33

  Modified:    lang/src/java/org/apache/commons/lang CharSetUtils.java
                        CharSet.java CharRange.java
               lang/src/test/org/apache/commons/lang LangTestSuite.java
  Added:       lang/src/test/org/apache/commons/lang CharSetTest.java
                        CharRangeTest.java
  Log:
  Completely rework CharRange and CharSet.
  Add multiple tests to fully define the set syntax.
  
  Revision  Changes    Path
  1.20      +8 -4      jakarta-commons/lang/src/java/org/apache/commons/lang/CharSetUtils.java
  
  Index: CharSetUtils.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/lang/src/java/org/apache/commons/lang/CharSetUtils.java,v
  retrieving revision 1.19
  retrieving revision 1.20
  diff -u -r1.19 -r1.20
  --- CharSetUtils.java	1 Aug 2003 20:45:17 -0000	1.19
  +++ CharSetUtils.java	2 Aug 2003 18:18:33 -0000	1.20
  @@ -98,12 +98,14 @@
        *
        * @param set  the set, may be null
        * @return a CharSet instance, <code>null</code> if null input
  +     * @deprecated Use {@link CharSet#getInstance(String)}.
  +     *             Method will be removed in Commons Lang 3.0.
        */
  -    public static CharSet evaluateSet(String set) {
  -        if (set == null) {
  +    public static CharSet evaluateSet(String setStr) {
  +        if (setStr == null) {
               return null;
           }
  -        return new CharSet(new String[] {set}); 
  +        return CharSet.getInstance(setStr); 
       }
   
       /**
  @@ -125,6 +127,8 @@
        *
        * @param set  the set, may be null
        * @return a CharSet instance, <code>null</code> if null input
  +     * @deprecated Use {@link CharSet#getInstance(String)}.
  +     *             Method will be removed in Commons Lang 3.0.
        */
       public static CharSet evaluateSet(String[] set) {
           if (set == null) {
  
  
  
  1.10      +213 -64   jakarta-commons/lang/src/java/org/apache/commons/lang/CharSet.java
  
  Index: CharSet.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/lang/src/java/org/apache/commons/lang/CharSet.java,v
  retrieving revision 1.9
  retrieving revision 1.10
  diff -u -r1.9 -r1.10
  --- CharSet.java	31 Jul 2003 21:32:47 -0000	1.9
  +++ CharSet.java	2 Aug 2003 18:18:33 -0000	1.10
  @@ -53,117 +53,266 @@
    */
   package org.apache.commons.lang;
   
  +import java.io.Serializable;
  +import java.util.HashMap;
  +import java.util.HashSet;
   import java.util.Iterator;
  -import java.util.LinkedList;
  -import java.util.List;
  +import java.util.Map;
  +import java.util.Set;
   
   /**
    * <p>A set of characters.</p>
  + * 
  + * <p>This class is immutable, but subclasses may not be.</p>
    *
  - * @author <a href="bayard@generationjava.com">Henri Yandell</a>
  + * @author Henri Yandell
    * @author Stephen Colebourne
    * @since 1.0
    * @version $Id$
    */
  -public class CharSet {
  +public class CharSet implements Serializable {
   
  -    private List set = new LinkedList();
  +    /** Serialization lock, Lang version 2.0 */
  +    static final long serialVersionUID = 5947847346149275958L;
  +    
  +    /** A CharSet defining no characters */
  +    public static final CharSet EMPTY = new CharSet((String) null);
  +    /** A CharSet defining ASCII alphabetic characters "a-zA-Z" */
  +    public static final CharSet ASCII_ALPHA = new CharSet("a-zA-Z");
  +    /** A CharSet defining ASCII alphabetic characters "a-z" */
  +    public static final CharSet ASCII_ALPHA_LOWER = new CharSet("a-z");
  +    /** A CharSet defining ASCII alphabetic characters "A-Z" */
  +    public static final CharSet ASCII_ALPHA_UPPER = new CharSet("A-Z");
  +    /** A CharSet defining ASCII alphabetic characters "0-9" */
  +    public static final CharSet ASCII_NUMERIC = new CharSet("0-9");
  +    
  +    /**
  +     * A Map of the common cases used in the factory.
  +     * Subclasses can add more common patterns if desired.
  +     */
  +    protected static final Map COMMON = new HashMap();
  +    static {
  +        COMMON.put(null, EMPTY);
  +        COMMON.put("", EMPTY);
  +        COMMON.put("a-zA-Z", ASCII_ALPHA);
  +        COMMON.put("A-Za-z", ASCII_ALPHA);
  +        COMMON.put("a-z", ASCII_ALPHA_LOWER);
  +        COMMON.put("A-Z", ASCII_ALPHA_UPPER);
  +        COMMON.put("0-9", ASCII_NUMERIC);
  +    }
  +    
  +    /** Shared range for the dash character */
  +    private static final CharRange DASH = new CharRange('-');
  +    /** Shared range for the negate character */
  +    private static final CharRange NEGATE = new CharRange('^');
  +    
  +    /** The set of CharRange objects */
  +    private Set set = new HashSet();
   
  +    //-----------------------------------------------------------------------
       /**
  -     * <p>Restricted constructor.</p>
  +     * <p>Factory method to create a new CharSet using a special syntax.</p>
  +     * 
  +     * <ul>
  +     *  <li><code>null</code> or empty string ("")
  +     * - set containing no characters</li>
  +     *  <li>Single character, such as "a"
  +     *  - set containing just that character</li>
  +     *  <li>Multi character, such as "a-e"
  +     *  - set containing characters from one character to the other</li>
  +     *  <li>Negated, such as "^a" or "^a-e"
  +     *  - set containing all characters except those defined</li>
  +     *  <li>Combinations, such as "abe-g"
  +     *  - set containing all the characters from the individual sets</li>
  +     * </ul>
  +     * 
  +     * <p>If the same range is defined twice using the same syntax, only
  +     * one range will be kept.
  +     * Thus, "a-ca-c" creates only one range of "a-c".
  +     * However, "a-cabc" creates two ranges as they are defined differently.</p>
        *
  -     * <p>Use the factory method
  -     * {@link CharSetUtils#evaluateSet(java.lang.String[])}.</p>
  +     * <p>All CharSet objects returned by this method will be immutable.</p>
  +     * 
  +     * @param setStr  the String describing the set, may be null
        */
  -    protected CharSet(String set) {
  -        add(set);
  +    public static CharSet getInstance(String setStr) {
  +        Object set = COMMON.get(setStr);
  +        if (set != null) {
  +            return (CharSet) set;
  +        }
  +        return new CharSet(setStr);
       }
   
  +    //-----------------------------------------------------------------------
       /**
  -     * <p>Restricted constructor.</p>
  +     * <p>Constructs a new CharSet using the set syntax.</p>
        *
  -     * <p>Use the factory method
  -     * {@link CharSetUtils#evaluateSet(java.lang.String[])}.</p>
  +     * @param setStr  the String describing the set, may be null
  +     */
  +    protected CharSet(String setStr) {
  +        super();
  +        add(setStr);
  +    }
  +
  +    /**
  +     * <p>Constructs a new CharSet using the set syntax.
  +     * Each string is merged in with the set.</p>
        *
        * @throws NullPointerException if set is <code>null</code>
        */
       protected CharSet(String[] set) {
  +        super();
           int sz = set.length;
           for (int i = 0; i < sz; i++) {
               add(set[i]);
           }
       }
   
  +    //-----------------------------------------------------------------------
  +    /**
  +     * <p>Add a set definition string to the <code>CharSet</code>.</p>
  +     * 
  +     * @param str  set definition string
  +     */
  +    protected void add(String str) {
  +        if (str == null) {
  +            return;
  +        }
  +
  +        int len = str.length();
  +        switch (len) {
  +            case 0:
  +            // do nothing
  +            break;
  +            
  +            case 1:
  +            set.add(new CharRange(str.charAt(0)));
  +            break;
  +            
  +            default:
  +            int start = -1;
  +            boolean negated = false;
  +            for (int i = 0; i < len; i++) {
  +                char ch = str.charAt(i);
  +                if (ch == '-') {
  +                    if (start == -1) {
  +                        // dash found not as range separator
  +                        // treat as ordinary start block char
  +                        start = ch; 
  +                    } else if (i == len - 1) {
  +                        // dash is last character, store two single characters
  +                        set.add(new CharRange((char) start, (char) start, negated));
  +                        set.add(DASH);
  +                        start = -1;
  +                        negated = false;
  +                    } else {
  +                        // range block found, store it
  +                        set.add(new CharRange((char) start, str.charAt(++i), negated));
  +                        start = -1;
  +                        negated = false;
  +                    }
  +                } else if (ch == '^') {
  +                    if (start == -1) {
  +                        if (negated) {
  +                            // double negate, treat second as ordinary start block char
  +                            start = ch;
  +                        } else {
  +                            // negate next block
  +                            negated = true;
  +                        }
  +                    } else {
  +                        // previous block has ended, store it
  +                        set.add(new CharRange((char) start, (char) start, negated));
  +                        start = -1;
  +                        negated = true;
  +                    }
  +                } else {
  +                    if (start == -1) {
  +                        // start of block
  +                        start = ch;
  +                    } else {
  +                        // previous block has ended, store it, and start next block
  +                        set.add(new CharRange((char) start, (char) start, negated));
  +                        start = ch;
  +                        negated = false;
  +                    }
  +                }
  +            }
  +            // handle leftovers
  +            if (start != -1) {
  +                set.add(new CharRange((char) start, (char) start, negated));
  +            } else if (negated) {
  +                set.add(NEGATE);
  +            }
  +            break;
  +        }
  +    }
  +
  +    //-----------------------------------------------------------------------
  +    /**
  +     * <p>Gets the internal set as an array of CharRange objects.</p>
  +     * 
  +     * @return an array of immutable CharRange objects
  +     */
  +    public CharRange[] getCharRanges() {
  +        return (CharRange[]) set.toArray(new CharRange[set.size()]);
  +    }
  +    
  +    //-----------------------------------------------------------------------
       /**
        * <p>Does the <code>CharSet</code> contain the specified
        * character <code>ch</code>.</p>
        * 
        * @param ch  the character to check for
  -     * @return <code>true</code> if it does contain the character
  -     *  <code>ch</code>
  +     * @return <code>true</code> if the set contains the characters
        */
       public boolean contains(char ch) {
  -        Iterator iterator = set.iterator();
  -        boolean bool = false;
  -        while (iterator.hasNext()) {
  -            CharRange range = (CharRange) iterator.next();
  -            if (range.isNegated()) {
  -                if (!range.inRange(ch)) {
  -                    bool = true;
  -                }
  -            } else {
  -                if (range.inRange(ch)) {
  -                    bool = true;
  -                }
  +        for (Iterator it = set.iterator(); it.hasNext();) {
  +            CharRange range = (CharRange) it.next();
  +            if (range.contains(ch)) {
  +                return true;
               }
           }
  -        return bool;
  +        return false;
       }
   
  +    // Basics
  +    //-----------------------------------------------------------------------
       /**
  -     * <p>Add a set definition string to the <code>CharSet</code>.</p>
  +     * <p>Compares two CharSet objects, returning true if they represent
  +     * exactly the same set of characters defined in the same way.</p>
        * 
  -     * @param str  set definition string
  +     * <p>The two sets <code>abc</code> and <code>a-c</code> are <i>not</i>
  +     * equal according to this method.</p>
  +     * 
  +     * 
  +     * @param obj  the object to compare to
  +     * @return true if equal
        */
  -    protected void add(String str) {
  -        if (str == null) {
  -            return;
  +    public boolean equals(Object obj) {
  +        if (obj == this) {
  +            return true;
           }
  -        int sz = str.length();
  -        CharRange range = null;
  -
  -        if ("-".equals(str)) {
  -            range = new CharRange('-');
  -            set.add(range);
  -            return;
  -        }
  -
  -        boolean end = false;
  -        boolean negated = false;
  -        for (int i = 0; i < sz; i++) {
  -            char ch = str.charAt(i);
  -            if (ch == '-') {
  -                end = true;
  -                continue;
  -            }
  -            if (end) {
  -                range.setEnd(ch);
  -                continue;
  -            }
  -            if (ch == '^') {
  -                negated = true;
  -                continue;
  -            }
  -            range = new CharRange(ch);
  -            range.setNegated(negated);
  -            set.add(range);
  +        if (obj instanceof CharSet == false) {
  +            return false;
           }
  +        CharSet other = (CharSet) obj;
  +        return (set.equals(other.set));
       }
   
       /**
  -     * <p>Returns a string representation of the set.</p>
  +     * <p>Gets a hashCode compatable with the equals method.</p>
  +     * 
  +     * @return a suitable hashCode
  +     */
  +    public int hashCode() {
  +        return 89 + set.hashCode();
  +    }
  +    
  +    /**
  +     * <p>Gets a string representation of the set.</p>
        * 
  -     * @return string representation
  +     * @return string representation of the set
        */
       public String toString() {
           return set.toString();
  
  
  
  1.10      +127 -86   jakarta-commons/lang/src/java/org/apache/commons/lang/CharRange.java
  
  Index: CharRange.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/lang/src/java/org/apache/commons/lang/CharRange.java,v
  retrieving revision 1.9
  retrieving revision 1.10
  diff -u -r1.9 -r1.10
  --- CharRange.java	2 Aug 2003 11:20:49 -0000	1.9
  +++ CharRange.java	2 Aug 2003 18:18:33 -0000	1.10
  @@ -53,159 +53,200 @@
    */
   package org.apache.commons.lang;
   
  +import java.io.Serializable;
  +
   /**
  - * <p>A range of characters. Able to understand the idea of a contiguous
  - * sublist of an alphabet, a negated concept, and a set of characters.</p>
  - *
  - * <p>Used by <code>CharSet</code> to handle sets of characters.</p>
  + * <p>A contiguous range of characters, optionally negated.</p>
  + * 
  + * <p>This class is immutable.</p>
    *
  - * @author <a href="bayard@generationjava.com">Henri Yandell</a>
  + * @author Henri Yandell
    * @author Stephen Colebourne
    * @author Chris Feldhacker
    * @since 1.0
    * @version $Id$
    */
  -class CharRange {
  -
  -    /**
  -     * <p>Used internally to represent <code>null</code> in a char.</p>
  -     */
  -    private static final char UNSET = 0;
  +public final class CharRange implements Serializable {
   
  -    private char start;
  -    private char close;
  -    private boolean negated;
  +    /** Serialization lock, Lang version 2.0 */
  +    static final long serialVersionUID = 8270183163158333422L;
  +    
  +    /** The first character, inclusive, in the range */
  +    private final char start;
  +    /** The last character, inclusive, in the range */
  +    private final char end;
  +    /** True if the range is everything except the characters specified */
  +    private final boolean negated;
  +    
  +    /** Cached toString */
  +    private transient String iToString;
   
  +    //-----------------------------------------------------------------------
       /**
  -     * <p>Construct a <code>CharRange</code> over a single character.</p>
  +     * <p>Constructs a <code>CharRange</code> over a single character.</p>
        *
  -     * @param start char over which this range is placed
  +     * @param ch  only character in this range
        */
  -    public CharRange(char start) {
  -        this.start = start;
  +    public CharRange(char ch) {
  +        this(ch, ch, false);
       }
   
       /**
  -     * <p>Construct a <code>CharRange</code> over a set of characters.</p>
  +     * <p>Constructs a <code>CharRange</code> over a set of characters.</p>
        *
  -     * @param start  char start character in this range. inclusive
  -     * @param close  char close character in this range. inclusive
  +     * @param start  first character, inclusive, in this range
  +     * @param end  last character, inclusive, in this range
        */
  -    public CharRange(char start, char close) {
  -        this.start = start;
  -        this.close = close;
  +    public CharRange(char start, char end) {
  +        this(start, end, false);
       }
   
       /**
  -     * <p>Construct a <code>CharRange</code> over a set of characters.</p>
  +     * <p>Constructs a <code>CharRange</code> over a set of characters,
  +     * optionally negating the range.</p>
  +     *
  +     * <p>A negated range includes everything except that defined by the
  +     * start and end characters.</p>
  +     * 
  +     * <p>If start and end are in the wrong order, they are reversed.
  +     * Thus <code>a-e</code> is the same as <code>e-a</code>.</p>
        *
  -     * @param start  String start first character is in this range (inclusive).
  -     * @param close  String first character is close character in this
  -     *  range (inclusive).
  -     * @throws NullPointerException if either String is <code>null</code>
  +     * @param start  first character, inclusive, in this range
  +     * @param end  last character, inclusive, in this range
  +     * @param negated  true to express everything except the range
        */
  -    public CharRange(String start, String close) {
  -        this.start = start.charAt(0);
  -        this.close = close.charAt(0);
  +    public CharRange(char start, char end, boolean negated) {
  +        super();
  +        if (start > end) {
  +            char temp = start;
  +            start = end;
  +            end = temp;
  +        }
  +        
  +        this.start = start;
  +        this.end = end;
  +        this.negated = negated;
       }
   
  +    // Accessors
  +    //-----------------------------------------------------------------------
       /**
  -     * <p>Get the start character for this character range.</p>
  +     * <p>Gets the start character for this character range.</p>
        * 
  -     * @return start char (inclusive)
  +     * @return the start char (inclusive)
        */
       public char getStart() {
           return this.start;
       }
   
       /**
  -     * <p>Get the end character for this character range.</p>
  +     * <p>Gets the end character for this character range.</p>
        * 
  -     * @return end char (inclusive)
  +     * @return the end char (inclusive)
        */
       public char getEnd() {
  -        return this.close;
  +        return this.end;
       }
   
       /**
  -     * <p>Set the start character for this character range.</p>
  +     * <p>Is this <code>CharRange</code> negated.</p>
        * 
  -     * @param ch  start char (inclusive)
  -     */
  -    public void setStart(char ch) {
  -        this.start = ch;
  -    }
  -
  -    /**
  -     * <p>Set the end character for this character range.</p>
  -     * 
  -     * @param ch  start char (inclusive)
  +     * <p>A negated range includes everything except that defined by the
  +     * start and end characters.</p>
  +     *
  +     * @return <code>true</code> is negated
        */
  -    public void setEnd(char ch) {
  -        this.close = ch;
  +    public boolean isNegated() {
  +        return negated;
       }
   
  +    // Contains
  +    //-----------------------------------------------------------------------
       /**
  -     * <p>Is this <code>CharRange</code> over many characters.</p>
  +     * <p>Is the character specified contained in this range.</p>
        *
  -     * @return boolean <code>true</code> is many characters
  +     * @param ch  the character to check
  +     * @return <code>true</code> if this range contains the input character
        */
  -    public boolean isRange() {
  -        return this.close != UNSET;
  +    public boolean contains(char ch) {
  +        return ((ch >= start && ch <= end) != negated);
       }
   
       /**
  -     * <p>Is the passed in character <code>ch</code> inside
  +     * <p>Are all the characters of the passed in range contained in
        * this range.</p>
        *
  -     * @param ch character to test for
  -     * @return boolean <code>true</code> is in range
  -     */
  -    public boolean inRange(char ch) {
  -        if( isRange() ) {
  -            return ((ch >= start) && (ch <= close));
  +     * @param range  the range to check against
  +     * @return <code>true</code> if this range entirely contains the input range
  +     * @throws IllegalArgumentException if <code>null</code> input
  +     */
  +    public boolean contains(CharRange range) {
  +        if (range == null) {
  +            throw new IllegalArgumentException("The Range must not be null");
  +        }
  +        if (negated) {
  +            if (range.negated) {
  +                return (start >= range.start && end <= range.end);
  +            } else {
  +                return (range.end < start || range.start > end);
  +            }
           } else {
  -            return start == ch;
  +            if (range.negated) {
  +                return (start == 0 && end == Character.MAX_VALUE);
  +            } else {
  +                return (start <= range.start && end >= range.end);
  +            }
           }
       }
   
  +    // Basics
  +    //-----------------------------------------------------------------------
       /**
  -     * <p>Checks if this <code>CharRange</code> is negated.</p>
  -     *
  -     * @return boolean <code>true</code> is negated
  +     * <p>Compares two CharRange objects, returning true if they represent
  +     * exactly the same range of characters defined in the same way.</p>
  +     * 
  +     * @param obj  the object to compare to
  +     * @return true if equal
        */
  -    public boolean isNegated() {
  -        return negated;
  +    public boolean equals(Object obj) {
  +        if (obj == this) {
  +            return true;
  +        }
  +        if (obj instanceof CharRange == false) {
  +            return false;
  +        }
  +        CharRange other = (CharRange) obj;
  +        return (start == other.start && end == other.end && negated == other.negated);
       }
   
       /**
  -     * <p>Sets this character range to be negated or not.</p>
  -     *
  -     * <p>This implies that this <code>CharRange</code> is over
  -     * all characters except the ones in this range.</p>
  +     * <p>Gets a hashCode compatable with the equals method.</p>
        * 
  -     * @param negated  <code>true</code> to negate the range
  +     * @return a suitable hashCode
        */
  -    public void setNegated(boolean negated) {
  -        this.negated = negated;
  +    public int hashCode() {
  +        return 83 + start + 7 * end + (negated ? 1 : 0);
       }
  -
  +    
       /**
  -     * <p>Output a string representation of the character range.</p>
  +     * <p>Gets a string representation of the character range.</p>
        * 
        * @return string representation of this range
        */
       public String toString() {
  -        StringBuffer buf = new StringBuffer(4);
  -        if (isNegated()) {
  -            buf.append('^');
  -        }
  -        buf.append(start);
  -        if (isRange()) {
  -            buf.append('-');
  -            buf.append(close);
  +        if (iToString == null) {
  +            StringBuffer buf = new StringBuffer(4);
  +            if (isNegated()) {
  +                buf.append('^');
  +            }
  +            buf.append(start);
  +            if (start != end) {
  +                buf.append('-');
  +                buf.append(end);
  +            }
  +            iToString = buf.toString();
           }
  -        return buf.toString();
  +        return iToString;
       }
       
   }
  
  
  
  1.19      +3 -1      jakarta-commons/lang/src/test/org/apache/commons/lang/LangTestSuite.java
  
  Index: LangTestSuite.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/lang/src/test/org/apache/commons/lang/LangTestSuite.java,v
  retrieving revision 1.18
  retrieving revision 1.19
  diff -u -r1.18 -r1.19
  --- LangTestSuite.java	24 May 2003 12:11:02 -0000	1.18
  +++ LangTestSuite.java	2 Aug 2003 18:18:33 -0000	1.19
  @@ -90,6 +90,8 @@
           suite.setName("Commons-Lang Tests");
           suite.addTest(ArrayUtilsTest.suite());
           suite.addTest(BooleanUtilsTest.suite());
  +        suite.addTest(CharRangeTest.suite());
  +        suite.addTest(CharSetTest.suite());
           suite.addTest(CharSetUtilsTest.suite());
           suite.addTest(ClassUtilsTest.suite());
           suite.addTest(EntitiesTest.suite());
  
  
  
  1.1                  jakarta-commons/lang/src/test/org/apache/commons/lang/CharSetTest.java
  
  Index: CharSetTest.java
  ===================================================================
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2003 The Apache Software Foundation.  All rights
   * reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution, if
   *    any, must include the following acknowlegement:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowlegement may appear in the software itself,
   *    if and wherever such third-party acknowlegements normally appear.
   *
   * 4. The names "The Jakarta Project", "Commons", and "Apache Software
   *    Foundation" must not be used to endorse or promote products derived
   *    from this software without prior written permission. For written
   *    permission, please contact apache@apache.org.
   *
   * 5. Products derived from this software may not be called "Apache"
   *    nor may "Apache" appear in their names without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  package org.apache.commons.lang;
  
  import java.lang.reflect.Modifier;
  
  import junit.framework.Test;
  import junit.framework.TestCase;
  import junit.framework.TestSuite;
  import junit.textui.TestRunner;
  
  /**
   * Unit tests {@link org.apache.commons.lang.CharSet}.
   *
   * @author Stephen Colebourne
   * @version $Id: CharSetTest.java,v 1.1 2003/08/02 18:18:33 scolebourne Exp $
   */
  public class CharSetTest extends TestCase {
      
      public CharSetTest(String name) {
          super(name);
      }
  
      public static void main(String[] args) {
          TestRunner.run(suite());
      }
  
      public static Test suite() {
          TestSuite suite = new TestSuite(CharSetTest.class);
          suite.setName("CharSet Tests");
          return suite;
      }
  
      protected void setUp() throws Exception {
          super.setUp();
      }
  
      protected void tearDown() throws Exception {
          super.tearDown();
      }
  
      //-----------------------------------------------------------------------
      public void testClass() {
          assertEquals(true, Modifier.isPublic(CharSet.class.getModifiers()));
          assertEquals(false, Modifier.isFinal(CharSet.class.getModifiers()));
      }
      
      //-----------------------------------------------------------------------
      public void testGetInstance() {
          assertSame(CharSet.EMPTY, CharSet.getInstance(null));
          assertSame(CharSet.EMPTY, CharSet.getInstance(""));
          assertSame(CharSet.ASCII_ALPHA, CharSet.getInstance("a-zA-Z"));
          assertSame(CharSet.ASCII_ALPHA, CharSet.getInstance("A-Za-z"));
          assertSame(CharSet.ASCII_ALPHA_LOWER, CharSet.getInstance("a-z"));
          assertSame(CharSet.ASCII_ALPHA_UPPER, CharSet.getInstance("A-Z"));
          assertSame(CharSet.ASCII_NUMERIC, CharSet.getInstance("0-9"));
      }
              
      //-----------------------------------------------------------------------
      public void testConstructor_String_simple() {
          CharSet set;
          CharRange[] array;
          
          set = CharSet.getInstance((String) null);
          array = set.getCharRanges();
          assertEquals("[]", set.toString());
          assertEquals(0, array.length);
          
          set = CharSet.getInstance("");
          array = set.getCharRanges();
          assertEquals("[]", set.toString());
          assertEquals(0, array.length);
          
          set = CharSet.getInstance("a");
          array = set.getCharRanges();
          assertEquals("[a]", set.toString());
          assertEquals(1, array.length);
          assertEquals("a", array[0].toString());
          
          set = CharSet.getInstance("^a");
          array = set.getCharRanges();
          assertEquals("[^a]", set.toString());
          assertEquals(1, array.length);
          assertEquals("^a", array[0].toString());
          
          set = CharSet.getInstance("a-e");
          array = set.getCharRanges();
          assertEquals("[a-e]", set.toString());
          assertEquals(1, array.length);
          assertEquals("a-e", array[0].toString());
          
          set = CharSet.getInstance("^a-e");
          array = set.getCharRanges();
          assertEquals("[^a-e]", set.toString());
          assertEquals(1, array.length);
          assertEquals("^a-e", array[0].toString());
      }
      
      public void testConstructor_String_combo() {
          CharSet set;
          CharRange[] array;
          
          set = CharSet.getInstance("abc");
          array = set.getCharRanges();
          assertEquals(3, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('a')));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('b')));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('c')));
          
          set = CharSet.getInstance("a-ce-f");
          array = set.getCharRanges();
          assertEquals(2, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('a', 'c')));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('e', 'f')));
          
          set = CharSet.getInstance("ae-f");
          array = set.getCharRanges();
          assertEquals(2, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('a')));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('e', 'f')));
          
          set = CharSet.getInstance("e-fa");
          array = set.getCharRanges();
          assertEquals(2, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('a')));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('e', 'f')));
          
          set = CharSet.getInstance("ae-fm-pz");
          array = set.getCharRanges();
          assertEquals(4, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('a')));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('e', 'f')));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('m', 'p')));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('z')));
      }
      
      public void testConstructor_String_comboNegated() {
          CharSet set;
          CharRange[] array;
          
          set = CharSet.getInstance("^abc");
          array = set.getCharRanges();
          assertEquals(3, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('a', 'a', true)));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('b')));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('c')));
          
          set = CharSet.getInstance("b^ac");
          array = set.getCharRanges();
          assertEquals(3, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('b')));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('a', 'a', true)));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('c')));
          
          set = CharSet.getInstance("db^ac");
          array = set.getCharRanges();
          assertEquals(4, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('d')));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('b')));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('a', 'a', true)));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('c')));
          
          set = CharSet.getInstance("^b^a");
          array = set.getCharRanges();
          assertEquals(2, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('b', 'b', true)));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('a', 'a', true)));
          
          set = CharSet.getInstance("b^a-c^z");
          array = set.getCharRanges();
          assertEquals(3, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('a', 'c', true)));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('z', 'z', true)));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('b')));
      }
          
      public void testConstructor_String_oddDash() {
          CharSet set;
          CharRange[] array;
          
          set = CharSet.getInstance("-");
          array = set.getCharRanges();
          assertEquals(1, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('-')));
          
          set = CharSet.getInstance("--");
          array = set.getCharRanges();
          assertEquals(1, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('-')));
          
          set = CharSet.getInstance("---");
          array = set.getCharRanges();
          assertEquals(1, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('-')));
          
          set = CharSet.getInstance("----");
          array = set.getCharRanges();
          assertEquals(1, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('-')));
          
          set = CharSet.getInstance("-a");
          array = set.getCharRanges();
          assertEquals(2, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('-')));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('a')));
          
          set = CharSet.getInstance("a-");
          array = set.getCharRanges();
          assertEquals(2, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('a')));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('-')));
          
          set = CharSet.getInstance("a--");
          array = set.getCharRanges();
          assertEquals(1, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('a', '-')));
          
          set = CharSet.getInstance("--a");
          array = set.getCharRanges();
          assertEquals(1, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('-', 'a')));
      }
      
      public void testConstructor_String_oddNegate() {
          CharSet set;
          CharRange[] array;
          set = CharSet.getInstance("^");
          array = set.getCharRanges();
          assertEquals(1, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('^')));
          
          set = CharSet.getInstance("^^");
          array = set.getCharRanges();
          assertEquals(1, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('^', '^', true)));
          
          set = CharSet.getInstance("^^^");
          array = set.getCharRanges();
          assertEquals(2, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('^', '^', true)));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('^', '^')));
          
          set = CharSet.getInstance("^^^^");
          array = set.getCharRanges();
          assertEquals(1, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('^', '^', true)));
          
          set = CharSet.getInstance("a^");
          array = set.getCharRanges();
          assertEquals(2, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('a')));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('^')));
          
          set = CharSet.getInstance("^a-");
          array = set.getCharRanges();
          assertEquals(2, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('a', 'a', true)));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('-')));
          
          set = CharSet.getInstance("^^-c");
          array = set.getCharRanges();
          assertEquals(1, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('^', 'c', true)));
          
          set = CharSet.getInstance("^c-^");
          array = set.getCharRanges();
          assertEquals(1, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('c', '^', true)));
          
          set = CharSet.getInstance("^c-^d");
          array = set.getCharRanges();
          assertEquals(2, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('c', '^', true)));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('d')));
          
          set = CharSet.getInstance("^^-");
          array = set.getCharRanges();
          assertEquals(2, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('^', '^', true)));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('-')));
      }
      
      //-----------------------------------------------------------------------    
      public void testEquals_Object() {
          CharSet abc = CharSet.getInstance("abc");
          CharSet abc2 = CharSet.getInstance("abc");
          CharSet atoc = CharSet.getInstance("a-c");
          CharSet atoc2 = CharSet.getInstance("a-c");
          CharSet notatoc = CharSet.getInstance("^a-c");
          CharSet notatoc2 = CharSet.getInstance("^a-c");
          
          assertEquals(false, abc.equals(null));
          
          assertEquals(true, abc.equals(abc));
          assertEquals(true, abc.equals(abc2));
          assertEquals(false, abc.equals(atoc));
          assertEquals(false, abc.equals(notatoc));
          
          assertEquals(false, atoc.equals(abc));
          assertEquals(true, atoc.equals(atoc));
          assertEquals(true, atoc.equals(atoc2));
          assertEquals(false, atoc.equals(notatoc));
          
          assertEquals(false, notatoc.equals(abc));
          assertEquals(false, notatoc.equals(atoc));
          assertEquals(true, notatoc.equals(notatoc));
          assertEquals(true, notatoc.equals(notatoc2));
      }
              
      public void testHashCode() {
          CharSet abc = CharSet.getInstance("abc");
          CharSet abc2 = CharSet.getInstance("abc");
          CharSet atoc = CharSet.getInstance("a-c");
          CharSet atoc2 = CharSet.getInstance("a-c");
          CharSet notatoc = CharSet.getInstance("^a-c");
          CharSet notatoc2 = CharSet.getInstance("^a-c");
          
          assertEquals(abc.hashCode(), abc.hashCode());
          assertEquals(abc.hashCode(), abc2.hashCode());
          assertEquals(atoc.hashCode(), atoc.hashCode());
          assertEquals(atoc.hashCode(), atoc2.hashCode());
          assertEquals(notatoc.hashCode(), notatoc.hashCode());
          assertEquals(notatoc.hashCode(), notatoc2.hashCode());
      }
      
      //-----------------------------------------------------------------------    
      public void testContains_Char() {
          CharSet btod = CharSet.getInstance("b-d");
          CharSet bcd = CharSet.getInstance("bcd");
          CharSet bd = CharSet.getInstance("bd");
          CharSet notbtod = CharSet.getInstance("^b-d");
          
          assertEquals(false, btod.contains('a'));
          assertEquals(true, btod.contains('b'));
          assertEquals(true, btod.contains('c'));
          assertEquals(true, btod.contains('d'));
          assertEquals(false, btod.contains('e'));
          
          assertEquals(false, bcd.contains('a'));
          assertEquals(true, bcd.contains('b'));
          assertEquals(true, bcd.contains('c'));
          assertEquals(true, bcd.contains('d'));
          assertEquals(false, bcd.contains('e'));
          
          assertEquals(false, bd.contains('a'));
          assertEquals(true, bd.contains('b'));
          assertEquals(false, bd.contains('c'));
          assertEquals(true, bd.contains('d'));
          assertEquals(false, bd.contains('e'));
          
          assertEquals(true, notbtod.contains('a'));
          assertEquals(false, notbtod.contains('b'));
          assertEquals(false, notbtod.contains('c'));
          assertEquals(false, notbtod.contains('d'));
          assertEquals(true, notbtod.contains('e'));
      }
      
      //-----------------------------------------------------------------------    
      public void testSerialization() {
          CharSet set = CharSet.getInstance("a");
          assertEquals(set, SerializationUtils.clone(set)); 
          set = CharSet.getInstance("a-e");
          assertEquals(set, SerializationUtils.clone(set)); 
          set = CharSet.getInstance("be-f^a-z");
          assertEquals(set, SerializationUtils.clone(set)); 
      }
      
      //-----------------------------------------------------------------------    
      public void testStatics() {
          CharRange[] array;
          
          array = CharSet.EMPTY.getCharRanges();
          assertEquals(0, array.length);
          
          array = CharSet.ASCII_ALPHA.getCharRanges();
          assertEquals(2, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('a', 'z')));
          assertEquals(true, ArrayUtils.contains(array, new CharRange('A', 'Z')));
          
          array = CharSet.ASCII_ALPHA_LOWER.getCharRanges();
          assertEquals(1, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('a', 'z')));
          
          array = CharSet.ASCII_ALPHA_UPPER.getCharRanges();
          assertEquals(1, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('A', 'Z')));
          
          array = CharSet.ASCII_NUMERIC.getCharRanges();
          assertEquals(1, array.length);
          assertEquals(true, ArrayUtils.contains(array, new CharRange('0', '9')));
      }
      
  }
  
  
  
  1.1                  jakarta-commons/lang/src/test/org/apache/commons/lang/CharRangeTest.java
  
  Index: CharRangeTest.java
  ===================================================================
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2003 The Apache Software Foundation.  All rights
   * reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution, if
   *    any, must include the following acknowlegement:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowlegement may appear in the software itself,
   *    if and wherever such third-party acknowlegements normally appear.
   *
   * 4. The names "The Jakarta Project", "Commons", and "Apache Software
   *    Foundation" must not be used to endorse or promote products derived
   *    from this software without prior written permission. For written
   *    permission, please contact apache@apache.org.
   *
   * 5. Products derived from this software may not be called "Apache"
   *    nor may "Apache" appear in their names without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  package org.apache.commons.lang;
  
  import java.lang.reflect.Modifier;
  
  import junit.framework.Test;
  import junit.framework.TestCase;
  import junit.framework.TestSuite;
  import junit.textui.TestRunner;
  
  /**
   * Unit tests {@link org.apache.commons.lang.CharRange}.
   *
   * @author Stephen Colebourne
   * @version $Id: CharRangeTest.java,v 1.1 2003/08/02 18:18:33 scolebourne Exp $
   */
  public class CharRangeTest extends TestCase {
      
      public CharRangeTest(String name) {
          super(name);
      }
  
      public static void main(String[] args) {
          TestRunner.run(suite());
      }
  
      public static Test suite() {
          TestSuite suite = new TestSuite(CharRangeTest.class);
          suite.setName("CharRange Tests");
          return suite;
      }
  
      protected void setUp() throws Exception {
          super.setUp();
      }
  
      protected void tearDown() throws Exception {
          super.tearDown();
      }
  
      //-----------------------------------------------------------------------
      public void testClass() {
          assertEquals(true, Modifier.isPublic(CharRange.class.getModifiers()));
          assertEquals(true, Modifier.isFinal(CharRange.class.getModifiers()));
      }
      
      //-----------------------------------------------------------------------
      public void testConstructorAccessors_Char() {
          CharRange rangea = new CharRange('a');
          CharRange rangeb = new CharRange('b');
          assertEquals('a', rangea.getStart());
          assertEquals('a', rangea.getEnd());
          assertEquals(false, rangea.isNegated());
          assertEquals("a", rangea.toString());
      }
      
      public void testConstructorAccessors_CharChar_Same() {
          CharRange rangea = new CharRange('a', 'a');
          assertEquals('a', rangea.getStart());
          assertEquals('a', rangea.getEnd());
          assertEquals(false, rangea.isNegated());
          assertEquals("a", rangea.toString());
      }
      
      public void testConstructorAccessors_CharChar_Normal() {
          CharRange rangea = new CharRange('a', 'e');
          assertEquals('a', rangea.getStart());
          assertEquals('e', rangea.getEnd());
          assertEquals(false, rangea.isNegated());
          assertEquals("a-e", rangea.toString());
      }
      
      public void testConstructorAccessors_CharChar_Reversed() {
          CharRange rangea = new CharRange('e', 'a');
          assertEquals('a', rangea.getStart());
          assertEquals('e', rangea.getEnd());
          assertEquals(false, rangea.isNegated());
          assertEquals("a-e", rangea.toString());
      }
      
      public void testConstructorAccessors_CharCharBoolean_Same() {
          CharRange rangea = new CharRange('a', 'a', false);
          assertEquals('a', rangea.getStart());
          assertEquals('a', rangea.getEnd());
          assertEquals(false, rangea.isNegated());
          assertEquals("a", rangea.toString());
      }
      
      public void testConstructorAccessors_CharCharBoolean_Normal() {
          CharRange rangea = new CharRange('a', 'e', false);
          assertEquals('a', rangea.getStart());
          assertEquals('e', rangea.getEnd());
          assertEquals(false, rangea.isNegated());
          assertEquals("a-e", rangea.toString());
      }
      
      public void testConstructorAccessors_CharCharBoolean_Reversed() {
          CharRange rangea = new CharRange('e', 'a', false);
          assertEquals('a', rangea.getStart());
          assertEquals('e', rangea.getEnd());
          assertEquals(false, rangea.isNegated());
          assertEquals("a-e", rangea.toString());
      }
      
      public void testConstructorAccessors_CharCharBoolean_SameNegated() {
          CharRange rangea = new CharRange('a', 'a', true);
          assertEquals('a', rangea.getStart());
          assertEquals('a', rangea.getEnd());
          assertEquals(true, rangea.isNegated());
          assertEquals("^a", rangea.toString());
      }
      
      public void testConstructorAccessors_CharCharBoolean_NormalNegated() {
          CharRange rangea = new CharRange('a', 'e', true);
          assertEquals('a', rangea.getStart());
          assertEquals('e', rangea.getEnd());
          assertEquals(true, rangea.isNegated());
          assertEquals("^a-e", rangea.toString());
      }
      
      public void testConstructorAccessors_CharCharBoolean_ReversedNegated() {
          CharRange rangea = new CharRange('e', 'a', true);
          assertEquals('a', rangea.getStart());
          assertEquals('e', rangea.getEnd());
          assertEquals(true, rangea.isNegated());
          assertEquals("^a-e", rangea.toString());
      }
  
      //-----------------------------------------------------------------------    
      public void testEquals_Object() {
          CharRange rangea = new CharRange('a');
          CharRange rangeae = new CharRange('a', 'e');
          CharRange rangenotbf = new CharRange('b', 'f', false);
          
          assertEquals(false, rangea.equals(null));
          
          assertEquals(true, rangea.equals(rangea));
          assertEquals(true, rangea.equals(new CharRange('a')));
          assertEquals(true, rangeae.equals(rangeae));
          assertEquals(true, rangeae.equals(new CharRange('a', 'e')));
          assertEquals(true, rangenotbf.equals(rangenotbf));
          assertEquals(true, rangenotbf.equals(new CharRange('b', 'f', false)));
          
          assertEquals(false, rangea.equals(rangeae));
          assertEquals(false, rangea.equals(rangenotbf));
          assertEquals(false, rangeae.equals(rangea));
          assertEquals(false, rangeae.equals(rangenotbf));
          assertEquals(false, rangenotbf.equals(rangea));
          assertEquals(false, rangenotbf.equals(rangeae));
      }
              
      public void testHashCode() {
          CharRange rangea = new CharRange('a');
          CharRange rangeae = new CharRange('a', 'e');
          CharRange rangenotbf = new CharRange('b', 'f', false);
          
          assertEquals(true, rangea.hashCode() == rangea.hashCode());
          assertEquals(true, rangea.hashCode() == new CharRange('a').hashCode());
          assertEquals(true, rangeae.hashCode() == rangeae.hashCode());
          assertEquals(true, rangeae.hashCode() == new CharRange('a', 'e').hashCode());
          assertEquals(true, rangenotbf.hashCode() == rangenotbf.hashCode());
          assertEquals(true, rangenotbf.hashCode() == new CharRange('b', 'f', false).hashCode());
          
          assertEquals(false, rangea.hashCode() == rangeae.hashCode());
          assertEquals(false, rangea.hashCode() == rangenotbf.hashCode());
          assertEquals(false, rangeae.hashCode() == rangea.hashCode());
          assertEquals(false, rangeae.hashCode() == rangenotbf.hashCode());
          assertEquals(false, rangenotbf.hashCode() == rangea.hashCode());
          assertEquals(false, rangenotbf.hashCode() == rangeae.hashCode());
      }
      
      //-----------------------------------------------------------------------    
      public void testContains_Char() {
          CharRange range = new CharRange('c');
          assertEquals(false, range.contains('b'));
          assertEquals(true, range.contains('c'));
          assertEquals(false, range.contains('d'));
          assertEquals(false, range.contains('e'));
          
          range = new CharRange('c', 'd');
          assertEquals(false, range.contains('b'));
          assertEquals(true, range.contains('c'));
          assertEquals(true, range.contains('d'));
          assertEquals(false, range.contains('e'));
          
          range = new CharRange('d', 'c');
          assertEquals(false, range.contains('b'));
          assertEquals(true, range.contains('c'));
          assertEquals(true, range.contains('d'));
          assertEquals(false, range.contains('e'));
          
          range = new CharRange('c', 'd', false);
          assertEquals(false, range.contains('b'));
          assertEquals(true, range.contains('c'));
          assertEquals(true, range.contains('d'));
          assertEquals(false, range.contains('e'));
          
          range = new CharRange('c', 'd', true);
          assertEquals(true, range.contains('b'));
          assertEquals(false, range.contains('c'));
          assertEquals(false, range.contains('d'));
          assertEquals(true, range.contains('e'));
          assertEquals(true, range.contains((char) 0));
          assertEquals(true, range.contains(Character.MAX_VALUE));
      }
      
      //-----------------------------------------------------------------------    
      public void testContains_Charrange() {
          CharRange a = new CharRange('a');
          CharRange b = new CharRange('b');
          CharRange c = new CharRange('c');
          CharRange c2 = new CharRange('c');
          CharRange d = new CharRange('d');
          CharRange e = new CharRange('e');
          CharRange cd = new CharRange('c', 'd');
          CharRange bd = new CharRange('b', 'd');
          CharRange bc = new CharRange('b', 'c');
          CharRange ab = new CharRange('a', 'b');
          CharRange de = new CharRange('d', 'e');
          CharRange ef = new CharRange('e', 'f');
          CharRange ae = new CharRange('a', 'e');
          
          // normal/normal
          assertEquals(false, c.contains(b));
          assertEquals(true, c.contains(c));
          assertEquals(true, c.contains(c2));
          assertEquals(false, c.contains(d));
          
          assertEquals(false, c.contains(cd));
          assertEquals(false, c.contains(bd));
          assertEquals(false, c.contains(bc));
          assertEquals(false, c.contains(ab));
          assertEquals(false, c.contains(de));
          
          assertEquals(true, cd.contains(c));
          assertEquals(true, bd.contains(c));
          assertEquals(true, bc.contains(c));
          assertEquals(false, ab.contains(c));
          assertEquals(false, de.contains(c));
  
          assertEquals(true, ae.contains(b));
          assertEquals(true, ae.contains(ab));
          assertEquals(true, ae.contains(bc));
          assertEquals(true, ae.contains(cd));
          assertEquals(true, ae.contains(de));
          
          CharRange notb = new CharRange('b', 'b', true);
          CharRange notc = new CharRange('c', 'c', true);
          CharRange notd = new CharRange('d', 'd', true);
          CharRange notab = new CharRange('a', 'b', true);
          CharRange notbc = new CharRange('b', 'c', true);
          CharRange notbd = new CharRange('b', 'd', true);
          CharRange notcd = new CharRange('c', 'd', true);
          CharRange notde = new CharRange('d', 'e', true);
          CharRange notae = new CharRange('a', 'e', true);
          CharRange all = new CharRange((char) 0, Character.MAX_VALUE);
          CharRange allbutfirst = new CharRange((char) 1, Character.MAX_VALUE);
          
          // normal/negated
          assertEquals(false, c.contains(notc));
          assertEquals(false, c.contains(notbd));
          assertEquals(true, all.contains(notc));
          assertEquals(true, all.contains(notbd));
          assertEquals(false, allbutfirst.contains(notc));
          assertEquals(false, allbutfirst.contains(notbd));
          
          // negated/normal
          assertEquals(true, notc.contains(a));
          assertEquals(true, notc.contains(b));
          assertEquals(false, notc.contains(c));
          assertEquals(true, notc.contains(d));
          assertEquals(true, notc.contains(e));
          
          assertEquals(true, notc.contains(ab));
          assertEquals(false, notc.contains(bc));
          assertEquals(false, notc.contains(bd));
          assertEquals(false, notc.contains(cd));
          assertEquals(true, notc.contains(de));
          assertEquals(false, notc.contains(ae));
          assertEquals(false, notc.contains(all));
          assertEquals(false, notc.contains(allbutfirst));
          
          assertEquals(true, notbd.contains(a));
          assertEquals(false, notbd.contains(b));
          assertEquals(false, notbd.contains(c));
          assertEquals(false, notbd.contains(d));
          assertEquals(true, notbd.contains(e));
          
          assertEquals(true, notcd.contains(ab));
          assertEquals(false, notcd.contains(bc));
          assertEquals(false, notcd.contains(bd));
          assertEquals(false, notcd.contains(cd));
          assertEquals(false, notcd.contains(de));
          assertEquals(false, notcd.contains(ae));
          assertEquals(true, notcd.contains(ef));
          assertEquals(false, notcd.contains(all));
          assertEquals(false, notcd.contains(allbutfirst));
          
          // negated/negated
          assertEquals(false, notc.contains(notb));
          assertEquals(true, notc.contains(notc));
          assertEquals(false, notc.contains(notd));
          
          assertEquals(false, notc.contains(notab));
          assertEquals(true, notc.contains(notbc));
          assertEquals(true, notc.contains(notbd));
          assertEquals(true, notc.contains(notcd));
          assertEquals(false, notc.contains(notde));
          
          assertEquals(false, notbd.contains(notb));
          assertEquals(false, notbd.contains(notc));
          assertEquals(false, notbd.contains(notd));
          
          assertEquals(false, notbd.contains(notab));
          assertEquals(false, notbd.contains(notbc));
          assertEquals(true, notbd.contains(notbd));
          assertEquals(false, notbd.contains(notcd));
          assertEquals(false, notbd.contains(notde));
          assertEquals(true, notbd.contains(notae));
      }
      
      //-----------------------------------------------------------------------    
      public void testSerialization() {
          CharRange range = new CharRange('a');
          assertEquals(range, SerializationUtils.clone(range)); 
          range = new CharRange('a', 'e');
          assertEquals(range, SerializationUtils.clone(range)); 
          range = new CharRange('a', 'e', true);
          assertEquals(range, SerializationUtils.clone(range)); 
      }
      
  }
  
  
  

Mime
View raw message