/*

 * 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 4328178

   @summary Performs baseline and regression test on the ISCII91 charset

 */

import java.io.*;

public class ISCIITest {

    private static void failureReport() {

        System.err.println ("Failed ISCII91 Regression Test");

    }

    private static void mapEquiv(int start,

                                 int end,

                                 String testName)

    throws Exception

    {

        byte[] singleByte = new byte[1];

        byte[] encoded = new byte[1];

        for (int i = start; i <= end; i++ ) {

            singleByte[0] = (byte) i;

            try {

                String unicodeStr =

                        new String (singleByte,"ISCII91");

                if (i != (int)unicodeStr.charAt(0)) {

                    System.err.println ("FAILED ISCII91 Regression test"

                                        + "input byte is " + i );

                    throw new Exception("");

                }

                encoded = unicodeStr.getBytes("ISCII91");

                if (encoded[0] != singleByte[0]) {

                   System.err.println("Encoding error " + testName);

                   throw new Exception("Failed ISCII91 Regression test");

                }

            } catch (UnsupportedEncodingException e) {

                failureReport();

            }

        }

        return;

    }

    private static void checkUnmapped(int start,

                                      int end,

                                      String testName)

    throws Exception {

        byte[] singleByte = new byte[1];

        for (int i = start; i <= end; i++ ) {

            singleByte[0] = (byte) i;

            try {

                String unicodeStr = new String (singleByte, "ISCII91");

                if (unicodeStr.charAt(0) != '\uFFFD') {

                    System.err.println("FAILED " + testName +

                                        "input byte is " + i );

                    throw new Exception ("Failed ISCII91 regression test");

                }

            } catch (UnsupportedEncodingException e) {

                System.err.println("Unsupported character encoding");

            }

        }

        return;

    }

    /*

     *

     */

    private static void checkRange(int start, int end,

                                   char[] expectChars,

                                   String testName)

                                   throws Exception {

        byte[] singleByte = new byte[1];

        byte[] encoded = new byte[1];

        int lookupOffset = 0;

        for (int i=start; i <= end; i++ ) {

            singleByte[0] = (byte) i;

            String unicodeStr = new String (singleByte, "ISCII91");

            if (unicodeStr.charAt(0) != expectChars[lookupOffset++]) {

                throw new Exception ("Failed ISCII91 Regression Test");

            }

            encoded = unicodeStr.getBytes("ISCII");

        }

        return;

    }

    /*

     * Tests the ISCII91 Indic character encoding

     * as per IS 13194:1991 Bureau of Indian Standards.

     */

