add Base64OutputStream to android-common
Base64OutputStream is a FilterOutputStream that can encode or decode
base-64 data (with any of the flags supported by the Base64 class --
crlf, padding vs not, line wrapping vs not, etc.)
We change Base64 to have package-private decodeInternal and
encodeInternal methods that save all their state in objects and can be
called multiple times to stream data. The existing functions for
in-memory encoding/decoding call the internal method once; the output
stream calls it multiple times.
Change-Id: Iac661d05329bc2e6b2863088efcedc974415ec44
diff --git a/common/java/com/android/common/Base64.java b/common/java/com/android/common/Base64.java
index 771875c..772d567 100644
--- a/common/java/com/android/common/Base64.java
+++ b/common/java/com/android/common/Base64.java
@@ -51,6 +51,10 @@
*/
public static final int WEB_SAFE = 8;
+ // --------------------------------------------------------
+ // decoding
+ // --------------------------------------------------------
+
/**
* Lookup table for turning bytes into their position in the
* Base64 alphabet.
@@ -155,18 +159,71 @@
* incorrect padding
*/
public static byte[] decode(byte[] input, int offset, int len, int flags) {
- int p = offset;
// Allocate space for the most data the input could represent.
// (It could contain less if it contains whitespace, etc.)
- byte[] output = new byte[len*3/4];
- len += offset;
+ DecoderState state = new DecoderState(flags, new byte[len*3/4]);
+
+ if (!decodeInternal(input, offset, len, state, true)) {
+ throw new IllegalArgumentException("bad base-64");
+ }
+
+ // Maybe we got lucky and allocated exactly enough output space.
+ if (state.op == state.output.length) {
+ return state.output;
+ }
+
+ // Need to shorten the array, so allocate a new one of the
+ // right size and copy.
+ byte[] temp = new byte[state.op];
+ System.arraycopy(state.output, 0, temp, 0, state.op);
+ return temp;
+ }
+
+ /* package */ static class DecoderState {
+ public byte[] output;
+ public int op;
+
+ public int state; // state number (0 to 6)
+ public int value;
+
+ final public int[] alphabet;
+
+ public DecoderState(int flags, byte[] output) {
+ this.output = output;
+
+ alphabet = ((flags & WEB_SAFE) == 0) ? DECODE : DECODE_WEBSAFE;
+ state = 0;
+ value = 0;
+ }
+ }
+
+ /**
+ * Decode another block of input data.
+ *
+ * @param dstate a DecoderState object whose (caller-provided)
+ * output array is big enough to hold all the decoded data.
+ * On return, dstate.op will be set to the length of the
+ * decoded data.
+ * @param finish true if this is the final call to decodeInternal
+ * with the given DecoderState object. Will finalize the
+ * decoder state and include any final bytes in the output.
+ *
+ * @return true if the state machine is still healthy. false if
+ * bad base-64 data has been detected in the input stream.
+ */
+
+ /* package */ static boolean decodeInternal(
+ byte[] input, int offset, int len, final DecoderState dstate, boolean finish) {
+ if (dstate.state == 6) return false;
+
+ int state = dstate.state;
+ int value = dstate.value;
+ final int[] decode = dstate.alphabet;
+ final byte[] output = dstate.output;
int op = 0;
- final int[] decode = ((flags & WEB_SAFE) == 0) ?
- DECODE : DECODE_WEBSAFE;
-
- int state = 0;
- int value = 0;
+ int p = offset;
+ len += offset;
while (p < len) {
@@ -207,6 +264,8 @@
// one more.
// State 5 is expecting no more data or padding characters
// in the input.
+ // State 6 is the error state; an error has been detected
+ // in the input and no future input can "fix" it.
int d = decode[input[p++] & 0xff];
@@ -216,7 +275,8 @@
value = d;
++state;
} else if (d != SKIP) {
- throw new IllegalArgumentException("bad base-64");
+ dstate.state = 6;
+ return false;
}
break;
@@ -225,7 +285,8 @@
value = (value << 6) | d;
++state;
} else if (d != SKIP) {
- throw new IllegalArgumentException("bad base-64");
+ dstate.state = 6;
+ return false;
}
break;
@@ -239,7 +300,8 @@
output[op++] = (byte) (value >> 4);
state = 4;
} else if (d != SKIP) {
- throw new IllegalArgumentException("bad base-64");
+ dstate.state = 6;
+ return false;
}
break;
@@ -260,7 +322,8 @@
op += 2;
state = 5;
} else if (d != SKIP) {
- throw new IllegalArgumentException("bad base-64");
+ dstate.state = 6;
+ return false;
}
break;
@@ -268,18 +331,30 @@
if (d == EQUALS) {
++state;
} else if (d != SKIP) {
- throw new IllegalArgumentException("bad base-64");
+ dstate.state = 6;
+ return false;
}
break;
case 5:
if (d != SKIP) {
- throw new IllegalArgumentException("bad base-64");
+ dstate.state = 6;
+ return false;
}
break;
}
}
+ if (!finish) {
+ // We're out of input, but a future call could provide
+ // more. Return the output we've produced on this call
+ // and save the current state of the state machine.
+ dstate.state = state;
+ dstate.value = value;
+ dstate.op = op;
+ return true;
+ }
+
// Done reading input. Now figure out where we are left in
// the state machine and finish up.
@@ -290,7 +365,8 @@
case 1:
// Read one extra input byte, which isn't enough to
// make another output byte. Illegal.
- throw new IllegalArgumentException("bad base-64");
+ dstate.state = 6;
+ return false;
case 2:
// Read two extra input bytes, enough to emit 1 more
// output byte. Fine.
@@ -305,25 +381,22 @@
break;
case 4:
// Read one padding '=' when we expected 2. Illegal.
- throw new IllegalArgumentException("bad base-64");
+ dstate.state = 6;
+ return false;
case 5:
// Read all the padding '='s we expected and no more.
// Fine.
break;
}
- // Maybe we got lucky and allocated exactly enough output space.
- if (op == output.length) {
- return output;
- }
-
- // Need to shorten the array, so allocate a new one of the
- // right size and copy.
- byte[] temp = new byte[op];
- System.arraycopy(output, 0, temp, 0, op);
- return temp;
+ dstate.op = op;
+ return true;
}
+ // --------------------------------------------------------
+ // encoding
+ // --------------------------------------------------------
+
/**
* Emit a new line every this many output tuples. Corresponds to
* a 76-character line length (the maximum allowable according to
@@ -416,17 +489,13 @@
* adheres to RFC 2045.
*/
public static byte[] encode(byte[] input, int offset, int len, int flags) {
- final boolean do_padding = (flags & NO_PADDING) == 0;
- final boolean do_newline = (flags & NO_WRAP) == 0;
- final boolean do_cr = (flags & CRLF) != 0;
-
- final byte[] encode = ((flags & WEB_SAFE) == 0) ? ENCODE : ENCODE_WEBSAFE;
+ EncoderState state = new EncoderState(flags, null);
// Compute the exact length of the array we will produce.
int output_len = len / 3 * 4;
// Account for the tail of the data and the padding bytes, if any.
- if (do_padding) {
+ if (state.do_padding) {
if (len % 3 > 0) {
output_len += 4;
}
@@ -439,26 +508,107 @@
}
// Account for the newlines, if any.
- if (do_newline && len > 0) {
- output_len += (((len-1) / (3 * LINE_GROUPS)) + 1) * (do_cr ? 2 : 1);
+ if (state.do_newline && len > 0) {
+ output_len += (((len-1) / (3 * LINE_GROUPS)) + 1) * (state.do_cr ? 2 : 1);
}
- int op = 0;
- byte[] output = new byte[output_len];
+ state.output = new byte[output_len];
+ encodeInternal(input, offset, len, state, true);
- // The main loop, turning 3 input bytes into 4 output bytes on
- // each iteration.
- int count = do_newline ? LINE_GROUPS : -1;
+ assert state.op == output_len;
+
+ return state.output;
+ }
+
+ /* package */ static class EncoderState {
+ public byte[] output;
+ public int op;
+
+ final public byte[] tail;
+ public int tailLen;
+ public int count;
+
+ final public boolean do_padding;
+ final public boolean do_newline;
+ final public boolean do_cr;
+ final public byte[] alphabet;
+
+ public EncoderState(int flags, byte[] output) {
+ this.output = output;
+
+ do_padding = (flags & NO_PADDING) == 0;
+ do_newline = (flags & NO_WRAP) == 0;
+ do_cr = (flags & CRLF) != 0;
+ alphabet = ((flags & WEB_SAFE) == 0) ? ENCODE : ENCODE_WEBSAFE;
+
+ tail = new byte[2];
+ tailLen = 0;
+
+ count = do_newline ? LINE_GROUPS : -1;
+ }
+ }
+
+ /**
+ * Encode another block of input data.
+ *
+ * @param estate an EncoderState object whose (caller-provided)
+ * output array is big enough to hold all the encoded data.
+ * On return, estate.op will be set to the length of the
+ * encoded data.
+ * @param finish true if this is the final call to encodeInternal
+ * with the given EncoderState object. Will finalize the
+ * encoder state and include any final bytes in the output.
+ */
+ static void encodeInternal(byte[] input, int offset, int len,
+ final EncoderState estate, boolean finish) {
+ final boolean do_cr = estate.do_cr;
+ final boolean do_newline = estate.do_newline;
+ final boolean do_padding = estate.do_padding;
+ final byte[] output = estate.output;
+
+ int op = 0;
+
int p = offset;
len += offset;
- while (p+3 <= len) {
- int v = ((input[p++] & 0xff) << 16) |
- ((input[p++] & 0xff) << 8) |
- (input[p++] & 0xff);
- output[op++] = encode[(v >> 18) & 0x3f];
- output[op++] = encode[(v >> 12) & 0x3f];
- output[op++] = encode[(v >> 6) & 0x3f];
- output[op++] = encode[v & 0x3f];
+ int v = -1;
+ int count = estate.count;
+
+ // First we need to concatenate the tail of the previous call
+ // with any input bytes available now and see if we can empty
+ // the tail.
+
+ switch (estate.tailLen) {
+ case 0:
+ // There was no tail.
+ break;
+
+ case 1:
+ if (p+2 <= len) {
+ // A 1-byte tail with at least 2 bytes of
+ // input available now.
+ v = ((estate.tail[0] & 0xff) << 16) |
+ ((input[p++] & 0xff) << 8) |
+ (input[p++] & 0xff);
+ estate.tailLen = 0;
+ };
+ break;
+
+ case 2:
+ if (p+1 <= len) {
+ // A 2-byte tail with at least 1 byte of input.
+ v = ((estate.tail[0] & 0xff) << 16) |
+ ((estate.tail[1] & 0xff) << 8) |
+ (input[p++] & 0xff);
+ estate.tailLen = 0;
+ }
+ break;
+ }
+
+ if (v != -1) {
+ output[op++] = estate.alphabet[(v >> 18) & 0x3f];
+ output[op++] = estate.alphabet[(v >> 12) & 0x3f];
+ output[op++] = estate.alphabet[(v >> 6) & 0x3f];
+ output[op++] = estate.alphabet[v & 0x3f];
if (--count == 0) {
if (do_cr) output[op++] = '\r';
output[op++] = '\n';
@@ -466,38 +616,82 @@
}
}
- // Finish up the tail of the input.
- if (p == len-1) {
- int v = (input[p] & 0xff) << 4;
- output[op++] = encode[(v >> 6) & 0x3f];
- output[op++] = encode[v & 0x3f];
- if (do_padding) {
- output[op++] = '=';
- output[op++] = '=';
- }
- if (do_newline) {
+ // At this point either there is no tail, or there are fewer
+ // than 3 bytes of input available.
+
+ // The main loop, turning 3 input bytes into 4 output bytes on
+ // each iteration.
+ while (p+3 <= len) {
+ v = ((input[p++] & 0xff) << 16) |
+ ((input[p++] & 0xff) << 8) |
+ (input[p++] & 0xff);
+ output[op++] = estate.alphabet[(v >> 18) & 0x3f];
+ output[op++] = estate.alphabet[(v >> 12) & 0x3f];
+ output[op++] = estate.alphabet[(v >> 6) & 0x3f];
+ output[op++] = estate.alphabet[v & 0x3f];
+ if (--count == 0) {
if (do_cr) output[op++] = '\r';
output[op++] = '\n';
+ count = LINE_GROUPS;
}
- } else if (p == len-2) {
- int v = ((input[p] & 0xff) << 10) | ((input[p+1] & 0xff) << 2);
- output[op++] = encode[(v >> 12) & 0x3f];
- output[op++] = encode[(v >> 6) & 0x3f];
- output[op++] = encode[v & 0x3f];
- if (do_padding) {
- output[op++] = '=';
- }
- if (do_newline) {
- if (do_cr) output[op++] = '\r';
- output[op++] = '\n';
- }
- } else if (do_newline && op > 0 && count != LINE_GROUPS) {
- if (do_cr) output[op++] = '\r';
- output[op++] = '\n';
}
- assert op == output.length;
- return output;
+ if (finish) {
+ // Finish up the tail of the input. Note that we need to
+ // consume any bytes in estate.tail before any bytes
+ // remaining in input; there should be at most two bytes
+ // total.
+
+ if (p-estate.tailLen == len-1) {
+ int t = 0;
+ v = ((estate.tailLen > 0 ? estate.tail[t++] : input[p++]) & 0xff) << 4;
+ estate.tailLen -= t;
+ output[op++] = estate.alphabet[(v >> 6) & 0x3f];
+ output[op++] = estate.alphabet[v & 0x3f];
+ if (do_padding) {
+ output[op++] = '=';
+ output[op++] = '=';
+ }
+ if (do_newline) {
+ if (do_cr) output[op++] = '\r';
+ output[op++] = '\n';
+ }
+ } else if (p-estate.tailLen == len-2) {
+ int t = 0;
+ v = (((estate.tailLen > 1 ? estate.tail[t++] : input[p++]) & 0xff) << 10) |
+ (((estate.tailLen > 0 ? estate.tail[t++] : input[p++]) & 0xff) << 2);
+ estate.tailLen -= t;
+ output[op++] = estate.alphabet[(v >> 12) & 0x3f];
+ output[op++] = estate.alphabet[(v >> 6) & 0x3f];
+ output[op++] = estate.alphabet[v & 0x3f];
+ if (do_padding) {
+ output[op++] = '=';
+ }
+ if (do_newline) {
+ if (do_cr) output[op++] = '\r';
+ output[op++] = '\n';
+ }
+ } else if (do_newline && op > 0 && count != LINE_GROUPS) {
+ if (do_cr) output[op++] = '\r';
+ output[op++] = '\n';
+ }
+
+ assert estate.tailLen == 0;
+ assert p == len;
+ } else {
+ // Save the leftovers in tail to be consumed on the next
+ // call to encodeInternal.
+
+ if (p == len-1) {
+ estate.tail[estate.tailLen++] = input[p];
+ } else if (p == len-2) {
+ estate.tail[estate.tailLen++] = input[p];
+ estate.tail[estate.tailLen++] = input[p+1];
+ }
+ }
+
+ estate.op = op;
+ estate.count = count;
}
private Base64() { } // don't instantiate
diff --git a/common/java/com/android/common/Base64OutputStream.java b/common/java/com/android/common/Base64OutputStream.java
new file mode 100644
index 0000000..7c37428
--- /dev/null
+++ b/common/java/com/android/common/Base64OutputStream.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.common;
+
+import java.io.FilterOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+
+/**
+ * An OutputStream that does either Base64 encoding or decoding on the
+ * data written to it, writing the resulting data to another
+ * OutputStream.
+ */
+public class Base64OutputStream extends FilterOutputStream {
+ private final boolean encode;
+ private final Base64.EncoderState estate;
+ private final Base64.DecoderState dstate;
+
+ private byte[] buffer = null;
+ private int bpos = 0;
+
+ private static byte[] EMPTY = new byte[0];
+
+ /**
+ * Performs Base64 encoding on the data written to the stream,
+ * writing the encoded data to another OutputStream.
+ *
+ * @param out the OutputStream to write the encoded data to
+ * @param flags bit flags for controlling the encoder; see the
+ * constants in {@link Base64}
+ */
+ public Base64OutputStream(OutputStream out, int flags) {
+ this(out, flags, true);
+ }
+
+ /**
+ * Performs Base64 encoding or decoding on the data written to the
+ * stream, writing the encoded/decoded data to another
+ * OutputStream.
+ *
+ * @param out the OutputStream to write the encoded data to
+ * @param flags bit flags for controlling the encoder; see the
+ * constants in {@link Base64}
+ * @param encode true to encode, false to decode
+ */
+ public Base64OutputStream(OutputStream out, int flags, boolean encode) {
+ super(out);
+ this.encode = encode;
+ if (encode) {
+ estate = new Base64.EncoderState(flags, null);
+ dstate = null;
+ } else {
+ estate = null;
+ dstate = new Base64.DecoderState(flags, null);
+ }
+ }
+
+ public void write(int b) throws IOException {
+ // To avoid invoking the encoder/decoder routines for single
+ // bytes, we buffer up calls to write(int) in an internal
+ // byte array to transform them into writes of decently-sized
+ // arrays.
+
+ if (buffer == null) {
+ buffer = new byte[1024];
+ }
+ if (bpos >= buffer.length) {
+ // internal buffer full; write it out.
+ internalWrite(buffer, 0, bpos, false);
+ bpos = 0;
+ }
+ buffer[bpos++] = (byte) b;
+ }
+
+ /**
+ * Flush any buffered data from calls to write(int). Needed
+ * before doing a write(byte[], int, int) or a close().
+ */
+ private void flushBuffer() throws IOException {
+ if (bpos > 0) {
+ internalWrite(buffer, 0, bpos, false);
+ bpos = 0;
+ }
+ }
+
+ public void write(byte[] b, int off, int len) throws IOException {
+ if (len <= 0) return;
+ flushBuffer();
+ internalWrite(b, off, len, false);
+ }
+
+ public void close() throws IOException {
+ flushBuffer();
+ internalWrite(EMPTY, 0, 0, true);
+ out.close();
+ }
+
+ /**
+ * Write the given bytes to the encoder/decoder.
+ *
+ * @param finish true if this is the last batch of input, to cause
+ * encoder/decoder state to be finalized.
+ */
+ private void internalWrite(byte[] b, int off, int len, boolean finish) throws IOException {
+ if (encode) {
+ // len*8/5+10 is an overestimate of the most bytes the
+ // encoder can produce for len bytes of input.
+ estate.output = embiggen(estate.output, len*8/5+10);
+ Base64.encodeInternal(b, off, len, estate, finish);
+ out.write(estate.output, 0, estate.op);
+ } else {
+ // len*3/4+10 is an overestimate of the most bytes the
+ // decoder can produce for len bytes of input.
+ dstate.output = embiggen(dstate.output, len*3/4+10);
+ if (!Base64.decodeInternal(b, off, len, dstate, finish)) {
+ throw new IOException("bad base-64");
+ }
+ out.write(dstate.output, 0, dstate.op);
+ }
+ }
+
+ /**
+ * If b.length is at least len, return b. Otherwise return a new
+ * byte array of length len.
+ */
+ private byte[] embiggen(byte[] b, int len) {
+ if (b == null || b.length < len) {
+ return new byte[len];
+ } else {
+ return b;
+ }
+ }
+}
diff --git a/common/tests/src/com/android/common/Base64Test.java b/common/tests/src/com/android/common/Base64Test.java
index 5c9712a..e6b491f 100644
--- a/common/tests/src/com/android/common/Base64Test.java
+++ b/common/tests/src/com/android/common/Base64Test.java
@@ -18,6 +18,9 @@
import junit.framework.TestCase;
+import java.io.ByteArrayOutputStream;
+import java.util.Random;
+
public class Base64Test extends TestCase {
private static final String TAG = "B64Test";
@@ -55,6 +58,22 @@
}
}
+ /** Assert that actual equals the first len bytes of expected. */
+ private void assertEquals(byte[] expected, int len, byte[] actual, int alen) {
+ assertEquals(len, alen);
+ for (int i = 0; i < len; ++i) {
+ assertEquals(expected[i], actual[i]);
+ }
+ }
+
+ /** Assert that actual equals the first len bytes of expected. */
+ private void assertEquals(byte[] expected, byte[] actual) {
+ assertEquals(expected.length, actual.length);
+ for (int i = 0; i < expected.length; ++i) {
+ assertEquals(expected[i], actual[i]);
+ }
+ }
+
public void testDecodeExtraChars() throws Exception {
// padding 0
assertEquals("hello, world", decodeString("aGVsbG8sIHdvcmxk"));
@@ -205,4 +224,187 @@
assertEquals(out_60.replaceAll("\n", ""), encodeToString(in_60, Base64.NO_WRAP));
assertEquals(out_61.replaceAll("\n", ""), encodeToString(in_61, Base64.NO_WRAP));
}
+
+ /**
+ * Tests that Base64.encodeInternal does correct handling of the
+ * tail for each call.
+ */
+ public void testEncodeInternal() throws Exception {
+ byte[] input = { (byte) 0x61, (byte) 0x62, (byte) 0x63 };
+ byte[] output = new byte[100];
+
+ Base64.EncoderState state = new Base64.EncoderState(Base64.NO_PADDING | Base64.NO_WRAP,
+ output);
+
+ Base64.encodeInternal(input, 0, 3, state, false);
+ assertEquals("YWJj".getBytes(), 4, state.output, state.op);
+ assertEquals(0, state.tailLen);
+
+ Base64.encodeInternal(input, 0, 3, state, false);
+ assertEquals("YWJj".getBytes(), 4, state.output, state.op);
+ assertEquals(0, state.tailLen);
+
+ Base64.encodeInternal(input, 0, 1, state, false);
+ assertEquals(0, state.op);
+ assertEquals(1, state.tailLen);
+
+ Base64.encodeInternal(input, 0, 1, state, false);
+ assertEquals(0, state.op);
+ assertEquals(2, state.tailLen);
+
+ Base64.encodeInternal(input, 0, 1, state, false);
+ assertEquals("YWFh".getBytes(), 4, state.output, state.op);
+ assertEquals(0, state.tailLen);
+
+ Base64.encodeInternal(input, 0, 2, state, false);
+ assertEquals(0, state.op);
+ assertEquals(2, state.tailLen);
+
+ Base64.encodeInternal(input, 0, 2, state, false);
+ assertEquals("YWJh".getBytes(), 4, state.output, state.op);
+ assertEquals(1, state.tailLen);
+
+ Base64.encodeInternal(input, 0, 2, state, false);
+ assertEquals("YmFi".getBytes(), 4, state.output, state.op);
+ assertEquals(0, state.tailLen);
+
+ Base64.encodeInternal(input, 0, 1, state, true);
+ assertEquals("YQ".getBytes(), 2, state.output, state.op);
+ }
+
+ /**
+ * Tests that Base64OutputStream produces exactly the same results
+ * as calling Base64.encode/.decode on an in-memory array.
+ */
+ public void testOutputStream() throws Exception {
+ int[] flagses = { Base64.DEFAULT,
+ Base64.NO_PADDING,
+ Base64.NO_WRAP,
+ Base64.NO_PADDING | Base64.NO_WRAP,
+ Base64.CRLF,
+ Base64.WEB_SAFE };
+ int[] writeLengths = { -10, -5, -1, 0, 1, 1, 2, 2, 3, 10, 100 };
+ Random rng = new Random(32176L);
+
+ // input needs to be at least 1024 bytes to test filling up
+ // the write(int) buffer.
+ byte[] input = ("Lorem ipsum dolor sit amet, consectetur adipiscing elit. " +
+ "Quisque congue eleifend odio, eu ornare nulla facilisis eget. " +
+ "Integer eget elit diam, sit amet laoreet nibh. Quisque enim " +
+ "urna, pharetra vitae consequat eget, adipiscing eu ante. " +
+ "Aliquam venenatis arcu nec nibh imperdiet tempor. In id dui " +
+ "eget lorem aliquam rutrum vel vitae eros. In placerat ornare " +
+ "pretium. Curabitur non fringilla mi. Fusce ultricies, turpis " +
+ "eu ultrices suscipit, ligula nisi consectetur eros, dapibus " +
+ "aliquet dui sapien a turpis. Donec ultricies varius ligula, " +
+ "ut hendrerit arcu malesuada at. Praesent sed elit pretium " +
+ "eros luctus gravida. In ac dolor lorem. Cras condimentum " +
+ "convallis elementum. Phasellus vel felis in nulla ultrices " +
+ "venenatis. Nam non tortor non orci convallis convallis. " +
+ "Nam tristique lacinia hendrerit. Pellentesque habitant morbi " +
+ "tristique senectus et netus et malesuada fames ac turpis " +
+ "egestas. Vivamus cursus, nibh eu imperdiet porta, magna " +
+ "ipsum mollis mauris, sit amet fringilla mi nisl eu mi. " +
+ "Phasellus posuere, leo at ultricies vehicula, massa risus " +
+ "volutpat sapien, eu tincidunt diam ipsum eget nulla. Cras " +
+ "molestie dapibus commodo. Ut vel tellus at massa gravida " +
+ "semper non sed orci.").getBytes();
+
+ for (int f = 0; f < flagses.length; ++f) {
+ int flags = flagses[f];
+
+ byte[] expected = Base64.encode(input, flags);
+
+ ByteArrayOutputStream baos;
+ Base64OutputStream b64os;
+ byte[] actual;
+ int p;
+
+ // ----- test encoding ("input" -> "expected") -----
+
+ // one large write(byte[]) of the whole input
+ baos = new ByteArrayOutputStream();
+ b64os = new Base64OutputStream(baos, flags);
+ b64os.write(input);
+ b64os.close();
+ actual = baos.toByteArray();
+ assertEquals(expected, actual);
+
+ // many calls to write(int)
+ baos = new ByteArrayOutputStream();
+ b64os = new Base64OutputStream(baos, flags);
+ for (int i = 0; i < input.length; ++i) {
+ b64os.write(input[i]);
+ }
+ b64os.close();
+ actual = baos.toByteArray();
+ assertEquals(expected, actual);
+
+ // intermixed sequences of write(int) with
+ // write(byte[],int,int) of various lengths.
+ baos = new ByteArrayOutputStream();
+ b64os = new Base64OutputStream(baos, flags);
+ p = 0;
+ while (p < input.length) {
+ int l = writeLengths[rng.nextInt(writeLengths.length)];
+ l = Math.min(l, input.length-p);
+ if (l >= 0) {
+ b64os.write(input, p, l);
+ p += l;
+ } else {
+ l = Math.min(-l, input.length-p);
+ for (int i = 0; i < l; ++i) {
+ b64os.write(input[p+i]);
+ }
+ p += l;
+ }
+ }
+ b64os.close();
+ actual = baos.toByteArray();
+ assertEquals(expected, actual);
+
+ // ----- test decoding ("expected" -> "input") -----
+
+ // one large write(byte[]) of the whole input
+ baos = new ByteArrayOutputStream();
+ b64os = new Base64OutputStream(baos, flags, false);
+ b64os.write(expected);
+ b64os.close();
+ actual = baos.toByteArray();
+ assertEquals(input, actual);
+
+ // many calls to write(int)
+ baos = new ByteArrayOutputStream();
+ b64os = new Base64OutputStream(baos, flags, false);
+ for (int i = 0; i < expected.length; ++i) {
+ b64os.write(expected[i]);
+ }
+ b64os.close();
+ actual = baos.toByteArray();
+ assertEquals(input, actual);
+
+ // intermixed sequences of write(int) with
+ // write(byte[],int,int) of various lengths.
+ baos = new ByteArrayOutputStream();
+ b64os = new Base64OutputStream(baos, flags, false);
+ p = 0;
+ while (p < expected.length) {
+ int l = writeLengths[rng.nextInt(writeLengths.length)];
+ l = Math.min(l, expected.length-p);
+ if (l >= 0) {
+ b64os.write(expected, p, l);
+ p += l;
+ } else {
+ l = Math.min(-l, expected.length-p);
+ for (int i = 0; i < l; ++i) {
+ b64os.write(expected[p+i]);
+ }
+ p += l;
+ }
+ }
+ b64os.close();
+ actual = baos.toByteArray();
+ assertEquals(input, actual);
+ }
+ }
}
