commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ggreg...@apache.org
Subject svn commit: r801391 - in /commons/proper/codec/trunk/src: java/org/apache/commons/codec/binary/ java/org/apache/commons/codec/digest/ test/org/apache/commons/codec/binary/
Date Wed, 05 Aug 2009 19:55:55 GMT
Author: ggregory
Date: Wed Aug  5 19:55:54 2009
New Revision: 801391

URL: http://svn.apache.org/viewvc?rev=801391&view=rev
Log:
[CODEC-73] Hex: Make string2byte conversions indepedent of platform default encoding.
Also refactor DigestUtils to call a new method on Hex.

Modified:
    commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/Hex.java
    commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/StringUtils.java
    commons/proper/codec/trunk/src/java/org/apache/commons/codec/digest/DigestUtils.java
    commons/proper/codec/trunk/src/test/org/apache/commons/codec/binary/Base64Test.java
    commons/proper/codec/trunk/src/test/org/apache/commons/codec/binary/HexTest.java
    commons/proper/codec/trunk/src/test/org/apache/commons/codec/binary/StringUtilsTest.java

Modified: commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/Hex.java
URL: http://svn.apache.org/viewvc/commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/Hex.java?rev=801391&r1=801390&r2=801391&view=diff
==============================================================================
--- commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/Hex.java (original)
+++ commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/Hex.java Wed Aug 
5 19:55:54 2009
@@ -17,13 +17,17 @@
 
 package org.apache.commons.codec.binary;
 
+import java.io.UnsupportedEncodingException;
+
 import org.apache.commons.codec.BinaryDecoder;
 import org.apache.commons.codec.BinaryEncoder;
