3457ff4337
8008925: Base64.getMimeDecoder().decode() does not ignore padding chars Updated implementation and spec for corner cases. Reviewed-by: alanb
638 lines
26 KiB
Java
638 lines
26 KiB
Java
/*
|
|
* Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
/**
|
|
* @test 4235519 8004212 8005394 8007298 8006295 8006315 8006530 8007379 8008925
|
|
* @summary tests java.util.Base64
|
|
*/
|
|
|
|
import java.io.ByteArrayInputStream;
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.InputStream;
|
|
import java.io.IOException;
|
|
import java.io.OutputStream;
|
|
import java.nio.ByteBuffer;
|
|
import java.util.Arrays;
|
|
import java.util.Base64;
|
|
import java.util.Random;
|
|
|
|
public class TestBase64 {
|
|
|
|
public static void main(String args[]) throws Throwable {
|
|
int numRuns = 10;
|
|
int numBytes = 200;
|
|
if (args.length > 1) {
|
|
numRuns = Integer.parseInt(args[0]);
|
|
numBytes = Integer.parseInt(args[1]);
|
|
}
|
|
|
|
test(Base64.getEncoder(), Base64.getDecoder(),
|
|
numRuns, numBytes);
|
|
test(Base64.getUrlEncoder(), Base64.getUrlDecoder(),
|
|
numRuns, numBytes);
|
|
test(Base64.getMimeEncoder(), Base64.getMimeDecoder(),
|
|
numRuns, numBytes);
|
|
|
|
Random rnd = new java.util.Random();
|
|
byte[] nl_1 = new byte[] {'\n'};
|
|
byte[] nl_2 = new byte[] {'\n', '\r'};
|
|
byte[] nl_3 = new byte[] {'\n', '\r', '\n'};
|
|
for (int i = 0; i < 10; i++) {
|
|
int len = rnd.nextInt(200) + 4;
|
|
test(Base64.getEncoder(len, nl_1),
|
|
Base64.getMimeDecoder(),
|
|
numRuns, numBytes);
|
|
test(Base64.getEncoder(len, nl_2),
|
|
Base64.getMimeDecoder(),
|
|
numRuns, numBytes);
|
|
test(Base64.getEncoder(len, nl_3),
|
|
Base64.getMimeDecoder(),
|
|
numRuns, numBytes);
|
|
}
|
|
|
|
testNull(Base64.getEncoder());
|
|
testNull(Base64.getUrlEncoder());
|
|
testNull(Base64.getMimeEncoder());
|
|
testNull(Base64.getEncoder(10, new byte[]{'\n'}));
|
|
testNull(Base64.getDecoder());
|
|
testNull(Base64.getUrlDecoder());
|
|
testNull(Base64.getMimeDecoder());
|
|
checkNull(new Runnable() { public void run() { Base64.getEncoder(10, null); }});
|
|
|
|
testIOE(Base64.getEncoder());
|
|
testIOE(Base64.getUrlEncoder());
|
|
testIOE(Base64.getMimeEncoder());
|
|
testIOE(Base64.getEncoder(10, new byte[]{'\n'}));
|
|
|
|
byte[] src = new byte[1024];
|
|
new Random().nextBytes(src);
|
|
final byte[] decoded = Base64.getEncoder().encode(src);
|
|
testIOE(Base64.getDecoder(), decoded);
|
|
testIOE(Base64.getMimeDecoder(), decoded);
|
|
testIOE(Base64.getUrlDecoder(), Base64.getUrlEncoder().encode(src));
|
|
|
|
// illegal line separator
|
|
checkIAE(new Runnable() { public void run() { Base64.getEncoder(10, new byte[]{'\r', 'N'}); }});
|
|
|
|
// illegal base64 character
|
|
decoded[2] = (byte)0xe0;
|
|
checkIAE(new Runnable() {
|
|
public void run() { Base64.getDecoder().decode(decoded); }});
|
|
checkIAE(new Runnable() {
|
|
public void run() { Base64.getDecoder().decode(decoded, new byte[1024]); }});
|
|
checkIAE(new Runnable() { public void run() {
|
|
Base64.getDecoder().decode(ByteBuffer.wrap(decoded)); }});
|
|
checkIAE(new Runnable() { public void run() {
|
|
Base64.getDecoder().decode(ByteBuffer.wrap(decoded), ByteBuffer.allocate(1024)); }});
|
|
checkIAE(new Runnable() { public void run() {
|
|
Base64.getDecoder().decode(ByteBuffer.wrap(decoded), ByteBuffer.allocateDirect(1024)); }});
|
|
|
|
// illegal ending unit
|
|
checkIAE(new Runnable() { public void run() { Base64.getMimeDecoder().decode("$=#"); }});
|
|
|
|
// test return value from decode(ByteBuffer, ByteBuffer)
|
|
testDecBufRet();
|
|
|
|
// test single-non-base64 character for mime decoding
|
|
testSingleNonBase64MimeDec();
|
|
|
|
// test decoding of unpadded data
|
|
testDecodeUnpadded();
|
|
// test mime decoding with ignored character after padding
|
|
testDecodeIgnoredAfterPadding();
|
|
}
|
|
|
|
private static sun.misc.BASE64Encoder sunmisc = new sun.misc.BASE64Encoder();
|
|
|
|
private static void test(Base64.Encoder enc, Base64.Decoder dec,
|
|
int numRuns, int numBytes) throws Throwable {
|
|
Random rnd = new java.util.Random();
|
|
|
|
enc.encode(new byte[0]);
|
|
dec.decode(new byte[0]);
|
|
|
|
for (int i=0; i<numRuns; i++) {
|
|
for (int j=1; j<numBytes; j++) {
|
|
byte[] orig = new byte[j];
|
|
rnd.nextBytes(orig);
|
|
|
|
// --------testing encode/decode(byte[])--------
|
|
byte[] encoded = enc.encode(orig);
|
|
byte[] decoded = dec.decode(encoded);
|
|
|
|
checkEqual(orig, decoded,
|
|
"Base64 array encoding/decoding failed!");
|
|
|
|
// compare to sun.misc.BASE64Encoder
|
|
byte[] encoded2 = sunmisc.encode(orig).getBytes("ASCII");
|
|
checkEqual(normalize(encoded),
|
|
normalize(encoded2),
|
|
"Base64 enc.encode() does not match sun.misc.base64!");
|
|
|
|
// remove padding '=' to test non-padding decoding case
|
|
if (encoded[encoded.length -2] == '=')
|
|
encoded2 = Arrays.copyOf(encoded, encoded.length -2);
|
|
else if (encoded[encoded.length -1] == '=')
|
|
encoded2 = Arrays.copyOf(encoded, encoded.length -1);
|
|
else
|
|
encoded2 = null;
|
|
|
|
// --------testing encodetoString(byte[])/decode(String)--------
|
|
String str = enc.encodeToString(orig);
|
|
if (!Arrays.equals(str.getBytes("ASCII"), encoded)) {
|
|
throw new RuntimeException(
|
|
"Base64 encodingToString() failed!");
|
|
}
|
|
byte[] buf = dec.decode(new String(encoded, "ASCII"));
|
|
checkEqual(buf, orig, "Base64 decoding(String) failed!");
|
|
|
|
if (encoded2 != null) {
|
|
buf = dec.decode(new String(encoded2, "ASCII"));
|
|
checkEqual(buf, orig, "Base64 decoding(String) failed!");
|
|
}
|
|
|
|
//-------- testing encode/decode(Buffer)--------
|
|
testEncode(enc, ByteBuffer.wrap(orig), encoded);
|
|
ByteBuffer bin = ByteBuffer.allocateDirect(orig.length);
|
|
bin.put(orig).flip();
|
|
testEncode(enc, bin, encoded);
|
|
|
|
testDecode(dec, ByteBuffer.wrap(encoded), orig);
|
|
bin = ByteBuffer.allocateDirect(encoded.length);
|
|
bin.put(encoded).flip();
|
|
testDecode(dec, bin, orig);
|
|
|
|
if (encoded2 != null)
|
|
testDecode(dec, ByteBuffer.wrap(encoded2), orig);
|
|
|
|
// -------- testing encode(Buffer, Buffer)--------
|
|
testEncode(enc, encoded,
|
|
ByteBuffer.wrap(orig),
|
|
ByteBuffer.allocate(encoded.length + 10));
|
|
|
|
testEncode(enc, encoded,
|
|
ByteBuffer.wrap(orig),
|
|
ByteBuffer.allocateDirect(encoded.length + 10));
|
|
|
|
// --------testing decode(Buffer, Buffer);--------
|
|
testDecode(dec, orig,
|
|
ByteBuffer.wrap(encoded),
|
|
ByteBuffer.allocate(orig.length + 10));
|
|
|
|
testDecode(dec, orig,
|
|
ByteBuffer.wrap(encoded),
|
|
ByteBuffer.allocateDirect(orig.length + 10));
|
|
|
|
// --------testing decode.wrap(input stream)--------
|
|
// 1) random buf length
|
|
ByteArrayInputStream bais = new ByteArrayInputStream(encoded);
|
|
InputStream is = dec.wrap(bais);
|
|
buf = new byte[orig.length + 10];
|
|
int len = orig.length;
|
|
int off = 0;
|
|
while (true) {
|
|
int n = rnd.nextInt(len);
|
|
if (n == 0)
|
|
n = 1;
|
|
n = is.read(buf, off, n);
|
|
if (n == -1) {
|
|
checkEqual(off, orig.length,
|
|
"Base64 stream decoding failed");
|
|
break;
|
|
}
|
|
off += n;
|
|
len -= n;
|
|
if (len == 0)
|
|
break;
|
|
}
|
|
buf = Arrays.copyOf(buf, off);
|
|
checkEqual(buf, orig, "Base64 stream decoding failed!");
|
|
|
|
// 2) read one byte each
|
|
bais.reset();
|
|
is = dec.wrap(bais);
|
|
buf = new byte[orig.length + 10];
|
|
off = 0;
|
|
int b;
|
|
while ((b = is.read()) != -1) {
|
|
buf[off++] = (byte)b;
|
|
}
|
|
buf = Arrays.copyOf(buf, off);
|
|
checkEqual(buf, orig, "Base64 stream decoding failed!");
|
|
|
|
// --------testing encode.wrap(output stream)--------
|
|
ByteArrayOutputStream baos = new ByteArrayOutputStream((orig.length + 2) / 3 * 4 + 10);
|
|
OutputStream os = enc.wrap(baos);
|
|
off = 0;
|
|
len = orig.length;
|
|
for (int k = 0; k < 5; k++) {
|
|
if (len == 0)
|
|
break;
|
|
int n = rnd.nextInt(len);
|
|
if (n == 0)
|
|
n = 1;
|
|
os.write(orig, off, n);
|
|
off += n;
|
|
len -= n;
|
|
}
|
|
if (len != 0)
|
|
os.write(orig, off, len);
|
|
os.close();
|
|
buf = baos.toByteArray();
|
|
checkEqual(buf, encoded, "Base64 stream encoding failed!");
|
|
|
|
// 2) write one byte each
|
|
baos.reset();
|
|
os = enc.wrap(baos);
|
|
off = 0;
|
|
while (off < orig.length) {
|
|
os.write(orig[off++]);
|
|
}
|
|
os.close();
|
|
buf = baos.toByteArray();
|
|
checkEqual(buf, encoded, "Base64 stream encoding failed!");
|
|
|
|
// --------testing encode(in, out); -> bigger buf--------
|
|
buf = new byte[encoded.length + rnd.nextInt(100)];
|
|
int ret = enc.encode(orig, buf);
|
|
checkEqual(ret, encoded.length,
|
|
"Base64 enc.encode(src, null) returns wrong size!");
|
|
buf = Arrays.copyOf(buf, ret);
|
|
checkEqual(buf, encoded,
|
|
"Base64 enc.encode(src, dst) failed!");
|
|
|
|
// --------testing decode(in, out); -> bigger buf--------
|
|
buf = new byte[orig.length + rnd.nextInt(100)];
|
|
ret = dec.decode(encoded, buf);
|
|
checkEqual(ret, orig.length,
|
|
"Base64 enc.encode(src, null) returns wrong size!");
|
|
buf = Arrays.copyOf(buf, ret);
|
|
checkEqual(buf, orig,
|
|
"Base64 dec.decode(src, dst) failed!");
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
private static final byte[] ba_null = null;
|
|
private static final String str_null = null;
|
|
private static final ByteBuffer bb_null = null;
|
|
|
|
private static void testNull(final Base64.Encoder enc) {
|
|
checkNull(new Runnable() { public void run() { enc.encode(ba_null); }});
|
|
checkNull(new Runnable() { public void run() { enc.encodeToString(ba_null); }});
|
|
checkNull(new Runnable() { public void run() { enc.encode(ba_null, new byte[10]); }});
|
|
checkNull(new Runnable() { public void run() { enc.encode(new byte[10], ba_null); }});
|
|
checkNull(new Runnable() { public void run() { enc.encode(bb_null); }});
|
|
checkNull(new Runnable() { public void run() { enc.encode(bb_null, ByteBuffer.allocate(10), 0); }});
|
|
checkNull(new Runnable() { public void run() { enc.encode(ByteBuffer.allocate(10), bb_null, 0); }});
|
|
checkNull(new Runnable() { public void run() { enc.wrap(null); }});
|
|
}
|
|
|
|
private static void testNull(final Base64.Decoder dec) {
|
|
checkNull(new Runnable() { public void run() { dec.decode(ba_null); }});
|
|
checkNull(new Runnable() { public void run() { dec.decode(str_null); }});
|
|
checkNull(new Runnable() { public void run() { dec.decode(ba_null, new byte[10]); }});
|
|
checkNull(new Runnable() { public void run() { dec.decode(new byte[10], ba_null); }});
|
|
checkNull(new Runnable() { public void run() { dec.decode(bb_null); }});
|
|
checkNull(new Runnable() { public void run() { dec.decode(bb_null, ByteBuffer.allocate(10)); }});
|
|
checkNull(new Runnable() { public void run() { dec.decode(ByteBuffer.allocate(10), bb_null); }});
|
|
checkNull(new Runnable() { public void run() { dec.wrap(null); }});
|
|
}
|
|
|
|
private static interface Testable {
|
|
public void test() throws Throwable;
|
|
}
|
|
|
|
private static void testIOE(final Base64.Encoder enc) throws Throwable {
|
|
ByteArrayOutputStream baos = new ByteArrayOutputStream(8192);
|
|
final OutputStream os = enc.wrap(baos);
|
|
os.write(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9});
|
|
os.close();
|
|
checkIOE(new Testable() { public void test() throws Throwable { os.write(10); }});
|
|
checkIOE(new Testable() { public void test() throws Throwable { os.write(new byte[] {10}); }});
|
|
checkIOE(new Testable() { public void test() throws Throwable { os.write(new byte[] {10}, 1, 4); }});
|
|
}
|
|
|
|
private static void testIOE(final Base64.Decoder dec, byte[] decoded) throws Throwable {
|
|
ByteArrayInputStream bais = new ByteArrayInputStream(decoded);
|
|
final InputStream is = dec.wrap(bais);
|
|
is.read(new byte[10]);
|
|
is.close();
|
|
checkIOE(new Testable() { public void test() throws Throwable { is.read(); }});
|
|
checkIOE(new Testable() { public void test() throws Throwable { is.read(new byte[] {10}); }});
|
|
checkIOE(new Testable() { public void test() throws Throwable { is.read(new byte[] {10}, 1, 4); }});
|
|
checkIOE(new Testable() { public void test() throws Throwable { is.available(); }});
|
|
checkIOE(new Testable() { public void test() throws Throwable { is.skip(20); }});
|
|
}
|
|
|
|
private static final void checkNull(Runnable r) {
|
|
try {
|
|
r.run();
|
|
throw new RuntimeException("NPE is not thrown as expected");
|
|
} catch (NullPointerException npe) {}
|
|
}
|
|
|
|
private static final void checkIOE(Testable t) throws Throwable {
|
|
try {
|
|
t.test();
|
|
throw new RuntimeException("IOE is not thrown as expected");
|
|
} catch (IOException ioe) {}
|
|
}
|
|
|
|
private static final void checkIAE(Runnable r) throws Throwable {
|
|
try {
|
|
r.run();
|
|
throw new RuntimeException("IAE is not thrown as expected");
|
|
} catch (IllegalArgumentException iae) {}
|
|
}
|
|
|
|
private static void testDecodeIgnoredAfterPadding() throws Throwable {
|
|
for (byte nonBase64 : new byte[] {'#', '(', '!', '\\', '-', '_', '\n', '\r'}) {
|
|
byte[][] src = new byte[][] {
|
|
"A".getBytes("ascii"),
|
|
"AB".getBytes("ascii"),
|
|
"ABC".getBytes("ascii"),
|
|
"ABCD".getBytes("ascii"),
|
|
"ABCDE".getBytes("ascii")
|
|
};
|
|
Base64.Encoder encM = Base64.getMimeEncoder();
|
|
Base64.Decoder decM = Base64.getMimeDecoder();
|
|
Base64.Encoder enc = Base64.getEncoder();
|
|
Base64.Decoder dec = Base64.getDecoder();
|
|
for (int i = 0; i < src.length; i++) {
|
|
// decode(byte[])
|
|
byte[] encoded = encM.encode(src[i]);
|
|
encoded = Arrays.copyOf(encoded, encoded.length + 1);
|
|
encoded[encoded.length - 1] = nonBase64;
|
|
checkEqual(decM.decode(encoded), src[i], "Non-base64 char is not ignored");
|
|
byte[] decoded = new byte[src[i].length];
|
|
decM.decode(encoded, decoded);
|
|
checkEqual(decoded, src[i], "Non-base64 char is not ignored");
|
|
|
|
try {
|
|
dec.decode(encoded);
|
|
throw new RuntimeException("No IAE for non-base64 char");
|
|
} catch (IllegalArgumentException iae) {}
|
|
|
|
// decode(ByteBuffer[], ByteBuffer[])
|
|
ByteBuffer encodedBB = ByteBuffer.wrap(encoded);
|
|
ByteBuffer decodedBB = ByteBuffer.allocate(100);
|
|
int ret = decM.decode(encodedBB, decodedBB);
|
|
byte[] buf = new byte[ret];
|
|
decodedBB.flip();
|
|
decodedBB.get(buf);
|
|
checkEqual(buf, src[i], "Non-base64 char is not ignored");
|
|
try {
|
|
encodedBB.rewind();
|
|
decodedBB.clear();
|
|
dec.decode(encodedBB, decodedBB);
|
|
throw new RuntimeException("No IAE for non-base64 char");
|
|
} catch (IllegalArgumentException iae) {}
|
|
// direct
|
|
encodedBB.rewind();
|
|
decodedBB = ByteBuffer.allocateDirect(100);
|
|
ret = decM.decode(encodedBB, decodedBB);
|
|
buf = new byte[ret];
|
|
decodedBB.flip();
|
|
decodedBB.get(buf);
|
|
checkEqual(buf, src[i], "Non-base64 char is not ignored");
|
|
try {
|
|
encodedBB.rewind();
|
|
decodedBB.clear();
|
|
dec.decode(encodedBB, decodedBB);
|
|
throw new RuntimeException("No IAE for non-base64 char");
|
|
} catch (IllegalArgumentException iae) {}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void testDecodeUnpadded() throws Throwable {
|
|
byte[] srcA = new byte[] { 'Q', 'Q' };
|
|
byte[] srcAA = new byte[] { 'Q', 'Q', 'E'};
|
|
Base64.Decoder dec = Base64.getDecoder();
|
|
byte[] ret = dec.decode(srcA);
|
|
if (ret[0] != 'A')
|
|
throw new RuntimeException("Decoding unpadding input A failed");
|
|
ret = dec.decode(srcAA);
|
|
if (ret[0] != 'A' && ret[1] != 'A')
|
|
throw new RuntimeException("Decoding unpadding input AA failed");
|
|
ret = new byte[10];
|
|
if (dec.wrap(new ByteArrayInputStream(srcA)).read(ret) != 1 &&
|
|
ret[0] != 'A')
|
|
throw new RuntimeException("Decoding unpadding input A from stream failed");
|
|
if (dec.wrap(new ByteArrayInputStream(srcA)).read(ret) != 2 &&
|
|
ret[0] != 'A' && ret[1] != 'A')
|
|
throw new RuntimeException("Decoding unpadding input AA from stream failed");
|
|
}
|
|
|
|
// single-non-base64-char should be ignored for mime decoding, but
|
|
// iae for basic decoding
|
|
private static void testSingleNonBase64MimeDec() throws Throwable {
|
|
for (String nonBase64 : new String[] {"#", "(", "!", "\\", "-", "_"}) {
|
|
if (Base64.getMimeDecoder().decode(nonBase64).length != 0) {
|
|
throw new RuntimeException("non-base64 char is not ignored");
|
|
}
|
|
try {
|
|
Base64.getDecoder().decode(nonBase64);
|
|
throw new RuntimeException("No IAE for single non-base64 char");
|
|
} catch (IllegalArgumentException iae) {}
|
|
}
|
|
}
|
|
|
|
private static void testDecBufRet() throws Throwable {
|
|
Random rnd = new java.util.Random();
|
|
Base64.Encoder encoder = Base64.getEncoder();
|
|
Base64.Decoder decoder = Base64.getDecoder();
|
|
// src pos, len expected
|
|
int[][] tests = { { 6, 3, 3, 3}, // xxx xxx -> yyyy yyyy
|
|
{ 6, 3, 4, 3},
|
|
{ 6, 3, 5, 3},
|
|
{ 6, 3, 6, 6},
|
|
{ 6, 11, 4, 3},
|
|
{ 6, 11, 4, 3},
|
|
{ 6, 11, 5, 3},
|
|
{ 6, 11, 6, 6},
|
|
{ 7, 3, 6, 6}, // xxx xxx x -> yyyy yyyy yy==
|
|
{ 7, 3, 7, 7},
|
|
{ 7, 11, 6, 6},
|
|
{ 7, 11, 7, 7},
|
|
{ 8, 3, 6, 6}, // xxx xxx xx -> yyyy yyyy yyy=
|
|
{ 8, 3, 7, 6},
|
|
{ 8, 3, 8, 8},
|
|
{ 8, 13, 6, 6},
|
|
{ 8, 13, 7, 6},
|
|
{ 8, 13, 8, 8},
|
|
|
|
};
|
|
ByteBuffer dstBuf = ByteBuffer.allocate(100);
|
|
for (boolean direct : new boolean[] { false, true}) {
|
|
for (int[] test : tests) {
|
|
byte[] src = new byte[test[0]];
|
|
rnd.nextBytes(src);
|
|
ByteBuffer srcBuf = direct ? ByteBuffer.allocate(100)
|
|
: ByteBuffer.allocateDirect(100);
|
|
srcBuf.put(encoder.encode(src)).flip();
|
|
dstBuf.clear().position(test[1]).limit(test[1]+ test[2]);
|
|
int ret = decoder.decode(srcBuf, dstBuf);
|
|
if (ret != test[3]) {
|
|
System.out.printf(" [%6s] src=%d, pos=%d, len=%d, expected=%d, ret=%d%n",
|
|
direct?"direct":"",
|
|
test[0], test[1], test[2], test[3], ret);
|
|
throw new RuntimeException("ret != expected");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static final void testEncode(Base64.Encoder enc, ByteBuffer bin, byte[] expected)
|
|
throws Throwable {
|
|
|
|
ByteBuffer bout = enc.encode(bin);
|
|
byte[] buf = new byte[bout.remaining()];
|
|
bout.get(buf);
|
|
if (bin.hasRemaining()) {
|
|
throw new RuntimeException(
|
|
"Base64 enc.encode(ByteBuffer) failed!");
|
|
}
|
|
checkEqual(buf, expected, "Base64 enc.encode(bf, bf) failed!");
|
|
}
|
|
|
|
private static final void testDecode(Base64.Decoder dec, ByteBuffer bin, byte[] expected)
|
|
throws Throwable {
|
|
|
|
ByteBuffer bout = dec.decode(bin);
|
|
byte[] buf = new byte[bout.remaining()];
|
|
bout.get(buf);
|
|
checkEqual(buf, expected, "Base64 dec.decode(bf) failed!");
|
|
}
|
|
|
|
private static final void testEncode(Base64.Encoder enc, byte[] expected,
|
|
ByteBuffer ibb, ByteBuffer obb)
|
|
throws Throwable {
|
|
Random rnd = new Random();
|
|
int bytesOut = enc.encode(ibb, obb, 0);
|
|
if (ibb.hasRemaining()) {
|
|
throw new RuntimeException(
|
|
"Base64 enc.encode(bf, bf) failed with wrong return!");
|
|
}
|
|
obb.flip();
|
|
byte[] buf = new byte[obb.remaining()];
|
|
obb.get(buf);
|
|
checkEqual(buf, expected, "Base64 enc.encode(bf, bf) failed!");
|
|
ibb.rewind();
|
|
obb.position(0);
|
|
obb.limit(0);
|
|
bytesOut = 0;
|
|
|
|
do { // increase the "limit" incrementally & randomly
|
|
int n = rnd.nextInt(expected.length - obb.position());
|
|
if (n == 0)
|
|
n = 1;
|
|
obb.limit(obb.limit() + n);
|
|
//obb.limit(Math.min(obb.limit() + n, expected.length));
|
|
bytesOut = enc.encode(ibb, obb, bytesOut);
|
|
} while (ibb.hasRemaining());
|
|
obb.flip();
|
|
buf = new byte[obb.remaining()];
|
|
obb.get(buf);
|
|
checkEqual(buf, expected, "Base64 enc.encode(bf, bf) failed!");
|
|
}
|
|
|
|
private static final void testDecode(Base64.Decoder dec, byte[] expected,
|
|
ByteBuffer ibb, ByteBuffer obb)
|
|
throws Throwable {
|
|
Random rnd = new Random();
|
|
|
|
dec.decode(ibb, obb);
|
|
if (ibb.hasRemaining()) {
|
|
throw new RuntimeException(
|
|
"Base64 dec.decode(bf, bf) failed with un-decoded ibb!");
|
|
}
|
|
obb.flip();
|
|
byte[] buf = new byte[obb.remaining()];
|
|
obb.get(buf);
|
|
checkEqual(buf, expected, "Base64 dec.decode(bf, bf) failed!");
|
|
|
|
ibb.rewind();
|
|
obb.position(0);
|
|
obb.limit(0);
|
|
do { // increase the "limit" incrementally & randomly
|
|
int n = rnd.nextInt(expected.length - obb.position());
|
|
if (n == 0)
|
|
n = 1;
|
|
obb.limit(obb.limit() + n);
|
|
dec.decode(ibb, obb);
|
|
} while (ibb.hasRemaining());
|
|
|
|
|
|
obb.flip();
|
|
buf = new byte[obb.remaining()];
|
|
obb.get(buf);
|
|
checkEqual(buf, expected, "Base64 dec.decode(bf, bf) failed!");
|
|
}
|
|
|
|
private static final void checkEqual(int v1, int v2, String msg)
|
|
throws Throwable {
|
|
if (v1 != v2) {
|
|
System.out.printf(" v1=%d%n", v1);
|
|
System.out.printf(" v2=%d%n", v2);
|
|
throw new RuntimeException(msg);
|
|
}
|
|
}
|
|
|
|
private static final void checkEqual(byte[] r1, byte[] r2, String msg)
|
|
throws Throwable {
|
|
if (!Arrays.equals(r1, r2)) {
|
|
System.out.printf(" r1[%d]=[%s]%n", r1.length, new String(r1));
|
|
System.out.printf(" r2[%d]=[%s]%n", r2.length, new String(r2));
|
|
throw new RuntimeException(msg);
|
|
}
|
|
}
|
|
|
|
// remove line feeds,
|
|
private static final byte[] normalize(byte[] src) {
|
|
int n = 0;
|
|
boolean hasUrl = false;
|
|
for (int i = 0; i < src.length; i++) {
|
|
if (src[i] == '\r' || src[i] == '\n')
|
|
n++;
|
|
if (src[i] == '-' || src[i] == '_')
|
|
hasUrl = true;
|
|
}
|
|
if (n == 0 && hasUrl == false)
|
|
return src;
|
|
byte[] ret = new byte[src.length - n];
|
|
int j = 0;
|
|
for (int i = 0; i < src.length; i++) {
|
|
if (src[i] == '-')
|
|
ret[j++] = '+';
|
|
else if (src[i] == '_')
|
|
ret[j++] = '/';
|
|
else if (src[i] != '\r' && src[i] != '\n')
|
|
ret[j++] = src[i];
|
|
}
|
|
return ret;
|
|
}
|
|
}
|