/*
 * Copyright (c) 1999, 2005, 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 4241440 4220470
   @summary Test the various two-byte Unicode encodings

   @run main Unicode UnicodeLittle little true
   @run main Unicode UnicodeBig big true
   @run main Unicode UnicodeLittleUnmarked little false
   @run main Unicode UnicodeBigUnmarked big false
   @run main Unicode iso-10646-ucs-2 big false
   @run main Unicode x-utf-16be big false
   @run main Unicode x-utf-16le little false
 */

import java.io.ByteArrayOutputStream;


public class Unicode {

    static final int BOM_HIGH = 0xfe;
    static final int BOM_LOW  = 0xff;

    static final int BIG = 0;
    static final int LITTLE = 1;


    static void fail(String enc, String msg, int e0, int e1, int b0, int b1)
        throws Exception
    {
        throw new Exception(enc + ": " + msg
                            + ": Expected "
                            + Integer.toHexString(e0)
                            + " " + Integer.toHexString(e1)
                            + ", got "
                            + Integer.toHexString(b0)
                            + " " + Integer.toHexString(b1));
    }


    /* Chars to bytes */
    static void encode(String enc, int byteOrder, boolean markExpected)
        throws Exception
    {
        String s = "abc";
        byte[] b = s.getBytes(enc);
        int i = 0;
        if (markExpected) {
            int b0 = b[i++] & 0xff;
            int b1 = b[i++] & 0xff;
            int e0 = 0, e1 = 0;
            if (byteOrder == BIG) {
                e0 = BOM_HIGH;
                e1 = BOM_LOW;
            } else if (byteOrder == LITTLE) {
                e0 = BOM_LOW;
                e1 = BOM_HIGH;
            }
            if ((b0 != e0) || (b1 != e1))
                fail(enc, "Incorrect or missing byte-order mark",
                     e0, e1, b0, b1);
        }
        for (int j = 0; j < s.length(); j++) {
            char c = s.charAt(j);
            int b0 = b[i++] & 0xff;
            int b1 = b[i++] & 0xff;
            int e0 = 0, e1 = 0;
            if (byteOrder == BIG) {
                e0 = c >> 8;
                e1 = c & 0xff;
            } else if (byteOrder == LITTLE) {
                e0 = c & 0xff;
                e1 = c >> 8;
            }
            if ((b0 != e0) || (b1 != e1))
                fail(enc, "Incorrect content at index " + j,
                     e0, e1, b0, b1);
        }
    }


    /* Bytes to chars */
    static void decode(String enc, int byteOrder, boolean markit)
        throws Exception
    {
        String s = "abc";
        ByteArrayOutputStream bo = new ByteArrayOutputStream();
        if (markit) {
            if (byteOrder == BIG) {
                bo.write(BOM_HIGH);
                bo.write(BOM_LOW);
            } else if (byteOrder == LITTLE) {
                bo.write(BOM_LOW);
                bo.write(BOM_HIGH);
            }
        }
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (byteOrder == BIG) {
                bo.write(c >> 8);
                bo.write(c & 0xff);
            } else if (byteOrder == LITTLE) {
                bo.write(c & 0xff);
                bo.write(c >> 8);
            }
        }
        byte[] b = bo.toByteArray();
        String s2 = new String(b, enc);
        if (!s.equals(s2))
            throw new Exception(enc + ": Decode error");
    }


    public static void main(String[] args) throws Exception {
        String enc = args[0];
        String bos = args[1];
        boolean markExpected = Boolean.valueOf(args[2]).booleanValue();
        int byteOrder = -1;
        if (bos.equals("big")) byteOrder = BIG;
        if (bos.equals("little")) byteOrder = LITTLE;

        /* We run each test twice in order to check the repeatability of
           String.getBytes and String(byte[], String) (4220470) */
        encode(enc, byteOrder, markExpected);
        encode(enc, byteOrder, markExpected);
        decode(enc, byteOrder, markExpected);
        decode(enc, byteOrder, markExpected);
    }

}