+import org.apache.commons.codec.CharEncoding;
 import org.apache.commons.codec.DecoderException;
 import org.apache.commons.codec.EncoderException;
 
 /**
- * Hex encoder and decoder.
+ * Hex encoder and decoder. The charset used for certain operation can be set, the default
is set in
+ * {@link #DEFAULT_CHARSET_NAME}
  * 
  * @since 1.1
  * @author Apache Software Foundation
@@ -31,34 +35,31 @@
  */
 public class Hex implements BinaryEncoder, BinaryDecoder {
 
-    /** 
-     * Used to build output as Hex 
+    /**
+     * Default charset name is {@link CharEncoding#UTF_8}
+     */
+    public static final String DEFAULT_CHARSET_NAME = CharEncoding.UTF_8;
+
+    /**
+     * Used to build output as Hex
+     */
+    private static final char[] DIGITS_LOWER = {'0', '1', '2', '3', '4', '5', '6', '7', '8',
'9', 'a', 'b', 'c', 'd', 'e', 'f'};
+
+    /**
+     * Used to build output as Hex
      */
-    private static final char[] DIGITS_LOWER = {
-        '0', '1', '2', '3', '4', '5', '6', '7',
-           '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
-    };
-
-    /** 
-     * Used to build output as Hex 
-     */
-    private static final char[] DIGITS_UPPER = {
-        '0', '1', '2', '3', '4', '5', '6', '7',
-           '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
-    };
-
-    /**
-     * Converts an array of characters representing hexadecimal values into an
-     * array of bytes of those same values. The returned array will be half the
-     * length of the passed array, as it takes two characters to represent any
-     * given byte. An exception is thrown if the passed char array has an odd
-     * number of elements.
-     * 
-     * @param data An array of characters containing hexadecimal digits
-     * @return A byte array containing binary data decoded from
-     *         the supplied char array.
-     * @throws DecoderException Thrown if an odd number or illegal of characters 
-     *         is supplied
+    private static final char[] DIGITS_UPPER = {'0', '1', '2', '3', '4', '5', '6', '7', '8',
'9', 'A', 'B', 'C', 'D', 'E', 'F'};
+
+    /**
+     * Converts an array of characters representing hexadecimal values into an array of bytes
of those same values. The
+     * returned array will be half the length of the passed array, as it takes two characters
to represent any given
+     * byte. An exception is thrown if the passed char array has an odd number of elements.
+     * 
+     * @param data
+     *            An array of characters containing hexadecimal digits
+     * @return A byte array containing binary data decoded from the supplied char array.
+     * @throws DecoderException
+     *             Thrown if an odd number or illegal of characters is supplied
      */
     public static byte[] decodeHex(char[] data) throws DecoderException {
 
@@ -83,22 +84,6 @@
     }
 
     /**
-     * Converts a hexadecimal character to an integer.
-     *  
-     * @param ch A character to convert to an integer digit
-     * @param index The index of the character in the source
-     * @return An integer
-     * @throws DecoderException Thrown if ch is an illegal hex character
-     */
-    protected static int toDigit(char ch, int index) throws DecoderException {
-        int digit = Character.digit(ch, 16);
-        if (digit == -1) {
-            throw new DecoderException("Illegal hexadecimal charcter " + ch + " at index
" + index);
-        }
-        return digit;
-    }
-
-    /**
      * Converts an array of bytes into an array of characters representing the hexadecimal
values of each byte in order.
      * The returned array will be double the length of the passed array, as it takes two
characters to represent any
      * given byte.
@@ -151,35 +136,87 @@
     }
 
     /**
-     * Converts an array of character bytes representing hexadecimal values into an
-     * array of bytes of those same values. The returned array will be half the
-     * length of the passed array, as it takes two characters to represent any
-     * given byte. An exception is thrown if the passed char array has an odd
-     * number of elements.
-     * 
-     * @param array An array of character bytes containing hexadecimal digits
-     * @return A byte array containing binary data decoded from
-     *         the supplied byte array (representing characters).
-     * @throws DecoderException Thrown if an odd number of characters is supplied
-     *                   to this function
+     * Converts an array of bytes into a String representing the hexadecimal values of each
byte in order. The returned
+     * String will be double the length of the passed array, as it takes two characters to
represent any given byte.
+     * 
+     * @param data
+     *            a byte[] to convert to Hex characters
+     * @return A String containing hexadecimal characters
+     * @since 1.4
+     */
+    public static String encodeHexString(byte[] data) {
+        return new String(encodeHex(data));
+    }
+
+    /**
+     * Converts a hexadecimal character to an integer.
+     * 
+     * @param ch
+     *            A character to convert to an integer digit
+     * @param index
+     *            The index of the character in the source
+     * @return An integer
+     * @throws DecoderException
+     *             Thrown if ch is an illegal hex character
+     */
+    protected static int toDigit(char ch, int index) throws DecoderException {
+        int digit = Character.digit(ch, 16);
+        if (digit == -1) {
+            throw new DecoderException("Illegal hexadecimal charcter " + ch + " at index
" + index);
+        }
+        return digit;
+    }
+
+    private String charsetName = DEFAULT_CHARSET_NAME;
+
+    /**
+     * Creates a new codec with the default charset name {@link #DEFAULT_CHARSET_NAME}
+     */
+    public Hex() {
+        // use default encoding
+    }
+
+    /**
+     * Creates a new codec with the given charset name.
+     * 
+     * @param csName
+     *            the charset name.
+     */
+    public Hex(String csName) {
+        setCharsetName(csName);
+    }
+
+    /**
+     * Converts an array of character bytes representing hexadecimal values into an array
of bytes of those same values.
+     * The returned array will be half the length of the passed array, as it takes two characters
to represent any given
+     * byte. An exception is thrown if the passed char array has an odd number of elements.
+     * 
+     * @param array
+     *            An array of character bytes containing hexadecimal digits
+     * @return A byte array containing binary data decoded from the supplied byte array (representing
characters).
+     * @throws DecoderException
+     *             Thrown if an odd number of characters is supplied to this function
      * @see #decodeHex(char[])
      */
     public byte[] decode(byte[] array) throws DecoderException {
-        return decodeHex(new String(array).toCharArray());
+        try {
+            return decodeHex(new String(array, getCharsetName()).toCharArray());
+        } catch (UnsupportedEncodingException e) {
+            throw new DecoderException(e.getMessage(), e);
+        }
     }
-    
+
     /**
-     * Converts a String or an array of character bytes representing hexadecimal values into
an
-     * array of bytes of those same values. The returned array will be half the
-     * length of the passed String or array, as it takes two characters to represent any
-     * given byte. An exception is thrown if the passed char array has an odd
-     * number of elements.
-     * 
-     * @param object A String or, an array of character bytes containing hexadecimal digits
-     * @return A byte array containing binary data decoded from
-     *         the supplied byte array (representing characters).
-     * @throws DecoderException Thrown if an odd number of characters is supplied
-     *                   to this function or the object is not a String or char[]
+     * Converts a String or an array of character bytes representing hexadecimal values into
an array of bytes of those
+     * same values. The returned array will be half the length of the passed String or array,
as it takes two characters
+     * to represent any given byte. An exception is thrown if the passed char array has an
odd number of elements.
+     * 
+     * @param object
+     *            A String or, an array of character bytes containing hexadecimal digits
+     * @return A byte array containing binary data decoded from the supplied byte array (representing
characters).
+     * @throws DecoderException
+     *             Thrown if an odd number of characters is supplied to this function or
the object is not a String or
+     *             char[]
      * @see #decodeHex(char[])
      */
     public Object decode(Object object) throws DecoderException {
@@ -192,38 +229,73 @@
     }
 
     /**
-     * Converts an array of bytes into an array of bytes for the characters representing
the
-     * hexadecimal values of each byte in order. The returned array will be
-     * double the length of the passed array, as it takes two characters to
+     * Converts an array of bytes into an array of bytes for the characters representing
the hexadecimal values of each
+     * byte in order. The returned array will be double the length of the passed array, as
it takes two characters to
      * represent any given byte.
-     *
-     * @param array a byte[] to convert to Hex characters
+     * <p>
+     * The conversion from hexadecimal characters to the returned bytes is performed with
the charset named by
+     * {@link #getCharsetName()}.
+     * </p>
+     * 
+     * @param array
+     *            a byte[] to convert to Hex characters
      * @return A byte[] containing the bytes of the hexadecimal characters
+     * @throws IllegalStateException
+     *             if the charsetName is invalid. This API throws {@link IllegalStateException}
instead of
+     *             {@link UnsupportedEncodingException} for backward compatibility.
      * @see #encodeHex(byte[])
      */
     public byte[] encode(byte[] array) {
-        return new String(encodeHex(array)).getBytes();
+        return StringUtils.getBytesUnchecked(encodeHexString(array), getCharsetName());
     }
 
     /**
-     * Converts a String or an array of bytes into an array of characters representing the
-     * hexadecimal values of each byte in order. The returned array will be
-     * double the length of the passed String or array, as it takes two characters to
-     * represent any given byte.
-     *
-     * @param object a String, or byte[] to convert to Hex characters
+     * Converts a String or an array of bytes into an array of characters representing the
hexadecimal values of each
+     * byte in order. The returned array will be double the length of the passed String or
array, as it takes two
+     * characters to represent any given byte.
+     * <p>
+     * The conversion from hexadecimal characters to bytes to be encoded to performed with
the charset named by
+     * {@link #getCharsetName()}.
+     * </p>
+     * 
+     * @param object
+     *            a String, or byte[] to convert to Hex characters
      * @return A char[] containing hexadecimal characters
-     * @throws EncoderException Thrown if the given object is not a String or byte[]
+     * @throws EncoderException
+     *             Thrown if the given object is not a String or byte[]
      * @see #encodeHex(byte[])
      */
-    public Object encode(Object object) throws EncoderException {    
+    public Object encode(Object object) throws EncoderException {
         try {
-            byte[] byteArray = object instanceof String ? ((String) object).getBytes() :
(byte[]) object;
+            byte[] byteArray = object instanceof String ? ((String) object).getBytes(getCharsetName())
: (byte[]) object;
             return encodeHex(byteArray);
         } catch (ClassCastException e) {
             throw new EncoderException(e.getMessage(), e);
+        } catch (UnsupportedEncodingException e) {
+            throw new EncoderException(e.getMessage(), e);
         }
     }
 
-}
+    /**
+     * Gets the charset name.
+     * 
+     * @return the charset name.
+     */
+    public String getCharsetName() {
+        return this.charsetName;
+    }
 
+    /**
+     * Sets the charset name.
+     * 
+     * @param charsetName
+     *            the charset name.
+     */
+    public void setCharsetName(String charsetName) {
+        this.charsetName = charsetName;
+    }
+
+    public String toString() {
+        return super.toString() + "[charsetName=" + this.charsetName + "]";
+    }
+}

Modified: commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/StringUtils.java
URL: http://svn.apache.org/viewvc/commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/StringUtils.java?rev=801391&r1=801390&r2=801391&view=diff
==============================================================================
--- commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/StringUtils.java (original)
+++ commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/StringUtils.java Wed
Aug  5 19:55:54 2009
@@ -43,10 +43,10 @@
      * @throws IllegalStateException
      *             Thrown when the charset is missing, which should be never according the
the Java specification.
      * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard
charsets</a>
-     * @see #getSupportedBytes(String, String)
+     * @see #getBytesUnchecked(String, String)
      */
     public static byte[] getBytesIso8859_1(String string) {
-        return StringUtils.getSupportedBytes(string, CharEncoding.ISO_8859_1);
+        return StringUtils.getBytesUnchecked(string, CharEncoding.ISO_8859_1);
     }
 
     /**
@@ -59,10 +59,10 @@
      * @throws IllegalStateException
      *             Thrown when the charset is missing, which should be never according the
the Java specification.
      * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard
charsets</a>
-     * @see #getSupportedBytes(String, String)
+     * @see #getBytesUnchecked(String, String)
      */
     public static byte[] getBytesUsAscii(String string) {
-        return StringUtils.getSupportedBytes(string, CharEncoding.US_ASCII);
+        return StringUtils.getBytesUnchecked(string, CharEncoding.US_ASCII);
     }
 
     /**
@@ -75,10 +75,10 @@
      * @throws IllegalStateException
      *             Thrown when the charset is missing, which should be never according the
the Java specification.
      * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard
charsets</a>
-     * @see #getSupportedBytes(String, String)
+     * @see #getBytesUnchecked(String, String)
      */
     public static byte[] getBytesUtf16(String string) {
-        return StringUtils.getSupportedBytes(string, CharEncoding.UTF_16);
+        return StringUtils.getBytesUnchecked(string, CharEncoding.UTF_16);
     }
 
     /**
@@ -91,10 +91,10 @@
      * @throws IllegalStateException
      *             Thrown when the charset is missing, which should be never according the
the Java specification.
      * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard
charsets</a>
-     * @see #getSupportedBytes(String, String)
+     * @see #getBytesUnchecked(String, String)
      */
     public static byte[] getBytesUtf16Be(String string) {
-        return StringUtils.getSupportedBytes(string, CharEncoding.UTF_16BE);
+        return StringUtils.getBytesUnchecked(string, CharEncoding.UTF_16BE);
     }
 
     /**
@@ -107,10 +107,10 @@
      * @throws IllegalStateException
      *             Thrown when the charset is missing, which should be never according the
the Java specification.
      * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard
charsets</a>
-     * @see #getSupportedBytes(String, String)
+     * @see #getBytesUnchecked(String, String)
      */
     public static byte[] getBytesUtf16Le(String string) {
-        return StringUtils.getSupportedBytes(string, CharEncoding.UTF_16LE);
+        return StringUtils.getBytesUnchecked(string, CharEncoding.UTF_16LE);
     }
 
     /**
@@ -123,10 +123,10 @@
      * @throws IllegalStateException
      *             Thrown when the charset is missing, which should be never according the
the Java specification.
      * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard
charsets</a>
-     * @see #getSupportedBytes(String, String)
+     * @see #getBytesUnchecked(String, String)
      */
     public static byte[] getBytesUtf8(String string) {
-        return StringUtils.getSupportedBytes(string, CharEncoding.UTF_8);
+        return StringUtils.getBytesUnchecked(string, CharEncoding.UTF_8);
     }
 
     /**
@@ -148,7 +148,7 @@
      * @see CharEncoding
      * @see String#getBytes(String)
      */
-    public static byte[] getSupportedBytes(String string, String charsetName) {
+    public static byte[] getBytesUnchecked(String string, String charsetName) {
         if (string == null) {
             return null;
         }

Modified: commons/proper/codec/trunk/src/java/org/apache/commons/codec/digest/DigestUtils.java
URL: http://svn.apache.org/viewvc/commons/proper/codec/trunk/src/java/org/apache/commons/codec/digest/DigestUtils.java?rev=801391&r1=801390&r2=801391&view=diff
==============================================================================
--- commons/proper/codec/trunk/src/java/org/apache/commons/codec/digest/DigestUtils.java (original)
+++ commons/proper/codec/trunk/src/java/org/apache/commons/codec/digest/DigestUtils.java Wed
Aug  5 19:55:54 2009
@@ -198,7 +198,7 @@
      * @return MD5 digest as a hex string
      */
     public static String md5Hex(byte[] data) {
-        return new String(Hex.encodeHex(md5(data)));
+        return Hex.encodeHexString(md5(data));
     }
 
     /**
@@ -212,7 +212,7 @@
      * @since 1.4
      */
     public static String md5Hex(InputStream data) throws IOException {
-        return new String(Hex.encodeHex(md5(data)));
+        return Hex.encodeHexString(md5(data));
     }
 
     /**
@@ -223,7 +223,7 @@
      * @return MD5 digest as a hex string
      */
     public static String md5Hex(String data) {
-        return new String(Hex.encodeHex(md5(data)));
+        return Hex.encodeHexString(md5(data));
     }
 
     /**
@@ -321,7 +321,7 @@
      * @since 1.4
      */
     public static String sha256Hex(byte[] data) {
-        return new String(Hex.encodeHex(sha256(data)));
+        return Hex.encodeHexString(sha256(data));
     }
 
     /**
@@ -338,7 +338,7 @@
      * @since 1.4
      */
     public static String sha256Hex(InputStream data) throws IOException {
-        return new String(Hex.encodeHex(sha256(data)));
+        return Hex.encodeHexString(sha256(data));
     }
 
     /**
@@ -353,7 +353,7 @@
      * @since 1.4
      */
     public static String sha256Hex(String data) {
-        return new String(Hex.encodeHex(sha256(data)));
+        return Hex.encodeHexString(sha256(data));
     }
 
     /**
@@ -415,7 +415,7 @@
      * @since 1.4
      */
     public static String sha384Hex(byte[] data) {
-        return new String(Hex.encodeHex(sha384(data)));
+        return Hex.encodeHexString(sha384(data));
     }
 
     /**
@@ -432,7 +432,7 @@
      * @since 1.4
      */
     public static String sha384Hex(InputStream data) throws IOException {
-        return new String(Hex.encodeHex(sha384(data)));
+        return Hex.encodeHexString(sha384(data));
     }
 
     /**
@@ -447,7 +447,7 @@
      * @since 1.4
      */
     public static String sha384Hex(String data) {
-        return new String(Hex.encodeHex(sha384(data)));
+        return Hex.encodeHexString(sha384(data));
     }
 
     /**
@@ -509,7 +509,7 @@
      * @since 1.4
      */
     public static String sha512Hex(byte[] data) {
-        return new String(Hex.encodeHex(sha512(data)));
+        return Hex.encodeHexString(sha512(data));
     }
 
     /**
@@ -526,7 +526,7 @@
      * @since 1.4
      */
     public static String sha512Hex(InputStream data) throws IOException {
-        return new String(Hex.encodeHex(sha512(data)));
+        return Hex.encodeHexString(sha512(data));
     }
 
     /**
@@ -541,7 +541,7 @@
      * @since 1.4
      */
     public static String sha512Hex(String data) {
-        return new String(Hex.encodeHex(sha512(data)));
+        return Hex.encodeHexString(sha512(data));
     }
 
     /**
@@ -552,7 +552,7 @@
      * @return SHA-1 digest as a hex string
      */
     public static String shaHex(byte[] data) {
-        return new String(Hex.encodeHex(sha(data)));
+        return Hex.encodeHexString(sha(data));
     }
 
     /**
@@ -566,7 +566,7 @@
      * @since 1.4
      */
     public static String shaHex(InputStream data) throws IOException {
-        return new String(Hex.encodeHex(sha(data)));
+        return Hex.encodeHexString(sha(data));
     }
 
     /**
@@ -577,6 +577,6 @@
      * @return SHA-1 digest as a hex string
      */
     public static String shaHex(String data) {
-        return new String(Hex.encodeHex(sha(data)));
+        return Hex.encodeHexString(sha(data));
     }
 }

Modified: commons/proper/codec/trunk/src/test/org/apache/commons/codec/binary/Base64Test.java
URL: http://svn.apache.org/viewvc/commons/proper/codec/trunk/src/test/org/apache/commons/codec/binary/Base64Test.java?rev=801391&r1=801390&r2=801391&view=diff
==============================================================================
--- commons/proper/codec/trunk/src/test/org/apache/commons/codec/binary/Base64Test.java (original)
+++ commons/proper/codec/trunk/src/test/org/apache/commons/codec/binary/Base64Test.java Wed
Aug  5 19:55:54 2009
@@ -940,24 +940,24 @@
             // Very important debugging output should anyone
             // ever need to delve closely into this stuff.
             if (false) {
-                System.out.println("reference: [" + new String(Hex.encodeHex(ids[i])) + "]");
+                System.out.println("reference: [" + Hex.encodeHexString(ids[i]) + "]");
                 System.out.println("standard:  [" +
-                    new String(Hex.encodeHex(decodedStandard)) +
+                        Hex.encodeHexString(decodedStandard) +
                     "] From: [" +
                     StringUtils.newStringUtf8(standard[i]) +
                     "]");
                 System.out.println("safe1:     [" +
-                    new String(Hex.encodeHex(decodedUrlSafe1)) +
+                        Hex.encodeHexString(decodedUrlSafe1) +
                     "] From: [" +
                     StringUtils.newStringUtf8(urlSafe1[i]) +
                     "]");
                 System.out.println("safe2:     [" +
-                    new String(Hex.encodeHex(decodedUrlSafe2)) +
+                        Hex.encodeHexString(decodedUrlSafe2) +
                     "] From: [" +
                     StringUtils.newStringUtf8(urlSafe2[i]) +
                     "]");
                 System.out.println("safe3:     [" +
-                    new String(Hex.encodeHex(decodedUrlSafe3)) +
+                        Hex.encodeHexString(decodedUrlSafe3) +
                     "] From: [" +
                     StringUtils.newStringUtf8(urlSafe3[i]) +
                     "]");

Modified: commons/proper/codec/trunk/src/test/org/apache/commons/codec/binary/HexTest.java
URL: http://svn.apache.org/viewvc/commons/proper/codec/trunk/src/test/org/apache/commons/codec/binary/HexTest.java?rev=801391&r1=801390&r2=801391&view=diff
==============================================================================
--- commons/proper/codec/trunk/src/test/org/apache/commons/codec/binary/HexTest.java (original)
+++ commons/proper/codec/trunk/src/test/org/apache/commons/codec/binary/HexTest.java Wed Aug
 5 19:55:54 2009
@@ -17,9 +17,15 @@
 
 package org.apache.commons.codec.binary;
 
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
 import java.util.Arrays;
+import java.util.Iterator;
 import java.util.Random;
+import java.util.Set;
+import java.util.SortedMap;
 
+import junit.framework.Assert;
 import junit.framework.TestCase;
 
 import org.apache.commons.codec.DecoderException;
@@ -31,19 +37,112 @@
  * @author Apache Software Foundation
  * @version $Id$
  */
-
 public class HexTest extends TestCase {
 
+    private final static boolean LOG = false;
+
     public HexTest(String name) {
         super(name);
     }
-    
-    public void testDecodeArrayOddCharacters() {
+
+    /**
+     * @param data
+     */
+    private void checkDecodeHexOddCharacters(char[] data) {
         try {
-            new Hex().decode(new byte[] { 65 });
+            Hex.decodeHex(data);
             fail("An exception wasn't thrown when trying to decode an odd number of characters");
+        } catch (DecoderException e) {
+            // Expected exception
+        }
+    }
+
+    private void log(String s) {
+        if (LOG) {
+            System.out.println(s);
+        }
+    }
+
+    public void testCustomCharset() throws UnsupportedEncodingException, DecoderException
{
+        SortedMap map = Charset.availableCharsets();
+        Set keys = map.keySet();
+        Iterator iterator = keys.iterator();
+        log("testCustomCharset: Checking " + keys.size() + " charsets...");
+        while (iterator.hasNext()) {
+            String name = (String) iterator.next();
+            testCustomCharset(name, "testCustomCharset");
+        }
+    }
+
+    /**
+     * @param name
+     * @param parent
+     *            TODO
+     * @throws UnsupportedEncodingException
+     * @throws DecoderException
+     */
+    private void testCustomCharset(String name, String parent) throws UnsupportedEncodingException,
DecoderException {
+        if (charsetSanityCheck(name) == false) {
+            log("Interesting Java charset oddity: Charset sanity check failed for " + name);
+            return;
+        }
+        log(parent + "=" + name);
+        Hex customCodec = new Hex(name);
+        // source data
+        String sourceString = "Hello World";
+        byte[] sourceBytes = sourceString.getBytes(name);
+        // test 1
+        // encode source to hex string to bytes with charset
+        byte[] actualEncodedBytes = customCodec.encode(sourceBytes);
+        // encode source to hex string...
+        String expectedHexString = Hex.encodeHexString(sourceBytes);
+        // ... and get the bytes in the expected charset
+        byte[] expectedHexStringBytes = expectedHexString.getBytes(name);
+        Assert.assertTrue(Arrays.equals(expectedHexStringBytes, actualEncodedBytes));
+        // test 2
+        String actualStringFromBytes = new String(actualEncodedBytes, name);
+        assertEquals(name + ", expectedHexString=" + expectedHexString + ", actualStringFromBytes="
+ actualStringFromBytes,
+                expectedHexString, actualStringFromBytes);
+        // second test:
+        Hex utf8Codec = new Hex();
+        expectedHexString = "48656c6c6f20576f726c64";
+        byte[] decodedUtf8Bytes = (byte[]) utf8Codec.decode(expectedHexString);
+        actualStringFromBytes = new String(decodedUtf8Bytes, utf8Codec.getCharsetName());
+        // sanity check:
+        assertEquals(name, sourceString, actualStringFromBytes);
+        // actual check:
+        byte[] decodedCustomBytes = customCodec.decode(actualEncodedBytes);
+        actualStringFromBytes = new String(decodedCustomBytes, name);
+        assertEquals(name, sourceString, actualStringFromBytes);
+    }
+
+    private boolean charsetSanityCheck(String name) {
+        final String source = "the quick brown dog jumped over the lazy fox";
+        try {
+            byte[] bytes = source.getBytes(name);
+            String str = new String(bytes, name);
+            return source.equals(str);
+        } catch (UnsupportedEncodingException e) {
+            // Should NEVER happen since we are getting the name from the Charset class.
+            if (LOG) {
+                e.printStackTrace();
+            }
+            return false;
+        } catch (UnsupportedOperationException e) {
+            // Happens with:
+            // x-JIS0208 on Windows XP and Java Sun 1.6.0_14
+            if (LOG) {
+                e.printStackTrace();
+            }
+            return false;
         }
-        catch (DecoderException e) {
+    }
+
+    public void testDecodeArrayOddCharacters() {
+        try {
+            new Hex().decode(new byte[]{65});
+            fail("An exception wasn't thrown when trying to decode an odd number of characters");
+        } catch (DecoderException e) {
             // Expected exception
         }
     }
@@ -52,8 +151,7 @@
         try {
             new Hex().decode("q0");
             fail("An exception wasn't thrown when trying to decode an illegal character");
-        }
-        catch (DecoderException e) {
+        } catch (DecoderException e) {
             // Expected exception
         }
     }
@@ -62,38 +160,37 @@
         try {
             new Hex().decode("0q");
             fail("An exception wasn't thrown when trying to decode an illegal character");
-        }
-        catch (DecoderException e) {
+        } catch (DecoderException e) {
             // Expected exception
         }
     }
 
     public void testDecodeClassCastException() {
         try {
-            new Hex().decode(new int[] { 65 });
+            new Hex().decode(new int[]{65});
             fail("An exception wasn't thrown when trying to decode.");
-        }
-        catch (DecoderException e) {
+        } catch (DecoderException e) {
             // Expected exception
         }
     }
 
-    public void testDecodeHexOddCharacters() {
-        try {
-            Hex.decodeHex(new char[] { 'A' });
-            fail("An exception wasn't thrown when trying to decode an odd number of characters");
-        }
-        catch (DecoderException e) {
-            // Expected exception
-        }
+    public void testDecodeHexOddCharacters1() {
+        checkDecodeHexOddCharacters(new char[]{'A'});
+    }
+
+    public void testDecodeHexOddCharacters3() {
+        checkDecodeHexOddCharacters(new char[]{'A', 'B', 'C'});
+    }
+
+    public void testDecodeHexOddCharacters5() {
+        checkDecodeHexOddCharacters(new char[]{'A', 'B', 'C', 'D', 'E'});
     }
 
     public void testDecodeStringOddCharacters() {
         try {
             new Hex().decode("6");
             fail("An exception wasn't thrown when trying to decode an odd number of characters");
-        }
-        catch (DecoderException e) {
+        } catch (DecoderException e) {
             // Expected exception
         }
     }
@@ -101,15 +198,14 @@
     public void testDencodeEmpty() throws DecoderException {
         assertTrue(Arrays.equals(new byte[0], Hex.decodeHex(new char[0])));
         assertTrue(Arrays.equals(new byte[0], new Hex().decode(new byte[0])));
-        assertTrue(Arrays.equals(new byte[0], (byte[])new Hex().decode("")));
+        assertTrue(Arrays.equals(new byte[0], (byte[]) new Hex().decode("")));
     }
-    
+
     public void testEncodeClassCastException() {
         try {
-            new Hex().encode(new int[] { 65 });
+            new Hex().encode(new int[]{65});
             fail("An exception wasn't thrown when trying to encode.");
-        }
-        catch (EncoderException e) {
+        } catch (EncoderException e) {
             // Expected exception
         }
     }
@@ -126,7 +222,7 @@
             char[] encodedChars = Hex.encodeHex(data);
             byte[] decodedBytes = Hex.decodeHex(encodedChars);
             assertTrue(Arrays.equals(data, decodedBytes));
-            
+
             // instance API with array parameter
             byte[] encodedStringBytes = hex.encode(data);
             decodedBytes = hex.decode(encodedStringBytes);
@@ -134,34 +230,31 @@
 
             // instance API with char[] (Object) parameter
             String dataString = new String(encodedChars);
-            char[] encodedStringChars = (char[])hex.encode(dataString);
-            decodedBytes = (byte[])hex.decode(encodedStringChars);
-            assertTrue(Arrays.equals(dataString.getBytes(), decodedBytes));
+            char[] encodedStringChars = (char[]) hex.encode(dataString);
+            decodedBytes = (byte[]) hex.decode(encodedStringChars);
+            assertTrue(Arrays.equals(StringUtils.getBytesUtf8(dataString), decodedBytes));
 
             // instance API with String (Object) parameter
             dataString = new String(encodedChars);
-            encodedStringChars = (char[])hex.encode(dataString);
-            decodedBytes = (byte[])hex.decode(new String(encodedStringChars));
-            assertTrue(Arrays.equals(dataString.getBytes(), decodedBytes));
+            encodedStringChars = (char[]) hex.encode(dataString);
+            decodedBytes = (byte[]) hex.decode(new String(encodedStringChars));
+            assertTrue(Arrays.equals(StringUtils.getBytesUtf8(dataString), decodedBytes));
         }
     }
 
     public void testEncodeEmpty() throws EncoderException {
         assertTrue(Arrays.equals(new char[0], Hex.encodeHex(new byte[0])));
         assertTrue(Arrays.equals(new byte[0], new Hex().encode(new byte[0])));
-        assertTrue(Arrays.equals(new char[0], (char[])new Hex().encode("")));
+        assertTrue(Arrays.equals(new char[0], (char[]) new Hex().encode("")));
     }
 
     public void testEncodeZeroes() {
         char[] c = Hex.encodeHex(new byte[36]);
-        assertEquals(
-            "000000000000000000000000000000000000"
-                + "000000000000000000000000000000000000",
-            new String(c));
+        assertEquals("000000000000000000000000000000000000000000000000000000000000000000000000",
new String(c));
     }
 
     public void testHelloWorldLowerCaseHex() {
-        byte[] b = "Hello World".getBytes();
+        byte[] b = StringUtils.getBytesUtf8("Hello World");
         final String expected = "48656c6c6f20576f726c64";
         char[] actual;
         actual = Hex.encodeHex(b);
@@ -173,7 +266,7 @@
     }
 
     public void testHelloWorldUpperCaseHex() {
-        byte[] b = "Hello World".getBytes();
+        byte[] b = StringUtils.getBytesUtf8("Hello World");
         final String expected = "48656C6C6F20576F726C64";
         char[] actual;
         actual = Hex.encodeHex(b);
@@ -183,4 +276,13 @@
         actual = Hex.encodeHex(b, false);
         assertTrue(expected.equals(new String(actual)));
     }
+
+    public void testRequiredCharset() throws UnsupportedEncodingException, DecoderException
{
+        testCustomCharset("UTF-8", "testRequiredCharset");
+        testCustomCharset("UTF-16", "testRequiredCharset");
+        testCustomCharset("UTF-16BE", "testRequiredCharset");
+        testCustomCharset("UTF-16LE", "testRequiredCharset");
+        testCustomCharset("US-ASCII", "testRequiredCharset");
+        testCustomCharset("ISO8859_1", "testRequiredCharset");
+    }
 }

Modified: commons/proper/codec/trunk/src/test/org/apache/commons/codec/binary/StringUtilsTest.java
URL: http://svn.apache.org/viewvc/commons/proper/codec/trunk/src/test/org/apache/commons/codec/binary/StringUtilsTest.java?rev=801391&r1=801390&r2=801391&view=diff
==============================================================================
--- commons/proper/codec/trunk/src/test/org/apache/commons/codec/binary/StringUtilsTest.java
(original)
+++ commons/proper/codec/trunk/src/test/org/apache/commons/codec/binary/StringUtilsTest.java
Wed Aug  5 19:55:54 2009
@@ -53,15 +53,21 @@
 
     public void testGetBytesIso8859_1() throws UnsupportedEncodingException {
         String charsetName = "ISO-8859-1";
-        testGetSupportedBytes(charsetName);
+        testGetBytesUnchecked(charsetName);
         byte[] expected = STRING_FIXTURE.getBytes(charsetName);
         byte[] actual = StringUtils.getBytesIso8859_1(STRING_FIXTURE);
         Assert.assertTrue(Arrays.equals(expected, actual));
     }
 
+    private void testGetBytesUnchecked(String charsetName) throws UnsupportedEncodingException
{
+        byte[] expected = STRING_FIXTURE.getBytes(charsetName);
+        byte[] actual = StringUtils.getBytesUnchecked(STRING_FIXTURE, charsetName);
+        Assert.assertTrue(Arrays.equals(expected, actual));
+    }
+
     public void testGetBytesUsAscii() throws UnsupportedEncodingException {
         String charsetName = "US-ASCII";
-        testGetSupportedBytes(charsetName);
+        testGetBytesUnchecked(charsetName);
         byte[] expected = STRING_FIXTURE.getBytes(charsetName);
         byte[] actual = StringUtils.getBytesUsAscii(STRING_FIXTURE);
         Assert.assertTrue(Arrays.equals(expected, actual));
@@ -69,7 +75,7 @@
 
     public void testGetBytesUtf16() throws UnsupportedEncodingException {
         String charsetName = "UTF-16";
-        testGetSupportedBytes(charsetName);
+        testGetBytesUnchecked(charsetName);
         byte[] expected = STRING_FIXTURE.getBytes(charsetName);
         byte[] actual = StringUtils.getBytesUtf16(STRING_FIXTURE);
         Assert.assertTrue(Arrays.equals(expected, actual));
@@ -77,7 +83,7 @@
 
     public void testGetBytesUtf16Be() throws UnsupportedEncodingException {
         String charsetName = "UTF-16BE";
-        testGetSupportedBytes(charsetName);
+        testGetBytesUnchecked(charsetName);
         byte[] expected = STRING_FIXTURE.getBytes(charsetName);
         byte[] actual = StringUtils.getBytesUtf16Be(STRING_FIXTURE);
         Assert.assertTrue(Arrays.equals(expected, actual));
@@ -85,7 +91,7 @@
 
     public void testGetBytesUtf16Le() throws UnsupportedEncodingException {
         String charsetName = "UTF-16LE";
-        testGetSupportedBytes(charsetName);
+        testGetBytesUnchecked(charsetName);
         byte[] expected = STRING_FIXTURE.getBytes(charsetName);
         byte[] actual = StringUtils.getBytesUtf16Le(STRING_FIXTURE);
         Assert.assertTrue(Arrays.equals(expected, actual));
@@ -93,21 +99,15 @@
 
     public void testGetBytesUtf8() throws UnsupportedEncodingException {
         String charsetName = "UTF-8";
-        testGetSupportedBytes(charsetName);
+        testGetBytesUnchecked(charsetName);
         byte[] expected = STRING_FIXTURE.getBytes(charsetName);
         byte[] actual = StringUtils.getBytesUtf8(STRING_FIXTURE);
         Assert.assertTrue(Arrays.equals(expected, actual));
     }
 
-    private void testGetSupportedBytes(String charsetName) throws UnsupportedEncodingException
{
-        byte[] expected = STRING_FIXTURE.getBytes(charsetName);
-        byte[] actual = StringUtils.getSupportedBytes(STRING_FIXTURE, charsetName);
-        Assert.assertTrue(Arrays.equals(expected, actual));
-    }
-
-    public void testGetSupportedBytesBadEnc() {
+    public void testGetBytesUncheckedBadName() {
         try {
-            StringUtils.getSupportedBytes(STRING_FIXTURE, "UNKNOWN");
+            StringUtils.getBytesUnchecked(STRING_FIXTURE, "UNKNOWN");
             Assert.fail("Expected " + IllegalStateException.class.getName());
         } catch (IllegalStateException e) {
             // Expected



Mime
View raw message