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