jars/icu4j-52_1/main/tests/core/src/com/ibm/icu/dev/test/bidi/TestMultipleParagraphs.java

   1 /*
   2 *******************************************************************************
   3 *   Copyright (C) 2008-2010, International Business Machines
   4 *   Corporation and others.  All Rights Reserved.
   5 *******************************************************************************
   6 */
   7
   8 package com.ibm.icu.dev.test.bidi;
   9
  10 import java.util.Arrays;
  11
  12 import com.ibm.icu.impl.Utility;
  13 import com.ibm.icu.text.Bidi;
  14 import com.ibm.icu.text.BidiRun;
  15
  16 /**
  17  * Regression test for Bidi multiple paragraphs
  18  *
  19  * @author Lina Kemmel, Matitiahu Allouche
  20  */
  21
  22 public class TestMultipleParagraphs extends BidiTest {
  23
  24     private static final String text =
  25         "__ABC\u001c"                  /* Para #0 offset 0 */
  26         + "__\u05d0DE\u001c"           /*       1        6 */
  27         + "__123\u001c"                /*       2       12 */
  28         + "\r\n"                       /*       3       18 */
  29         + "FG\r"                       /*       4       20 */
  30         + "\r"                         /*       5       23 */
  31         + "HI\r\n"                     /*       6       24 */
  32         + "\r\n"                       /*       7       28 */
  33         + "\n"                         /*       8       30 */
  34         + "\n"                         /*       9       31 */
  35         + "JK\u001c";                  /*      10       32 */
  36     private static final int paraCount = 11;
  37     private static final int[] paraBounds = {
  38         0, 6, 12, 18, 20, 23, 24, 28, 30, 31, 32, 35
  39     };
  40     private static final byte[] paraLevels = {
  41         Bidi.LTR, Bidi.RTL, Bidi.LEVEL_DEFAULT_LTR, Bidi.LEVEL_DEFAULT_RTL, 22, 23
  42     };
  43     private static final byte[][] multiLevels = {
  44         {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  45         {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
  46         {0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  47         {0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0},
  48         {22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22},
  49         {23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23}
  50     };
  51     private static final String text2 = "\u05d0 1-2\u001c\u0630 1-2\u001c1-2";
  52     private static final byte[] levels2 = {
  53         1, 1, 2, 2, 2, 0, 1, 1, 2, 1, 2, 0, 2, 2, 2
  54     };
  55     private static final char[] multiparaTestString = {
  56         0x5de, 0x5e0, 0x5e1, 0x5d4, 0x20,  0x5e1, 0x5e4, 0x5da,
  57         0x20,  0xa,   0xa,   0x41,  0x72,  0x74,  0x69,  0x73,
  58         0x74,  0x3a,  0x20,  0x5de, 0x5e0, 0x5e1, 0x5d4, 0x20,
  59         0x5e1, 0x5e4, 0x5da, 0x20,  0xa,   0xa,   0x41,  0x6c,
  60         0x62,  0x75,  0x6d,  0x3a,  0x20,  0x5de, 0x5e0, 0x5e1,
  61         0x5d4, 0x20,  0x5e1, 0x5e4, 0x5da, 0x20,  0xa,   0xa,
  62         0x54,  0x69,  0x6d,  0x65,  0x3a,  0x20,  0x32,  0x3a,
  63         0x32,  0x37,  0xa,  0xa
  64     };
  65     private static final byte[] multiparaTestLevels = {
  66         1, 1, 1, 1, 1, 1, 1, 1,
  67         1, 1, 0, 0, 0, 0, 0, 0,
  68         0, 0, 0, 1, 1, 1, 1, 1,
  69         1, 1, 1, 0, 0, 0, 0, 0,
  70         0, 0, 0, 0, 0, 1, 1, 1,
  71         1, 1, 1, 1, 1, 0, 0, 0,
  72         0, 0, 0, 0, 0, 0, 0, 0,
  73         0, 0, 0, 0
  74     };
  75
  76     public void testMultipleParagraphs()
  77     {
  78         byte gotLevel;
  79         byte[] gotLevels;
  80         boolean orderParagraphsLTR;
  81         String src;
  82         Bidi bidi = new Bidi();
  83         Bidi bidiLine;
  84         int count, paraStart, paraLimit, paraIndex, length;
  85         int i, j, k;
  86
  87         logln("\nEntering TestMultipleParagraphs\n");
  88         try {
  89             bidi.setPara(text, Bidi.LTR, null);
  90         } catch (IllegalArgumentException e) {
  91             errln("1st Bidi.setPara failed, paraLevel = " + Bidi.LTR);
  92         }
  93
  94         /* check paragraph count and boundaries */
  95         if (paraCount != (count = bidi.countParagraphs())) {
  96             errln("1st Bidi.countParagraphs returned " + count + ", should be " +
  97                   paraCount);
  98         }
  99         BidiRun run;
 100         for (i = 0; i < paraCount; i++) {
 101             run = bidi.getParagraphByIndex(i);
 102             paraStart = run.getStart();
 103             paraLimit = run.getLimit();
 104             if ((paraStart != paraBounds[i]) ||
 105                 (paraLimit != paraBounds[i + 1])) {
 106                 errln("Found boundaries of paragraph " + i + ": " +
 107                       paraStart + "-" + paraLimit + "; expected: " +
 108                       paraBounds[i] + "-" + paraBounds[i + 1]);
 109             }
 110         }
 111
 112         /* check with last paragraph not terminated by B */
 113         char[] chars = text.toCharArray();
 114         chars[chars.length - 1] = 'L';
 115         src = new String(chars);
 116         try {
 117             bidi.setPara(src, Bidi.LTR, null);
 118         } catch (IllegalArgumentException e) {
 119             errln("2nd Bidi.setPara failed, paraLevel = " + Bidi.LTR);
 120         }
 121         if (paraCount != (count = bidi.countParagraphs())) {
 122             errln("2nd Bidi.countParagraphs returned " + count +
 123                   ", should be " + paraCount);
 124         }
 125         i = paraCount - 1;
 126         run = bidi.getParagraphByIndex(i);
 127         paraStart = run.getStart();
 128         paraLimit = run.getLimit();
 129         if ((paraStart != paraBounds[i]) ||
 130             (paraLimit != paraBounds[i + 1])) {
 131             errln("2nd Found boundaries of paragraph " + i + ": " +
 132                   paraStart + "-" + paraLimit + "; expected: " +
 133                   paraBounds[i] + "-" + paraBounds[i + 1]);
 134         }
 135
 136         /* check paraLevel for all paragraphs under various paraLevel specs */
 137         for (k = 0; k < 6; k++) {
 138             try {
 139                 bidi.setPara(src, paraLevels[k], null);
 140             } catch (IllegalArgumentException e) {
 141                 errln("3nd Bidi.setPara failed, paraLevel = " + paraLevels[k]);
 142             }
 143             for (i = 0; i < paraCount; i++) {
 144                 paraIndex = bidi.getParagraphIndex(paraBounds[i]);
 145                 run = bidi.getParagraph(paraBounds[i]);
 146                 if (paraIndex != i) {
 147                     errln("#1 For paraLevel = " + paraLevels[k] +
 148                           " paragraph = " + i + ", found paragraph" +
 149                           " index = " + paraIndex + " expected = " + i);
 150                 }
 151                 gotLevel = run.getEmbeddingLevel();
 152                 if (gotLevel != multiLevels[k][i]) {
 153                     errln("#2 For paraLevel = " + paraLevels[k] +
 154                           " paragraph = " + i + ", found level = " + gotLevel +
 155                           ", expected = " + multiLevels[k][i]);
 156                 }
 157             }
 158             gotLevel = bidi.getParaLevel();
 159             if (gotLevel != multiLevels[k][0]) {
 160                 errln("#3 For paraLevel = " + paraLevels[k] +
 161                       " getParaLevel = " + gotLevel + ", expected " +
 162                       multiLevels[k][0]);
 163             }
 164         }
 165
 166         /* check that the result of Bidi.getParaLevel changes if the first
 167          * paragraph has a different level
 168          */
 169         chars[0] = '\u05d2';            /* Hebrew letter Gimel */
 170         src = new String(chars);
 171         try {
 172             bidi.setPara(src, Bidi.LEVEL_DEFAULT_LTR, null);
 173         } catch (IllegalArgumentException e) {
 174             errln("Bidi.setPara failed, paraLevel = " + Bidi.LEVEL_DEFAULT_LTR);
 175         }
 176         gotLevel = bidi.getParaLevel();
 177         if (gotLevel != Bidi.RTL) {
 178             errln("#4 For paraLevel = Bidi.LEVEL_DEFAULT_LTR getParaLevel = " +
 179                   gotLevel + ", expected = " + Bidi.RTL);
 180         }
 181
 182         /* check that line cannot overlap paragraph boundaries */
 183         bidiLine = new Bidi();
 184         i = paraBounds[1];
 185         k = paraBounds[2] + 1;
 186         try {
 187             bidiLine = bidi.setLine(i, k);
 188             errln("For line limits " + i + "-" + k
 189                     + " got success, while expected failure");
 190         } catch (Exception e) {}
 191
 192         i = paraBounds[1];
 193         k = paraBounds[2];
 194         try {
 195             bidiLine = bidi.setLine(i, k);
 196         } catch (Exception e) {
 197             errln("For line limits " + i + "-" + k + " got failure");
 198         }
 199
 200         /* check level of block separator at end of paragraph when orderParagraphsLTR==FALSE */
 201         try {
 202             bidi.setPara(src, Bidi.RTL, null);
 203         } catch (IllegalArgumentException e) {
 204             errln("Bidi.setPara failed, paraLevel = " + Bidi.RTL);
 205         }
 206         /* get levels through para Bidi block */
 207         try {
 208             gotLevels = bidi.getLevels();
 209         } catch (Exception e) {
 210             errln("Error on Bidi.getLevels");
 211             gotLevels = new byte[bidi.getLength()];
 212             Arrays.fill(gotLevels, (byte)-1);
 213         }
 214         for (i = 26; i < 32; i++) {
 215             if (gotLevels[i] != Bidi.RTL) {
 216                 errln("For char " + i + "(0x" + Utility.hex(chars[i]) +
 217                       "), level = " + gotLevels[i] + ", expected = " + Bidi.RTL);
 218             }
 219         }
 220         /* get levels through para Line block */
 221         i = paraBounds[1];
 222         k = paraBounds[2];
 223         try {
 224             bidiLine = bidi.setLine(i, k);
 225         } catch (Exception e) {
 226             errln("For line limits " + i + "-" + k + " got failure");
 227             return;
 228         }
 229         paraIndex = bidiLine.getParagraphIndex(i);
 230         run = bidiLine.getParagraph(i);
 231         try {
 232             gotLevels = bidiLine.getLevels();
 233         } catch (Exception e) {
 234             errln("Error on bidiLine.getLevels");
 235             gotLevels = new byte[bidiLine.getLength()];
 236             Arrays.fill(gotLevels, (byte)-1);
 237         }
 238         length = bidiLine.getLength();
 239         gotLevel = run.getEmbeddingLevel();
 240         if ((gotLevel != Bidi.RTL) || (gotLevels[length - 1] != Bidi.RTL)) {
 241             errln("For paragraph " + paraIndex + " with limits " +
 242                   run.getStart() + "-" + run.getLimit() +
 243                   ", paraLevel = " + gotLevel +
 244                   "expected = " + Bidi.RTL +
 245                   ", level of separator = " + gotLevels[length - 1] +
 246                   " expected = " + Bidi.RTL);
 247         }
 248         orderParagraphsLTR = bidi.isOrderParagraphsLTR();
 249         assertFalse("orderParagraphsLTR is true", orderParagraphsLTR);
 250         bidi.orderParagraphsLTR(true);
 251         orderParagraphsLTR = bidi.isOrderParagraphsLTR();
 252         assertTrue("orderParagraphsLTR is false", orderParagraphsLTR);
 253
 254         /* check level of block separator at end of paragraph when orderParagraphsLTR==TRUE */
 255         try {
 256             bidi.setPara(src, Bidi.RTL, null);
 257         } catch (IllegalArgumentException e) {
 258             errln("Bidi.setPara failed, paraLevel = " + Bidi.RTL);
 259         }
 260         /* get levels through para Bidi block */
 261         try {
 262             gotLevels = bidi.getLevels();
 263         } catch (Exception e) {
 264             errln("Error on Bidi.getLevels");
 265             gotLevels = new byte[bidi.getLength()];
 266             Arrays.fill(gotLevels, (byte)-1);
 267         }
 268         for (i = 26; i < 32; i++) {
 269             if (gotLevels[i] != 0) {
 270                 errln("For char " + i + "(0x" + Utility.hex(chars[i]) +
 271                       "), level = "+ gotLevels[i] + ", expected = 0");
 272             }
 273         }
 274         /* get levels through para Line block */
 275         i = paraBounds[1];
 276         k = paraBounds[2];
 277         paraStart = run.getStart();
 278         paraLimit = run.getLimit();
 279         try {
 280             bidiLine = bidi.setLine(paraStart, paraLimit);
 281         } catch (Exception e) {
 282             errln("For line limits " + paraStart + "-" + paraLimit +
 283                   " got failure");
 284         }
 285         paraIndex = bidiLine.getParagraphIndex(i);
 286         run = bidiLine.getParagraph(i);
 287         try {
 288             gotLevels = bidiLine.getLevels();
 289         } catch (Exception e) {
 290             errln("Error on bidiLine.getLevels");
 291             gotLevels = new byte[bidiLine.getLength()];
 292             Arrays.fill(gotLevels, (byte)-1);
 293         }
 294         length = bidiLine.getLength();
 295         gotLevel = run.getEmbeddingLevel();
 296         if ((gotLevel != Bidi.RTL) || (gotLevels[length - 1] != 0)) {
 297             err("\nFor paragraph " + paraIndex + " with limits " +
 298                 run.getStart() + "-" + run.getLimit() +
 299                 ", paraLevel = " + gotLevel + "expected = " + Bidi.RTL +
 300                 ", level of separator = " + gotLevels[length - 1] +
 301                 " expected = 0\nlevels = ");
 302             for (count = 0; count < length; count++) {
 303                 errcont(gotLevels[count] + "  ");
 304             }
 305             errcont("\n");
 306         }
 307
 308         /* test that the concatenation of separate invocations of the bidi code
 309          * on each individual paragraph in order matches the levels array that
 310          * results from invoking bidi once over the entire multiparagraph tests
 311          * (with orderParagraphsLTR false, of course)
 312          */
 313         src = text;                     /* restore original content */
 314         bidi.orderParagraphsLTR(false);
 315         try {
 316             bidi.setPara(src, Bidi.LEVEL_DEFAULT_RTL, null);
 317         } catch (IllegalArgumentException e) {
 318             errln("Bidi.setPara failed, paraLevel = " + Bidi.LEVEL_DEFAULT_RTL);
 319         }
 320         try {
 321             gotLevels = bidi.getLevels();
 322         } catch (Exception e) {
 323             errln("Error on bidiLine.getLevels");
 324             gotLevels = new byte[bidi.getLength()];
 325             Arrays.fill(gotLevels, (byte)-1);
 326         }
 327         for (i = 0; i < paraCount; i++) {
 328             /* use pLine for individual paragraphs */
 329             paraStart = paraBounds[i];
 330             length = paraBounds[i + 1] - paraStart;
 331             try {
 332                 bidiLine.setPara(src.substring(paraStart, paraStart + length),
 333                                  Bidi.LEVEL_DEFAULT_RTL, null);
 334             } catch (IllegalArgumentException e) {
 335                 errln("Bidi.setPara failed, paraLevel = " + Bidi.LEVEL_DEFAULT_RTL);
 336             }
 337             for (j = 0; j < length; j++) {
 338                 if ((k = bidiLine.getLevelAt(j)) !=
 339                         (gotLevel = gotLevels[paraStart + j])) {
 340                     errln("Checking paragraph concatenation: for paragraph[" +
 341                           i + "], char[" + j + "] = 0x" +
 342                           Utility.hex(src.charAt(paraStart + j)) +
 343                           ", level = " + k + ", expected = " + gotLevel);
 344                 }
 345             }
 346         }
 347
 348         /* ensure that leading numerics in a paragraph are not treated as arabic
 349            numerals because of arabic text in a preceding paragraph
 350          */
 351         src = text2;
 352         bidi.orderParagraphsLTR(true);
 353         try {
 354             bidi.setPara(src, Bidi.RTL, null);
 355         } catch (IllegalArgumentException e) {
 356             errln("Bidi.setPara failed, paraLevel = " + Bidi.RTL);
 357         }
 358         try {
 359             gotLevels = bidi.getLevels();
 360         } catch (Exception e) {
 361             errln("Error on Bidi.getLevels");
 362             gotLevels = new byte[bidi.getLength()];
 363             Arrays.fill(gotLevels, (byte)-1);
 364         }
 365         for (i = 0, length = src.length(); i < length; i++) {
 366             if (gotLevels[i] != levels2[i]) {
 367                 errln("Checking leading numerics: for char " + i + "(0x" +
 368                       Utility.hex(src.charAt(i)) + "), level = " +
 369                       gotLevels[i] + ", expected = " + levels2[i]);
 370             }
 371         }
 372
 373         /* check handling of whitespace before end of paragraph separator when
 374          * orderParagraphsLTR==TRUE, when last paragraph has, and lacks, a terminating B
 375          */
 376         chars = src.toCharArray();
 377         Arrays.fill(chars, '\u0020');
 378         bidi.orderParagraphsLTR(true);
 379         for (i = 0x001c; i <= 0x0020; i += (0x0020-0x001c)) {
 380             chars[4] = (char)i;         /* with and without terminating B */
 381             for (j = 0x0041; j <= 0x05d0; j += (0x05d0-0x0041)) {
 382                 chars[0] = (char)j;     /* leading 'A' or Alef */
 383                 src = new String(chars);
 384                 for (gotLevel = 4; gotLevel <= 5; gotLevel++) {
 385                     /* test even and odd paraLevel */
 386                     try {
 387                         bidi.setPara(src, gotLevel, null);
 388                     } catch (IllegalArgumentException e) {
 389                         errln("Bidi.setPara failed, paraLevel = " + gotLevel);
 390                     }
 391                     try {
 392                         gotLevels = bidi.getLevels();
 393                     } catch (Exception e) {
 394                         errln("Error on Bidi.getLevels");
 395                         gotLevels = new byte[bidi.getLength()];
 396                         Arrays.fill(gotLevels, (byte)-1);
 397                     }
 398                     for (k = 1; k <= 3; k++) {
 399                         if (gotLevels[k] != gotLevel) {
 400                             errln("Checking trailing spaces for leading char 0x" +
 401                                   Utility.hex(chars[0]) + ", last_char = " +
 402                                   Utility.hex(chars[4]) + ", index = " + k +
 403                                   "level = " + gotLevels[k] +
 404                                   ", expected = " + gotLevel);
 405                         }
 406                     }
 407                 }
 408             }
 409         }
 410
 411         /* check default orientation when inverse bidi and paragraph starts
 412          * with LTR strong char and ends with RTL strong char, with and without
 413          * a terminating B
 414          */
 415         bidi.setReorderingMode(Bidi.REORDER_INVERSE_LIKE_DIRECT);
 416         bidi.setPara("abc \u05d2\u05d1\n", Bidi.LEVEL_DEFAULT_LTR, null);
 417         String out = bidi.writeReordered(0);
 418         assertEquals("\nInvalid output", "\u05d1\u05d2 abc\n", out);
 419         bidi.setPara("abc \u05d2\u05d1", Bidi.LEVEL_DEFAULT_LTR, null);
 420         out = bidi.writeReordered(0);
 421         assertEquals("\nInvalid output #1", "\u05d1\u05d2 abc", out);
 422
 423         /* check multiple paragraphs together with explicit levels
 424          */
 425         bidi.setReorderingMode(Bidi.REORDER_DEFAULT);
 426         gotLevels = new byte[] {0,0,0,0,0,0,0,0,0,0};
 427         bidi.setPara("ab\u05d1\u05d2\n\u05d3\u05d4123", Bidi.LTR, gotLevels);
 428         out = bidi.writeReordered(0);
 429         assertEquals("\nInvalid output #2", "ab\u05d2\u05d1\n123\u05d4\u05d3", out);
 430         assertEquals("\nInvalid number of paras", 2, bidi.countParagraphs());
 431
 432         logln("\nExiting TestMultipleParagraphs\n");
 433
 434         /* check levels in multiple paragraphs with default para level
 435          */
 436         bidi = new Bidi();
 437         bidi.setPara(multiparaTestString, Bidi.LEVEL_DEFAULT_LTR, null);
 438         try {
 439             gotLevels = bidi.getLevels();
 440         } catch (Exception e) {
 441             errln("Error on Bidi.getLevels for multiparaTestString");
 442             return;
 443         }
 444         for (i = 0; i < multiparaTestString.length; i++) {
 445             if (gotLevels[i] != multiparaTestLevels[i]) {
 446                 errln("Error on level for multiparaTestString at index " + i +
 447                       ", expected=" + multiparaTestLevels[i] +
 448                       ", actual=" + gotLevels[i]);
 449             }
 450         }
 451     }
 452
 453
 454     public static void main(String[] args) {
 455         try {
 456             new TestMultipleParagraphs().run(args);
 457         }
 458         catch (Exception e) {
 459             System.out.println(e);
 460         }
 461     }
 462 }