- Applied patch for [CODEC-81] production pretty much unchanged.

- Applied patch for [CODEC-81] tests and split one new unit test method into two tests. One for URL-safe and another for normal processing.
- Renamed StringBytesUtils to StringUtils
- Added missing @return tags to StringUtils

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/codec/trunk@798333 13f79535-47bb-0310-9956-ffa450edef68

Author: garydgregory

src/java/org/apache/commons/codec/binary/Base64.java

@@ -254,7 +254,7 @@ public Base64(boolean urlSafe) {
      * </p>
      * 
      * @param lineLength
-     *            Each line of encoded data will be at most of the given length (rounded up to nearest multiple of 4).
+     *            Each line of encoded data will be at most of the given length (rounded down to nearest multiple of 4).
      *            If lineLength <= 0, then the output will not be divided into lines (chunks). Ignored when decoding.
      * @since 1.4
      */
@@ -276,7 +276,7 @@ public Base64(int lineLength) {
      * </p>
      * 
      * @param lineLength
-     *            Each line of encoded data will be at most of the given length (rounded up to nearest multiple of 4).
+     *            Each line of encoded data will be at most of the given length (rounded down to nearest multiple of 4).
      *            If lineLength <= 0, then the output will not be divided into lines (chunks). Ignored when decoding.
      * @param lineSeparator
      *            Each line of encoded data will end with this sequence of bytes.
@@ -302,7 +302,7 @@ public Base64(int lineLength, byte[] lineSeparator) {
      * </p>
      * 
      * @param lineLength
-     *            Each line of encoded data will be at most of the given length (rounded up to nearest multiple of 4).
+     *            Each line of encoded data will be at most of the given length (rounded down to nearest multiple of 4).
      *            If lineLength <= 0, then the output will not be divided into lines (chunks). Ignored when decoding.
      * @param lineSeparator
      *            Each line of encoded data will end with this sequence of bytes.
@@ -314,7 +314,7 @@ public Base64(int lineLength, byte[] lineSeparator) {
      * @since 1.4
      */
     public Base64(int lineLength, byte[] lineSeparator, boolean urlSafe) {
-        this.lineLength = lineLength;
+        this.lineLength = lineLength > 0 ? (lineLength / 4) * 4 : 0;
         this.lineSeparator = new byte[lineSeparator.length];
         System.arraycopy(lineSeparator, 0, this.lineSeparator, 0, lineSeparator.length);
         if (lineLength > 0) {
@@ -324,7 +324,7 @@ public Base64(int lineLength, byte[] lineSeparator, boolean urlSafe) {
         }
         this.decodeSize = this.encodeSize - 1;
         if (containsBase64Byte(lineSeparator)) {
-            String sep = StringBytesUtils.newStringUtf8(lineSeparator);
+            String sep = StringUtils.newStringUtf8(lineSeparator);
             throw new IllegalArgumentException("lineSeperator must not contain base64 characters: [" + sep + "]");
         }
         this.encodeTable = urlSafe ? URL_SAFE_ENCODE_TABLE : STANDARD_ENCODE_TABLE;
@@ -669,10 +669,11 @@ public static byte[] encodeBase64Chunked(byte[] binaryData) {
      *             if the parameter supplied is not of type byte[]
      */
     public Object decode(Object pObject) throws DecoderException {
-        if (!(pObject instanceof byte[])) {
+        if (pObject instanceof byte[]) {
+            return decode((byte[]) pObject);
+        } else {
             throw new DecoderException("Parameter supplied to Base64 decode is not a byte[]");
         }
-        return decode((byte[]) pObject);
     }
 
     /**
@@ -683,7 +684,24 @@ public Object decode(Object pObject) throws DecoderException {
      * @return a byte array containing binary data
      */
     public byte[] decode(byte[] pArray) {
-        return decodeBase64(pArray);
+        if (pArray == null || pArray.length == 0) {
+            return pArray;
+        }
+        long len = (pArray.length * 3) / 4;
+        byte[] buf = new byte[(int) len];
+        setInitialBuffer(buf, 0, buf.length);
+        decode(pArray, 0, pArray.length);
+        decode(pArray, 0, -1); // Notify decoder of EOF.
+
+        // Would be nice to just return buf (like we sometimes do in the encode
+        // logic), but we have no idea what the line-length was (could even be
+        // variable).  So we cannot determine ahead of time exactly how big an
+        // array is necessary.  Hence the need to construct a 2nd byte array to
+        // hold the final result:
+
+        byte[] result = new byte[pos];
+        readResults(result, 0, result.length);
+        return result;
     }
 
     /**
@@ -739,41 +757,17 @@ public static byte[] encodeBase64(byte[] binaryData, boolean isChunked, boolean
         if (binaryData == null || binaryData.length == 0) {
             return binaryData;
         }
-        Base64 b64 = isChunked ? new Base64(urlSafe) : new Base64(0, CHUNK_SEPARATOR, urlSafe);
-        long len = (binaryData.length * 4) / 3;
-        long mod = len % 4;
-        if (mod != 0) {
-            len += 4 - mod;
-        }
-        if (isChunked) {
-            boolean lenChunksPerfectly = len % CHUNK_SIZE == 0;
-            len += (len / CHUNK_SIZE) * CHUNK_SEPARATOR.length;
-            if (!lenChunksPerfectly) {
-                len += CHUNK_SEPARATOR.length;
-            }
-        }
+
+        long len = getEncodeLength(binaryData, CHUNK_SIZE, CHUNK_SEPARATOR);
         if (len > maxResultSize) {
             throw new IllegalArgumentException("Input array too big, the output array would be bigger (" +
                 len +
                 ") than the specified maxium size of " +
                 maxResultSize);
         }
-        byte[] buf = new byte[(int) len];
-        b64.setInitialBuffer(buf, 0, buf.length);
-        b64.encode(binaryData, 0, binaryData.length);
-        b64.encode(binaryData, 0, -1); // Notify encoder of EOF.
-        // Encoder might have resized, even though it was unnecessary.
-        if (b64.buffer != buf) {
-            b64.readResults(buf, 0, buf.length);
-        }
-        // In URL-SAFE mode we skip the padding characters, so sometimes our
-        // final length is a bit smaller.
-        if (urlSafe && b64.pos < buf.length) {
-            byte[] smallerBuf = new byte[b64.pos];
-            System.arraycopy(buf, 0, smallerBuf, 0, b64.pos);
-            buf = smallerBuf;
-        }
-        return buf;
+                
+        Base64 b64 = isChunked ? new Base64(urlSafe) : new Base64(0, CHUNK_SEPARATOR, urlSafe);
+        return b64.encode(binaryData);
     }
 
     /**
@@ -784,20 +778,8 @@ public static byte[] encodeBase64(byte[] binaryData, boolean isChunked, boolean
      * @return Array containing decoded data.
      */
     public static byte[] decodeBase64(byte[] base64Data) {
-        if (base64Data == null || base64Data.length == 0) {
-            return base64Data;
-        }
         Base64 b64 = new Base64();
-        long len = (base64Data.length * 3) / 4;
-        byte[] buf = new byte[(int) len];
-        b64.setInitialBuffer(buf, 0, buf.length);
-        b64.decode(base64Data, 0, base64Data.length);
-        b64.decode(base64Data, 0, -1); // Notify decoder of EOF.
-        // We have no idea what the line-length was, so we
-        // cannot know how much of our array wasn't used.
-        byte[] result = new byte[b64.pos];
-        b64.readResults(result, 0, result.length);
-        return result;
+        return b64.decode(base64Data);
     }
 
     /**
@@ -873,7 +855,53 @@ public Object encode(Object pObject) throws EncoderException {
      * @return A byte array containing only Base64 character data
      */
     public byte[] encode(byte[] pArray) {
-        return encodeBase64(pArray, false, isUrlSafe());
+        long len = getEncodeLength(pArray, lineLength, lineSeparator);
+        byte[] buf = new byte[(int) len];
+        setInitialBuffer(buf, 0, buf.length);
+        encode(pArray, 0, pArray.length);
+        encode(pArray, 0, -1); // Notify encoder of EOF.
+        // Encoder might have resized, even though it was unnecessary.
+        if (buffer != buf) {
+            readResults(buf, 0, buf.length);
+        }
+        // In URL-SAFE mode we skip the padding characters, so sometimes our
+        // final length is a bit smaller.
+        if (isUrlSafe() && pos < buf.length) {
+            byte[] smallerBuf = new byte[pos];
+            System.arraycopy(buf, 0, smallerBuf, 0, pos);
+            buf = smallerBuf;
+        }
+        return buf;        
+    }
+
+    /**
+     * Pre-calculates the amount of space needed to base64-encode the supplied array.
+     *
+     * @param pArray byte[] array which will later be encoded
+     * @param chunkSize line-length of the output (<= 0 means no chunking) between each
+     *        chunkSeparator (e.g. CRLF).
+     * @param chunkSeparator the sequence of bytes used to separate chunks of output (e.g. CRLF).
+     *
+     * @return amount of space needed to encoded the supplied array.  Returns
+     *         a long since a max-len array will require Integer.MAX_VALUE + 33%.
+     */
+    private static long getEncodeLength(byte[] pArray, int chunkSize, byte[] chunkSeparator) {
+        // base64 always encodes to multiples of 4.
+        chunkSize = (chunkSize / 4) * 4;
+
+        long len = (pArray.length * 4) / 3;
+        long mod = len % 4;
+        if (mod != 0) {
+            len += 4 - mod;
+        }
+        if (chunkSize > 0 && chunkSeparator != null) {
+            boolean lenChunksPerfectly = len % chunkSize == 0;
+            len += (len / chunkSize) * chunkSeparator.length;
+            if (!lenChunksPerfectly) {
+                len += chunkSeparator.length;
+            }
+        }
+        return len;
     }
 
     // Implementation of integer encoding used for crypto

src/java/org/apache/commons/codec/binary/Base64InputStream.java

@@ -22,21 +22,22 @@
 import java.io.InputStream;
 
 /**
- * Provides Base64 encoding and decoding in a streaming fashion (unlimited size).
- * When encoding the default lineLength is 76 characters and the default
- * lineEnding is CRLF, but these can be overridden by using the appropriate
+ * Provides Base64 encoding and decoding in a streaming fashion (unlimited size). When encoding the default lineLength
+ * is 76 characters and the default lineEnding is CRLF, but these can be overridden by using the appropriate
  * constructor.
  * <p>
- * The default behaviour of the Base64InputStream is to DECODE, whereas the
- * default behaviour of the Base64OutputStream is to ENCODE, but this
- * behaviour can be overridden by using a different constructor.
- * </p><p>
+ * The default behaviour of the Base64InputStream is to DECODE, whereas the default behaviour of the Base64OutputStream
+ * is to ENCODE, but this behaviour can be overridden by using a different constructor.
+ * </p>
+ * <p>
  * This class implements section <cite>6.8. Base64 Content-Transfer-Encoding</cite> from RFC 2045 <cite>Multipurpose
  * Internet Mail Extensions (MIME) Part One: Format of Internet Message Bodies</cite> by Freed and Borenstein.
- * </p><p>
+ * </p>
+ * <p>
  * Since this class operates directly on byte streams, and not character streams, it is hard-coded to only encode/decode
- * character encodings which are compatible with the lower 127 ASCII chart (ISO-8859-1, Windows-1252, UTF-8, etc). 
+ * character encodings which are compatible with the lower 127 ASCII chart (ISO-8859-1, Windows-1252, UTF-8, etc).
  * </p>
+ * 
  * @author Apache Software Foundation
  * @version $Id $
  * @see <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045</a>
@@ -45,26 +46,29 @@
 public class Base64InputStream extends FilterInputStream {
 
     private final boolean doEncode;
+
     private final Base64 base64;
+
     private final byte[] singleByte = new byte[1];
 
     /**
-     * Creates a Base64InputStream such that all data read is Base64-decoded
-     * from the original provided InputStream.
-     *
-     * @param in InputStream to wrap.
+     * Creates a Base64InputStream such that all data read is Base64-decoded from the original provided InputStream.
+     * 
+     * @param in
+     *            InputStream to wrap.
      */
     public Base64InputStream(InputStream in) {
         this(in, false);
     }
 
     /**
-     * Creates a Base64InputStream such that all data read is either
-     * Base64-encoded or Base64-decoded from the original provided InputStream.
-     *
-     * @param in       InputStream to wrap.
-     * @param doEncode true if we should encode all data read from us,
-     *                 false if we should decode.
+     * Creates a Base64InputStream such that all data read is either Base64-encoded or Base64-decoded from the original
+     * provided InputStream.
+     * 
+     * @param in
+     *            InputStream to wrap.
+     * @param doEncode
+     *            true if we should encode all data read from us, false if we should decode.
      */
     public Base64InputStream(InputStream in, boolean doEncode) {
         super(in);
@@ -73,20 +77,20 @@ public Base64InputStream(InputStream in, boolean doEncode) {
     }
 
     /**
-     * Creates a Base64InputStream such that all data read is either
-     * Base64-encoded or Base64-decoded from the original provided InputStream.
-     *
-     * @param in            InputStream to wrap.
-     * @param doEncode      true if we should encode all data read from us,
-     *                      false if we should decode.
-     * @param lineLength    If doEncode is true, each line of encoded
-     *                      data will contain lineLength characters.
-     *                      If lineLength <=0, the encoded data is not divided into lines.
-     *                      If doEncode is false, lineLength is ignored.
-     * @param lineSeparator If doEncode is true, each line of encoded
-     *                      data will be terminated with this byte sequence (e.g. \r\n).
-     *                      If lineLength <= 0, the lineSeparator is not used.  
-     *                      If doEncode is false lineSeparator is ignored.
+     * Creates a Base64InputStream such that all data read is either Base64-encoded or Base64-decoded from the original
+     * provided InputStream.
+     * 
+     * @param in
+     *            InputStream to wrap.
+     * @param doEncode
+     *            true if we should encode all data read from us, false if we should decode.
+     * @param lineLength
+     *            If doEncode is true, each line of encoded data will contain lineLength characters (rounded down to
+     *            nearest multiple of 4). If lineLength <=0, the encoded data is not divided into lines. If doEncode is
+     *            false, lineLength is ignored.
+     * @param lineSeparator
+     *            If doEncode is true, each line of encoded data will be terminated with this byte sequence (e.g. \r\n).
+     *            If lineLength <= 0, the lineSeparator is not used. If doEncode is false lineSeparator is ignored.
      */
     public Base64InputStream(InputStream in, boolean doEncode, int lineLength, byte[] lineSeparator) {
         super(in);
@@ -97,8 +101,9 @@ public Base64InputStream(InputStream in, boolean doEncode, int lineLength, byte[
     /**
      * Reads one <code>byte</code> from this input stream.
      * 
-     * @return the byte as an integer in the range 0 to 255
-     * Returns -1 if EOF has been reached.
+     * @return the byte as an integer in the range 0 to 255. Returns -1 if EOF has been reached.
+     * @throws IOException
+     *             if an I/O error occurs.
      */
     public int read() throws IOException {
         int r = read(singleByte, 0, 1);
@@ -112,18 +117,23 @@ public int read() throws IOException {
     }
 
     /**
-     * Attempts to read <code>len</code> bytes into the specified
-     * <code>b</code> array starting at <code>offset</code> from
-     * this InputStream.
+     * Attempts to read <code>len</code> bytes into the specified <code>b</code> array starting at <code>offset</code>
+     * from this InputStream.
      * 
-     * @param b destination byte array
-     * @param offset where to start writing the bytes
-     * @param len maximum number of bytes to read
+     * @param b
+     *            destination byte array
+     * @param offset
+     *            where to start writing the bytes
+     * @param len
+     *            maximum number of bytes to read
      * 
      * @return number of bytes read
-     * @throws IOException if an I/O error occurs.
-     * @throws NullPointerException if the byte array parameter is null
-     * @throws IndexOutOfBoundsException if offset, len or buffer size are invalid
+     * @throws IOException
+     *             if an I/O error occurs.
+     * @throws NullPointerException
+     *             if the byte array parameter is null
+     * @throws IndexOutOfBoundsException
+     *             if offset, len or buffer size are invalid
      */
     public int read(byte b[], int offset, int len) throws IOException {
         if (b == null) {
@@ -138,13 +148,11 @@ public int read(byte b[], int offset, int len) throws IOException {
             if (!base64.hasData()) {
                 byte[] buf = new byte[doEncode ? 4096 : 8192];
                 int c = in.read(buf);
-
                 // A little optimization to avoid System.arraycopy()
                 // when possible.
                 if (c > 0 && b.length == len) {
                     base64.setInitialBuffer(b, offset, len);
                 }
-
                 if (doEncode) {
                     base64.encode(buf, 0, c);
                 } else {
@@ -157,6 +165,7 @@ public int read(byte b[], int offset, int len) throws IOException {
 
     /**
      * {@inheritDoc}
+     * 
      * @return false
      */
     public boolean markSupported() {