commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From a...@apache.org
Subject cvs commit: jakarta-commons/lang/src/test/org/apache/commons/lang StringUtilsTest.java
Date Sat, 29 Mar 2003 16:17:21 GMT
alex        2003/03/29 08:17:21

  Modified:    lang/src/java/org/apache/commons/lang StringUtils.java
               lang/src/test/org/apache/commons/lang StringUtilsTest.java
  Log:
  changed chomp() to match Perl
  deprecated chomp* methods in favor of new slice methods
  improved unit tests and documentation
  
  Revision  Changes    Path
  1.40      +162 -23   jakarta-commons/lang/src/java/org/apache/commons/lang/StringUtils.java
  
  Index: StringUtils.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/lang/src/java/org/apache/commons/lang/StringUtils.java,v
  retrieving revision 1.39
  retrieving revision 1.40
  diff -u -r1.39 -r1.40
  --- StringUtils.java	25 Mar 2003 00:15:58 -0000	1.39
  +++ StringUtils.java	29 Mar 2003 16:17:21 -0000	1.40
  @@ -820,36 +820,72 @@
   
       // Chomping
       //--------------------------------------------------------------------------
  -    
  -    /** 
  -     * <p>Remove the last newline, and everything after it from a String.</p>
  +
  +    /**
  +     * <p>Remove one newline from end of a String if it's there,
  +     * otherwise leave it alone.  A newline is "\n", "\r", or "\r\n".
  +     * <p>
  +     * Note that this behavior has changed from 1.0.  It
  +     * now more closely matches Perl chomp.  For the previous behavior,
  +     * use slice(String).
        *
  -     * @param str String to chomp the newline from
  -     * @return String without chomped newline
  +     * @param str String to chomp a newline from
  +     * @return String without newline
        * @throws NullPointerException if str is <code>null</code>
        */
       public static String chomp(String str) {
  -        return chomp(str, "\n");
  +        if (str.length() == 0) {
  +            return str;
  +        }
  +
  +        if (str.length() == 1) {
  +            if ("\r".equals(str) || "\n".equals(str)) {
  +                return "";
  +            }
  +            else {
  +                return str;
  +            }
  +        }
  +
  +        int lastIdx = str.length() - 1;
  +        char last = str.charAt(lastIdx);
  +
  +        if (last == '\n') {
  +            if (str.charAt(lastIdx - 1) == '\r') {
  +                lastIdx--;
  +            }
  +        } else if (last == '\r') {
  +
  +        } else {
  +            lastIdx++;
  +        }
  +        return str.substring(0, lastIdx);
       }
  -    
  -    /** 
  -     * <p>Remove the last value of a supplied String, and everything after
  -     * it from a String.</p>
  +
  +    /**
  +     * <p>Remove one string (the separator) from the end of another
  +     * string if it's there, otherwise leave it alone.
  +     * <p>
        *
  -     * @param str String to chomp from
  -     * @param sep String to chomp
  -     * @return String without chomped ending
  -     * @throws NullPointerException if str or sep is <code>null</code>
  +     * Note that this behavior has changed from 1.0.  It
  +     * now more closely matches Perl chomp.  For the previous behavior,
  +     * use slice(String,String).
  +     *
  +     * @param str string to chomp from
  +     * @param separator separator string
  +     * @return String without trailing separator
  +     * @throws NullPointerException if str is <code>null</code>
        */
  -    public static String chomp(String str, String sep) {
  -        int idx = str.lastIndexOf(sep);
  -        if (idx != -1) {
  -            return str.substring(0, idx);
  -        } else {
  +    public static String chomp(String str, String separator) {
  +        if (str.length() == 0) {
               return str;
           }
  +        if (str.endsWith(separator)) {
  +            return str.substring(0, str.length() - separator.length());
  +        }
  +        return str;
       }
  -    
  +
       /**
        * <p>Remove a newline if and only if it is at the end
        * of the supplied String.</p>
  @@ -857,6 +893,7 @@
        * @param str String to chomp from
        * @return String without chomped ending
        * @throws NullPointerException if str is <code>null</code>
  +     * @deprecated use chomp(String) instead
        */
       public static String chompLast(String str) {
           return chompLast(str, "\n");
  @@ -869,6 +906,7 @@
        * @param sep String to chomp
        * @return String without chomped ending
        * @throws NullPointerException if str or sep is <code>null</code>
  +     * @deprecated use chomp(String,String) instead
        */
       public static String chompLast(String str, String sep) {
           if (str.length() == 0) {
  @@ -884,12 +922,14 @@
   
       /** 
        * <p>Remove everything and return the last value of a supplied String, and
  -     * everything after it from a String.</p>
  +     * everything after it from a String.
  +     * [That makes no sense. Just use sliceRemainder() :-)]</p>
        *
        * @param str String to chomp from
        * @param sep String to chomp
        * @return String chomped
        * @throws NullPointerException if str or sep is <code>null</code>
  +     * @deprecated use sliceRemainder(String,String) instead
        */
       public static String getChomp(String str, String sep) {
           int idx = str.lastIndexOf(sep);
  @@ -910,6 +950,7 @@
        * @param sep String to chomp
        * @return String without chomped beginning
        * @throws NullPointerException if str or sep is <code>null</code>
  +     * @deprecated use sliceFirstRemainder(String,String) instead
        */
       public static String prechomp(String str, String sep) {
           int idx = str.indexOf(sep);
  @@ -928,6 +969,7 @@
        * @param sep String to chomp
        * @return String prechomped
        * @throws NullPointerException if str or sep is <code>null</code>
  +     * @deprecated use sliceFirst(String) instead
        */
       public static String getPrechomp(String str, String sep) {
           int idx = str.indexOf(sep);
  @@ -976,6 +1018,7 @@
        * @param str String to chop a newline from
        * @return String without newline
        * @throws NullPointerException if str is <code>null</code>
  +     * @deprecated use chomp(String) instead
        */
       public static String chopNewline(String str) {
           int lastIdx = str.length() - 1;
  @@ -990,6 +1033,102 @@
           return str.substring(0, lastIdx);
       }
   
  +
  +    // Slicing
  +    //--------------------------------------------------------------------------
  +
  +    /**
  +     * <p>Remove the last newline, and everything after it from a String.</p>
  +     * (This method was formerly named chomp or chopNewline.)
  +     *
  +     * @param str String to slice the newline from
  +     * @return String without sliced newline
  +     * @throws NullPointerException if str is <code>null</code>
  +     */
  +    public static String slice(String str) {
  +        return slice(str, "\n");
  +    }
  +
  +    /**
  +     * <p>Find the last occurence of a separator String;
  +     * remove it and everything after it.</p>
  +     * (This method was formerly named chomp.)
  +     *
  +     * @param str String to slice from
  +     * @param sep String to slice
  +     * @return String without sliced ending
  +     * @throws NullPointerException if str or sep is <code>null</code>
  +     */
  +    public static String slice(String str, String sep) {
  +        int idx = str.lastIndexOf(sep);
  +        if (idx != -1) {
  +            return str.substring(0, idx);
  +        } else {
  +            return str;
  +        }
  +    }
  +
  +    /**
  +     * <p>Find the last occurence of a separator String, and return
  +     * everything after it.</p>
  +     * (This method was formerly named getchomp. Also, now it does not
  +     * include the separator in the return value.)
  +     *
  +     * @param str String to slice from
  +     * @param sep String to slice
  +     * @return String sliced
  +     * @throws NullPointerException if str or sep is <code>null</code>
  +     */
  +    public static String sliceRemainder(String str, String sep) {
  +        int idx = str.lastIndexOf(sep);
  +        if (idx == str.length() - sep.length()) {
  +            return "";
  +        } else if (idx != -1) {
  +            return str.substring(idx + sep.length());
  +        } else {
  +            return "";
  +        }
  +    }
  +
  +    /**
  +     * <p>Find the first occurence of a separator String, and return
  +     * everything after it.</p>
  +     * (This method was formerly named prechomp.  Also, previously
  +     * it included the separator in the return value; now it does not.)
  +     *
  +     * @param str String to slice from
  +     * @param sep String to slice
  +     * @return String without sliced beginning
  +     * @throws NullPointerException if str or sep is <code>null</code>
  +     */
  +    public static String sliceFirstRemainder(String str, String sep) {
  +        int idx = str.indexOf(sep);
  +        if (idx != -1) {
  +            return str.substring(idx + sep.length());
  +        } else {
  +            return str;
  +        }
  +    }
  +
  +    /**
  +     * <p>Find the first occurence of a separator string;
  +     * return everything before it (but not including the separator).</p>
  +     * (This method was formerly named getPrechomp.  Also, it used to
  +     * include the separator, but now it does not.)
  +     *
  +     * @param str String to slice from
  +     * @param sep String to slice
  +     * @return String presliced
  +     * @throws NullPointerException if str or sep is <code>null</code>
  +     */
  +    public static String sliceFirst(String str, String sep) {
  +        int idx = str.indexOf(sep);
  +        if (idx != -1) {
  +            return str.substring(0, idx);
  +        } else {
  +            return "";
  +        }
  +    }
   
       // Conversion
       //--------------------------------------------------------------------------
  
  
  
  1.17      +91 -17    jakarta-commons/lang/src/test/org/apache/commons/lang/StringUtilsTest.java
  
  Index: StringUtilsTest.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/lang/src/test/org/apache/commons/lang/StringUtilsTest.java,v
  retrieving revision 1.16
  retrieving revision 1.17
  diff -u -r1.16 -r1.17
  --- StringUtilsTest.java	23 Mar 2003 21:51:19 -0000	1.16
  +++ StringUtilsTest.java	29 Mar 2003 16:17:21 -0000	1.17
  @@ -153,7 +153,7 @@
       }
   
       public void testJoin() {
  -        assertEquals("concatenate(Object[]) failed", 
  +        assertEquals("concatenate(Object[]) failed",
                        TEXT_LIST_NOSEP, StringUtils.concatenate(ARRAY_LIST));
           assertEquals("join(Object[], String) failed", TEXT_LIST,
                        StringUtils.join(ARRAY_LIST, SEPARATOR));
  @@ -173,7 +173,7 @@
                        StringUtils.join(Arrays.asList(ARRAY_LIST).iterator(),
                                         null));
   
  -        assertEquals("concatenate(Object[]) failed", 
  +        assertEquals("concatenate(Object[]) failed",
                        "", StringUtils.concatenate(EMPTY_ARRAY_LIST));
           assertEquals("join(Object[], String) failed", "",
                        StringUtils.join(EMPTY_ARRAY_LIST, SEPARATOR));
  @@ -268,10 +268,7 @@
                        "   "+FOO+"   ", StringUtils.center(FOO, 9) );
       }
   
  -    public void testChompFunctions() {
  -        assertEquals("chomp(String) failed",
  -                     FOO, StringUtils.chomp(FOO + "\n" + FOO) );
  -
  +    public void testDeprecatedChompFunctions() {
           assertEquals("chompLast(String) failed",
                        FOO, StringUtils.chompLast(FOO + "\n") );
   
  @@ -284,13 +281,90 @@
           assertEquals("getPrechomp(String, String) failed",
                        FOO + "\n", StringUtils.getPrechomp(FOO + "\n" + FOO, "\n") );
   
  -        assertEquals("chop(String, String) failed",
  -                     FOO, StringUtils.chop(FOO + "\r\n") );
  -
           assertEquals("chopNewline(String, String) failed",
                        FOO, StringUtils.chopNewline(FOO + "\r\n") );
       }
   
  +    public void testChop() {
  +
  +        String[][] chopCases = {
  +            { FOO + "\r\n", FOO } ,
  +            { FOO + "\n" , FOO } ,
  +            { FOO + "\r", FOO },
  +            { "foo", "fo"},
  +            { "foo\nfoo", "foo\nfo" },
  +            { "\n", "" },
  +            { "\r", "" },
  +            { "\r\n", "" },
  +        };
  +        for (int i = 0; i < chopCases.length; i++) {
  +            String original = chopCases[i][0];
  +            String expectedResult = chopCases[i][1];
  +            assertEquals("chop(String) failed",
  +                    expectedResult, StringUtils.chop(original));
  +        }
  +    }
  +
  +    public void testChomp() {
  +
  +        String[][] chompCases = {
  +            { FOO + "\r\n", FOO } ,
  +            { FOO + "\n" , FOO } ,
  +            { FOO + "\r", FOO },
  +            { FOO, FOO },
  +            { FOO + "\n\n", FOO + "\n"},
  +            { "foo\nfoo", "foo\nfoo" },
  +            { "\n", "" },
  +            { "\r", "" },
  +            { "\r\n", "" },
  +        };
  +        for (int i = 0; i < chompCases.length; i++) {
  +            String original = chompCases[i][0];
  +            String expectedResult = chompCases[i][1];
  +            assertEquals("chomp(String) failed",
  +                    expectedResult, StringUtils.chomp(original));
  +        }
  +
  +        assertEquals("chomp(String, String) failed",
  +                "foo", StringUtils.chomp("foobar", "bar"));
  +        assertEquals("chomp(String, String) failed",
  +                "foobar", StringUtils.chomp("foobar", "baz"));
  +        assertEquals("chomp(String, String) failed",
  +                "foo", StringUtils.chomp("foo", "foooo"));
  +    }
  +
  +    public void testSliceFunctions() {
  +
  +        String[][] sliceCases = {
  +            {"foo\n", "foo"},
  +            {"foo\nbar", "foo"},
  +            {"foo\nbar\n", "foo\nbar"},
  +            {"foo\nbar\nbaz", "foo\nbar"},
  +        };
  +        for (int i = 0; i < sliceCases.length; i++) {
  +            String original = sliceCases[i][0];
  +            String expectedResult = sliceCases[i][1];
  +            assertEquals("slice(String) failed",
  +                    expectedResult, StringUtils.slice(original));
  +        }
  +
  +        String original = "fooXXbarXXbaz";
  +        String sep = "XX";
  +
  +        assertEquals("slice(String,String) failed",
  +                     "fooXXbar", StringUtils.slice(original, sep) );
  +
  +        assertEquals("sliceRemainder(String, String) failed",
  +                     "baz", StringUtils.sliceRemainder(original, sep) );
  +
  +        assertEquals("sliceFirst(String, String) failed",
  +                     "foo", StringUtils.sliceFirst(original, sep) );
  +
  +        assertEquals("sliceFirstRemainder(String, String) failed",
  +                     "barXXbaz", StringUtils.sliceFirstRemainder(original, sep) );
  +
  +    }
  +
       public void testPadFunctions() {
           assertEquals("rightPad(String, int) failed",
                        "1234    ", StringUtils.rightPad ("1234", 8) );
  @@ -317,13 +391,13 @@
           assertEquals("reverse(empty-string) failed",
                        "", StringUtils.reverse("") );
           assertEquals("reverseDelimitedString(String,'.') failed",
  -                     "org.apache.test", 
  +                     "org.apache.test",
                          StringUtils.reverseDelimitedString("test.apache.org", ".") );
           assertEquals("reverseDelimitedString(empty-string,'.') failed",
  -                     "", 
  +                     "",
                          StringUtils.reverseDelimitedString("", ".") );
           assertEquals("reverseDelimitedString(String,' ') failed",
  -                     "once upon a time", 
  +                     "once upon a time",
                          StringUtils.reverseDelimitedString("time a upon once"," ") );
       }
   
  @@ -359,13 +433,13 @@
                        "\\u0234", StringUtils.escape("\u0234") );
           assertEquals("escape(String) failed",
                        "\\u00fd", StringUtils.escape("\u00fd") );
  -        assertEquals("unescape(String) failed", 
  +        assertEquals("unescape(String) failed",
                        "", StringUtils.unescape("") );
  -        assertEquals("unescape(String) failed", 
  +        assertEquals("unescape(String) failed",
                        "test", StringUtils.unescape("test") );
  -        assertEquals("unescape(String) failed", 
  +        assertEquals("unescape(String) failed",
                        "\ntest\b", StringUtils.unescape("\\ntest\\b") );
  -        assertEquals("unescape(String) failed", 
  +        assertEquals("unescape(String) failed",
                        "\u123425foo\ntest\b", StringUtils.unescape("\\u123425foo\\ntest\\b")
);
       }
   
  
  
  

---------------------------------------------------------------------
To unsubscribe, e-mail: commons-dev-unsubscribe@jakarta.apache.org
For additional commands, e-mail: commons-dev-help@jakarta.apache.org


Mime
View raw message