1 /*

     2  * Copyright (c) 2009 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  */

    23 

    24 /*

    25  * @test

    26  * @bug 6850113

    27  * @summary confirm the behavior of new Bidi implementation. (Backward compatibility)

    28  */

    29 

    30 import java.awt.font.NumericShaper;

    31 import java.awt.font.TextAttribute;

    32 import java.text.AttributedString;

    33 import java.text.Bidi;

    34 import java.util.Arrays;

    35 

    36 public class BidiConformance {

    37 

    38     /* internal flags */

    39     private static boolean error = false;

    40     private static boolean verbose = false;

    41     private static boolean abort = false;

    42 

    43     public static void main(String[] args) {

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

    45             String arg = args[i];

    46             if (arg.equals("-verbose")) {

    47                 verbose = true;

    48             } else if (arg.equals("-abort")) {

    49                 abort = true;

    50             }

    51         }

    52 

    53         BidiConformance bc = new BidiConformance();

    54         bc.test();

    55 

    56         if (error) {

    57             throw new RuntimeException("Failed.");

    58         } else {

    59             System.out.println("Passed.");

    60         }

    61     }

    62 

    63     private void test() {

    64         testConstants();

    65         testConstructors();

    66         testMethods();

    67 

    68         testMethods4Constructor1();  // Bidi(AttributedCharacterIterator)

    69         testMethods4Constructor2();  // Bidi(String, int)

    70         testMethods4Constructor3();  // Bidi(char[], ...)

    71     }

    72 

    73     private void testConstants() {

    74         System.out.println("*** Test constants");

    75 

    76         checkResult("Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT",

    77                      -2, Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);

    78         checkResult("Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT",

    79                      -1, Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT);

    80         checkResult("Bidi.DIRECTION_LEFT_TO_RIGHT",

    81                      0, Bidi.DIRECTION_LEFT_TO_RIGHT);

    82         checkResult("Bidi.DIRECTION_RIGHT_TO_LEFT",

    83                      1, Bidi.DIRECTION_RIGHT_TO_LEFT);

    84     }

    85 

    86     private void testConstructors() {

    87         System.out.println("*** Test constructors");

    88 

    89         testConstructor1();  // Bidi(AttributedCharacterIterator)

    90         testConstructor2();  // Bidi(String, int)

    91         testConstructor3();  // Bidi(char[], ...)

    92     }

    93 

    94     private void testMethods() {

    95         System.out.println("*** Test methods");

    96 

    97         testMethod_createLineBidi1();

    98         testMethod_createLineBidi2();

    99         testMethod_getLevelAt();

   100         testMethod_getRunLevel();

   101         testMethod_getRunLimit();

   102         testMethod_getRunStart();

   103         testMethod_reorderVisually1();

   104         testMethod_reorderVisually2();

   105         testMethod_requiresBidi();

   106     }

   107 

   108     private void testMethods4Constructor1() {

   109         System.out.println("*** Test methods for constructor 1");

   110 

   111         String paragraph;

   112         Bidi bidi;

   113         NumericShaper ns = NumericShaper.getShaper(NumericShaper.ARABIC);

   114 

   115         for (int textNo = 0; textNo < data4Constructor1.length; textNo++) {

   116             paragraph = data4Constructor1[textNo][0];

   117             int start = paragraph.indexOf('<')+1;

   118             int limit = paragraph.indexOf('>');

   119             int testNo;

   120 

   121             System.out.println("*** Test textNo=" + textNo +

   122                 ": Bidi(AttributedCharacterIterator\"" +

   123                 toReadableString(paragraph) + "\") " +

   124                 "  start=" + start + ", limit=" + limit);

   125 

   126             // Test 0

   127             testNo = 0;

   128             System.out.println(" Test#" + testNo +": RUN_DIRECTION_LTR");

   129             AttributedString astr = new AttributedString(paragraph);

   130             astr.addAttribute(TextAttribute.RUN_DIRECTION,

   131                               TextAttribute.RUN_DIRECTION_LTR);

   132             bidi = new Bidi(astr.getIterator());

   133 

   134             callTestEachMethod4Constructor1(textNo, testNo, bidi);

   135 

   136             // Test 1

   137             ++testNo;

   138             System.out.println(" Test#" + testNo +

   139                 ": RUN_DIRECTION_LTR, BIDI_EMBEDDING(1)");

   140             astr = new AttributedString(paragraph);

   141             astr.addAttribute(TextAttribute.RUN_DIRECTION,

   142                               TextAttribute.RUN_DIRECTION_LTR);

   143             astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(1),

   144                               start, limit);

   145             bidi = new Bidi(astr.getIterator());

   146             callTestEachMethod4Constructor1(textNo, testNo, bidi);

   147 

   148             // Test 2

   149             ++testNo;

   150             System.out.println(" Test#" + testNo +

   151                 ": RUN_DIERCTION_LTR, BIDI_EMBEDDING(2)");

   152             astr = new AttributedString(paragraph);

   153             astr.addAttribute(TextAttribute.RUN_DIRECTION,

   154                               TextAttribute.RUN_DIRECTION_LTR);

   155             astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(2),

   156                               start, limit);

   157             bidi = new Bidi(astr.getIterator());

   158             callTestEachMethod4Constructor1(textNo, testNo, bidi);

   159 

   160             // Test 3

   161             ++testNo;

   162             System.out.println(" Test#" + testNo +

   163                 ": RUN_DIRECTIOIN_LTR, BIDI_EMBEDDING(-3)");

   164             astr = new AttributedString(paragraph);

   165             astr.addAttribute(TextAttribute.RUN_DIRECTION,

   166                               TextAttribute.RUN_DIRECTION_LTR);

   167             astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(-3),

   168                               start, limit);

   169             bidi = new Bidi(astr.getIterator());

   170             callTestEachMethod4Constructor1(textNo, testNo, bidi);

   171 

   172             // Test 4

   173             ++testNo;

   174             System.out.println(" Test#" + testNo +

   175                 ": RUN_DIRECTION_LTR, BIDI_EMBEDDING(-4)");

   176             astr = new AttributedString(paragraph);

   177             astr.addAttribute(TextAttribute.RUN_DIRECTION,

   178                               TextAttribute.RUN_DIRECTION_LTR);

   179             astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(-4),

   180                               start, limit);

   181             bidi = new Bidi(astr.getIterator());

   182             callTestEachMethod4Constructor1(textNo, testNo, bidi);

   183 

   184             // Test 5

   185             ++testNo;

   186             System.out.println(" Test#" + testNo + ": RUN_DIRECTION_RTL");

   187             astr = new AttributedString(paragraph);

   188             astr.addAttribute(TextAttribute.RUN_DIRECTION,

   189                               TextAttribute.RUN_DIRECTION_RTL);

   190             bidi = new Bidi(astr.getIterator());

   191             callTestEachMethod4Constructor1(textNo, testNo, bidi);

   192 

   193             // Test 6

   194             ++testNo;

   195             System.out.println(" Test#" + testNo +

   196                 ": RUN_DIRECTION_RTL, BIDI_EMBEDDING(1)");

   197             astr = new AttributedString(paragraph);

   198             astr.addAttribute(TextAttribute.RUN_DIRECTION,

   199                               TextAttribute.RUN_DIRECTION_RTL);

   200             astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(1),

   201                               start, limit);

   202             try {

   203                 bidi = new Bidi(astr.getIterator());

   204                 callTestEachMethod4Constructor1(textNo, testNo, bidi);

   205             }

   206             catch (IllegalArgumentException e) {

   207                 errorHandling("  Unexpected exception: " + e);

   208             }

   209 

   210             // Test 7

   211             ++testNo;

   212             System.out.println(" Test#" + testNo +

   213                 ": RUN_DIRECTION_RTL, BIDI_EMBEDDING(2)");

   214             astr = new AttributedString(paragraph);

   215             astr.addAttribute(TextAttribute.RUN_DIRECTION,

   216                               TextAttribute.RUN_DIRECTION_RTL);

   217             astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(2),

   218                               start, limit);

   219             try {

   220                 bidi = new Bidi(astr.getIterator());

   221                 callTestEachMethod4Constructor1(textNo, testNo, bidi);

   222             }

   223             catch (IllegalArgumentException e) {

   224                 errorHandling("  Unexpected exception: " + e);

   225             }

   226 

   227             // Test 8

   228             ++testNo;

   229             System.out.println(" Test#" + testNo +

   230                 ": RUN_DIRECTION_RTL, BIDI_EMBEDDING(-3)");

   231             astr = new AttributedString(paragraph);

   232             astr.addAttribute(TextAttribute.RUN_DIRECTION,

   233                               TextAttribute.RUN_DIRECTION_RTL);

   234             astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(-3),

   235                               start, limit);

   236             try {

   237                 bidi = new Bidi(astr.getIterator());

   238                 callTestEachMethod4Constructor1(textNo, testNo, bidi);

   239             }

   240             catch (IllegalArgumentException e) {

   241                 errorHandling("  Unexpected exception: " + e);

   242             }

   243 

   244             // Test 9

   245             ++testNo;

   246             System.out.println(" Test#" + testNo +

   247                 ": RUN_DIRECTION_RTL, BIDI_EMBEDDING(-4)");

   248             astr = new AttributedString(paragraph);

   249             astr.addAttribute(TextAttribute.RUN_DIRECTION,

   250                               TextAttribute.RUN_DIRECTION_RTL);

   251             astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(-4),

   252                               start, limit);

   253             try {

   254                 bidi = new Bidi(astr.getIterator());

   255                 callTestEachMethod4Constructor1(textNo, testNo, bidi);

   256             }

   257             catch (IllegalArgumentException e) {

   258                 errorHandling("  Unexpected exception: " + e);

   259             }

   260 

   261             // Test 10

   262             ++testNo;

   263             System.out.println(" Test#" + testNo +

   264                 ": TextAttribute not specified");

   265             astr = new AttributedString(paragraph);

   266             bidi = new Bidi(astr.getIterator());

   267             callTestEachMethod4Constructor1(textNo, testNo, bidi);

   268 

   269             // Test 11

   270             ++testNo;

   271             System.out.println(" Test#" + testNo +

   272                 ": RUN_DIRECTION_LTR, NUMERIC_SHAPING(ARABIC)");

   273             astr = new AttributedString(paragraph);

   274             astr.addAttribute(TextAttribute.RUN_DIRECTION,

   275                               TextAttribute.RUN_DIRECTION_LTR);

   276             astr.addAttribute(TextAttribute.NUMERIC_SHAPING, ns);

   277             bidi = new Bidi(astr.getIterator());

   278             callTestEachMethod4Constructor1(textNo, testNo, bidi);

   279 

   280             // Test 12

   281             ++testNo;

   282             System.out.println(" Test#" + testNo +

   283                  ": RUN_DIRECTION_RTL, NUMERIC_SHAPING(ARABIC)");

   284             astr = new AttributedString(paragraph);

   285             astr.addAttribute(TextAttribute.RUN_DIRECTION,

   286                               TextAttribute.RUN_DIRECTION_RTL);

   287             astr.addAttribute(TextAttribute.NUMERIC_SHAPING, ns);

   288             bidi = new Bidi(astr.getIterator());

   289             callTestEachMethod4Constructor1(textNo, testNo, bidi);

   290         }

   291     }

   292 

   293     private void testMethods4Constructor2() {

   294         System.out.println("*** Test methods for constructor 2");

   295 

   296         String paragraph;

   297         Bidi bidi;

   298 

   299         for (int textNo = 0; textNo < data4Constructor2.length; textNo++) {

   300             paragraph = data4Constructor2[textNo][0];

   301             for (int flagNo = 0; flagNo < FLAGS.length; flagNo++) {

   302                 int flag = FLAGS[flagNo];

   303 

   304                 System.out.println("*** Test textNo=" + textNo +

   305                     ": Bidi(\"" + toReadableString(paragraph) +

   306                     "\", " + getFlagName(flag) + ")");

   307 

   308                 bidi = new Bidi(paragraph, flag);

   309                 callTestEachMethod4Constructor2(textNo, flagNo, bidi);

   310             }

   311         }

   312     }

   313 

   314     private void testMethods4Constructor3() {

   315         System.out.println("*** Test methods for constructor 3");

   316 

   317         String paragraph;

   318         Bidi bidi;

   319 

   320         for (int textNo = 0; textNo < data4Constructor3.length; textNo++) {

   321             paragraph = data4Constructor3[textNo][0];

   322             char[] c = paragraph.toCharArray();

   323             int start = paragraph.indexOf('<')+1;

   324             byte[][] embeddings = (c.length < emb4Constructor3[1][0].length) ?

   325                                   emb4Constructor3[0] : emb4Constructor3[1];

   326             for (int flagNo = 0; flagNo < FLAGS.length; flagNo++) {

   327                 int flag = FLAGS[flagNo];

   328                 for (int embNo = 0; embNo < embeddings.length; embNo++) {

   329                     int dataNo = flagNo * FLAGS.length + embNo;

   330 

   331                     System.out.println("*** Test textNo=" + textNo +

   332                         ": Bidi(char[]\"" + toReadableString(paragraph) +

   333                         "\", 0, embeddings={" + toString(embeddings[embNo]) +

   334                         "}, " + c.length + ", " +

   335                        getFlagName(flag) + ")" + "  dataNo=" + dataNo);

   336 

   337                     try {

   338                         bidi = new Bidi(c, 0, embeddings[embNo], 0,

   339                                         c.length, flag);

   340                         callTestEachMethod4Constructor3(textNo, dataNo, bidi);

   341                     }

   342                     catch (Exception e) {

   343                         errorHandling("  Unexpected exception: " + e);

   344                     }

   345                 }

   346             }

   347         }

   348     }

   349 

   350     private void testConstructor1() {

   351         Bidi bidi;

   352 

   353         try {

   354             bidi = new Bidi(null);

   355             errorHandling("Bidi((AttributedCharacterIterator)null) " +

   356                 "should throw an IAE.");

   357         }

   358         catch (IllegalArgumentException e) {

   359         }

   360         catch (NullPointerException e) {

   361             errorHandling("Bidi((AttributedCharacterIterator)null) " +

   362                 "should not throw an NPE but an IAE.");

   363         }

   364 

   365         String paragraph = data4Constructor1[1][0];

   366         int start = paragraph.indexOf('<')+1;

   367         int limit = paragraph.indexOf('>');

   368         AttributedString astr = new AttributedString(paragraph);

   369         astr.addAttribute(TextAttribute.RUN_DIRECTION,

   370                           TextAttribute.RUN_DIRECTION_RTL);

   371         astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(-61),

   372                           start, limit);

   373         try {

   374             bidi = new Bidi(astr.getIterator());

   375             for (int i = start; i < limit; i++) {

   376                 if (bidi.getLevelAt(i) != 61) {

   377                     errorHandling("Bidi(AttributedCharacterIterator).getLevelAt(" +

   378                         i + ") should not be " + bidi.getLevelAt(i) +

   379                         " but 60 when BIDI_EMBEDDING is -61.");

   380                 }

   381             }

   382         }

   383         catch (Exception e) {

   384             errorHandling("  Unexpected exception: " + e);

   385         }

   386 

   387         astr = new AttributedString(paragraph);

   388         astr.addAttribute(TextAttribute.RUN_DIRECTION,

   389                           TextAttribute.RUN_DIRECTION_RTL);

   390         astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(-62),

   391                           start, limit);

   392         try {

   393             bidi = new Bidi(astr.getIterator());

   394             for (int i = start; i < limit; i++) {

   395                 if (bidi.getLevelAt(i) != 1) {

   396                     errorHandling("Bidi(AttributedCharacterIterator).getLevelAt() " +

   397                         "should be 1 when BIDI_EMBEDDING is -62.");

   398                 }

   399             }

   400         }

   401         catch (Exception e) {

   402             errorHandling("  Unexpected exception: " + e);

   403         }

   404 

   405         astr = new AttributedString(paragraph);

   406         astr.addAttribute(TextAttribute.RUN_DIRECTION,

   407                           TextAttribute.RUN_DIRECTION_RTL);

   408         astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(60),

   409                           start, limit);

   410         try {

   411             bidi = new Bidi(astr.getIterator());

   412             for (int i = start; i < limit; i++) {

   413                 if (bidi.getLevelAt(i) != 61) {

   414                     errorHandling("Bidi(AttributedCharacterIterator).getLevelAt() " +

   415                         "should be 61 when BIDI_EMBEDDING is 60.");

   416                 }

   417             }

   418         }

   419         catch (Exception e) {

   420             errorHandling("  Unexpected exception: " + e);

   421         }

   422 

   423         astr = new AttributedString(paragraph);

   424         astr.addAttribute(TextAttribute.RUN_DIRECTION,

   425                           TextAttribute.RUN_DIRECTION_RTL);

   426         astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(61),

   427                           start, limit);

   428         try {

   429             bidi = new Bidi(astr.getIterator());

   430             for (int i = start; i < limit; i++) {

   431                 if (bidi.getLevelAt(i) != 61) {

   432                     errorHandling("Bidi(AttributedCharacterIterator).getLevelAt(" +

   433                         i + ") should not be " + bidi.getLevelAt(i) +

   434                         " but 61 when BIDI_EMBEDDING is 61.");

   435                 }

   436             }

   437         }

   438         catch (Exception e) {

   439             errorHandling("  Unexpected exception: " + e);

   440         }

   441 

   442         astr = new AttributedString(paragraph);

   443         astr.addAttribute(TextAttribute.RUN_DIRECTION,

   444                           TextAttribute.RUN_DIRECTION_RTL);

   445         astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(62),

   446                           start, limit);

   447         try {

   448             bidi = new Bidi(astr.getIterator());

   449             for (int i = start; i < limit; i++) {

   450                 if (bidi.getLevelAt(i) != 1) {

   451                     errorHandling("Bidi(AttributedCharacterIterator).getLevelAt()" +

   452                         " should not be " + bidi.getLevelAt(i) +

   453                         " but 1 when BIDI_EMBEDDING is 62.");

   454                 }

   455             }

   456         }

   457         catch (Exception e) {

   458             errorHandling("  Unexpected exception: " + e);

   459         }

   460     }

   461 

   462     private void testConstructor2() {

   463         Bidi bidi;

   464 

   465         try {

   466             bidi = new Bidi(null, Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);

   467             errorHandling("Bidi((String)null, DIRECTION_DEFAULT_LEFT_TO_RIGHT)" +

   468                 " should throw an IAE.");

   469         }

   470         catch (IllegalArgumentException e) {

   471         }

   472         catch (NullPointerException e) {

   473             errorHandling("Bidi((String)null, DIRECTION_DEFAULT_LEFT_TO_RIGHT) " +

   474                 "should not throw an NPE but an IAE.");

   475         }

   476 

   477         try {

   478             bidi = new Bidi("abc", -3);

   479         }

   480         catch (Exception e) {

   481             errorHandling("Bidi(\"abc\", -3) should not throw an exception: " +

   482                 e);

   483         }

   484 

   485         try {

   486             bidi = new Bidi("abc", 2);

   487         }

   488         catch (Exception e) {

   489             errorHandling("Bidi(\"abc\", 2) should not throw an exception: " +

   490                 e);

   491         }

   492     }

   493 

   494     private void testConstructor3() {

   495         char[] text = {'a', 'b', 'c', 'd', 'e'};

   496         byte[] embeddings = {0, 0, 0, 0, 0};

   497         Bidi bidi;

   498 

   499         try {

   500             bidi = new Bidi(null, 0, embeddings, 0, 5,

   501                             Bidi.DIRECTION_LEFT_TO_RIGHT);

   502             errorHandling("Bidi(char[], ...) should throw an IAE " +

   503                 "when text=null.");

   504         }

   505         catch (IllegalArgumentException e) {

   506         }

   507         catch (NullPointerException e) {

   508             errorHandling("Bidi(char[], ...) should not throw an NPE " +

   509                 "but an IAE when text=null.");

   510         }

   511 

   512         try {

   513             bidi = new Bidi(text, -1, embeddings, 0, 5,

   514                             Bidi.DIRECTION_LEFT_TO_RIGHT);

   515             errorHandling("Bidi(char[], ...) should throw an IAE " +

   516                 "when textStart is incorrect(-1: too small).");

   517         }

   518         catch (IllegalArgumentException e) {

   519         }

   520         catch (ArrayIndexOutOfBoundsException e) {

   521             errorHandling("Bidi(char[], ...) should not throw an NPE " +

   522                 "but an IAE when textStart is incorrect(-1: too small).");

   523         }

   524 

   525         try {

   526             bidi = new Bidi(text, 4, embeddings, 0, 2,

   527                             Bidi.DIRECTION_LEFT_TO_RIGHT);

   528             errorHandling("Bidi(char[], ...) should throw an IAE " +

   529                 "when textStart is incorrect(4: too large).");

   530         }

   531         catch (IllegalArgumentException e) {

   532         }

   533         catch (ArrayIndexOutOfBoundsException e) {

   534             errorHandling("Bidi(char[], ...) should not throw an NPE " +

   535                 "but an IAE when textStart is incorrect(4: too large).");

   536         }

   537 

   538         byte[] actualLevels = new byte[text.length];

   539         byte[] validEmbeddings1 = {0, -61, -60, -2, -1};

   540         byte[] expectedLevels1  = {0,  61,  60,  2,  1};

   541         try {

   542             bidi = new Bidi(text, 0, validEmbeddings1, 0, 5,

   543                             Bidi.DIRECTION_LEFT_TO_RIGHT);

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

   545                 actualLevels[i] = (byte)bidi.getLevelAt(i);

   546             }

   547             if (!Arrays.equals(expectedLevels1, actualLevels)) {

   548                 errorHandling("Bidi(char[], ...).getLevelAt()" +

   549                     " should be {" + toString(actualLevels) +

   550                     "} when embeddings are {" +

   551                     toString(expectedLevels1) + "}.");

   552             }

   553         }

   554         catch (Exception e) {

   555             errorHandling("Bidi(char[], ...) should not throw an exception " +

   556                 "when embeddings is valid(-61).");

   557         }

   558 

   559         byte[] validEmbeddings2 = {0,  61,  60,  2,  1};

   560         byte[] expectedLevels2  = {0,  62,  60,  2,  2};

   561         try {

   562             bidi = new Bidi(text, 0, validEmbeddings2, 0, 5,

   563                             Bidi.DIRECTION_LEFT_TO_RIGHT);

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

   565                 actualLevels[i] = (byte)bidi.getLevelAt(i);

   566             }

   567             if (!Arrays.equals(expectedLevels2, actualLevels)) {

   568                 errorHandling("Bidi(char[], ...).getLevelAt()" +

   569                     " should be {" + toString(actualLevels) +

   570                     "} when embeddings are {" +

   571                     toString(expectedLevels2) + "}.");

   572             }

   573         }

   574         catch (Exception e) {

   575             errorHandling("Bidi(char[], ...) should not throw an exception " +

   576                 "when embeddings is valid(61).");

   577         }

   578 

   579         byte[] invalidEmbeddings1 = {0, -62, 0, 0, 0};

   580         try {

   581             bidi = new Bidi(text, 0, invalidEmbeddings1, 0, 5,

   582                             Bidi.DIRECTION_LEFT_TO_RIGHT);

   583             if (bidi.getLevelAt(1) != 0) {

   584                 errorHandling("Bidi(char[], ...).getLevelAt(1) should be 0 " +

   585                     "when embeddings[1] is -62.");

   586             }

   587         }

   588         catch (Exception e) {

   589             errorHandling("Bidi(char[], ...) should not throw an exception " +

   590                 "even when embeddings includes -62.");

   591         }

   592 

   593         byte[] invalidEmbeddings2 = {0, 62, 0, 0, 0};

   594         try {

   595             bidi = new Bidi(text, 0, invalidEmbeddings2, 0, 5,

   596                             Bidi.DIRECTION_LEFT_TO_RIGHT);

   597             if (bidi.getLevelAt(1) != 0) {

   598                 errorHandling("Bidi(char[], ...).getLevelAt(1) should be 0 " +

   599                     "when embeddings[1] is 62.");

   600             }

   601         }

   602         catch (Exception e) {

   603             errorHandling("Bidi(char[], ...) should not throw an exception " +

   604                 "even when embeddings includes 62.");

   605         }

   606 

   607         try {

   608             bidi = new Bidi(text, 0, embeddings, 0, -1,

   609                             Bidi.DIRECTION_LEFT_TO_RIGHT);

   610             errorHandling("Bidi(char[], ...) should throw an IAE " +

   611                 "when paragraphLength=-1(too small).");

   612         }

   613         catch (IllegalArgumentException e) {

   614         }

   615         catch (NegativeArraySizeException e) {

   616             errorHandling("Bidi(char[], ...) should not throw an NASE " +

   617                 "but an IAE when paragraphLength=-1(too small).");

   618         }

   619 

   620         try {

   621             bidi = new Bidi(text, 0, embeddings, 0, 6,

   622                             Bidi.DIRECTION_LEFT_TO_RIGHT);

   623             errorHandling("Bidi(char[], ...) should throw an IAE " +

   624                 "when paragraphLength=6(too large).");

   625         }

   626         catch (IllegalArgumentException e) {

   627         }

   628         catch (ArrayIndexOutOfBoundsException e) {

   629             errorHandling("Bidi(char[], ...) should not throw an AIOoBE " +

   630                 "but an IAE when paragraphLength=6(too large).");

   631         }

   632 

   633         try {

   634             bidi = new Bidi(text, 0, embeddings, 0, 4, -3);

   635         }

   636         catch (Exception e) {

   637             errorHandling("Bidi(char[], ...) should not throw an exception " +

   638                 "even when flag=-3(too small).");

   639         }

   640 

   641         try {

   642             bidi = new Bidi(text, 0, embeddings, 0, 5, 2);

   643         }

   644         catch (Exception e) {

   645             errorHandling("Bidi(char[], ...) should not throw an exception " +

   646                 "even when flag=2(too large).");

   647         }

   648     }

   649 

   650     private void callTestEachMethod4Constructor1(int textNo,

   651                                                  int testNo,

   652                                                  Bidi bidi) {

   653         testEachMethod(bidi,

   654                        data4Constructor1[textNo][0],

   655                        data4Constructor1[textNo][testNo+1],

   656                        baseIsLTR4Constructor1[textNo][testNo],

   657                        isLTR_isRTL4Constructor1[textNo][0][testNo],

   658                        isLTR_isRTL4Constructor1[textNo][1][testNo]);

   659 System.out.println(bidi.toString());

   660     }

   661 

   662     private void callTestEachMethod4Constructor2(int textNo,

   663                                                  int flagNo,

   664                                                  Bidi bidi) {

   665         testEachMethod(bidi,

   666                        data4Constructor2[textNo][0],

   667                        data4Constructor2[textNo][flagNo+1],

   668                        baseIsLTR4Constructor2[textNo][flagNo],

   669                        isLTR_isRTL4Constructor2[textNo][0][flagNo],

   670                        isLTR_isRTL4Constructor2[textNo][1][flagNo]);

   671 System.out.println(bidi.toString());

   672     }

   673 

   674     private void callTestEachMethod4Constructor3(int textNo,

   675                                                  int dataNo,

   676                                                  Bidi bidi) {

   677         testEachMethod(bidi,

   678                        data4Constructor3[textNo][0],

   679                        data4Constructor3[textNo][dataNo+1],

   680                        baseIsLTR4Constructor3[textNo][dataNo],

   681                        isLTR_isRTL4Constructor3[textNo][0][dataNo],

   682                        isLTR_isRTL4Constructor3[textNo][1][dataNo]);

   683 System.out.println(bidi.toString());

   684     }

   685 

   686     private StringBuilder sb = new StringBuilder();

   687     private void testEachMethod(Bidi bidi,

   688                                 String text,

   689                                 String expectedLevels,

   690                                 boolean expectedBaseIsLTR,

   691                                 boolean expectedIsLTR,

   692                                 boolean expectedIsRTL

   693                                ) {

   694         /* Test baseIsLeftToRight() */

   695         boolean actualBoolean = bidi.baseIsLeftToRight();

   696         checkResult("baseIsLeftToRight()", expectedBaseIsLTR, actualBoolean);

   697 

   698         /* Test getBaseLevel() */

   699         int expectedInt = (expectedBaseIsLTR) ? 0 : 1;

   700         int actualInt = bidi.getBaseLevel();

   701         checkResult("getBaseLevel()", expectedInt, actualInt);

   702 

   703         /* Test getLength() */

   704         expectedInt = text.length();

   705         actualInt = bidi.getLength();

   706         checkResult("getLength()", expectedInt, actualInt);

   707 

   708         /* Test getLevelAt() */

   709         sb.setLength(0);

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

   711             sb.append(bidi.getLevelAt(i));

   712         }

   713         checkResult("getLevelAt()", expectedLevels, sb.toString());

   714 

   715         /* Test getRunCount() */

   716         expectedInt = getRunCount(expectedLevels);

   717         actualInt = bidi.getRunCount();

   718         checkResult("getRunCount()", expectedInt, actualInt);

   719 

   720         /* Test getRunLevel(), getRunLimit() and getRunStart() */

   721         if (expectedInt == actualInt) {

   722             int runCount = expectedInt;

   723             int[] expectedRunLevels = getRunLevels_int(runCount, expectedLevels);

   724             int[] expectedRunLimits = getRunLimits(runCount, expectedLevels);

   725             int[] expectedRunStarts = getRunStarts(runCount, expectedLevels);

   726             int[] actualRunLevels = new int[runCount];

   727             int[] actualRunLimits = new int[runCount];

   728             int[] actualRunStarts = new int[runCount];

   729 

   730             for (int k = 0; k < runCount; k++) {

   731                 actualRunLevels[k] = bidi.getRunLevel(k);

   732                 actualRunLimits[k] = bidi.getRunLimit(k);

   733                 actualRunStarts[k] = bidi.getRunStart(k);

   734             }

   735 

   736             checkResult("getRunLevel()", expectedRunLevels, actualRunLevels);

   737             checkResult("getRunStart()", expectedRunStarts, actualRunStarts);

   738             checkResult("getRunLimit()", expectedRunLimits, actualRunLimits);

   739         }

   740 

   741         /* Test isLeftToRight() */

   742         boolean expectedBoolean = expectedIsLTR;

   743         actualBoolean = bidi.isLeftToRight();

   744         checkResult("isLeftToRight()", expectedBoolean, actualBoolean);

   745 

   746         /* Test isMixed() */

   747         expectedBoolean = !(expectedIsLTR || expectedIsRTL);

   748         actualBoolean = bidi.isMixed();

   749         checkResult("isMixed()", expectedBoolean, actualBoolean);

   750 

   751         /* Test isRightToLeft() */

   752         expectedBoolean = expectedIsRTL;

   753         actualBoolean = bidi.isRightToLeft();

   754         checkResult("isRightToLeft()", expectedBoolean, actualBoolean);

   755     }

   756 

   757     private int getRunCount(String levels) {

   758         int len = levels.length();

   759         char c = levels.charAt(0);

   760         int runCount = 1;

   761 

   762         for (int index = 1; index < len; index++) {

   763             if (levels.charAt(index) != c) {

   764                 runCount++;

   765                 c = levels.charAt(index);

   766             }

   767         }

   768 

   769         return runCount;

   770     }

   771 

   772     private int[] getRunLevels_int(int runCount, String levels) {

   773         int[] array = new int[runCount];

   774         int len = levels.length();

   775         char c = levels.charAt(0);

   776         int i = 0;

   777         array[i++] = c - '0';

   778 

   779         for (int index = 1; index < len; index++) {

   780             if (levels.charAt(index) != c) {

   781                 c = levels.charAt(index);

   782                 array[i++] = c - '0';

   783             }

   784         }

   785 

   786         return array;

   787     }

   788 

   789     private byte[] getRunLevels_byte(int runCount, String levels) {

   790         byte[] array = new byte[runCount];

   791         int len = levels.length();

   792         char c = levels.charAt(0);

   793         int i = 0;

   794         array[i++] = (byte)(c - '0');

   795 

   796         for (int index = 1; index < len; index++) {

   797             if (levels.charAt(index) != c) {

   798                 c = levels.charAt(index);

   799                 array[i++] = (byte)(c - '0');

   800             }

   801         }

   802 

   803         return array;

   804     }

   805 

   806     private int[] getRunLimits(int runCount, String levels) {

   807         int[] array = new int[runCount];

   808         int len = levels.length();

   809         char c = levels.charAt(0);

   810         int i = 0;

   811 

   812         for (int index = 1; index < len; index++) {

   813             if (levels.charAt(index) != c) {

   814                 c = levels.charAt(index);

   815                 array[i++] = index;

   816             }

   817         }

   818         array[i] = len;

   819 

   820         return array;

   821     }

   822 

   823     private int[] getRunStarts(int runCount, String levels) {

   824         int[] array = new int[runCount];

   825         int len = levels.length();

   826         char c = levels.charAt(0);

   827         int i = 1;

   828 

   829         for (int index = 1; index < len; index++) {

   830             if (levels.charAt(index) != c) {

   831                 c = levels.charAt(index);

   832                 array[i++] = index;

   833             }

   834         }

   835 

   836         return array;

   837     }

   838 

   839     private String[] getObjects(int runCount, String text, String levels) {

   840         String[] array = new String[runCount];

   841         int[] runLimits = getRunLimits(runCount, levels);

   842         int runStart = 0;

   843 

   844         for (int i = 0; i < runCount; i++) {

   845             array[i] = text.substring(runStart, runLimits[i]);

   846             runStart = runLimits[i];

   847         }

   848 

   849         return array;

   850     }

   851 

   852     private void testMethod_createLineBidi1() {

   853         System.out.println("*** Test createLineBidi() 1");

   854 

   855         String str = " ABC 123. " + HebrewABC + " " + NKo123 + ". ABC 123";

   856 

   857         int lineStart = str.indexOf('.') + 2;

   858         int lineLimit = str.lastIndexOf('.') + 2;

   859         Bidi bidi = new Bidi(str, FLAGS[0]);

   860         Bidi lineBidi = bidi.createLineBidi(lineStart, lineLimit);

   861 

   862         checkResult("getBaseLevel()",

   863             bidi.getBaseLevel(), lineBidi.getBaseLevel());

   864         checkResult("getLevelAt(5)",

   865             bidi.getLevelAt(lineStart+5), lineBidi.getLevelAt(5));

   866     }

   867 

   868     private void testMethod_createLineBidi2() {

   869         System.out.println("*** Test createLineBidi() 2");

   870 

   871         Bidi bidi = new Bidi(data4Constructor1[0][0], FLAGS[0]);

   872         int len = data4Constructor1[0][0].length();

   873 

   874         try {

   875             Bidi lineBidi = bidi.createLineBidi(0, len);

   876         }

   877         catch (Exception e) {

   878             errorHandling("createLineBidi(0, textLength)" +

   879                 " should not throw an exception.");

   880         }

   881 

   882         try {

   883             Bidi lineBidi = bidi.createLineBidi(-1, len);

   884             errorHandling("createLineBidi(-1, textLength)" +

   885                 " should throw an IAE.");

   886         }

   887         catch (IllegalArgumentException e) {

   888         }

   889 

   890         try {

   891             Bidi lineBidi = bidi.createLineBidi(0, len+1);

   892             errorHandling("createLineBidi(0, textLength+1)" +

   893                 " should throw an IAE.");

   894         }

   895         catch (IllegalArgumentException e) {

   896         }

   897     }

   898 

   899     /*

   900      * Confirm that getLevelAt() doesn't throw an exception for invalid offset

   901      * unlike ICU4J.

   902      */

   903     private void testMethod_getLevelAt() {

   904         System.out.println("*** Test getLevelAt()");

   905 

   906         Bidi bidi = new Bidi(data4Constructor1[1][0], FLAGS[0]);

   907         int len = data4Constructor1[1][0].length();

   908 

   909         try {

   910             int level = bidi.getLevelAt(-1);

   911             if (level != bidi.getBaseLevel()) {

   912                 errorHandling("getLevelAt(-1) returned a wrong level." +

   913                     " Expected=" + bidi.getBaseLevel() + ", got=" + level);

   914             }

   915         }

   916         catch (Exception e) {

   917             errorHandling("getLevelAt(-1) should not throw an exception.");

   918         }

   919 

   920         try {

   921             int level = bidi.getLevelAt(len+1);

   922             if (level != bidi.getBaseLevel()) {

   923                 errorHandling("getLevelAt(textLength+1)" +

   924                     " returned a wrong level." +

   925                     " Expected=" + bidi.getBaseLevel() + ", got=" + level);

   926             }

   927         }

   928         catch (Exception e) {

   929             errorHandling("getLevelAt(-1) should not throw an exception.");

   930         }

   931     }

   932 

   933     private void testMethod_getRunLevel() {

   934         System.out.println("*** Test getRunLevel()");

   935 

   936         String str = "ABC 123";

   937         int length = str.length();

   938         Bidi bidi = new Bidi(str, Bidi.DIRECTION_LEFT_TO_RIGHT);

   939 

   940         try {

   941             if (bidi.getRunLevel(-1) != 0 ||  // runCount - 2

   942                 bidi.getRunLevel(0) != 0 ||   // runCount - 1

   943                 bidi.getRunLevel(1) != 0 ||   // runCount

   944                 bidi.getRunLevel(2) != 0) {   // runCount + 1

   945                 errorHandling("getRunLevel() should return 0" +

   946                     " when getRunCount() is 1.");

   947             }

   948         }

   949         catch (Exception e) {

   950             errorHandling("getRunLevel() should not throw an exception " +

   951                 "when getRunCount() is 1.");

   952         }

   953 

   954         str = "ABC " + HebrewABC + " 123";

   955         length = str.length();

   956         bidi = new Bidi(str, Bidi.DIRECTION_LEFT_TO_RIGHT);

   957 

   958         try {

   959             bidi.getRunLevel(-1);

   960             errorHandling("getRunLevel() should throw an AIOoBE " +

   961                 "when run is -1(too small).");

   962         }

   963         catch (ArrayIndexOutOfBoundsException e) {

   964         }

   965         catch (IllegalArgumentException e) {

   966             errorHandling("getRunLevel() should not throw an IAE " +

   967                 "but an AIOoBE when run is -1(too small).");

   968         }

   969 

   970         try {

   971             bidi.getRunLevel(0);

   972             bidi.getRunLevel(1);

   973             bidi.getRunLevel(2);

   974         }

   975         catch (Exception e) {

   976             errorHandling("getRunLevel() should not throw an exception" +

   977                 " when run is from 0 to 2(runCount-1).");

   978         }

   979 

   980         try {

   981             bidi.getRunLevel(3);

   982             errorHandling("getRunLevel() should throw an AIOoBE" +

   983                 " when run is 3(same as runCount).");

   984         }

   985         catch (ArrayIndexOutOfBoundsException e) {

   986         }

   987         catch (IllegalArgumentException e) {

   988             errorHandling("getRunLevel() should not throw an IAE " +

   989                 "but an AIOoBE when run is 3(same as runCount).");

   990         }

   991     }

   992 

   993     private void testMethod_getRunLimit() {

   994         System.out.println("*** Test getRunLimit()");

   995 

   996         String str = "ABC 123";

   997         int length = str.length();

   998         Bidi bidi = new Bidi(str, Bidi.DIRECTION_LEFT_TO_RIGHT);

   999 

  1000         try {

  1001             if (bidi.getRunLimit(-1) != length ||  // runCount - 2

  1002                 bidi.getRunLimit(0) != length ||   // runCount - 1

  1003                 bidi.getRunLimit(1) != length ||   // runCount

  1004                 bidi.getRunLimit(2) != length) {   // runCount + 1

  1005                 errorHandling("getRunLimit() should return " + length +

  1006                     " when getRunCount() is 1.");

  1007             }

  1008         }

  1009         catch (Exception e) {

  1010             errorHandling("getRunLimit() should not throw an exception " +

  1011                 "when getRunCount() is 1.");

  1012         }

  1013 

  1014         str = "ABC " + ArabicABC + " 123";

  1015         length = str.length();

  1016         bidi = new Bidi(str, Bidi.DIRECTION_LEFT_TO_RIGHT);

  1017 

  1018         try {

  1019             bidi.getRunLimit(-1);

  1020             errorHandling("getRunLimit() should throw an AIOoBE " +

  1021                 "when run is -1(too small).");

  1022         }

  1023         catch (ArrayIndexOutOfBoundsException e) {

  1024         }

  1025         catch (IllegalArgumentException e) {

  1026             errorHandling("getRunLimit() should not throw an IAE " +

  1027                 "but an AIOoBE when run is -1(too small).");

  1028         }

  1029 

  1030         try {

  1031             bidi.getRunLimit(0);

  1032             bidi.getRunLimit(1);

  1033             bidi.getRunLimit(2);

  1034         }

  1035         catch (ArrayIndexOutOfBoundsException e) {

  1036             errorHandling("getRunLimit() should not throw an AIOOBE " +

  1037                 "when run is from 0 to 2(runCount-1).");

  1038         }

  1039 

  1040         try {

  1041             bidi.getRunLimit(3);

  1042             errorHandling("getRunLimit() should throw an AIOoBE " +

  1043                 "when run is 3(same as runCount).");

  1044         }

  1045         catch (ArrayIndexOutOfBoundsException e) {

  1046         }

  1047         catch (IllegalArgumentException e) {

  1048             errorHandling("getRunLimit() should not throw an IAE " +

  1049                 "but an AIOoBE when run is 3(same as runCount).");

  1050         }

  1051     }

  1052 

  1053     private void testMethod_getRunStart() {

  1054         System.out.println("*** Test getRunStart()");

  1055 

  1056         String str = "ABC 123";

  1057         int length = str.length();

  1058         Bidi bidi = new Bidi(str, Bidi.DIRECTION_LEFT_TO_RIGHT);

  1059 

  1060         try {

  1061             if (bidi.getRunStart(-1) != 0 ||  // runCount - 2

  1062                 bidi.getRunStart(0) != 0 ||   // runCount - 1

  1063                 bidi.getRunStart(1) != 0 ||   // runCount

  1064                 bidi.getRunStart(2) != 0) {   // runCount + 1

  1065                 errorHandling("getRunStart() should return 0" +

  1066                     " when getRunCount() is 1.");

  1067             }

  1068         }

  1069         catch (Exception e) {

  1070             errorHandling("getRunLimit() should not throw an exception" +

  1071                 " when getRunCount() is 1.");

  1072         }

  1073 

  1074         str = "ABC " + NKoABC + " 123";

  1075         length = str.length();

  1076         bidi = new Bidi(str, Bidi.DIRECTION_LEFT_TO_RIGHT);

  1077 

  1078         try {

  1079             bidi.getRunStart(-1);

  1080             errorHandling("getRunStart() should throw an AIOoBE" +

  1081                 " when run is -1(too small).");

  1082         }

  1083         catch (ArrayIndexOutOfBoundsException e) {

  1084         }

  1085         catch (IllegalArgumentException e) {

  1086             errorHandling("getRunStart() should not throw an IAE " +

  1087                 "but an AIOoBE when run is -1(too small).");

  1088         }

  1089 

  1090         try {

  1091             bidi.getRunStart(0);

  1092             bidi.getRunStart(1);

  1093             bidi.getRunStart(2);

  1094         }

  1095         catch (ArrayIndexOutOfBoundsException e) {

  1096             errorHandling("getRunStart() should not throw an AIOOBE " +

  1097                 "when run is from 0 to 2(runCount-1).");

  1098         }

  1099 

  1100         try {

  1101             if (bidi.getRunStart(3) != length) {

  1102                 errorHandling("getRunStart() should return " + length +

  1103                     " when run is 3(same as runCount).");

  1104             }

  1105         }

  1106         catch (Exception e) {

  1107             errorHandling("getRunStart() should not throw an exception " +

  1108                 "when run is 3(same as runCount).");

  1109         }

  1110 

  1111         try {

  1112             bidi.getRunStart(4);

  1113             errorHandling("getRunStart() should throw an AIOoBE " +

  1114                 "when run is runCount+1(too large).");

  1115         }

  1116         catch (ArrayIndexOutOfBoundsException e) {

  1117         }

  1118         catch (IllegalArgumentException e) {

  1119             errorHandling("getRunStart() should not throw an IAE " +

  1120                 "but an AIOoBE when run is runCount+1(too large).");

  1121         }

  1122     }

  1123 

  1124     private void testMethod_reorderVisually1() {

  1125         System.out.println("*** Test reorderVisually() 1");

  1126 

  1127         for (int textNo = 0; textNo < data4reorderVisually.length; textNo++) {

  1128             Object[] objects = data4reorderVisually[textNo][0];

  1129             byte[] levels = getLevels(data4reorderVisually[textNo]);

  1130             Object[] expectedObjects = data4reorderVisually[textNo][2];

  1131 

  1132             Bidi.reorderVisually(levels, 0, objects, 0, objects.length);

  1133 

  1134             checkResult("textNo=" + textNo + ": reorderVisually(levels=[" +

  1135                 toString(levels) + "], objects=[" + toString(objects) + "])",