remove Base64 from android-common

This is now available in the framework as android.util.base64.*;

Change-Id: I54901d32b2b5b291cfa0b4c2479b805038ba12ac

4 files changed, 0 insertions, 1547 deletions

diff --git a/common/java/com/android/common/Base64.java b/common/java/com/android/common/Base64.java
deleted file mode 100644
index d65e24e..0000000
--- a/common/java/com/android/common/Base64.java
+++ /dev/null
@@ -1,705 +0,0 @@
-/*
- * 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;
-
-/**
- * Utilities for encoding and decoding the Base64 encoding.  See RFCs
- * 2045 and 3548.
- */
-public class Base64 {
-    /**
-     * Default values for encoder/decoder flags.
-     */
-    public static final int DEFAULT = 0;
-
-    /**
-     * Encoder flag bit to indicate you want the padding '='
-     * characters at the end (if any) to be omitted.
-     */
-    public static final int NO_PADDING = 1;
-
-    /**
-     * Encoder flag bit to indicate you want all line terminators to
-     * be omitted (ie, the output will be on one long line).
-     */
-    public static final int NO_WRAP = 2;
-
-    /**
-     * Encoder flag bit to indicate you want lines to be ended with
-     * CRLF instead of just LF.
-     */
-    public static final int CRLF = 4;
-
-    /**
-     * Encoder/decoder flag bit to indicate using the "web safe"
-     * variant of Base64 (see RFC 3548 section 4) where '-' and '_'
-     * are used in place of '+' and '/'.
-     */
-    public static final int WEB_SAFE = 8;
-
-    /**
-     * Flag to pass to Base64OutputStream to indicate that it should
-     * not close the output stream it is wrapping when it itself is
-     * closed.
-     */
-    public static final int NO_CLOSE = 16;
-
-    //  --------------------------------------------------------
-    //  decoding
-    //  --------------------------------------------------------
-
-    /**
-     * Lookup table for turning bytes into their position in the
-     * Base64 alphabet.
-     */
-    private static final int DECODE[] = {
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
-        52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1,
-        -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
-        15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
-        -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
-        41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    };
-
-    /**
-     * Decode lookup table for the "web safe" variant (RFC 3548
-     * sec. 4) where - and _ replace + and /.
-     */
-    private static final int DECODE_WEBSAFE[] = {
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1,
-        52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1,
-        -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
-        15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63,
-        -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
-        41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    };
-
-    /** Non-data values in the DECODE arrays. */
-    private static final int SKIP = -1;
-    private static final int EQUALS = -2;
-
-    /**
-     * Decode the Base64-encoded data in input and return the data in
-     * a new byte array.
-     *
-     * The padding '=' characters at the end are considered optional, but
-     * if any are present, there must be the correct number of them.
-     *
-     * @param input the input String to decode, which is converted to
-     *               bytes using the default charset
-     * @param flags  controls certain features of the decoded output.
-     *               Pass {@code DEFAULT} to decode standard Base64.
-     *
-     * @throws IllegalArgumentException if the input contains
-     * incorrect padding
-     */
-    public static byte[] decode(String str, int flags) {
-        return decode(str.getBytes(), flags);
-    }
-
-    /**
-     * Decode the Base64-encoded data in input and return the data in
-     * a new byte array.
-     *
-     * The padding '=' characters at the end are considered optional, but
-     * if any are present, there must be the correct number of them.
-     *
-     * @param input the input array to decode
-     * @param flags  controls certain features of the decoded output.
-     *               Pass {@code DEFAULT} to decode standard Base64.
-     *
-     * @throws IllegalArgumentException if the input contains
-     * incorrect padding
-     */
-    public static byte[] decode(byte[] input, int flags) {
-        return decode(input, 0, input.length, flags);
-    }
-
-    /**
-     * Decode the Base64-encoded data in input and return the data in
-     * a new byte array.
-     *
-     * The padding '=' characters at the end are considered optional, but
-     * if any are present, there must be the correct number of them.
-     *
-     * @param input  the data to decode
-     * @param offset the position within the input array at which to start
-     * @param len    the number of bytes of input to decode
-     * @param flags  controls certain features of the decoded output.
-     *               Pass {@code DEFAULT} to decode standard Base64.
-     *
-     * @throws IllegalArgumentException if the input contains
-     * incorrect padding
-     */
-    public static byte[] decode(byte[] input, int offset, int len, int flags) {
-        // Allocate space for the most data the input could represent.
-        // (It could contain less if it contains whitespace, etc.)
-        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;
-
-        int p = offset;
-        len += offset;
-
-        while (p < len) {
-
-            // Try the fast path:  we're starting a new tuple and the
-            // next four bytes of the input stream are all data
-            // bytes.  This corresponds to going through states
-            // 0-1-2-3-0.  We expect to use this method for most of
-            // the data.
-            //
-            // If any of the next four bytes of input are non-data
-            // (whitespace, etc.), value will end up negative.  (All
-            // the non-data values in decode are small negative
-            // numbers, so shifting any of them up and or'ing them
-            // together will result in a value with its top bit set.)
-            //
-            // You can remove this whole block and the output should
-            // be the same, just slower.
-            if (state == 0 && p+4 <= len &&
-                (value = ((decode[input[p] & 0xff] << 18) |
-                          (decode[input[p+1] & 0xff] << 12) |
-                          (decode[input[p+2] & 0xff] << 6) |
-                          (decode[input[p+3] & 0xff]))) >= 0) {
-                output[op+2] = (byte) value;
-                output[op+1] = (byte) (value >> 8);
-                output[op] = (byte) (value >> 16);
-                op += 3;
-                p += 4;
-                continue;
-            }
-
-            // The fast path isn't available -- either we've read a
-            // partial tuple, or the next four input bytes aren't all
-            // data, or whatever.  Fall back to the slower state
-            // machine implementation.
-            //
-            // States 0-3 are reading through the next input tuple.
-            // State 4 is having read one '=' and expecting exactly
-            // 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];
-
-            switch (state) {
-                case 0:
-                    if (d >= 0) {
-                        value = d;
-                        ++state;
-                    } else if (d != SKIP) {
-                        dstate.state = 6;
-                        return false;
-                    }
-                    break;
-
-                case 1:
-                    if (d >= 0) {
-                        value = (value << 6) | d;
-                        ++state;
-                    } else if (d != SKIP) {
-                        dstate.state = 6;
-                        return false;
-                    }
-                    break;
-
-                case 2:
-                    if (d >= 0) {
-                        value = (value << 6) | d;
-                        ++state;
-                    } else if (d == EQUALS) {
-                        // Emit the last (partial) output tuple;
-                        // expect exactly one more padding character.
-                        output[op++] = (byte) (value >> 4);
-                        state = 4;
-                    } else if (d != SKIP) {
-                        dstate.state = 6;
-                        return false;
-                    }
-                    break;
-
-                case 3:
-                    if (d >= 0) {
-                        // Emit the output triple and return to state 0.
-                        value = (value << 6) | d;
-                        output[op+2] = (byte) value;
-                        output[op+1] = (byte) (value >> 8);
-                        output[op] = (byte) (value >> 16);
-                        op += 3;
-                        state = 0;
-                    } else if (d == EQUALS) {
-                        // Emit the last (partial) output tuple;
-                        // expect no further data or padding characters.
-                        output[op+1] = (byte) (value >> 2);
-                        output[op] = (byte) (value >> 10);
-                        op += 2;
-                        state = 5;
-                    } else if (d != SKIP) {
-                        dstate.state = 6;
-                        return false;
-                    }
-                    break;
-
-                case 4:
-                    if (d == EQUALS) {
-                        ++state;
-                    } else if (d != SKIP) {
-                        dstate.state = 6;
-                        return false;
-                    }
-                    break;
-
-                case 5:
-                    if (d != SKIP) {
-                        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.
-
-        switch (state) {
-            case 0:
-                // Output length is a multiple of three.  Fine.
-                break;
-            case 1:
-                // Read one extra input byte, which isn't enough to
-                // make another output byte.  Illegal.
-                dstate.state = 6;
-                return false;
-            case 2:
-                // Read two extra input bytes, enough to emit 1 more
-                // output byte.  Fine.
-                output[op++] = (byte) (value >> 4);
-                break;
-            case 3:
-                // Read three extra input bytes, enough to emit 2 more
-                // output bytes.  Fine.
-                output[op+1] = (byte) (value >> 2);
-                output[op] = (byte) (value >> 10);
-                op += 2;
-                break;
-            case 4:
-                // Read one padding '=' when we expected 2.  Illegal.
-                dstate.state = 6;
-                return false;
-            case 5:
-                // Read all the padding '='s we expected and no more.
-                // Fine.
-                break;
-        }
-
-        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
-     * RFC 2045).
-     */
-    private static final int LINE_GROUPS = 19;
-
-    /**
-     * Lookup table for turning Base64 alphabet positions (6 bits)
-     * into output bytes.
-     */
-    private static final byte ENCODE[] = {
-        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
-        'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
-        'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
-        'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
-        'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
-        'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
-        'w', 'x', 'y', 'z', '0', '1', '2', '3',
-        '4', '5', '6', '7', '8', '9', '+', '/',
-    };
-
-    /**
-     * Lookup table for turning Base64 alphabet positions (6 bits)
-     * into output bytes.
-     */
-    private static final byte ENCODE_WEBSAFE[] = {
-        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
-        'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
-        'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
-        'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
-        'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
-        'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
-        'w', 'x', 'y', 'z', '0', '1', '2', '3',
-        '4', '5', '6', '7', '8', '9', '-', '_',
-    };
-
-    /**
-     * Base64-encode the given data and return a newly allocated
-     * String with the result.
-     *
-     * @param input  the data to encode
-     * @param flags  controls certain features of the encoded output.
-     *               Passing {@code DEFAULT} results in output that
-     *               adheres to RFC 2045.
-     */
-    public static String encodeToString(byte[] input, int flags) {
-        return new String(encode(input, flags));
-    }
-
-    /**
-     * Base64-encode the given data and return a newly allocated
-     * String with the result.
-     *
-     * @param input  the data to encode
-     * @param offset the position within the input array at which to
-     *               start
-     * @param len    the number of bytes of input to encode
-     * @param flags  controls certain features of the encoded output.
-     *               Passing {@code DEFAULT} results in output that
-     *               adheres to RFC 2045.
-     */
-    public static String encodeToString(byte[] input, int offset, int len, int flags) {
-        return new String(encode(input, offset, len, flags));
-    }
-
-    /**
-     * Base64-encode the given data and return a newly allocated
-     * byte[] with the result.
-     *
-     * @param input  the data to encode
-     * @param flags  controls certain features of the encoded output.
-     *               Passing {@code DEFAULT} results in output that
-     *               adheres to RFC 2045.
-     */
-    public static byte[] encode(byte[] input, int flags) {
-        return encode(input, 0, input.length, flags);
-    }
-
-    /**
-     * Base64-encode the given data and return a newly allocated
-     * byte[] with the result.
-     *
-     * @param input  the data to encode
-     * @param offset the position within the input array at which to
-     *               start
-     * @param len    the number of bytes of input to encode
-     * @param flags  controls certain features of the encoded output.
-     *               Passing {@code DEFAULT} results in output that
-     *               adheres to RFC 2045.
-     */
-    public static byte[] encode(byte[] input, int offset, int len, int flags) {
-        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 (state.do_padding) {
-            if (len % 3 > 0) {
-                output_len += 4;
-            }
-        } else {
-            switch (len % 3) {
-                case 0: break;
-                case 1: output_len += 2; break;
-                case 2: output_len += 3; break;
-            }
-        }
-
-        // Account for the newlines, if any.
-        if (state.do_newline && len > 0) {
-            output_len += (((len-1) / (3 * LINE_GROUPS)) + 1) * (state.do_cr ? 2 : 1);
-        }
-
-        state.output = new byte[output_len];
-        encodeInternal(input, offset, len, state, true);
-
-        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;
-        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';
-                count = LINE_GROUPS;
-            }
-        }
-
-        // 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;
-            }
-        }
-
-        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/Base64InputStream.java b/common/java/com/android/common/Base64InputStream.java
deleted file mode 100644
index 1969bc4..0000000
--- a/common/java/com/android/common/Base64InputStream.java
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
- * 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.FilterInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-
-/**
- * An OutputStream that does either Base64 encoding or decoding on the
- * data written to it, writing the resulting data to another
- * OutputStream.
- */
-public class Base64InputStream extends FilterInputStream {
-    private final boolean encode;
-    private final Base64.EncoderState estate;
-    private final Base64.DecoderState dstate;
-
-    private static byte[] EMPTY = new byte[0];
-
-    private static final int BUFFER_SIZE = 2048;
-    private boolean eof;
-    private byte[] inputBuffer;
-    private byte[] outputBuffer;
-    private int outputStart;
-    private int outputEnd;
-
-    /**
-     * An InputStream that performs Base64 decoding on the data read
-     * from the wrapped stream.
-     *
-     * @param in the InputStream to read the source data from
-     * @param flags bit flags for controlling the decoder; see the
-     *        constants in {@link Base64}
-     */
-    public Base64InputStream(InputStream out, int flags) {
-        this(out, flags, false);
-    }
-
-    /**
-     * Performs Base64 encoding or decoding on the data read from the
-     * wrapped InputStream.
-     *
-     * @param in the InputStream to read the source data from
-     * @param flags bit flags for controlling the decoder; see the
-     *        constants in {@link Base64}
-     * @param encode true to encode, false to decode
-     */
-    public Base64InputStream(InputStream out, int flags, boolean encode) {
-        super(out);
-        this.encode = encode;
-        eof = false;
-        inputBuffer = new byte[BUFFER_SIZE];
-        if (encode) {
-            // len*8/5+10 is an overestimate of the most bytes the
-            // encoder can produce for len bytes of input.
-            outputBuffer = new byte[BUFFER_SIZE * 8/5 + 10];
-            estate = new Base64.EncoderState(flags, outputBuffer);
-            dstate = null;
-        } else {
-            // len*3/4+10 is an overestimate of the most bytes the
-            // decoder can produce for len bytes of input.
-            outputBuffer = new byte[BUFFER_SIZE * 3/4 + 10];
-            estate = null;
-            dstate = new Base64.DecoderState(flags, outputBuffer);
-        }
-        outputStart = 0;
-        outputEnd = 0;
-    }
-
-    public boolean markSupported() {
-        return false;
-    }
-
-    public void mark(int readlimit) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void reset() {
-        throw new UnsupportedOperationException();
-    }
-
-    public void close() throws IOException {
-        in.close();
-        inputBuffer = null;
-    }
-
-    public int available() {
-        return outputEnd - outputStart;
-    }
-
-    public long skip(long n) throws IOException {
-        if (outputStart >= outputEnd) {
-            refill();
-        }
-        if (outputStart >= outputEnd) {
-            return 0;
-        }
-        long bytes = Math.min(n, outputEnd-outputStart);
-        outputStart += bytes;
-        return bytes;
-    }
-
-    public int read() throws IOException {
-        if (outputStart >= outputEnd) {
-            refill();
-        }
-        if (outputStart >= outputEnd) {
-            return -1;
-        } else {
-            return outputBuffer[outputStart++];
-        }
-    }
-
-    public int read(byte[] b, int off, int len) throws IOException {
-        if (outputStart >= outputEnd) {
-            refill();
-        }
-        if (outputStart >= outputEnd) {
-            return -1;
-        }
-        int bytes = Math.min(len, outputEnd-outputStart);
-        System.arraycopy(outputBuffer, outputStart, b, off, bytes);
-        outputStart += bytes;
-        return bytes;
-    }
-
-    /**
-     * Read data from the input stream into inputBuffer, then
-     * decode/encode it into the empty outputBuffer, and reset the
-     * outputStart and outputEnd pointers.
-     */
-    private void refill() throws IOException {
-        if (eof) return;
-        int bytesRead = in.read(inputBuffer);
-        if (encode) {
-            if (bytesRead == -1) {
-                eof = true;
-                Base64.encodeInternal(EMPTY, 0, 0, estate, true);
-            } else {
-                Base64.encodeInternal(inputBuffer, 0, bytesRead, estate, false);
-            }
-            outputEnd = estate.op;
-        } else {
-            if (bytesRead == -1) {
-                eof = true;
-                Base64.decodeInternal(EMPTY, 0, 0, dstate, true);
-            } else {
-                Base64.decodeInternal(inputBuffer, 0, bytesRead, dstate, false);
-            }
-            outputEnd = dstate.op;
-        }
-        outputStart = 0;
-    }
-}
diff --git a/common/java/com/android/common/Base64OutputStream.java b/common/java/com/android/common/Base64OutputStream.java
deleted file mode 100644
index 76e1b6a..0000000
--- a/common/java/com/android/common/Base64OutputStream.java
+++ /dev/null
@@ -1,153 +0,0 @@
-/*
- * 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 final int flags;
-
-    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.flags = flags;
-        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);
-        if ((flags & Base64.NO_CLOSE) == 0) {
-            out.close();
-        } else {
-            out.flush();
-        }
-    }
-
-    /**
-     * 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
deleted file mode 100644
index 1064625f2..0000000
--- a/common/tests/src/com/android/common/Base64Test.java
+++ /dev/null
@@ -1,520 +0,0 @@
-/*
- * 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 junit.framework.TestCase;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.util.Random;
-
-public class Base64Test extends TestCase {
-    private static final String TAG = "B64Test";
-
-    /** Decodes a string, returning a string. */
-    private String decodeString(String in) throws Exception {
-        byte[] out = Base64.decode(in, 0);
-        return new String(out);
-    }
-
-    /**
-     * Encodes the string 'in' using 'flags'.  Asserts that decoding
-     * gives the same string.  Returns the encoded string.
-     */
-    private String encodeToString(String in, int flags) throws Exception {
-        String b64 = Base64.encodeToString(in.getBytes(), flags);
-        String dec = decodeString(b64);
-        assertEquals(in, dec);
-        return b64;
-    }
-
-    /** Assert that decoding 'in' throws IllegalArgumentException. */
-    private void assertBad(String in) throws Exception {
-        try {
-            byte[] out = Base64.decode(in, 0);
-            fail("should have failed to decode");
-        } catch (IllegalArgumentException e) {
-        }
-    }
-
-    /** Assert that actual equals the first len bytes of expected. */
-    private void assertEquals(byte[] expected, int len, byte[] actual) {
-        assertEquals(len, actual.length);
-        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, 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"));
-        assertBad("aGVsbG8sIHdvcmxk=");
-        assertBad("aGVsbG8sIHdvcmxk==");
-        assertBad("aGVsbG8sIHdvcmxk =");
-        assertBad("aGVsbG8sIHdvcmxk = = ");
-        assertEquals("hello, world", decodeString(" aGVs bG8s IHdv cmxk  "));
-        assertEquals("hello, world", decodeString(" aGV sbG8 sIHd vcmx k "));
-        assertEquals("hello, world", decodeString(" aG VsbG 8sIH dvcm xk "));
-        assertEquals("hello, world", decodeString(" a GVsb G8sI Hdvc mxk "));
-        assertEquals("hello, world", decodeString(" a G V s b G 8 s I H d v c m x k "));
-        assertEquals("hello, world", decodeString("_a*G_V*s_b*G_8*s_I*H_d*v_c*m_x*k_"));
-        assertEquals("hello, world", decodeString("aGVsbG8sIHdvcmxk"));
-
-        // padding 1
-        assertEquals("hello, world?!", decodeString("aGVsbG8sIHdvcmxkPyE="));
-        assertEquals("hello, world?!", decodeString("aGVsbG8sIHdvcmxkPyE"));
-        assertBad("aGVsbG8sIHdvcmxkPyE==");
-        assertBad("aGVsbG8sIHdvcmxkPyE ==");
-        assertBad("aGVsbG8sIHdvcmxkPyE = = ");
-        assertEquals("hello, world?!", decodeString("aGVsbG8sIHdvcmxkPy E="));
-        assertEquals("hello, world?!", decodeString("aGVsbG8sIHdvcmxkPy E"));
-        assertEquals("hello, world?!", decodeString("aGVsbG8sIHdvcmxkPy E ="));
-        assertEquals("hello, world?!", decodeString("aGVsbG8sIHdvcmxkPy E "));
-        assertEquals("hello, world?!", decodeString("aGVsbG8sIHdvcmxkPy E = "));
-        assertEquals("hello, world?!", decodeString("aGVsbG8sIHdvcmxkPy E   "));
-
-        // padding 2
-        assertEquals("hello, world.", decodeString("aGVsbG8sIHdvcmxkLg=="));
-        assertEquals("hello, world.", decodeString("aGVsbG8sIHdvcmxkLg"));
-        assertBad("aGVsbG8sIHdvcmxkLg=");
-        assertBad("aGVsbG8sIHdvcmxkLg =");
-        assertBad("aGVsbG8sIHdvcmxkLg = ");
-        assertEquals("hello, world.", decodeString("aGVsbG8sIHdvcmxkL g=="));
-        assertEquals("hello, world.", decodeString("aGVsbG8sIHdvcmxkL g"));
-        assertEquals("hello, world.", decodeString("aGVsbG8sIHdvcmxkL g =="));
-        assertEquals("hello, world.", decodeString("aGVsbG8sIHdvcmxkL g "));
-        assertEquals("hello, world.", decodeString("aGVsbG8sIHdvcmxkL g = = "));
-        assertEquals("hello, world.", decodeString("aGVsbG8sIHdvcmxkL g   "));
-    }
-
-    private static final byte[] BYTES = { (byte) 0xff, (byte) 0xee, (byte) 0xdd,
-                                          (byte) 0xcc, (byte) 0xbb, (byte) 0xaa,
-                                          (byte) 0x99, (byte) 0x88, (byte) 0x77 };
-
-    public void testBinaryDecode() throws Exception {
-        assertEquals(BYTES, 0, Base64.decode("", 0));
-        assertEquals(BYTES, 1, Base64.decode("/w==", 0));
-        assertEquals(BYTES, 2, Base64.decode("/+4=", 0));
-        assertEquals(BYTES, 3, Base64.decode("/+7d", 0));
-        assertEquals(BYTES, 4, Base64.decode("/+7dzA==", 0));
-        assertEquals(BYTES, 5, Base64.decode("/+7dzLs=", 0));
-        assertEquals(BYTES, 6, Base64.decode("/+7dzLuq", 0));
-        assertEquals(BYTES, 7, Base64.decode("/+7dzLuqmQ==", 0));
-        assertEquals(BYTES, 8, Base64.decode("/+7dzLuqmYg=", 0));
-    }
-
-    public void testWebSafe() throws Exception {
-        assertEquals(BYTES, 0, Base64.decode("", Base64.WEB_SAFE));
-        assertEquals(BYTES, 1, Base64.decode("_w==", Base64.WEB_SAFE));
-        assertEquals(BYTES, 2, Base64.decode("_-4=", Base64.WEB_SAFE));
-        assertEquals(BYTES, 3, Base64.decode("_-7d", Base64.WEB_SAFE));
-        assertEquals(BYTES, 4, Base64.decode("_-7dzA==", Base64.WEB_SAFE));
-        assertEquals(BYTES, 5, Base64.decode("_-7dzLs=", Base64.WEB_SAFE));
-        assertEquals(BYTES, 6, Base64.decode("_-7dzLuq", Base64.WEB_SAFE));
-        assertEquals(BYTES, 7, Base64.decode("_-7dzLuqmQ==", Base64.WEB_SAFE));
-        assertEquals(BYTES, 8, Base64.decode("_-7dzLuqmYg=", Base64.WEB_SAFE));
-
-        assertEquals("", Base64.encodeToString(BYTES, 0, 0, Base64.WEB_SAFE));
-        assertEquals("_w==\n", Base64.encodeToString(BYTES, 0, 1, Base64.WEB_SAFE));
-        assertEquals("_-4=\n", Base64.encodeToString(BYTES, 0, 2, Base64.WEB_SAFE));
-        assertEquals("_-7d\n", Base64.encodeToString(BYTES, 0, 3, Base64.WEB_SAFE));
-        assertEquals("_-7dzA==\n", Base64.encodeToString(BYTES, 0, 4, Base64.WEB_SAFE));
-        assertEquals("_-7dzLs=\n", Base64.encodeToString(BYTES, 0, 5, Base64.WEB_SAFE));
-        assertEquals("_-7dzLuq\n", Base64.encodeToString(BYTES, 0, 6, Base64.WEB_SAFE));
-        assertEquals("_-7dzLuqmQ==\n", Base64.encodeToString(BYTES, 0, 7, Base64.WEB_SAFE));
-        assertEquals("_-7dzLuqmYg=\n", Base64.encodeToString(BYTES, 0, 8, Base64.WEB_SAFE));
-    }
-
-    public void testFlags() throws Exception {
-        assertEquals("YQ==\n",       encodeToString("a", 0));
-        assertEquals("YQ==",         encodeToString("a", Base64.NO_WRAP));
-        assertEquals("YQ\n",         encodeToString("a", Base64.NO_PADDING));
-        assertEquals("YQ",           encodeToString("a", Base64.NO_PADDING | Base64.NO_WRAP));
-        assertEquals("YQ==\r\n",     encodeToString("a", Base64.CRLF));
-        assertEquals("YQ\r\n",       encodeToString("a", Base64.CRLF | Base64.NO_PADDING));
-
-        assertEquals("YWI=\n",       encodeToString("ab", 0));
-        assertEquals("YWI=",         encodeToString("ab", Base64.NO_WRAP));
-        assertEquals("YWI\n",        encodeToString("ab", Base64.NO_PADDING));
-        assertEquals("YWI",          encodeToString("ab", Base64.NO_PADDING | Base64.NO_WRAP));
-        assertEquals("YWI=\r\n",     encodeToString("ab", Base64.CRLF));
-        assertEquals("YWI\r\n",      encodeToString("ab", Base64.CRLF | Base64.NO_PADDING));
-
-        assertEquals("YWJj\n",       encodeToString("abc", 0));
-        assertEquals("YWJj",         encodeToString("abc", Base64.NO_WRAP));
-        assertEquals("YWJj\n",       encodeToString("abc", Base64.NO_PADDING));
-        assertEquals("YWJj",         encodeToString("abc", Base64.NO_PADDING | Base64.NO_WRAP));
-        assertEquals("YWJj\r\n",     encodeToString("abc", Base64.CRLF));
-        assertEquals("YWJj\r\n",     encodeToString("abc", Base64.CRLF | Base64.NO_PADDING));
-
-        assertEquals("YWJjZA==\n",   encodeToString("abcd", 0));
-        assertEquals("YWJjZA==",     encodeToString("abcd", Base64.NO_WRAP));
-        assertEquals("YWJjZA\n",     encodeToString("abcd", Base64.NO_PADDING));
-        assertEquals("YWJjZA",       encodeToString("abcd", Base64.NO_PADDING | Base64.NO_WRAP));
-        assertEquals("YWJjZA==\r\n", encodeToString("abcd", Base64.CRLF));
-        assertEquals("YWJjZA\r\n",   encodeToString("abcd", Base64.CRLF | Base64.NO_PADDING));
-    }
-
-    public void testLineLength() throws Exception {
-        String in_56 = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd";
-        String in_57 = in_56 + "e";
-        String in_58 = in_56 + "ef";
-        String in_59 = in_56 + "efg";
-        String in_60 = in_56 + "efgh";
-        String in_61 = in_56 + "efghi";
-
-        String prefix = "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXphYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5emFi";
-        String out_56 = prefix + "Y2Q=\n";
-        String out_57 = prefix + "Y2Rl\n";
-        String out_58 = prefix + "Y2Rl\nZg==\n";
-        String out_59 = prefix + "Y2Rl\nZmc=\n";
-        String out_60 = prefix + "Y2Rl\nZmdo\n";
-        String out_61 = prefix + "Y2Rl\nZmdoaQ==\n";
-
-        // no newline for an empty input array.
-        assertEquals("", encodeToString("", 0));
-
-        assertEquals(out_56, encodeToString(in_56, 0));
-        assertEquals(out_57, encodeToString(in_57, 0));
-        assertEquals(out_58, encodeToString(in_58, 0));
-        assertEquals(out_59, encodeToString(in_59, 0));
-        assertEquals(out_60, encodeToString(in_60, 0));
-        assertEquals(out_61, encodeToString(in_61, 0));
-
-        assertEquals(out_56.replaceAll("=", ""), encodeToString(in_56, Base64.NO_PADDING));
-        assertEquals(out_57.replaceAll("=", ""), encodeToString(in_57, Base64.NO_PADDING));
-        assertEquals(out_58.replaceAll("=", ""), encodeToString(in_58, Base64.NO_PADDING));
-        assertEquals(out_59.replaceAll("=", ""), encodeToString(in_59, Base64.NO_PADDING));
-        assertEquals(out_60.replaceAll("=", ""), encodeToString(in_60, Base64.NO_PADDING));
-        assertEquals(out_61.replaceAll("=", ""), encodeToString(in_61, Base64.NO_PADDING));
-
-        assertEquals(out_56.replaceAll("\n", ""), encodeToString(in_56, Base64.NO_WRAP));
-        assertEquals(out_57.replaceAll("\n", ""), encodeToString(in_57, Base64.NO_WRAP));
-        assertEquals(out_58.replaceAll("\n", ""), encodeToString(in_58, Base64.NO_WRAP));
-        assertEquals(out_59.replaceAll("\n", ""), encodeToString(in_59, Base64.NO_WRAP));
-        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.
-     *
-     * This test is disabled because while it passes if you can get it
-     * to run, android's test infrastructure currently doesn't allow
-     * us to get at package-private members (Base64.EncoderState in
-     * this case).
-     */
-    public void XXXtestEncodeInternal() 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);
-    }
-
-    private static final String lipsum =
-            "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.";
-
-    public void testInputStream() 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);
-
-        // Test input needs to be at least 2048 bytes to fill up the
-        // read buffer of Base64InputStream.
-        byte[] plain = (lipsum + lipsum + lipsum + lipsum + lipsum).getBytes();
-
-        for (int flags: flagses) {
-            byte[] encoded = Base64.encode(plain, flags);
-
-            ByteArrayInputStream bais;
-            Base64InputStream b64is;
-            byte[] actual = new byte[plain.length * 2];
-            int ap;
-            int b;
-
-            // ----- test decoding ("encoded" -> "plain") -----
-
-            // read as much as it will give us in one chunk
-            bais = new ByteArrayInputStream(encoded);
-            b64is = new Base64InputStream(bais, flags);
-            ap = 0;
-            while ((b = b64is.read(actual, ap, actual.length-ap)) != -1) {
-                ap += b;
-            }
-            assertEquals(actual, ap, plain);
-
-            // read individual bytes
-            bais = new ByteArrayInputStream(encoded);
-            b64is = new Base64InputStream(bais, flags);
-            ap = 0;
-            while ((b = b64is.read()) != -1) {
-                actual[ap++] = (byte) b;
-            }
-            assertEquals(actual, ap, plain);
-
-            // mix reads of variously-sized arrays with one-byte reads
-            bais = new ByteArrayInputStream(encoded);
-            b64is = new Base64InputStream(bais, flags);
-            ap = 0;
-            readloop: while (true) {
-                int l = writeLengths[rng.nextInt(writeLengths.length)];
-                if (l >= 0) {
-                    b = b64is.read(actual, ap, l);
-                    if (b == -1) break readloop;
-                    ap += b;
-                } else {
-                    for (int i = 0; i < -l; ++i) {
-                        if ((b = b64is.read()) == -1) break readloop;
-                        actual[ap++] = (byte) b;
-                    }
-                }
-            }
-            assertEquals(actual, ap, plain);
-
-            // ----- test encoding ("plain" -> "encoded") -----
-
-            // read as much as it will give us in one chunk
-            bais = new ByteArrayInputStream(plain);
-            b64is = new Base64InputStream(bais, flags, true);
-            ap = 0;
-            while ((b = b64is.read(actual, ap, actual.length-ap)) != -1) {
-                ap += b;
-            }
-            assertEquals(actual, ap, encoded);
-
-            // read individual bytes
-            bais = new ByteArrayInputStream(plain);
-            b64is = new Base64InputStream(bais, flags, true);
-            ap = 0;
-            while ((b = b64is.read()) != -1) {
-                actual[ap++] = (byte) b;
-            }
-            assertEquals(actual, ap, encoded);
-
-            // mix reads of variously-sized arrays with one-byte reads
-            bais = new ByteArrayInputStream(plain);
-            b64is = new Base64InputStream(bais, flags, true);
-            ap = 0;
-            readloop: while (true) {
-                int l = writeLengths[rng.nextInt(writeLengths.length)];
-                if (l >= 0) {
-                    b = b64is.read(actual, ap, l);
-                    if (b == -1) break readloop;
-                    ap += b;
-                } else {
-                    for (int i = 0; i < -l; ++i) {
-                        if ((b = b64is.read()) == -1) break readloop;
-                        actual[ap++] = (byte) b;
-                    }
-                }
-            }
-            assertEquals(actual, ap, encoded);
-        }
-    }
-
-    /**
-     * 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);
-
-        // Test input needs to be at least 1024 bytes to test filling
-        // up the write(int) buffer of Base64OutputStream.
-        byte[] plain = (lipsum + lipsum).getBytes();
-
-        for (int flags: flagses) {
-            byte[] encoded = Base64.encode(plain, flags);
-
-            ByteArrayOutputStream baos;
-            Base64OutputStream b64os;
-            byte[] actual;
-            int p;
-
-            // ----- test encoding ("plain" -> "encoded") -----
-
-            // one large write(byte[]) of the whole input
-            baos = new ByteArrayOutputStream();
-            b64os = new Base64OutputStream(baos, flags);
-            b64os.write(plain);
-            b64os.close();
-            actual = baos.toByteArray();
-            assertEquals(encoded, actual);
-
-            // many calls to write(int)
-            baos = new ByteArrayOutputStream();
-            b64os = new Base64OutputStream(baos, flags);
-            for (int i = 0; i < plain.length; ++i) {
-                b64os.write(plain[i]);
-            }
-            b64os.close();
-            actual = baos.toByteArray();
-            assertEquals(encoded, 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 < plain.length) {
-                int l = writeLengths[rng.nextInt(writeLengths.length)];
-                l = Math.min(l, plain.length-p);
-                if (l >= 0) {
-                    b64os.write(plain, p, l);
-                    p += l;
-                } else {
-                    l = Math.min(-l, plain.length-p);
-                    for (int i = 0; i < l; ++i) {
-                        b64os.write(plain[p+i]);
-                    }
-                    p += l;
-                }
-            }
-            b64os.close();
-            actual = baos.toByteArray();
-            assertEquals(encoded, actual);
-
-            // ----- test decoding ("encoded" -> "plain") -----
-
-            // one large write(byte[]) of the whole input
-            baos = new ByteArrayOutputStream();
-            b64os = new Base64OutputStream(baos, flags, false);
-            b64os.write(encoded);
-            b64os.close();
-            actual = baos.toByteArray();
-            assertEquals(plain, actual);
-
-            // many calls to write(int)
-            baos = new ByteArrayOutputStream();
-            b64os = new Base64OutputStream(baos, flags, false);
-            for (int i = 0; i < encoded.length; ++i) {
-                b64os.write(encoded[i]);
-            }
-            b64os.close();
-            actual = baos.toByteArray();
-            assertEquals(plain, 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 < encoded.length) {
-                int l = writeLengths[rng.nextInt(writeLengths.length)];
-                l = Math.min(l, encoded.length-p);
-                if (l >= 0) {
-                    b64os.write(encoded, p, l);
-                    p += l;
-                } else {
-                    l = Math.min(-l, encoded.length-p);
-                    for (int i = 0; i < l; ++i) {
-                        b64os.write(encoded[p+i]);
-                    }
-                    p += l;
-                }
-            }
-            b64os.close();
-            actual = baos.toByteArray();
-            assertEquals(plain, actual);
-        }
-    }
-}