/*

 * Copyright (c) 2009, 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

 * @bug 6843578

 * @summary Test old and new implementation of db charsets

 * @build IBM930_OLD IBM933_OLD IBM935_OLD IBM937_OLD IBM939_OLD IBM942_OLD IBM943_OLD IBM948_OLD IBM949_OLD IBM950_OLD IBM970_OLD IBM942C_OLD IBM943C_OLD IBM949C_OLD IBM1381_OLD IBM1383_OLD EUC_CN_OLD EUC_KR_OLD GBK_OLD Johab_OLD MS932_OLD MS936_OLD MS949_OLD MS950_OLD SJIS_OLD PCK_OLD EUC_JP_OLD EUC_JP_LINUX_OLD EUC_JP_Open_OLD

 * @modules java.base/sun.nio.cs jdk.charsets/sun.nio.cs.ext

 * @run main TestIBMDB

 */

import java.nio.charset.*;

import java.nio.*;

import java.util.*;

public class TestIBMDB {

    static class Time {

        long t;

    }

    static int iteration = 200;

    static char[] decode(byte[] bb, Charset cs, boolean testDirect, Time t)

        throws Exception {

        String csn = cs.name();

        CharsetDecoder dec = cs.newDecoder();

        ByteBuffer bbf;

        CharBuffer cbf;

        if (testDirect) {

            bbf = ByteBuffer.allocateDirect(bb.length);

            cbf = ByteBuffer.allocateDirect(bb.length*2).asCharBuffer();

            bbf.put(bb);

        } else {

            bbf = ByteBuffer.wrap(bb);

            cbf = CharBuffer.allocate(bb.length);

        }

        CoderResult cr = null;

        long t1 = System.nanoTime()/1000;

        for (int i = 0; i < iteration; i++) {

            bbf.rewind();

            cbf.clear();

            dec.reset();

            cr = dec.decode(bbf, cbf, true);

        }

        long t2 = System.nanoTime()/1000;

        t.t = (t2 - t1)/iteration;

        if (cr != CoderResult.UNDERFLOW) {

            System.out.println("DEC-----------------");

            int pos = bbf.position();

            System.out.printf("  cr=%s, bbf.pos=%d, bb[pos]=%x,%x,%x,%x%n",

                              cr.toString(), pos,

                              bb[pos++]&0xff, bb[pos++]&0xff,bb[pos++]&0xff, bb[pos++]&0xff);

            throw new RuntimeException("Decoding err: " + csn);

        }

        char[] cc = new char[cbf.position()];

        cbf.flip(); cbf.get(cc);

        return cc;

    }

    static CoderResult decodeCR(byte[] bb, Charset cs, boolean testDirect)

        throws Exception {

        CharsetDecoder dec = cs.newDecoder();

        ByteBuffer bbf;

        CharBuffer cbf;

        if (testDirect) {

            bbf = ByteBuffer.allocateDirect(bb.length);

            cbf = ByteBuffer.allocateDirect(bb.length*2).asCharBuffer();

            bbf.put(bb).flip();

        } else {

            bbf = ByteBuffer.wrap(bb);

            cbf = CharBuffer.allocate(bb.length);

        }

        CoderResult cr = null;

        for (int i = 0; i < iteration; i++) {

            bbf.rewind();

            cbf.clear();

            dec.reset();

            cr = dec.decode(bbf, cbf, true);

        }

        return cr;

    }

    static byte[] encode(char[] cc, Charset cs, boolean testDirect, Time t)

