New methods added.

Author: chdh

CHANGES.txt

@@ -4,6 +4,13 @@ Base64Coder Changes
 
 2010-02-23 chdh
 New directory layout and build script.
+Methods added:
+  encode(byte[],int,int)
+  encode(byte[],int,int)
+  decode(char[],int,int)
+  encodeLines(byte[])
+  encodeLines(byte[],int,int,int,String)
+  decodeLines(String)
 
 2010-01-27 chdh
 Package name added.

build.xml

@@ -4,22 +4,27 @@
 <property name="srcDir"            location="src/main/java"/>
 <property name="classesDir"        location="target/classes"/>
 <property name="javaDocDir"        location="target/javadoc"/>
+<property name="jarFile"           location="target/base64coder.jar"/>
 <property name="junitJar"          location="lib/junit-4.8.1.jar"/>
 <property name="testSrcDir"        location="src/test/java"/>
 <property name="testClassesDir"    location="target/test-classes"/>
 <property name="testReportsDir"    location="target/test-reports"/>
 
 <target name="buildAll" description="Compiles and generates the API docs."
-   depends="compile, javaDoc">
+   depends="buildJar, javaDoc">
 </target>
 
-<target name="compile" description="Compiles the main class.">
+<target name="buildJar" description="Compiles the Java source and builds the JAR file.">
  <delete dir="${classesDir}" failonerror="true"/>
  <mkdir dir="${classesDir}"/>
  <javac srcdir="${srcDir}" deprecation="true" includeAntRuntime="false" debug="true" debuglevel="lines,source"
     target="1.5" destdir="${classesDir}">
   <compilerarg line="-Xlint -Xmaxerrs 6"/>
  </javac>
+ <jar destfile="${jarFile}">
+  <fileset dir="${classesDir}"/>
+ </jar>
+ <delete dir="${classesDir}" failonerror="true"/>
 </target>
 
 <target name="compileTest" description="Compiles the test class.">
@@ -31,7 +36,7 @@
   <compilerarg line="-Xlint -Xmaxerrs 6"/>
   <classpath>
    <pathelement location="${junitJar}"/>
-   <pathelement location="${classesDir}"/>
+   <pathelement location="${jarFile}"/>
   </classpath>
  </javac>
 </target>
@@ -59,7 +64,7 @@
  <junit haltonfailure="on">
   <classpath>
    <pathelement location="${junitJar}"/>
-   <pathelement location="${classesDir}"/>
+   <pathelement location="${jarFile}"/>
    <pathelement location="${testClassesDir}"/>
   </classpath>
   <formatter type="plain"/>

src/main/java/biz/source_code/base64Coder/Base64Coder.java

@@ -24,11 +24,12 @@
 * Project home page: <a href="http://www.source-code.biz">www.source-code.biz</a><br>
 * Author: Christian d'Heureuse, Inventec Informatik AG, Zurich, Switzerland<br>
 * Multi-licensed: EPL/LGPL/AL/BSD.
-*
 */
