/*
 * 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.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * 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 xxxxxxx
 * @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.Random;

public class PermBase64 {

    public static void main(String args[]) throws Throwable {

        int numRuns  = 10000;
        int numBytes = 1000;

        if (args.length > 1) {
            numRuns  = Integer.parseInt(args[0]);
            numBytes = Integer.parseInt(args[1]);
        }

        java.util.Base64.Encoder enc = java.util.Base64.getEncoder();
        java.util.Base64.Decoder dec = java.util.Base64.getDecoder();

//        org.apache.commons.codec.binary.Base64 apache =
//            new org.apache.commons.codec.binary.Base64();

        Base64 migbase64 = new Base64();

        byte[] bytes = new byte[numBytes];
        new Random().nextBytes(bytes);

        byte[] encoded = enc.encode(bytes);
        byte[] decoded = null;
        ByteBuffer ibb = null;
        ByteBuffer obb = null;

        // j.u.Base64.encode(ba)
        for (int i= 0; i< numRuns; i++) {    //warm up
            enc.encode(bytes);
        }
        long t0 = System.nanoTime();
        for (int i= 0; i< numRuns; i++) {
            enc.encode(bytes);
        }
        long t1 = System.nanoTime();
        System.out.printf(" j.u.Base64.encode(ba)      : %d%n", (t1 - t0) / numBytes);

        // j.u.Base64.encodeToString(ba)
        for (int i= 0; i< numRuns; i++) {    //warm up
            enc.encodeToString(bytes);
        }
        String encodedStr = null;
        t0 = System.nanoTime();
        for (int i= 0; i< numRuns; i++) {
            encodedStr = enc.encodeToString(bytes);
        }
        t1 = System.nanoTime();
        System.out.printf(" j.u.Base64.encodeString(ba): %d%n", (t1 - t0) / numBytes);

        // j.u.Base64.encode(bb)
        ibb = ByteBuffer.wrap(bytes);
        for (int i= 0; i< numRuns; i++) {    //warm up
            ibb.rewind();
            obb = enc.encode(ibb);
        }
        t0 = System.nanoTime();
        for (int i= 0; i< numRuns; i++) {
            ibb.rewind();
            obb = enc.encode(ibb);
        }
        t1 = System.nanoTime();
        System.out.printf(" j.u.Base64.encode(bb)      : %d%n", (t1 - t0) / numBytes);
        byte[] encoded2 = new byte[obb.remaining()];
        obb.get(encoded2);
        if (!Arrays.equals(encoded, encoded2)) {
            System.out.println("  j.u.Base64.encode(bb) failed");
        }

        // j.u.Base64.encode(bb, bb)
        encodeBB(numRuns, numBytes,
                 enc,
                 encoded,
                 ByteBuffer.wrap(bytes),
                 ByteBuffer.allocate(encoded.length + 10));

        encodeBB(numRuns, numBytes,
                 enc,
                 encoded,
                 ByteBuffer.wrap(bytes),
                 ByteBuffer.allocateDirect(encoded.length + 10));

        // migBase64.encode(ba)
        for (int i= 0; i< numRuns; i++) {    //warm up
            migbase64.encodeToByte(bytes, false);
        }
        t0 = System.nanoTime();
        for (int i= 0; i< numRuns; i++) {
            migbase64.encodeToByte(bytes, false);
        }
        t1 = System.nanoTime();
        System.out.printf("  migBase64.encode(ba)      : %d%n", (t1 - t0) / numBytes);

        System.out.println("------------------");
        // j.u.Base64.decode(ba)
        for (int i= 0; i< numRuns; i++) {    //warm up
            dec.decode(encoded);
        }
        t0 = System.nanoTime();
        for (int i= 0; i< numRuns; i++) {
            decoded = dec.decode(encoded);
        }
        t1 = System.nanoTime();
        System.out.printf(" j.u.Base64.decode(ba)      : %d%n", (t1 - t0) / numBytes);
        if (!Arrays.equals(bytes, decoded)) {
            System.out.println("  j.u.Base64.decode() failed");
        }

        // j.u.Base64.decode(str)
        for (int i= 0; i< numRuns; i++) {    //warm up
            dec.decode(encodedStr);
        }
        t0 = System.nanoTime();
        for (int i= 0; i< numRuns; i++) {
            decoded = dec.decode(encodedStr);
        }
        t1 = System.nanoTime();
        System.out.printf(" j.u.Base64.decode(str)     : %d%n", (t1 - t0) / numBytes);
        if (!Arrays.equals(bytes, decoded)) {
            System.out.println("  j.u.Base64.decode() failed");
        }

        // j.u.Base64.decode(bb)
        ibb = ByteBuffer.wrap(encoded);
        for (int i= 0; i< numRuns; i++) {    //warm up
            ibb.rewind();
            obb = dec.decode(ibb);
        }
        t0 = System.nanoTime();
        for (int i= 0; i< numRuns; i++) {
            ibb.rewind();
            obb = dec.decode(ibb);
        }
        t1 = System.nanoTime();
        System.out.printf(" j.u.Base64.decode(bb)      : %d%n", (t1 - t0) / numBytes);
        decoded = new byte[obb.remaining()];
        obb.get(decoded);
        if (!Arrays.equals(bytes, decoded)) {
            System.out.println("  j.u.Base64.decode(bb) failed");
        }

        // j.u.Base64.decode(bb, bb)
        decodeBB(numRuns, numBytes,
                 dec,
                 decoded,
                 ByteBuffer.wrap(encoded),
                 ByteBuffer.allocate(decoded.length + 10));

        decodeBB(numRuns, numBytes,
                 dec,
                 decoded,
                 ByteBuffer.wrap(encoded),
                 ByteBuffer.allocateDirect(decoded.length + 10));

        // migBase64.decode(ba)
        for (int i= 0; i< numRuns; i++) {    //warm up
            migbase64.decode(encoded);
        }
        t0 = System.nanoTime();
        for (int i= 0; i< numRuns; i++) {
            decoded = migbase64.decode(encoded);
        }
        t1 = System.nanoTime();
        System.out.printf("  migBase64.decode(ba)      : %d%n", (t1 - t0) / numBytes);
        if (!Arrays.equals(bytes, decoded)) {
            System.out.println("  migBase64.decode() failed");
        }
    }

    private static void encodeBB(int numRuns,
                                 int numBytes,
                                 java.util.Base64.Encoder enc,
                                 byte[] expected,
                                 ByteBuffer ibb, ByteBuffer obb) {
        for (int i= 0; i< numRuns; i++) {    //warm up
            ibb.rewind();
            obb.clear();
            enc.encode(ibb, obb, 0);
        }
        long t0 = System.nanoTime();
        for (int i= 0; i< numRuns; i++) {
            ibb.rewind();
            obb.clear();
            enc.encode(ibb, obb, 0);
        }
        long t1 = System.nanoTime();
        if (obb.hasArray())
            System.out.printf(" j.u.Base64.encode(bb, bb)  : %d%n", (t1 - t0) / numBytes);
        else
            System.out.printf(" j.u.Base64.encode(bb, bb)-D: %d%n", (t1 - t0) / numBytes);

        obb.flip();
        byte[] encoded = new byte[obb.remaining()];
        obb.get(encoded);
        if (!Arrays.equals(encoded, expected)) {
            System.out.println("  j.u.Base64.encode(bb, bb) failed");
        }

    }

    private static void decodeBB(int numRuns,
                                 int numBytes,
                                 java.util.Base64.Decoder dec,
                                 byte[] expected,
                                 ByteBuffer ibb, ByteBuffer obb) {

        for (int i= 0; i< numRuns; i++) {    //warm up
            ibb.rewind();
            obb.clear();
            dec.decode(ibb, obb);
        }
        long t0 = System.nanoTime();
        for (int i= 0; i< numRuns; i++) {
            ibb.rewind();
            obb.clear();
            dec.decode(ibb, obb);
        }
        long t1 = System.nanoTime();
        if (obb.hasArray())
            System.out.printf(" j.u.Base64.decode(bb, bb)  : %d%n",
                             (t1 - t0) / numBytes);
        else
            System.out.printf(" j.u.Base64.decode(bb, bb)-D: %d%n",
                             (t1 - t0) / numBytes);
        obb.flip();
        byte[] decoded = new byte[obb.remaining()];
        obb.get(decoded);
        if (!Arrays.equals(decoded, expected)) {
            System.out.println("  j.u.Base64.decode(bb, bb) failed");
        }
    }

}