        throws Exception {

        ByteBuffer bbf;

        CharBuffer cbf;

        CharsetEncoder enc = cs.newEncoder();

        String csn = cs.name();

        if (testDirect) {

            bbf = ByteBuffer.allocateDirect(cc.length * 4);

            cbf = ByteBuffer.allocateDirect(cc.length * 2).asCharBuffer();

            cbf.put(cc).flip();

        } else {

            bbf = ByteBuffer.allocate(cc.length * 4);

            cbf = CharBuffer.wrap(cc);

        }

        CoderResult cr = null;

        long t1 = System.nanoTime()/1000;

        for (int i = 0; i < iteration; i++) {

            cbf.rewind();

            bbf.clear();

            enc.reset();

            cr = enc.encode(cbf, bbf, true);

        }

        long t2 = System.nanoTime()/1000;

        t.t = (t2 - t1)/iteration;

        if (cr != CoderResult.UNDERFLOW) {

            System.out.println("ENC-----------------");

            int pos = cbf.position();

            System.out.printf("  cr=%s, cbf.pos=%d, cc[pos]=%x%n",

                              cr.toString(), pos, cc[pos]&0xffff);

            throw new RuntimeException("Encoding err: " + csn);

        }

        byte[] bb = new byte[bbf.position()];

        bbf.flip(); bbf.get(bb);

        return bb;

    }

    static CoderResult encodeCR(char[] cc, Charset cs, boolean testDirect)

        throws Exception {

        ByteBuffer bbf;

        CharBuffer cbf;

        CharsetEncoder enc = cs.newEncoder();

        if (testDirect) {

            bbf = ByteBuffer.allocateDirect(cc.length * 4);

            cbf = ByteBuffer.allocateDirect(cc.length * 2).asCharBuffer();

            cbf.put(cc).flip();

        } else {

            bbf = ByteBuffer.allocate(cc.length * 4);

            cbf = CharBuffer.wrap(cc);

        }

        CoderResult cr = null;

        for (int i = 0; i < iteration; i++) {

            cbf.rewind();

            bbf.clear();

            enc.reset();

            cr = enc.encode(cbf, bbf, true);

        }

        return cr;

    }

    static void printEntry(char c, Charset cs) {

        byte[] bb = new String(new char[] {c}).getBytes(cs);

        for (byte b:bb)

            System.out.printf("%x", b&0xff);

        System.out.printf("    %x", c & 0xffff);

        String s2 = new String(bb, cs);

        System.out.printf("    %x%n", s2.charAt(0) & 0xffff);

    }

    // check and compare canEncoding/Encoding

    static char[] checkEncoding(Charset oldCS, Charset newCS)

        throws Exception {

        System.out.printf("Encoding <%s> <%s>...%n", oldCS.name(), newCS.name());

        CharsetEncoder encOLD = oldCS.newEncoder();

        CharsetEncoder encNew = newCS.newEncoder();

        char[] cc = new char[0x10000];

        int pos = 0;

        boolean is970 = "x-IBM970-Old".equals(oldCS.name());

        for (char c = 0; c < 0xffff; c++) {

            boolean canOld = encOLD.canEncode(c);

            boolean canNew = encNew.canEncode(c);

            if (is970 && c == 0x2299)

                continue;

            if (canOld != canNew) {

                if (canNew) {

                    System.out.printf("      NEW(only): ");

                    printEntry(c, newCS);

                } else {

                    if (is970) {

                        byte[] bb = new String(new char[] {c}).getBytes(oldCS);

                        if (bb.length == 2 && bb[0] == (byte)0xa2 && bb[1] == (byte)0xc1) {

                        // we know 970 has bogus nnnn -> a2c1 -> 2299

                            continue;

                        }

                    }

                    System.out.printf("      OLD(only): ");

                    printEntry(c, oldCS);

                }

            } else if (canNew) {

                byte[] bbNew = new String(new char[] {c}).getBytes(newCS);

                byte[] bbOld = new String(new char[] {c}).getBytes(oldCS);

                if (!Arrays.equals(bbNew, bbOld)) {

                    System.out.printf("      c->b NEW: ");

                    printEntry(c, newCS);

                    System.out.printf("      c->b OLD: ");

                    printEntry(c, oldCS);

                } else {

                    String sNew = new String(bbNew, newCS);

                    String sOld = new String(bbOld, oldCS);

                    if (!sNew.equals(sOld)) {

                        System.out.printf("      b2c NEW (c=%x):", c&0xffff);

                        printEntry(sNew.charAt(0), newCS);

                        System.out.printf("      b2c OLD:");

                        printEntry(sOld.charAt(0), oldCS);

                    }

                }

            }

            if (canNew & canOld) {  // added only both for now

                cc[pos++] = c;

            }

        }

        return Arrays.copyOf(cc, pos);

    }