-
 public class Base64Coder {
 
+// The line separator string of the operating system.
+private static final String systemLineSeparator = System.getProperty("line.separator");
+
 // Mapping table from 6-bit nibbles to Base64 characters.
 private static char[]    map1 = new char[64];
    static {
@@ -48,37 +49,81 @@ public class Base64Coder {
 * Encodes a string into Base64 format.
 * No blanks or line breaks are inserted.
 * @param s  a String to be encoded.
-* @return   A String with the Base64 encoded data.
+* @return   a String with the Base64 encoded data.
 */
 public static String encodeString (String s) {
    return new String(encode(s.getBytes())); }
 
+/**
+* Encodes a byte array into Base 64 format and splits the output into lines of 76 characters.
+* This method is compatible with <code>sun.misc.BASE64Encoder.encodeBuffer(byte[])</code>.
+* @param in  an array containing the data bytes to be encoded.
+* @return    a String with the Base64 encoded data, split into lines.
+*/
+public static String encodeLines (byte[] in) {
+   return encodeLines(in, 0, in.length, 76, systemLineSeparator); }
+
+/**
+* Encodes a byte array into Base 64 format and splits the output into lines.
+* @param in            an array containing the data bytes to be encoded.
+* #param iOff          offset of the first byte in <code>in</code> to be processed.
+* #param iLen          number of bytes to be processed in <code>in</code> starting at <code>iOff</code>.
+* @param lineLen       line length for the output data. Should be a multiple of 4.
+* @param lineSeparator the line separator to be used to split the output lines.
+* @return              a String with the Base64 encoded data, split into lines.
+*/
+public static String encodeLines (byte[] in, int iOff, int iLen, int lineLen, String lineSeparator) {
+   int blockLen = (lineLen*3) / 4;
+   if (blockLen <= 0) throw new IllegalArgumentException();
+   int lines = (iLen+blockLen-1) / blockLen;
+   int bufLen = ((iLen+2)/3)*4 + lines*lineSeparator.length();
+   StringBuilder buf = new StringBuilder(bufLen);
+   int ip = 0;
+   while (ip < iLen) {
+      int l = Math.min(iLen-ip, blockLen);
+      buf.append (encode(in, iOff+ip, l));
+      buf.append (lineSeparator);
+      ip += l; }
+   return buf.toString(); }
+
 /**
 * Encodes a byte array into Base64 format.
 * No blanks or line breaks are inserted.
 * @param in  an array containing the data bytes to be encoded.
-* @return    A character array with the Base64 encoded data.
+* @return    a character array with the Base64 encoded data.
 */
 public static char[] encode (byte[] in) {
-   return encode(in, in.length); }
+   return encode(in, 0, in.length); }
 
 /**
 * Encodes a byte array into Base64 format.
 * No blanks or line breaks are inserted.
-* @param in   an array containing the data bytes to be encoded.
-* @param iLen number of bytes to process in <code>in</code>.
-* @return     A character array with the Base64 encoded data.
+* @param in    an array containing the data bytes to be encoded.
+* @param iLen  number of bytes to process in <code>in</code>.
+* @return      a character array with the Base64 encoded data.
 */
 public static char[] encode (byte[] in, int iLen) {
+   return encode(in, 0, iLen); }
+
+/**
+* Encodes a byte array into Base64 format.
+* No blanks or line breaks are inserted.
+* @param in    an array containing the data bytes to be encoded.
+* @param iOff  offset of the first byte in <code>in</code> to be processed.
+* @param iLen  number of bytes to process in <code>in</code> starting at <code>iOff</code>.
+* @return      a character array with the Base64 encoded data.
+*/
+public static char[] encode (byte[] in, int iOff, int iLen) {
    int oDataLen = (iLen*4+2)/3;       // output length without padding
    int oLen = ((iLen+2)/3)*4;         // output length including padding
    char[] out = new char[oLen];
-   int ip = 0;
+   int ip = iOff;
+   int iEnd = iOff + iLen;
    int op = 0;
-   while (ip < iLen) {
+   while (ip < iEnd) {
       int i0 = in[ip++] & 0xff;
-      int i1 = ip < iLen ? in[ip++] & 0xff : 0;
-      int i2 = ip < iLen ? in[ip++] & 0xff : 0;
+      int i1 = ip < iEnd ? in[ip++] & 0xff : 0;
+      int i2 = ip < iEnd ? in[ip++] & 0xff : 0;
       int o0 = i0 >>> 2;
       int o1 = ((i0 &   3) << 4) | (i1 >>> 4);
       int o2 = ((i1 & 0xf) << 2) | (i2 >>> 6);
@@ -91,17 +136,36 @@ public static char[] encode (byte[] in, int iLen) {
 
 /**
 * Decodes a string from Base64 format.
+* No blanks or line breaks are allowed within the Base64 encoded data.
 * @param s  a Base64 String to be decoded.
-* @return   A String containing the decoded data.
+* @return   a String containing the decoded data.
 * @throws   IllegalArgumentException if the input is not valid Base64 encoded data.
 */
 public static String decodeString (String s) {
    return new String(decode(s)); }
 
+/**
+* Decodes a byte array from Base64 format and ignores line separators and blanks.
+* CR, LF, Tab and Space characters are ignored in the input data.
+* This method is compatible with <code>sun.misc.BASE64Decoder.decodeBuffer(String)</code>.
+* @param s  a Base64 String to be decoded.
+* @return   an array containing the decoded data bytes.
+* @throws   IllegalArgumentException if the input is not valid Base64 encoded data.
+*/
+public static byte[] decodeLines (String s) {
+   char[] buf = new char[s.length()];
+   int p = 0;
+   for (int ip = 0; ip < s.length(); ip++) {
+      char c = s.charAt(ip);
+      if (c != ' ' && c != '\r' && c != '\n' && c != '\t')
+         buf[p++] = c; }
+   return decode(buf, 0, p); }
+
 /**
 * Decodes a byte array from Base64 format.
+* No blanks or line breaks are allowed within the Base64 encoded data.
 * @param s  a Base64 String to be decoded.
-* @return   An array containing the decoded data bytes.
+* @return   an array containing the decoded data bytes.
 * @throws   IllegalArgumentException if the input is not valid Base64 encoded data.
 */
 public static byte[] decode (String s) {
@@ -111,22 +175,34 @@ public static byte[] decode (String s) {
 * Decodes a byte array from Base64 format.
 * No blanks or line breaks are allowed within the Base64 encoded data.
 * @param in  a character array containing the Base64 encoded data.
-* @return    An array containing the decoded data bytes.
+* @return    an array containing the decoded data bytes.
 * @throws    IllegalArgumentException if the input is not valid Base64 encoded data.
 */
 public static byte[] decode (char[] in) {
-   int iLen = in.length;
+   return decode(in, 0, in.length); }
+
+/**
+* Decodes a byte array from Base64 format.
+* No blanks or line breaks are allowed within the Base64 encoded data.
+* @param in    a character array containing the Base64 encoded data.
+* @param iOff  offset of the first character in <code>in</code> to be processed.
+* @param iLen  number of characters to process in <code>in</code> starting at <code>iOff</code>.
+* @return      an array containing the decoded data bytes.
+* @throws      IllegalArgumentException if the input is not valid Base64 encoded data.
+*/
+public static byte[] decode (char[] in, int iOff, int iLen) {
    if (iLen%4 != 0) throw new IllegalArgumentException ("Length of Base64 encoded input string is not a multiple of 4.");
-   while (iLen > 0 && in[iLen-1] == '=') iLen--;
+   while (iLen > 0 && in[iOff+iLen-1] == '=') iLen--;
    int oLen = (iLen*3) / 4;
    byte[] out = new byte[oLen];
-   int ip = 0;
+   int ip = iOff;
+   int iEnd = iOff + iLen;
    int op = 0;
-   while (ip < iLen) {
+   while (ip < iEnd) {
       int i0 = in[ip++];
       int i1 = in[ip++];
-      int i2 = ip < iLen ? in[ip++] : 'A';
-      int i3 = ip < iLen ? in[ip++] : 'A';
+      int i2 = ip < iEnd ? in[ip++] : 'A';
+      int i3 = ip < iEnd ? in[ip++] : 'A';
       if (i0 > 127 || i1 > 127 || i2 > 127 || i3 > 127)
          throw new IllegalArgumentException ("Illegal character in Base64 encoded data.");
       int b0 = map2[i0];

src/test/java/TestBase64Coder.java

@@ -1,7 +1,10 @@
 // Tests for the Base64Coder class.
 
 import biz.source_code.base64Coder.Base64Coder;
-import static org.junit.Assert.*;
+import java.util.Random;
+import static org.junit.Assert.fail;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertArrayEquals;
 import org.junit.Test;
 
 public class TestBase64Coder {
@@ -25,21 +28,45 @@ private static void check (String plainText, String base64Text) {
       fail ("Check failed for \""+plainText+"\" / \""+base64Text+"\"."); }
 
 // Test Base64Coder against sun.misc.BASE64Encoder/Decoder with random data.
+// Line length below 76.
 @Test
 public void test2() throws Exception {
-   sun.misc.BASE64Encoder enc = new sun.misc.BASE64Encoder();
-   sun.misc.BASE64Decoder dec = new sun.misc.BASE64Decoder();
-   java.util.Random rnd = new java.util.Random(0x538afb92);
+   final int maxLineLen = 76 - 1;                          // the Sun encoder adds a CR/LF when a line is longer
+   final int maxDataBlockLen = (maxLineLen*3) / 4;
+   sun.misc.BASE64Encoder sunEncoder = new sun.misc.BASE64Encoder();
+   sun.misc.BASE64Decoder sunDecoder = new sun.misc.BASE64Decoder();
+   Random rnd = new Random(0x538afb92);
    for (int i=0; i<50000; i++) {
-      int len = rnd.nextInt(55);
+      int len = rnd.nextInt(maxDataBlockLen+1);
       byte[] b0 = new byte[len];
       rnd.nextBytes(b0);
       String e1 = new String(Base64Coder.encode(b0));
-      String e2 = enc.encode(b0);
+      String e2 = sunEncoder.encode(b0);
       assertEquals (e2, e1);
       byte[] b1 = Base64Coder.decode(e1);
-      byte[] b2 = dec.decodeBuffer(e2);
+      byte[] b2 = sunDecoder.decodeBuffer(e2);
       assertArrayEquals (b0, b1);
       assertArrayEquals (b0, b2); }}
 
+// Test Base64Coder line encoding/decoding against sun.misc.BASE64Encoder/Decoder
+// with random data.
+@Test
+public void test3() throws Exception {
+   final int maxDataBlockLen = 512;
+   sun.misc.BASE64Encoder sunEncoder = new sun.misc.BASE64Encoder();
+   sun.misc.BASE64Decoder sunDecoder = new sun.misc.BASE64Decoder();
+   Random rnd = new Random(0x39ac7d6e);
+   for (int i=0; i<10000; i++) {
+      int len = rnd.nextInt(maxDataBlockLen+1);
+      byte[] b0 = new byte[len];
+      rnd.nextBytes(b0);
+      String e1 = new String(Base64Coder.encodeLines(b0));
+      String e2 = sunEncoder.encodeBuffer(b0);
+      assertEquals (e2, e1);
+      byte[] b1 = Base64Coder.decodeLines(e1);
+      byte[] b2 = sunDecoder.decodeBuffer(e2);
+      assertArrayEquals (b0, b1);
+      assertArrayEquals (b0, b2); }}
+
+
 } // end class TestBase64Coder