/*

 * Copyright (c) 2008, 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 4403848 6348426 6407730

   @summary Check correctness of the UTF-16 converter in all its flavors

 */

import java.io.IOException;

import java.nio.BufferOverflowException;

import java.nio.*;

import java.nio.charset.*;

public class TestUTF_16 {

    private static void testDecode(String charset,

                                   String expected,

                                   byte[] input)

    throws Exception

    {

        String out = new String(input, charset);

        if (!out.equals(expected)) {

            failureReport (out, expected);

            throw new Exception("UTF_16 Decoding test failed " + charset);

        }

    }

    private static void testEncode(String charset,

                                   String input,

                                   byte[] expected)

    throws Exception

    {

        byte[] testBytes = input.getBytes(charset);

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

            if (testBytes[i] != expected[i])

                throw new Exception("UTF_16 Encoding test failed " + charset);

    }

    private static void warn(String s) {

        System.err.println("FAILED Test 4403848 UTF-16" +

                            s) ;

    }

    private static void failureReport(String testStr,

                                      String expected) {

        System.err.println ("Expected Characters:");

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

            warn("expected char[" + i + "] : " +

                  Integer.toHexString((int)expected.charAt(i)) +

                 "obtained char[" + i + "] : " +

                  Integer.toHexString((int)testStr.charAt(i)));

        }

    }

    /*

    private static void checkResult(char[] expected,

                                    String testStr,

                                    String testName)

    throws Exception

    {

        if (testStr.length() != expected.length)

            failureReport(testStr, expected);

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

            if (testStr.charAt(i) != expected[i]) {

                failureReport(testStr, expected);

                throw new Exception ("REGTEST TestUTF16 failed: "

                                        + testName);

            }

        }

        System.err.println ("Test " + testName + " PASSED");

        return;

    }

    */

    private static void test() throws Exception  {

            // Tests: Check decoding of UTF-16.

            //        Ensures correct endian polarity

            //        of the decoders and appropriate

            //        interpretation of BOM bytes where

            //        they are required.

            // Test 1: BigEndian UTF-16 Decoding

            testDecode("UTF_16BE", "\u0092\u0093",

                        new byte[] { (byte) 0x00, (byte) 0x92,

                                     (byte) 0x00, (byte) 0x93 });

            // Test 1a: BigEndian UTF-16 Decoding. BOM bytes provided.

            testDecode("UTF_16BE", "\ufeff\u0092\u0093",

                        new byte[] { (byte) 0xfe, (byte) 0xff,

                                     (byte) 0x00, (byte) 0x92,

                                     (byte) 0x00, (byte) 0x93 });

            testDecode("UTF_16LE", "\u9200\u9300",

                        new byte[] { (byte) 0x00, (byte) 0x92,

                                     (byte) 0x00, (byte) 0x93 });

            // Test 2a: LittleEndian  UTF-16 Decoding, BOM bytes provided.

            testDecode("UTF_16LE", "\ufeff\u9200\u9300",

                        new byte[] { (byte) 0xff, (byte) 0xfe,

                                     (byte) 0x00, (byte) 0x92,

                                     (byte) 0x00, (byte) 0x93 });

            // Test 3: UTF-16 (with mandatory byte order mark) Decoding

            testDecode("UTF-16", "\u9200\u9300",

                        new byte[] { (byte) 0xfe, (byte) 0xff,

                                     (byte) 0x92, (byte) 0x00,

                                     (byte) 0x93, (byte) 0x00 });

            // Test 3a: UTF-16 BOM omitted. This should decode OK.

            testDecode("UTF-16", "\u9200\u9300",

                        new byte[] { (byte) 0x92, (byte) 0x00,

                                     (byte) 0x93, (byte) 0x00 });

            // Test 4: encoding using UTF-16

            // BOM must be emitted when encoding and must be BigEndian.

            testEncode("UTF-16", "\u0123",

                        new byte[] { (byte) 0xfe, (byte) 0xff,

                                     (byte) 0x01, (byte) 0x23 });

            // Test 5:

            if (CoderResult.OVERFLOW !=

                Charset.forName("UTF_16")

                .newDecoder()

                .decode((ByteBuffer)(ByteBuffer.allocate(4)

                                     .put(new byte[]

                                          {(byte)0xd8,(byte)0x00,

                                           (byte)0xdc,(byte)0x01})

                                     .flip()),

                        CharBuffer.allocate(1),

                        true)) {

                throw new Exception ("REGTEST TestUTF16 Overflow test failed");

            }

            // Test 6: decoding using UTF_16LE_BOM/UnicodeLittle

            // UnicodeLittle should accept non-BOM byte sequence

            testDecode("UnicodeLittle", "Arial",

                        new byte[] { 'A', 0, 'r', 0, 'i', 0, 'a', 0, 'l', 0});

            System.err.println ("\nPASSED UTF-16 encoder test");

        // Reversed BOM in middle of stream Negative test.

        /*

        boolean caughtException = false;

        try {

                String out = new String(new byte[] {(byte)0x00,

                                            (byte)0x92,

                                            (byte)0xff,

                                            (byte)0xfe},

                                            "UTF-16");

        } catch (IOException e) { caughtException = true; }

        if (caughtException == false)

           throw new Exception ("Incorrectly parsed BOM in middle of input");

        */

            // Fixed included with bug 4403848 fixes buffer sizing

            // issue due to non provision of additional 2 bytes

            // headroom for initial BOM bytes for UTF-16 encoding.

          System.err.println ("OVERALL PASS OF UTF-16 Test");

   }

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

     test();

   }

}