    // check and compare canEncoding/Encoding

    static void checkDecoding(Charset oldCS, Charset newCS)

        throws Exception

    {

        System.out.printf("Decoding <%s> <%s>...%n", oldCS.name(), newCS.name());

        boolean isEBCDIC = oldCS.name().startsWith("x-IBM93");

        //Try singlebyte first

        byte[] bb = new byte[1];

        System.out.printf("       trying SB...%n");

        for (int b = 0; b < 0x100; b++) {

            bb[0] = (byte)b;

            String sOld = new String(bb, oldCS);

            String sNew = new String(bb, newCS);

            if (!sOld.equals(sNew)) {

                System.out.printf("        b=%x:  %x/%d(old)  %x/%d(new)%n",

                                  b& 0xff,

                                  sOld.charAt(0) & 0xffff, sOld.length(),

                                  sNew.charAt(0) & 0xffff, sNew.length());

            }

        }

        System.out.printf("       trying DB...%n");

        bb = new byte[isEBCDIC?4:2];

        int b1Min = 0x40;

        int b1Max = 0xfe;

        for (int b1 = 0x40; b1 < 0xff; b1++) {

            if (!isEBCDIC) {

                // decodable singlebyte b1

                bb[0] = (byte)b1;

                String sOld = new String(bb, oldCS);

                String sNew = new String(bb, newCS);

                if (!sOld.equals(sNew)) {

                    if (sOld.length() != 2 && sOld.charAt(0) != 0) {

                        // only prints we are NOT expected. above two are known issue

                        System.out.printf("        b1=%x:  %x/%d(old)  %x/%d(new)%n",

                                          b1 & 0xff,

                                          sOld.charAt(0) & 0xffff, sOld.length(),

                                          sNew.charAt(0) & 0xffff, sNew.length());

                        continue;

                    }

                }

            }

            for (int b2 = 0x40; b2 < 0xff; b2++) {

                if (isEBCDIC) {

                    bb[0] = 0x0e;

                    bb[1] = (byte)b1;

                    bb[2] = (byte)b2;

                    bb[3] = 0x0f;

                } else {

                    bb[0] = (byte)b1;

                    bb[1] = (byte)b2;

                }

                String sOld = new String(bb, oldCS);

                String sNew = new String(bb, newCS);

                //if (!sOld.equals(sNew)) {

                if (sOld.charAt(0) != sNew.charAt(0)) {

if (sOld.charAt(0) == 0 && sNew.charAt(0) == 0xfffd)

    continue; // known issude in old implementation

                    System.out.printf("        bb=<%x,%x>  c(old)=%x,  c(new)=%x%n",

                        b1, b2, sOld.charAt(0) & 0xffff, sNew.charAt(0) & 0xffff);

                }

            }

        }

    }

    static void checkInit(String csn) throws Exception {

        System.out.printf("Check init <%s>...%n", csn);

        Charset.forName("Big5");    // load in the ExtendedCharsets

        long t1 = System.nanoTime()/1000;

        Charset cs = Charset.forName(csn);

        long t2 = System.nanoTime()/1000;

        System.out.printf("    charset     :%d%n", t2 - t1);

        t1 = System.nanoTime()/1000;

            cs.newDecoder();

        t2 = System.nanoTime()/1000;

        System.out.printf("    new Decoder :%d%n", t2 - t1);

        t1 = System.nanoTime()/1000;

            cs.newEncoder();

        t2 = System.nanoTime()/1000;

        System.out.printf("    new Encoder :%d%n", t2 - t1);

    }

