1 /*
2 * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /**
25 * @test 4235519 8004212 8005394 8007298 8006295 8006315 8006530 8007379 8008925
26 * 8014217 8025003
27 * @summary tests java.util.Base64
28 */
29
30 import java.io.ByteArrayInputStream;
31 import java.io.ByteArrayOutputStream;
32 import java.io.InputStream;
33 import java.io.IOException;
34 import java.io.OutputStream;
35 import java.nio.ByteBuffer;
36 import java.util.Arrays;
37 import java.util.Base64;
38 import java.util.Random;
39
40 public class TestBase64 {
41
42 public static void main(String args[]) throws Throwable {
43 int numRuns = 10;
44 int numBytes = 200;
45 if (args.length > 1) {
46 numRuns = Integer.parseInt(args[0]);
47 numBytes = Integer.parseInt(args[1]);
48 }
49
50 test(Base64.getEncoder(), Base64.getDecoder(),
51 numRuns, numBytes);
52 test(Base64.getUrlEncoder(), Base64.getUrlDecoder(),
53 numRuns, numBytes);
54 test(Base64.getMimeEncoder(), Base64.getMimeDecoder(),
55 numRuns, numBytes);
56
57 Random rnd = new java.util.Random();
58 byte[] nl_1 = new byte[] {'\n'};
59 byte[] nl_2 = new byte[] {'\n', '\r'};
60 byte[] nl_3 = new byte[] {'\n', '\r', '\n'};
61 for (int i = 0; i < 10; i++) {
62 int len = rnd.nextInt(200) + 4;
63 test(Base64.getMimeEncoder(len, nl_1),
64 Base64.getMimeDecoder(),
65 numRuns, numBytes);
66 test(Base64.getMimeEncoder(len, nl_2),
67 Base64.getMimeDecoder(),
68 numRuns, numBytes);
69 test(Base64.getMimeEncoder(len, nl_3),
70 Base64.getMimeDecoder(),
71 numRuns, numBytes);
72 }
73
74 testNull(Base64.getEncoder());
75 testNull(Base64.getUrlEncoder());
76 testNull(Base64.getMimeEncoder());
77 testNull(Base64.getMimeEncoder(10, new byte[]{'\n'}));
78 testNull(Base64.getDecoder());
79 testNull(Base64.getUrlDecoder());
80 testNull(Base64.getMimeDecoder());
81 checkNull(new Runnable() { public void run() { Base64.getMimeEncoder(10, null); }});
82
83 testIOE(Base64.getEncoder());
84 testIOE(Base64.getUrlEncoder());
85 testIOE(Base64.getMimeEncoder());
86 testIOE(Base64.getMimeEncoder(10, new byte[]{'\n'}));
87
88 byte[] src = new byte[1024];
89 new Random().nextBytes(src);
90 final byte[] decoded = Base64.getEncoder().encode(src);
91 testIOE(Base64.getDecoder(), decoded);
92 testIOE(Base64.getMimeDecoder(), decoded);
93 testIOE(Base64.getUrlDecoder(), Base64.getUrlEncoder().encode(src));
94
95 // illegal line separator
96 checkIAE(new Runnable() { public void run() { Base64.getMimeEncoder(10, new byte[]{'\r', 'N'}); }});
97
98 // illegal base64 character
99 decoded[2] = (byte)0xe0;
100 checkIAE(new Runnable() {
101 public void run() { Base64.getDecoder().decode(decoded); }});
102 checkIAE(new Runnable() {
103 public void run() { Base64.getDecoder().decode(decoded, new byte[1024]); }});
104 checkIAE(new Runnable() { public void run() {
105 Base64.getDecoder().decode(ByteBuffer.wrap(decoded)); }});
106 checkIAE(new Runnable() { public void run() {
107 Base64.getDecoder().decode(ByteBuffer.wrap(decoded), ByteBuffer.allocate(1024)); }});
108 checkIAE(new Runnable() { public void run() {
109 Base64.getDecoder().decode(ByteBuffer.wrap(decoded), ByteBuffer.allocateDirect(1024)); }});
110
111 // illegal ending unit
112 checkIOE(new Testable() { public void test() throws IOException {
113 byte[] bytes = "AA=".getBytes("ASCII");
114 try (InputStream stream =
115 Base64.getDecoder().wrap(new ByteArrayInputStream(bytes))) {
116 while (stream.read() != -1);
117 }
118 }});
119
120 // test return value from decode(ByteBuffer, ByteBuffer)
121 testDecBufRet();
122
123 // test single-non-base64 character for mime decoding
124 testSingleNonBase64MimeDec();
125
126 // test decoding of unpadded data
127 testDecodeUnpadded();
128 // test mime decoding with ignored character after padding
129 testDecodeIgnoredAfterPadding();
130
131 // lenient mode for ending unit
132 testLenientPadding();
133
134 }
135
136 private static sun.misc.BASE64Encoder sunmisc = new sun.misc.BASE64Encoder();
137
138 private static void test(Base64.Encoder enc, Base64.Decoder dec,
139 int numRuns, int numBytes) throws Throwable {
140 Random rnd = new java.util.Random();
141
142 enc.encode(new byte[0]);
143 dec.decode(new byte[0]);
144
145 for (int i=0; i<numRuns; i++) {
146 for (int j=1; j<numBytes; j++) {
147 byte[] orig = new byte[j];
148 rnd.nextBytes(orig);
149
150 // --------testing encode/decode(byte[])--------
151 byte[] encoded = enc.encode(orig);
152 byte[] decoded = dec.decode(encoded);
153
154 checkEqual(orig, decoded,
155 "Base64 array encoding/decoding failed!");
156
157 // compare to sun.misc.BASE64Encoder
158 byte[] encoded2 = sunmisc.encode(orig).getBytes("ASCII");
159 checkEqual(normalize(encoded),
160 normalize(encoded2),
161 "Base64 enc.encode() does not match sun.misc.base64!");
162
163 // remove padding '=' to test non-padding decoding case
164 if (encoded[encoded.length -2] == '=')
165 encoded2 = Arrays.copyOf(encoded, encoded.length -2);
166 else if (encoded[encoded.length -1] == '=')
167 encoded2 = Arrays.copyOf(encoded, encoded.length -1);
168 else
169 encoded2 = null;
170
171 // --------testing encodetoString(byte[])/decode(String)--------
172 String str = enc.encodeToString(orig);
173 if (!Arrays.equals(str.getBytes("ASCII"), encoded)) {
174 throw new RuntimeException(
175 "Base64 encodingToString() failed!");
176 }
177 byte[] buf = dec.decode(new String(encoded, "ASCII"));
178 checkEqual(buf, orig, "Base64 decoding(String) failed!");
179
180 if (encoded2 != null) {
181 buf = dec.decode(new String(encoded2, "ASCII"));
182 checkEqual(buf, orig, "Base64 decoding(String) failed!");
183 }
184
185 //-------- testing encode/decode(Buffer)--------
186 testEncode(enc, ByteBuffer.wrap(orig), encoded);
187 ByteBuffer bin = ByteBuffer.allocateDirect(orig.length);
188 bin.put(orig).flip();
189 testEncode(enc, bin, encoded);
190
191 testDecode(dec, ByteBuffer.wrap(encoded), orig);
192 bin = ByteBuffer.allocateDirect(encoded.length);
193 bin.put(encoded).flip();
194 testDecode(dec, bin, orig);
195
196 if (encoded2 != null)
197 testDecode(dec, ByteBuffer.wrap(encoded2), orig);
198
199 // -------- testing encode(Buffer, Buffer)--------
200 testEncode(enc, encoded,
201 ByteBuffer.wrap(orig),
202 ByteBuffer.allocate(encoded.length + 10));
203
204 testEncode(enc, encoded,
205 ByteBuffer.wrap(orig),
206 ByteBuffer.allocateDirect(encoded.length + 10));
207
208 // --------testing decode(Buffer, Buffer);--------
209 testDecode(dec, orig,
210 ByteBuffer.wrap(encoded),
211 ByteBuffer.allocate(orig.length + 10));
212
213 testDecode(dec, orig,
214 ByteBuffer.wrap(encoded),
215 ByteBuffer.allocateDirect(orig.length + 10));
216
217 // --------testing decode.wrap(input stream)--------
218 // 1) random buf length
219 ByteArrayInputStream bais = new ByteArrayInputStream(encoded);
220 InputStream is = dec.wrap(bais);
221 buf = new byte[orig.length + 10];
222 int len = orig.length;
223 int off = 0;
224 while (true) {
225 int n = rnd.nextInt(len);
226 if (n == 0)
227 n = 1;
228 n = is.read(buf, off, n);
229 if (n == -1) {
230 checkEqual(off, orig.length,
231 "Base64 stream decoding failed");
232 break;
233 }
234 off += n;
235 len -= n;
236 if (len == 0)
237 break;
238 }
239 buf = Arrays.copyOf(buf, off);
240 checkEqual(buf, orig, "Base64 stream decoding failed!");
241
242 // 2) read one byte each
243 bais.reset();
244 is = dec.wrap(bais);
245 buf = new byte[orig.length + 10];
246 off = 0;
247 int b;
248 while ((b = is.read()) != -1) {
249 buf[off++] = (byte)b;
250 }
251 buf = Arrays.copyOf(buf, off);
252 checkEqual(buf, orig, "Base64 stream decoding failed!");
253
254 // --------testing encode.wrap(output stream)--------
255 ByteArrayOutputStream baos = new ByteArrayOutputStream((orig.length + 2) / 3 * 4 + 10);
256 OutputStream os = enc.wrap(baos);
257 off = 0;
258 len = orig.length;
259 for (int k = 0; k < 5; k++) {
260 if (len == 0)
261 break;
262 int n = rnd.nextInt(len);
263 if (n == 0)
264 n = 1;
265 os.write(orig, off, n);
266 off += n;
267 len -= n;
268 }
269 if (len != 0)
270 os.write(orig, off, len);
271 os.close();
272 buf = baos.toByteArray();
273 checkEqual(buf, encoded, "Base64 stream encoding failed!");
274
275 // 2) write one byte each
276 baos.reset();
277 os = enc.wrap(baos);
278 off = 0;
279 while (off < orig.length) {
280 os.write(orig[off++]);
281 }
282 os.close();
283 buf = baos.toByteArray();
284 checkEqual(buf, encoded, "Base64 stream encoding failed!");
285
286 // --------testing encode(in, out); -> bigger buf--------
287 buf = new byte[encoded.length + rnd.nextInt(100)];
288 int ret = enc.encode(orig, buf);
289 checkEqual(ret, encoded.length,
290 "Base64 enc.encode(src, null) returns wrong size!");
291 buf = Arrays.copyOf(buf, ret);
292 checkEqual(buf, encoded,
293 "Base64 enc.encode(src, dst) failed!");
294
295 // --------testing decode(in, out); -> bigger buf--------
296 buf = new byte[orig.length + rnd.nextInt(100)];
297 ret = dec.decode(encoded, buf);
298 checkEqual(ret, orig.length,
299 "Base64 enc.encode(src, null) returns wrong size!");
300 buf = Arrays.copyOf(buf, ret);
301 checkEqual(buf, orig,
302 "Base64 dec.decode(src, dst) failed!");
303
304 }
305 }
306 }
307
308 private static final byte[] ba_null = null;
309 private static final String str_null = null;
310 private static final ByteBuffer bb_null = null;
311
312 private static void testNull(final Base64.Encoder enc) {
313 checkNull(new Runnable() { public void run() { enc.encode(ba_null); }});
314 checkNull(new Runnable() { public void run() { enc.encodeToString(ba_null); }});
315 checkNull(new Runnable() { public void run() { enc.encode(ba_null, new byte[10]); }});
316 checkNull(new Runnable() { public void run() { enc.encode(new byte[10], ba_null); }});
317 checkNull(new Runnable() { public void run() { enc.encode(bb_null); }});
318 checkNull(new Runnable() { public void run() { enc.encode(bb_null, ByteBuffer.allocate(10), 0); }});
319 checkNull(new Runnable() { public void run() { enc.encode(ByteBuffer.allocate(10), bb_null, 0); }});
320 checkNull(new Runnable() { public void run() { enc.wrap(null); }});
321 }
322
323 private static void testNull(final Base64.Decoder dec) {
324 checkNull(new Runnable() { public void run() { dec.decode(ba_null); }});
325 checkNull(new Runnable() { public void run() { dec.decode(str_null); }});
326 checkNull(new Runnable() { public void run() { dec.decode(ba_null, new byte[10]); }});
327 checkNull(new Runnable() { public void run() { dec.decode(new byte[10], ba_null); }});
328 checkNull(new Runnable() { public void run() { dec.decode(bb_null); }});
329 checkNull(new Runnable() { public void run() { dec.decode(bb_null, ByteBuffer.allocate(10)); }});
330 checkNull(new Runnable() { public void run() { dec.decode(ByteBuffer.allocate(10), bb_null); }});
331 checkNull(new Runnable() { public void run() { dec.wrap(null); }});
332 }
333
334 private static interface Testable {
335 public void test() throws Throwable;
336 }
337
338 private static void testIOE(final Base64.Encoder enc) throws Throwable {
339 ByteArrayOutputStream baos = new ByteArrayOutputStream(8192);
340 final OutputStream os = enc.wrap(baos);
341 os.write(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9});
342 os.close();
343 checkIOE(new Testable() { public void test() throws Throwable { os.write(10); }});
344 checkIOE(new Testable() { public void test() throws Throwable { os.write(new byte[] {10}); }});
345 checkIOE(new Testable() { public void test() throws Throwable { os.write(new byte[] {10}, 1, 4); }});
346 }
347
348 private static void testIOE(final Base64.Decoder dec, byte[] decoded) throws Throwable {
349 ByteArrayInputStream bais = new ByteArrayInputStream(decoded);
350 final InputStream is = dec.wrap(bais);
351 is.read(new byte[10]);
352 is.close();
353 checkIOE(new Testable() { public void test() throws Throwable { is.read(); }});
354 checkIOE(new Testable() { public void test() throws Throwable { is.read(new byte[] {10}); }});
355 checkIOE(new Testable() { public void test() throws Throwable { is.read(new byte[] {10}, 1, 4); }});
356 checkIOE(new Testable() { public void test() throws Throwable { is.available(); }});
357 checkIOE(new Testable() { public void test() throws Throwable { is.skip(20); }});
358 }
359
360 private static final void checkNull(Runnable r) {
361 try {
362 r.run();
363 throw new RuntimeException("NPE is not thrown as expected");
364 } catch (NullPointerException npe) {}
365 }
366
367 private static final void checkIOE(Testable t) throws Throwable {
368 try {
369 t.test();
370 throw new RuntimeException("IOE is not thrown as expected");
371 } catch (IOException ioe) {}
372 }
373
374 private static final void checkIAE(Runnable r) throws Throwable {
375 try {
376 r.run();
377 throw new RuntimeException("IAE is not thrown as expected");
378 } catch (IllegalArgumentException iae) {}
379 }
380
381 private static void testDecodeIgnoredAfterPadding() throws Throwable {
382 for (byte nonBase64 : new byte[] {'#', '(', '!', '\\', '-', '_', '\n', '\r'}) {
383 byte[][] src = new byte[][] {
384 "A".getBytes("ascii"),
385 "AB".getBytes("ascii"),
386 "ABC".getBytes("ascii"),
387 "ABCD".getBytes("ascii"),
388 "ABCDE".getBytes("ascii")
389 };
390 Base64.Encoder encM = Base64.getMimeEncoder();
391 Base64.Decoder decM = Base64.getMimeDecoder();
392 Base64.Encoder enc = Base64.getEncoder();
393 Base64.Decoder dec = Base64.getDecoder();
394 for (int i = 0; i < src.length; i++) {
395 // decode(byte[])
396 byte[] encoded = encM.encode(src[i]);
397 encoded = Arrays.copyOf(encoded, encoded.length + 1);
398 encoded[encoded.length - 1] = nonBase64;
399 checkEqual(decM.decode(encoded), src[i], "Non-base64 char is not ignored");
400 byte[] decoded = new byte[src[i].length];
401 decM.decode(encoded, decoded);
402 checkEqual(decoded, src[i], "Non-base64 char is not ignored");
403
404 try {
405 dec.decode(encoded);
406 throw new RuntimeException("No IAE for non-base64 char");
407 } catch (IllegalArgumentException iae) {}
408
409 // decode(ByteBuffer[], ByteBuffer[])
410 ByteBuffer encodedBB = ByteBuffer.wrap(encoded);
411 ByteBuffer decodedBB = ByteBuffer.allocate(100);
412 int ret = decM.decode(encodedBB, decodedBB);
413 byte[] buf = new byte[ret];
414 decodedBB.flip();
415 decodedBB.get(buf);
416 checkEqual(buf, src[i], "Non-base64 char is not ignored");
417 try {
418 encodedBB.rewind();
419 decodedBB.clear();
420 dec.decode(encodedBB, decodedBB);
421 throw new RuntimeException("No IAE for non-base64 char");
422 } catch (IllegalArgumentException iae) {}
423 // direct
424 encodedBB.rewind();
425 decodedBB = ByteBuffer.allocateDirect(100);
426 ret = decM.decode(encodedBB, decodedBB);
427 buf = new byte[ret];
428 decodedBB.flip();
429 decodedBB.get(buf);
430 checkEqual(buf, src[i], "Non-base64 char is not ignored");
431 try {
432 encodedBB.rewind();
433 decodedBB.clear();
434 dec.decode(encodedBB, decodedBB);
435 throw new RuntimeException("No IAE for non-base64 char");
436 } catch (IllegalArgumentException iae) {}
437 }
438 }
439 }
440
441 private static void testLenientPadding() throws Throwable {
442 String[] data = new String[] {
443 "=", "", // unnecessary padding
444 "QUJD=", "ABC", //"ABC".encode() -> "QUJD"
445
446 "QQ=", "A", // incomplete padding
447 "QQ=N", "A", // incorrect padding
448 "QQ=?", "A",
449 "QUJDQQ=", "ABCA",
450 "QUJDQQ=N", "ABCA",
451 "QUJDQQ=?", "ABCA",
452
453 "QUI=X", "AB", // incorrect padding
454 "QUI=?", "AB", // incorrect padding
455 };
456 Base64.Decoder dec = Base64.getMimeDecoder();
457
458 for (int i = 0; i < data.length; i += 2) {
459 byte[] src = data[i].getBytes("ASCII");
460 byte[] expected = data[i + 1].getBytes("ASCII");
461 // decode(byte[])
462 byte[] ret = dec.decode(src);
463 checkEqual(ret, expected, "lenient padding decoding failed!");
464
465 // decode(String)
466 ret = dec.decode(data[i]);
467 checkEqual(ret, expected, "lenient padding decoding failed!");
468
469 // decode(ByteBuffer)
470 ByteBuffer srcBB = ByteBuffer.wrap(src);
471 ByteBuffer retBB = dec.decode(srcBB);
472 checkEqual(srcBB.remaining(), 0, "lenient padding decoding failed!");
473 checkEqual(Arrays.copyOf(retBB.array(), retBB.remaining()),
474 expected, "lenient padding decoding failed!");
475
476 // wrap.decode(byte[])
477 ret = new byte[10];
478 int n = dec.wrap(new ByteArrayInputStream(src)).read(ret);
479 checkEqual(Arrays.copyOf(ret, n), expected, "lenient padding decoding failed!");
480 }
481 }
482
483 private static void testDecodeUnpadded() throws Throwable {
484 byte[] srcA = new byte[] { 'Q', 'Q' };
485 byte[] srcAA = new byte[] { 'Q', 'Q', 'E'};
486 Base64.Decoder dec = Base64.getDecoder();
487 byte[] ret = dec.decode(srcA);
488 if (ret[0] != 'A')
489 throw new RuntimeException("Decoding unpadding input A failed");
490 ret = dec.decode(srcAA);
491 if (ret[0] != 'A' && ret[1] != 'A')
492 throw new RuntimeException("Decoding unpadding input AA failed");
493 ret = new byte[10];
494 if (dec.wrap(new ByteArrayInputStream(srcA)).read(ret) != 1 &&
495 ret[0] != 'A')
496 throw new RuntimeException("Decoding unpadding input A from stream failed");
497 if (dec.wrap(new ByteArrayInputStream(srcA)).read(ret) != 2 &&
498 ret[0] != 'A' && ret[1] != 'A')
499 throw new RuntimeException("Decoding unpadding input AA from stream failed");
500 }
501
502 // single-non-base64-char should be ignored for mime decoding, but
503 // iae for basic decoding
504 private static void testSingleNonBase64MimeDec() throws Throwable {
505 for (String nonBase64 : new String[] {"#", "(", "!", "\\", "-", "_"}) {
506 if (Base64.getMimeDecoder().decode(nonBase64).length != 0) {
507 throw new RuntimeException("non-base64 char is not ignored");
508 }
509 try {
510 Base64.getDecoder().decode(nonBase64);
511 throw new RuntimeException("No IAE for single non-base64 char");
512 } catch (IllegalArgumentException iae) {}
513 }
514 }
515
516 private static void testDecBufRet() throws Throwable {
517 Random rnd = new java.util.Random();
518 Base64.Encoder encoder = Base64.getEncoder();
519 Base64.Decoder decoder = Base64.getDecoder();
520 // src pos, len expected
521 int[][] tests = { { 6, 3, 3, 3}, // xxx xxx -> yyyy yyyy
522 { 6, 3, 4, 3},
523 { 6, 3, 5, 3},
524 { 6, 3, 6, 6},
525 { 6, 11, 4, 3},
526 { 6, 11, 4, 3},
527 { 6, 11, 5, 3},
528 { 6, 11, 6, 6},
529 { 7, 3, 6, 6}, // xxx xxx x -> yyyy yyyy yy==
530 { 7, 3, 7, 7},
531 { 7, 11, 6, 6},
532 { 7, 11, 7, 7},
533 { 8, 3, 6, 6}, // xxx xxx xx -> yyyy yyyy yyy=
534 { 8, 3, 7, 6},
535 { 8, 3, 8, 8},
536 { 8, 13, 6, 6},
537 { 8, 13, 7, 6},
538 { 8, 13, 8, 8},
539
540 };
541 ByteBuffer dstBuf = ByteBuffer.allocate(100);
542 for (boolean direct : new boolean[] { false, true}) {
543 for (int[] test : tests) {
544 byte[] src = new byte[test[0]];
545 rnd.nextBytes(src);
546 ByteBuffer srcBuf = direct ? ByteBuffer.allocate(100)
547 : ByteBuffer.allocateDirect(100);
548 srcBuf.put(encoder.encode(src)).flip();
549 dstBuf.clear().position(test[1]).limit(test[1]+ test[2]);
550 int ret = decoder.decode(srcBuf, dstBuf);
551 if (ret != test[3]) {
552 System.out.printf(" [%6s] src=%d, pos=%d, len=%d, expected=%d, ret=%d%n",
553 direct?"direct":"",
554 test[0], test[1], test[2], test[3], ret);
555 throw new RuntimeException("ret != expected");
556 }
557 }
558 }
559 }
560
561 private static final void testEncode(Base64.Encoder enc, ByteBuffer bin, byte[] expected)
562 throws Throwable {
563
564 ByteBuffer bout = enc.encode(bin);
565 byte[] buf = new byte[bout.remaining()];
566 bout.get(buf);
567 if (bin.hasRemaining()) {
568 throw new RuntimeException(
569 "Base64 enc.encode(ByteBuffer) failed!");
570 }
571 checkEqual(buf, expected, "Base64 enc.encode(bf, bf) failed!");
572 }
573
574 private static final void testDecode(Base64.Decoder dec, ByteBuffer bin, byte[] expected)
575 throws Throwable {
576
577 ByteBuffer bout = dec.decode(bin);
578 byte[] buf = new byte[bout.remaining()];
579 bout.get(buf);
580 checkEqual(buf, expected, "Base64 dec.decode(bf) failed!");
581 }
582
583 private static final void testEncode(Base64.Encoder enc, byte[] expected,
584 ByteBuffer ibb, ByteBuffer obb)
585 throws Throwable {
586 Random rnd = new Random();
587 int bytesOut = enc.encode(ibb, obb, 0);
588 if (ibb.hasRemaining()) {
589 throw new RuntimeException(
590 "Base64 enc.encode(bf, bf) failed with wrong return!");
591 }
592 obb.flip();
593 byte[] buf = new byte[obb.remaining()];
594 obb.get(buf);
595 checkEqual(buf, expected, "Base64 enc.encode(bf, bf) failed!");
596 ibb.rewind();
597 obb.position(0);
598 obb.limit(0);
599 bytesOut = 0;
600
601 do { // increase the "limit" incrementally & randomly
602 int n = rnd.nextInt(expected.length - obb.position());
603 if (n == 0)
604 n = 1;
605 obb.limit(obb.limit() + n);
606 //obb.limit(Math.min(obb.limit() + n, expected.length));
607 bytesOut = enc.encode(ibb, obb, bytesOut);
608 } while (ibb.hasRemaining());
609 obb.flip();
610 buf = new byte[obb.remaining()];
611 obb.get(buf);
612 checkEqual(buf, expected, "Base64 enc.encode(bf, bf) failed!");
613 }
614
615 private static final void testDecode(Base64.Decoder dec, byte[] expected,
616 ByteBuffer ibb, ByteBuffer obb)
617 throws Throwable {
618 Random rnd = new Random();
619
620 dec.decode(ibb, obb);
621 if (ibb.hasRemaining()) {
622 throw new RuntimeException(
623 "Base64 dec.decode(bf, bf) failed with un-decoded ibb!");
624 }
625 obb.flip();
626 byte[] buf = new byte[obb.remaining()];
627 obb.get(buf);
628 checkEqual(buf, expected, "Base64 dec.decode(bf, bf) failed!");
629
630 ibb.rewind();
631 obb.position(0);
632 obb.limit(0);
633 do { // increase the "limit" incrementally & randomly
634 int n = rnd.nextInt(expected.length - obb.position());
635 if (n == 0)
636 n = 1;
637 obb.limit(obb.limit() + n);
638 dec.decode(ibb, obb);
639 } while (ibb.hasRemaining());
640
641
642 obb.flip();
643 buf = new byte[obb.remaining()];
644 obb.get(buf);
645 checkEqual(buf, expected, "Base64 dec.decode(bf, bf) failed!");
646 }
647
648 private static final void checkEqual(int v1, int v2, String msg)
649 throws Throwable {
650 if (v1 != v2) {
651 System.out.printf(" v1=%d%n", v1);
652 System.out.printf(" v2=%d%n", v2);
653 throw new RuntimeException(msg);
654 }
655 }
656
657 private static final void checkEqual(byte[] r1, byte[] r2, String msg)
658 throws Throwable {
659 if (!Arrays.equals(r1, r2)) {
660 System.out.printf(" r1[%d]=[%s]%n", r1.length, new String(r1));
661 System.out.printf(" r2[%d]=[%s]%n", r2.length, new String(r2));
662 throw new RuntimeException(msg);
663 }
664 }
665
666 // remove line feeds,
667 private static final byte[] normalize(byte[] src) {
668 int n = 0;
669 boolean hasUrl = false;
670 for (int i = 0; i < src.length; i++) {
671 if (src[i] == '\r' || src[i] == '\n')
672 n++;
673 if (src[i] == '-' || src[i] == '_')
674 hasUrl = true;
675 }
676 if (n == 0 && hasUrl == false)
677 return src;
678 byte[] ret = new byte[src.length - n];
679 int j = 0;
680 for (int i = 0; i < src.length; i++) {
681 if (src[i] == '-')
682 ret[j++] = '+';
683 else if (src[i] == '_')
684 ret[j++] = '/';
685 else if (src[i] != '\r' && src[i] != '\n')
686 ret[j++] = src[i];
687 }
688 return ret;
689 }
690 }