[CODEC-59] Add methods to Base64 which work with String instead of byte[]. Patch applied with one added test code line to keep line code coverage at 100%. Branch coverage up to 92% from 91%.

garydgregory · garydgregory · commit e17d5c54eebc · 2009-08-01T04:15:09.000Z
git-svn-id: https://svn.apache.org/repos/asf/commons/proper/codec/trunk@799800 13f79535-47bb-0310-9956-ffa450edef68
diff --git a/src/java/org/apache/commons/codec/binary/Base64.java b/src/java/org/apache/commons/codec/binary/Base64.java
@@ -540,7 +540,7 @@ void decode(byte[] in, int inPos, int inAvail) {
             }
             byte b = in[inPos++];
             if (b == PAD) {
-                // WE'RE DONE!!!!
+                // We're done.
                 eof = true;
                 break;
             } else {
@@ -628,25 +628,49 @@ private static boolean containsBase64Byte(byte[] arrayOctet) {
      * 
      * @param binaryData
      *            binary data to encode
-     * @return Base64 characters
+     * @return byte[] containing Base64 characters in their UTF-8 representation.
      */
     public static byte[] encodeBase64(byte[] binaryData) {
         return encodeBase64(binaryData, false);
     }
 
+    /**
+     * Encodes binary data using the base64 algorithm into 76 character blocks separated by CRLF.
+     *
+     * @param binaryData
+     *            binary data to encode
+     * @return String containing Base64 characters.
+     */    
+    public static String encodeBase64String(byte[] binaryData) {
+        return StringUtils.newStringUtf8(encodeBase64(binaryData, true));
+    }
+    
     /**
      * Encodes binary data using a URL-safe variation of the base64 algorithm but does not chunk the output. The
      * url-safe variation emits - and _ instead of + and / characters.
      * 
      * @param binaryData
      *            binary data to encode
-     * @return Base64 characters
+     * @return byte[] containing Base64 characters in their UTF-8 representation.
      * @since 1.4
      */
     public static byte[] encodeBase64URLSafe(byte[] binaryData) {
         return encodeBase64(binaryData, false, true);
     }
 
+    /**
+     * Encodes binary data using a URL-safe variation of the base64 algorithm but does not chunk the output. The
+     * url-safe variation emits - and _ instead of + and / characters.
+     *
+     * @param binaryData
+     *            binary data to encode
+     * @return String containing Base64 characters
+     * @since 1.4
+     */    
+    public static String encodeBase64URLSafeString(byte[] binaryData) {
+        return StringUtils.newStringUtf8(encodeBase64(binaryData, false, true));
+    }    
+
     /**
      * Encodes binary data using the base64 algorithm and chunks the encoded output into 76 character blocks
      * 
@@ -660,22 +684,35 @@ public static byte[] encodeBase64Chunked(byte[] binaryData) {
 
     /**
      * Decodes an Object using the base64 algorithm. This method is provided in order to satisfy the requirements of the
-     * Decoder interface, and will throw a DecoderException if the supplied object is not of type byte[].
+     * Decoder interface, and will throw a DecoderException if the supplied object is not of type byte[] or String.
      * 
      * @param pObject
      *            Object to decode
-     * @return An object (of type byte[]) containing the binary data which corresponds to the byte[] supplied.
+     * @return An object (of type byte[]) containing the binary data which corresponds to the byte[] or String supplied.
      * @throws DecoderException
      *             if the parameter supplied is not of type byte[]
      */
-    public Object decode(Object pObject) throws DecoderException {
+    public Object decode(Object pObject) throws DecoderException {        
         if (pObject instanceof byte[]) {
             return decode((byte[]) pObject);
+        } else if (pObject instanceof String) {
+            return decode((String) pObject);
         } else {
-            throw new DecoderException("Parameter supplied to Base64 decode is not a byte[]");
+            throw new DecoderException("Parameter supplied to Base64 decode is not a byte[] or a String");
         }
     }
 
+    /**
+     * Decodes a String containing containing characters in the Base64 alphabet.
+     *
+     * @param pArray
+     *            A String containing Base64 character data
+     * @return a byte array containing binary data
+     */
+    public byte[] decode(String pArray) {
+        return decode(StringUtils.getBytesUtf8(pArray));
+    }
+
     /**
      * Decodes a byte[] containing containing characters in the Base64 alphabet.
      * 
@@ -684,6 +721,7 @@ public Object decode(Object pObject) throws DecoderException {
      * @return a byte array containing binary data
      */
     public byte[] decode(byte[] pArray) {
+        reset();
         if (pArray == null || pArray.length == 0) {
             return pArray;
         }
@@ -770,6 +808,17 @@ public static byte[] encodeBase64(byte[] binaryData, boolean isChunked, boolean
         return b64.encode(binaryData);
     }
 
+    /**
+     * Decodes a Base64 String into octets
+     *
+     * @param base64String
+     *            String containing Base64 data
+     * @return Array containing decoded data.
+     */
+    public static byte[] decodeBase64(String base64String) {
+        return new Base64().decode(base64String);
+    }
+
     /**
      * Decodes Base64 data into octets
      * 
@@ -778,8 +827,7 @@ public static byte[] encodeBase64(byte[] binaryData, boolean isChunked, boolean
      * @return Array containing decoded data.
      */
     public static byte[] decodeBase64(byte[] base64Data) {
-        Base64 b64 = new Base64();
-        return b64.decode(base64Data);
+        return new Base64().decode(base64Data);
     }
 
     /**
@@ -847,6 +895,17 @@ public Object encode(Object pObject) throws EncoderException {
         return encode((byte[]) pObject);
     }
 
+    /**
+     * Encodes a byte[] containing binary data, into a String containing characters in the Base64 alphabet.
+     *
+     * @param pArray
+     *            a byte array containing binary data
+     * @return A String containing only Base64 character data
+     */    
+    public String encodeToString(byte[] pArray) {
+        return StringUtils.newStringUtf8(encode(pArray));
+    }
+
     /**
      * Encodes a byte[] containing binary data, into a byte[] containing characters in the Base64 alphabet.
      * 
@@ -855,6 +914,10 @@ public Object encode(Object pObject) throws EncoderException {
      * @return A byte array containing only Base64 character data
      */
     public byte[] encode(byte[] pArray) {
+        reset();        
+        if (pArray == null || pArray.length == 0) {
+            return pArray;
+        }
         long len = getEncodeLength(pArray, lineLength, lineSeparator);
         byte[] buf = new byte[(int) len];
         setInitialBuffer(buf, 0, buf.length);
@@ -964,4 +1027,17 @@ static byte[] toIntegerBytes(BigInteger bigInt) {
         System.arraycopy(bigBytes, startSrc, resizedBytes, startDst, len);
         return resizedBytes;
     }
+
+    /**
+     * Resets this Base64 object to its initial newly constructed state.
+     */
+    private void reset() {
+        buffer = null;
+        pos = 0;
+        readPos = 0;
+        currentLinePos = 0;
+        modulus = 0;
+        eof = false;
+    }
+
 }
diff --git a/src/java/org/apache/commons/codec/binary/StringUtils.java b/src/java/org/apache/commons/codec/binary/StringUtils.java
@@ -149,6 +149,9 @@ public static byte[] getBytesUtf8(String string) {
      * @see String#getBytes(String)
      */
     public static byte[] getSupportedBytes(String string, String charsetName) {
+        if (string == null) {
+            return null;
+        }
         try {
             return string.getBytes(charsetName);
         } catch (UnsupportedEncodingException e) {
@@ -179,6 +182,9 @@ private static IllegalStateException newIllegalStateException(String charsetName
      * @see String#String(byte[], String)
      */
     public static String newString(byte[] bytes, String charsetName) {
+        if (bytes == null) {
+            return null;
+        }
         try {
             return new String(bytes, charsetName);
         } catch (UnsupportedEncodingException e) {
diff --git a/src/test/org/apache/commons/codec/binary/Base64Test.java b/src/test/org/apache/commons/codec/binary/Base64Test.java
@@ -60,7 +60,8 @@ public Random getRandom() {
     public void testBase64() {
         String content = "Hello World";
         String encodedContent;
-        encodedContent = new String(Base64.encodeBase64(content.getBytes()));
+        byte[] encodedBytes = Base64.encodeBase64(StringUtils.getBytesUtf8(content));
+        encodedContent = StringUtils.newStringUtf8(encodedBytes);
         assertTrue("encoding hello world", encodedContent.equals("SGVsbG8gV29ybGQ="));
     }
 
@@ -288,7 +289,7 @@ public void testEmptyBase64() {
         empty = new byte[0];
         result = Base64.decodeBase64(empty);
         assertEquals("empty base64 decode", 0, result.length);
-        assertEquals("empty base64 encode", null, Base64.decodeBase64(null));
+        assertEquals("empty base64 encode", null, Base64.decodeBase64((byte[]) null));
     }
 
     // encode/decode a large random array
@@ -423,8 +424,8 @@ public void testObjectDecodeWithInvalidParameter() throws Exception {
         Base64 b64 = new Base64();
 
         try {
-            b64.decode("Yadayadayada");
-            fail("decode(Object) didn't throw an exception when passed a String object");
+            b64.decode(new Integer(5));
+            fail("decode(Object) didn't throw an exception when passed an Integer object");
         } catch (DecoderException e) {
             // ignored
         }
@@ -956,6 +957,45 @@ public void testUUID() throws DecoderException {
         }
     }
 
+    public void testByteToStringVariations() throws DecoderException {
+        Base64 base64 = new Base64(0);
+        byte[] b1 = StringUtils.getBytesUtf8("Hello World");
+        byte[] b2 = new byte[0];
+        byte[] b3 = null;
+        byte[] b4 = Hex.decodeHex("2bf7cc2701fe4397b49ebeed5acc7090".toCharArray());  // for url-safe tests
+
+        assertEquals("byteToString Hello World", "SGVsbG8gV29ybGQ=", base64.encodeToString(b1));
+        assertEquals("byteToString static Hello World", "SGVsbG8gV29ybGQ=\r\n", Base64.encodeBase64String(b1));
+        assertEquals("byteToString \"\"", "", base64.encodeToString(b2));
+        assertEquals("byteToString static \"\"", "", Base64.encodeBase64String(b2));
+        assertEquals("byteToString null", null, base64.encodeToString(b3));
+        assertEquals("byteToString static null", null, Base64.encodeBase64String(b3));
+        assertEquals("byteToString UUID", "K/fMJwH+Q5e0nr7tWsxwkA==", base64.encodeToString(b4));
+        assertEquals("byteToString static UUID", "K/fMJwH+Q5e0nr7tWsxwkA==\r\n", Base64.encodeBase64String(b4));
+        assertEquals("byteToString static-url-safe UUID", "K_fMJwH-Q5e0nr7tWsxwkA", Base64.encodeBase64URLSafeString(b4));
+    }
+
+    public void testStringToByteVariations() throws DecoderException {
+        Base64 base64 = new Base64();
+        String s1 = "SGVsbG8gV29ybGQ=\r\n";
+        String s2 = "";
+        String s3 = null;
+        String s4a = "K/fMJwH+Q5e0nr7tWsxwkA==\r\n";
+        String s4b = "K_fMJwH-Q5e0nr7tWsxwkA";
+        byte[] b4 = Hex.decodeHex("2bf7cc2701fe4397b49ebeed5acc7090".toCharArray());  // for url-safe tests
+
+        assertEquals("StringToByte Hello World", "Hello World", StringUtils.newStringUtf8(base64.decode(s1)));
+        assertEquals("StringToByte Hello World", "Hello World", StringUtils.newStringUtf8((byte[])base64.decode((Object)s1)));
+        assertEquals("StringToByte static Hello World", "Hello World", StringUtils.newStringUtf8(Base64.decodeBase64(s1)));
+        assertEquals("StringToByte \"\"", "", StringUtils.newStringUtf8(base64.decode(s2)));
+        assertEquals("StringToByte static \"\"", "", StringUtils.newStringUtf8(Base64.decodeBase64(s2)));
+        assertEquals("StringToByte null", null, StringUtils.newStringUtf8(base64.decode(s3)));
+        assertEquals("StringToByte static null", null, StringUtils.newStringUtf8(Base64.decodeBase64(s3)));
+        assertTrue("StringToByte UUID", Arrays.equals(b4, base64.decode(s4b)));
+        assertTrue("StringToByte static UUID", Arrays.equals(b4, Base64.decodeBase64(s4a)));
+        assertTrue("StringToByte static-url-safe UUID", Arrays.equals(b4, Base64.decodeBase64(s4b)));
+    }
+
     private String toString(byte[] data) {
         StringBuffer buf = new StringBuffer();
         for (int i = 0; i < data.length; i++) {