    private static void test () throws Exception {

        try {

            // ISCII91 is an 8-byte encoding which retains the ASCII

            // mappings in the lower half.

            mapEquiv(0, 0x7f, "7 bit ASCII range");

            // Checks a range of characters which are unmappable according

            // to the standards.

            checkUnmapped(0x81, 0x9f, "UNMAPPED");

            // Vowel Modifier chars can be used to modify the vowel

            // sound of the preceding consonant, vowel or matra character.

            byte[] testByte = new byte[1];

            char[] vowelModChars = {

                '\u0901', // Vowel modifier Chandrabindu

                '\u0902', // Vowel modifier Anuswar

                '\u0903'  // Vowel modifier Visarg

            };

            checkRange(0xa1, 0xa3, vowelModChars, "INDIC VOWEL MODIFIER CHARS");

            char[] expectChars = {

                '\u0905', // a4 -- Vowel A

                '\u0906', // a5 -- Vowel AA

                '\u0907', // a6 -- Vowel I

                '\u0908', // a7 -- Vowel II

                '\u0909', // a8 -- Vowel U

                '\u090a', // a9 -- Vowel UU

                '\u090b', // aa -- Vowel RI

                '\u090e', // ab -- Vowel E ( Southern Scripts )

                '\u090f', // ac -- Vowel EY

                '\u0910', // ad -- Vowel AI

                '\u090d', // ae -- Vowel AYE ( Devanagari Script )

                '\u0912', // af -- Vowel O ( Southern Scripts )

                '\u0913', // b0 -- Vowel OW

                '\u0914', // b1 -- Vowel AU

                '\u0911', // b2 -- Vowel AWE ( Devanagari Script )

            };

            checkRange(0xa4, 0xb2, expectChars, "INDIC VOWELS");

            char[] expectConsChars =

            {

                '\u0915', // b3 -- Consonant KA

                '\u0916', // b4 -- Consonant KHA

                '\u0917', // b5 -- Consonant GA

                '\u0918', // b6 -- Consonant GHA

                '\u0919', // b7 -- Consonant NGA

                '\u091a', // b8 -- Consonant CHA

                '\u091b', // b9 -- Consonant CHHA

                '\u091c', // ba -- Consonant JA

                '\u091d', // bb -- Consonant JHA

                '\u091e', // bc -- Consonant JNA

                '\u091f', // bd -- Consonant Hard TA

                '\u0920', // be -- Consonant Hard THA

                '\u0921', // bf -- Consonant Hard DA

                '\u0922', // c0 -- Consonant Hard DHA

                '\u0923', // c1 -- Consonant Hard NA

                '\u0924', // c2 -- Consonant Soft TA

                '\u0925', // c3 -- Consonant Soft THA

                '\u0926', // c4 -- Consonant Soft DA

                '\u0927', // c5 -- Consonant Soft DHA

                '\u0928', // c6 -- Consonant Soft NA

                '\u0929', // c7 -- Consonant NA ( Tamil )

                '\u092a', // c8 -- Consonant PA

                '\u092b', // c9 -- Consonant PHA

                '\u092c', // ca -- Consonant BA

                '\u092d', // cb -- Consonant BHA

                '\u092e', // cc -- Consonant MA

                '\u092f', // cd -- Consonant YA

                '\u095f', // ce -- Consonant JYA ( Bengali, Assamese & Oriya )

                '\u0930', // cf -- Consonant RA

                '\u0931', // d0 -- Consonant Hard RA ( Southern Scripts )

                '\u0932', // d1 -- Consonant LA

                '\u0933', // d2 -- Consonant Hard LA

                '\u0934', // d3 -- Consonant ZHA ( Tamil & Malayalam )

                '\u0935', // d4 -- Consonant VA

                '\u0936', // d5 -- Consonant SHA

                '\u0937', // d6 -- Consonant Hard SHA

                '\u0938', // d7 -- Consonant SA

                '\u0939', // d8 -- Consonant HA

            };

            checkRange(0xb3, 0xd8, expectConsChars, "INDIC CONSONANTS");

            char[] matraChars = {

                '\u093e', // da -- Vowel Sign AA

                '\u093f', // db -- Vowel Sign I

                '\u0940', // dc -- Vowel Sign II

                '\u0941', // dd -- Vowel Sign U

                '\u0942', // de -- Vowel Sign UU

                '\u0943', // df -- Vowel Sign RI

                '\u0946', // e0 -- Vowel Sign E ( Southern Scripts )

                '\u0947', // e1 -- Vowel Sign EY

                '\u0948', // e2 -- Vowel Sign AI

                '\u0945', // e3 -- Vowel Sign AYE ( Devanagari Script )

                '\u094a', // e4 -- Vowel Sign O ( Southern Scripts )

                '\u094b', // e5 -- Vowel Sign OW

                '\u094c', // e6 -- Vowel Sign AU

                '\u0949' // e7 -- Vowel Sign AWE ( Devanagari Script )

            };

            // Matras or Vowel signs alter the implicit

            // vowel sound associated with an Indic consonant.

            checkRange(0xda, 0xe7, matraChars, "INDIC MATRAS");

            char[] loneContextModifierChars = {

            '\u094d', // e8 -- Vowel Omission Sign ( Halant )

            '\u093c', // e9 -- Diacritic Sign ( Nukta )

            '\u0964' // ea -- Full Stop ( Viram, Northern Scripts )

            };

            checkRange(0xe8, 0xea,

                       loneContextModifierChars, "LONE INDIC CONTEXT CHARS");

            // Test Indic script numeral chars

            // (as opposed to international numerals)

            char[] expectNumeralChars =

            {

                '\u0966', // f1 -- Digit 0

                '\u0967', // f2 -- Digit 1

                '\u0968', // f3 -- Digit 2

                '\u0969', // f4 -- Digit 3

                '\u096a', // f5 -- Digit 4

                '\u096b', // f6 -- Digit 5

                '\u096c', // f7 -- Digit 6

                '\u096d', // f8 -- Digit 7

                '\u096e', // f9 -- Digit 8

                '\u096f'  // fa -- Digit 9

            };

            checkRange(0xf1, 0xfa,

                       expectNumeralChars, "NUMERAL/DIGIT CHARACTERS");

            int lookupOffset = 0;

            char[] expectNuktaSub = {

                '\u0950',

                '\u090c',

                '\u0961',

                '\u0960',

                '\u0962',

                '\u0963',

                '\u0944',

                '\u093d'

            };

            /*

             * ISCII uses a number of code extension techniques

             * to access a number of lesser used characters.

             * The Nukta character which ordinarily signifies

             * a diacritic is used in combination with existing

             * characters to escape them to a different character.

             * value.

            */

            byte[] codeExtensionBytes = {

                (byte)0xa1 , (byte)0xe9, // Chandrabindu + Nukta

                                         // =>DEVANAGARI OM SIGN

                (byte)0xa6 , (byte)0xe9, // Vowel I + Nukta

                                         // => DEVANAGARI VOCALIC L

                (byte)0xa7 , (byte)0xe9, // Vowel II + Nukta

                                         // => DEVANAGARI VOCALIC LL

                (byte)0xaa , (byte)0xe9, // Vowel RI + Nukta

                                         // => DEVANAGARI VOCALIC RR

                (byte)0xdb , (byte)0xe9, //  Vowel sign I + Nukta

                                         // => DEVANAGARI VOWEL SIGN VOCALIC L

                (byte)0xdc , (byte)0xe9, // Vowel sign II + Nukta

                                         // => DEVANAGARI VOWEL SIGN VOCALIC LL

                (byte)0xdf , (byte)0xe9, // Vowel sign Vocalic R + Nukta

                                         // => DEVANAGARI VOWEL SIGN VOCALIC RR

                (byte)0xea , (byte)0xe9  // Full stop/Phrase separator + Nukta

                                         // => DEVANAGARI SIGN AVAGRAHA

            };

            lookupOffset = 0;

            byte[] bytePair = new byte[2];

            for (int i=0; i < (codeExtensionBytes.length)/2; i++ ) {

                bytePair[0] = (byte) codeExtensionBytes[lookupOffset++];

                bytePair[1] = (byte) codeExtensionBytes[lookupOffset++];

                String unicodeStr = new String (bytePair,"ISCII91");

                if (unicodeStr.charAt(0) != expectNuktaSub[i]) {

                    throw new Exception("Failed Nukta Sub");

                }

            }

            lookupOffset = 0;

            byte[] comboBytes = {

                (byte)0xe8 , (byte)0xe8, //HALANT + HALANT

                (byte)0xe8 , (byte)0xe9  //HALANT + NUKTA    aka. Soft Halant

            };

            char[] expectCombChars = {

                '\u094d',

                '\u200c',

                '\u094d',

                '\u200d'

            };

            for (int i=0; i < (comboBytes.length)/2; i++ ) {

                bytePair[0] = (byte) comboBytes[lookupOffset++];

                bytePair[1] = (byte) comboBytes[lookupOffset];

                String unicodeStr = new String (bytePair, "ISCII91");

                if (unicodeStr.charAt(0) != expectCombChars[lookupOffset-1]

                    && unicodeStr.charAt(1) != expectCombChars[lookupOffset]) {

                    throw new Exception("Failed ISCII91 Regression Test");

                }

                lookupOffset++;

            }

        } catch (UnsupportedEncodingException e) {

             System.err.println ("ISCII91 encoding not supported");

             throw new Exception ("Failed ISCII91 Regression Test");

        }

    }

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

        test();

    }

}