    static void compare(Charset cs1, Charset cs2, char[] cc) throws Exception {

        System.gc();    // enqueue finalizable objects

        Thread.sleep(1000);

        System.gc();    // enqueue finalizable objects

        String csn1 = cs1.name();

        String csn2 = cs2.name();

        System.out.printf("Diff     <%s> <%s>...%n", csn1, csn2);

        Time t1 = new Time();

        Time t2 = new Time();

        byte[] bb1 = encode(cc, cs1, false, t1);

        byte[] bb2 = encode(cc, cs2, false, t2);

        System.out.printf("    Encoding TimeRatio %s/%s: %d,%d :%f%n",

                          csn2, csn1,

                          t2.t, t1.t,

                          (double)(t2.t)/(t1.t));

        if (!Arrays.equals(bb1, bb2)) {

            System.out.printf("        encoding failed%n");

        }

        char[] cc2 = decode(bb1, cs2, false, t2);

        char[] cc1 = decode(bb1, cs1, false, t1);

        System.out.printf("    Decoding TimeRatio %s/%s: %d,%d :%f%n",

                          csn2, csn1,

                          t2.t, t1.t,

                          (double)(t2.t)/(t1.t));

        if (!Arrays.equals(cc1, cc2)) {

            System.out.printf("        decoding failed%n");

        }

        bb1 = encode(cc, cs1, true, t1);

        bb2 = encode(cc, cs2, true, t2);

        System.out.printf("    Encoding(dir) TimeRatio %s/%s: %d,%d :%f%n",

                          csn2, csn1,

                          t2.t, t1.t,

                          (double)(t2.t)/(t1.t));

        if (!Arrays.equals(bb1, bb2))

            System.out.printf("        encoding (direct) failed%n");

        cc1 = decode(bb1, cs1, true, t1);

        cc2 = decode(bb1, cs2, true, t2);

        System.out.printf("    Decoding(dir) TimeRatio %s/%s: %d,%d :%f%n",

                          csn2, csn1,

                          t2.t, t1.t,

                          (double)(t2.t)/(t1.t));

        if (!Arrays.equals(cc1, cc2)) {

            System.out.printf("        decoding (direct) failed%n");

        }

    }

    /* The first byte is the length of malformed bytes

        byte[][] malformed = {

            {5, (byte)0xF8, (byte)0x80, (byte)0x80, (byte)0x9F, (byte)0x80, (byte)0xC0 },

        };

    */

    static void checkMalformed(Charset cs, byte[][] malformed)

        throws Exception

    {

        boolean failed = false;

        String csn = cs.name();

        System.out.printf("Check malformed <%s>...%n", csn);

        for (boolean direct: new boolean[] {false, true}) {

            for (byte[] bins : malformed) {

                int mlen = bins[0];

                byte[] bin = Arrays.copyOfRange(bins, 1, bins.length);

                CoderResult cr = decodeCR(bin, cs, direct);

                String ashex = "";

                for (int i = 0; i < bin.length; i++) {

                    if (i > 0) ashex += " ";

                        ashex += Integer.toString((int)bin[i] & 0xff, 16);

                }

                if (!cr.isMalformed()) {

                    System.out.printf("        FAIL(direct=%b): [%s] not malformed. -->cr=%s\n", direct, ashex, cr.toString());

                    failed = true;

                } else if (cr.length() != mlen) {

                    System.out.printf("        FAIL(direct=%b): [%s] malformed[len=%d].\n", direct, ashex, cr.length());

                    failed = true;

                }

            }

        }

        if (failed)

            throw new RuntimeException("Check malformed failed " + csn);

    }

    static boolean check(CharsetDecoder dec, byte[] bytes, boolean direct, int[] flow) {

        int inPos = flow[0];

        int inLen = flow[1];

        int outPos = flow[2];

        int outLen = flow[3];

        int expedInPos = flow[4];

        int expedOutPos = flow[5];

        CoderResult expedCR = (flow[6]==0)?CoderResult.UNDERFLOW