ISCIITest.java

/*
 * 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();
    }
}