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

   1 /*
   2 *******************************************************************************
   3 *   Copyright (C) 2001-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.text.Bidi;
  13
  14 /**
  15  * Regression test for variants to the UBA.
  16  *
  17  * @author Lina Kemmel, Matitiahu Allouche
  18  */
  19
  20 public class TestReorderingMode extends BidiTest {
  21
  22     static final String[] textIn = {
  23     /* (0) 123 */
  24         "123",
  25     /* (1) .123->4.5 */
  26         ".123->4.5",
  27     /* (2) 678 */
  28         "678",
  29     /* (3) .678->8.9 */
  30         ".678->8.9",
  31     /* (4) JIH1.2,3MLK */
  32         "JIH1.2,3MLK",
  33     /* (5) FE.>12-> */
  34         "FE.>12->",
  35     /* (6) JIH.>12->a */
  36         "JIH.>12->a",
  37     /* (7) CBA.>67->89=a */
  38         "CBA.>67->89=a",
  39     /* (8) CBA.123->xyz */
  40         "CBA.123->xyz",
  41     /* (9) .>12->xyz */
  42         ".>12->xyz",
  43     /* (10) a.>67->xyz */
  44         "a.>67->xyz",
  45     /* (11) 123JIH */
  46         "123JIH",
  47     /* (12) 123 JIH */
  48         "123 JIH"
  49     };
  50
  51     static final String[] textOut = {
  52     /* TC 0: 123 */
  53         "123",                                                              /* (0) */
  54     /* TC 1: .123->4.5 */
  55         ".123->4.5",                                                        /* (1) */
  56         "4.5<-123.",                                                        /* (2) */
  57     /* TC 2: 678 */
  58         "678",                                                              /* (3) */
  59     /* TC 3: .678->8.9 */
  60         ".8.9<-678",                                                        /* (4) */
  61         "8.9<-678.",                                                        /* (5) */
  62         ".678->8.9",                                                        /* (6) */
  63     /* TC 4: MLK1.2,3JIH */
  64         "KLM1.2,3HIJ",                                                      /* (7) */
  65     /* TC 5: FE.>12-> */
  66         "12<.EF->",                                                         /* (8) */
  67         "<-12<.EF",                                                         /* (9) */
  68         "EF.>@12->",                                                        /* (10) */
  69     /* TC 6: JIH.>12->a */
  70         "12<.HIJ->a",                                                       /* (11) */
  71         "a<-12<.HIJ",                                                       /* (12) */
  72         "HIJ.>@12->a",                                                      /* (13) */
  73         "a&<-12<.HIJ",                                                      /* (14) */
  74     /* TC 7: CBA.>67->89=a */
  75         "ABC.>@67->89=a",                                                   /* (15) */
  76         "a=89<-67<.ABC",                                                    /* (16) */
  77         "a&=89<-67<.ABC",                                                   /* (17) */
  78         "89<-67<.ABC=a",                                                    /* (18) */
  79     /* TC 8: CBA.123->xyz */
  80         "123.ABC->xyz",                                                     /* (19) */
  81         "xyz<-123.ABC",                                                     /* (20) */
  82         "ABC.@123->xyz",                                                    /* (21) */
  83         "xyz&<-123.ABC",                                                    /* (22) */
  84     /* TC 9: .>12->xyz */
  85         ".>12->xyz",                                                        /* (23) */
  86         "xyz<-12<.",                                                        /* (24) */
  87         "xyz&<-12<.",                                                       /* (25) */
  88     /* TC 10: a.>67->xyz */
  89         "a.>67->xyz",                                                       /* (26) */
  90         "a.>@67@->xyz",                                                     /* (27) */
  91         "xyz<-67<.a",                                                       /* (28) */
  92     /* TC 11: 123JIH */
  93         "123HIJ",                                                           /* (29) */
  94         "HIJ123",                                                           /* (30) */
  95     /* TC 12: 123 JIH */
  96         "123 HIJ",                                                          /* (31) */
  97         "HIJ 123",                                                          /* (32) */
  98     };
  99
 100     static final int[][][][] outIndices = {
 101         { /* TC 0: 123 */
 102             {{ 0,  0}, { 0,  0}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 103             {{ 0,  0}, { 0,  0}}, /* REORDER_INVERSE_LIKE_DIRECT */
 104             {{ 0,  0}, { 0,  0}}, /* REORDER_NUMBERS_SPECIAL */
 105             {{ 0,  0}, { 0,  0}}  /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 106         },
 107         { /* TC 1: .123->4.5 */
 108             {{ 1,  2}, { 1,  2}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 109             {{ 1,  2}, { 1,  2}}, /* REORDER_INVERSE_LIKE_DIRECT */
 110             {{ 1,  2}, { 1,  2}}, /* REORDER_NUMBERS_SPECIAL */
 111             {{ 1,  2}, { 1,  2}}  /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 112         },
 113         { /* TC 2: 678 */
 114             {{ 3,  3}, { 3,  3}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 115             {{ 3,  3}, { 3,  3}}, /* REORDER_INVERSE_LIKE_DIRECT */
 116             {{ 3,  3}, { 3,  3}}, /* REORDER_NUMBERS_SPECIAL */
 117             {{ 3,  3}, { 3,  3}}  /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 118         },
 119         { /* TC 3: .678->8.9 */
 120             {{ 6,  5}, { 6,  5}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 121             {{ 4,  5}, { 4,  5}}, /* REORDER_INVERSE_LIKE_DIRECT */
 122             {{ 6,  5}, { 6,  5}}, /* REORDER_NUMBERS_SPECIAL */
 123             {{ 6,  5}, { 6,  5}}  /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 124         },
 125         { /* TC 4: MLK1.2,3JIH */
 126             {{ 7,  7}, { 7,  7}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 127             {{ 7,  7}, { 7,  7}}, /* REORDER_INVERSE_LIKE_DIRECT */
 128             {{ 7,  7}, { 7,  7}}, /* REORDER_NUMBERS_SPECIAL */
 129             {{ 7,  7}, { 7,  7}}  /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 130         },
 131         { /* TC 5: FE.>12-> */
 132             {{ 8,  9}, { 8,  9}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 133             {{10,  9}, { 8,  9}}, /* REORDER_INVERSE_LIKE_DIRECT */
 134             {{ 8,  9}, { 8,  9}}, /* REORDER_NUMBERS_SPECIAL */
 135             {{10,  9}, { 8,  9}}  /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 136         },
 137         { /* TC 6: JIH.>12->a */
 138             {{11, 12}, {11, 12}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 139             {{13, 14}, {11, 12}}, /* REORDER_INVERSE_LIKE_DIRECT */
 140             {{11, 12}, {11, 12}}, /* REORDER_NUMBERS_SPECIAL */
 141             {{13, 14}, {11, 12}}  /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 142         },
 143         { /* TC 7: CBA.>67->89=a */
 144             {{18, 16}, {18, 16}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 145             {{18, 17}, {18, 16}}, /* REORDER_INVERSE_LIKE_DIRECT */
 146             {{18, 16}, {18, 16}}, /* REORDER_NUMBERS_SPECIAL */
 147             {{15, 17}, {18, 16}}  /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 148         },
 149         { /* TC 8: CBA.>124->xyz */
 150             {{19, 20}, {19, 20}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 151             {{21, 22}, {19, 20}}, /* REORDER_INVERSE_LIKE_DIRECT */
 152             {{19, 20}, {19, 20}}, /* REORDER_NUMBERS_SPECIAL */
 153             {{21, 22}, {19, 20}}  /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 154         },
 155         { /* TC 9: .>12->xyz */
 156             {{23, 24}, {23, 24}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 157             {{23, 25}, {23, 24}}, /* REORDER_INVERSE_LIKE_DIRECT */
 158             {{23, 24}, {23, 24}}, /* REORDER_NUMBERS_SPECIAL */
 159             {{23, 25}, {23, 24}}  /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 160         },
 161         { /* TC 10: a.>67->xyz */
 162             {{26, 26}, {26, 26}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 163             {{26, 27}, {26, 28}}, /* REORDER_INVERSE_LIKE_DIRECT */
 164             {{26, 28}, {26, 28}}, /* REORDER_NUMBERS_SPECIAL */
 165             {{26, 27}, {26, 28}}  /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 166         },
 167         { /* TC 11: 124JIH */
 168             {{30, 30}, {30, 30}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 169             {{29, 30}, {29, 30}}, /* REORDER_INVERSE_LIKE_DIRECT */
 170             {{30, 30}, {30, 30}}, /* REORDER_NUMBERS_SPECIAL */
 171             {{30, 30}, {30, 30}}  /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 172         },
 173         { /* TC 12: 124 JIH */
 174             {{32, 32}, {32, 32}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 175             {{31, 32}, {31, 32}}, /* REORDER_INVERSE_LIKE_DIRECT */
 176             {{31, 32}, {31, 32}}, /* REORDER_NUMBERS_SPECIAL */
 177             {{31, 32}, {31, 32}}  /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 178         }
 179     };
 180
 181     static final short[] modes = {
 182         Bidi.REORDER_GROUP_NUMBERS_WITH_R,
 183         Bidi.REORDER_INVERSE_LIKE_DIRECT,
 184         Bidi.REORDER_NUMBERS_SPECIAL,
 185         Bidi.REORDER_INVERSE_FOR_NUMBERS_SPECIAL,
 186         Bidi.REORDER_INVERSE_NUMBERS_AS_L
 187     };
 188
 189     static final int[] options = { Bidi.OPTION_INSERT_MARKS, 0 };
 190
 191     static final byte[] paraLevels = { Bidi.LTR, Bidi.RTL };
 192
 193     static final int TC_COUNT = textIn.length;
 194     static final int MODES_COUNT = modes.length;
 195     static final int OPTIONS_COUNT = options.length;
 196     static final int LEVELS_COUNT = paraLevels.length;
 197
 198     public void testReorderingMode() {
 199
 200         String src, dest;
 201         Bidi bidi = new Bidi();
 202         Bidi bidi2 = new Bidi();
 203         Bidi bidi3 = new Bidi();
 204         int tc, mode, option, level;
 205         int modeValue, modeBack;
 206         int optionValue, optionBack;
 207         int index;
 208         String expected;
 209         boolean testOK = true;
 210
 211         logln("\nEntering TestReorderingMode\n");
 212
 213         bidi2.setInverse(true);
 214
 215         for (tc = 0; tc < TC_COUNT; tc++) {
 216             src = textIn[tc];
 217
 218             for (mode = 0; mode < MODES_COUNT; mode++) {
 219                 modeValue = modes[mode];
 220                 bidi.setReorderingMode(modeValue);
 221                 modeBack = bidi.getReorderingMode();
 222                 if (modeValue != modeBack) {
 223                     errln("Error while setting reordering mode to " +
 224                     modeValue + ", returned " + modeBack);
 225                 }
 226
 227                 for (option = 0; option < OPTIONS_COUNT; option++) {
 228                     optionValue = options[option];
 229                     bidi.setReorderingOptions(optionValue);
 230                     optionBack = bidi.getReorderingOptions();
 231                     if (optionValue != optionBack) {
 232                         errln("Error while setting reordering options to " +
 233                         modeValue + ", returned " + modeBack);
 234                     }
 235
 236                     for (level = 0; level < LEVELS_COUNT; level++) {
 237                         logln("starting test " + tc + " mode=" + modeValue +
 238                             " option=" + optionValue + " level=" + level);
 239                         bidi.setPara(pseudoToU16(src), paraLevels[level], null);
 240
 241                         dest = bidi.writeReordered(Bidi.DO_MIRRORING);
 242                         dest = u16ToPseudo(dest);
 243                         if (!((modeValue == Bidi.REORDER_INVERSE_NUMBERS_AS_L) &&
 244                               (optionValue == Bidi.OPTION_INSERT_MARKS))) {
 245                             checkWhatYouCan(bidi, src, dest);
 246                         }
 247                         String modeDesc = modeToString(modeValue);
 248                         String optDesc = spOptionsToString(optionValue);
 249
 250                         if (modeValue == Bidi.REORDER_INVERSE_NUMBERS_AS_L) {
 251                             index = -1;
 252                             expected = inverseBasic(bidi2, src, optionValue,
 253                                                     paraLevels[level]);
 254                         }
 255                         else {
 256                             index = outIndices[tc][mode][option][level];
 257                             expected = textOut[index];
 258                         }
 259                         if (!assertEquals("Actual and expected output mismatch",
 260                                           expected, dest, src, modeDesc, optDesc,
 261                                           String.valueOf(level))) {
 262                             testOK = false;
 263                             continue;
 264                         }
 265                         if ((optionValue == Bidi.OPTION_INSERT_MARKS) &&
 266                             !assertRoundTrip(bidi3, tc, index, src, dest,
 267                                              mode, option,
 268                                              paraLevels[level])) {
 269                             testOK = false;
 270                             continue;
 271                         }
 272                         if (!checkResultLength(bidi, src, dest, modeDesc, optDesc,
 273                                                paraLevels[level])) {
 274                             testOK = false;
 275                             continue;
 276                         }
 277                         if ((index > -1) &&
 278                             !checkMaps(bidi, index, src, dest, modeDesc, optDesc,
 279                                        paraLevels[level], true)) {
 280                             testOK = false;
 281                         }
 282                     }
 283                 }
 284             }
 285         }
 286         if (testOK) {
 287             logln("Reordering mode test OK");
 288         }
 289
 290         logln("\nExiting TestReorderingMode\n");
 291     }
 292
 293     String inverseBasic(Bidi bidi, String src, int option, byte level) {
 294         String dest2;
 295
 296         if (bidi == null || src == null) {
 297             return null;
 298         }
 299         bidi.setReorderingOptions(option);
 300         bidi.setPara(pseudoToU16(src), level, null);
 301         dest2 = u16ToPseudo(bidi.writeReordered(Bidi.DO_MIRRORING));
 302         if (!(option == Bidi.OPTION_INSERT_MARKS)) {
 303             checkWhatYouCan(bidi, src, dest2);
 304         }
 305         return dest2;
 306     }
 307
 308     static final byte roundtrip[][][][] =
 309     {
 310         { /* TC 0: 123 */
 311             {{ 1,  1}, { 1,  1}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 312             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_LIKE_DIRECT */
 313             {{ 1,  1}, { 1,  1}}, /* REORDER_NUMBERS_SPECIAL */
 314             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 315             {{ 1,  1}, { 1,  1}}  /* REORDER_INVERSE_NUMBERS_AS_L */
 316         },
 317         { /* TC 1: .123->4.5 */
 318             {{ 1,  1}, { 1,  1}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 319             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_LIKE_DIRECT */
 320             {{ 1,  1}, { 1,  1}}, /* REORDER_NUMBERS_SPECIAL */
 321             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 322             {{ 1,  1}, { 1,  1}}  /* REORDER_INVERSE_NUMBERS_AS_L */
 323         },
 324         { /* TC 2: 678 */
 325             {{ 1,  1}, { 1,  1}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 326             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_LIKE_DIRECT */
 327             {{ 1,  1}, { 1,  1}}, /* REORDER_NUMBERS_SPECIAL */
 328             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 329             {{ 1,  1}, { 1,  1}}  /* REORDER_INVERSE_NUMBERS_AS_L */
 330         },
 331         { /* TC 3: .678->8.9 */
 332             {{ 1,  1}, { 1,  1}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 333             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_LIKE_DIRECT */
 334             {{ 1,  1}, { 1,  1}}, /* REORDER_NUMBERS_SPECIAL */
 335             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 336             {{ 0,  0}, { 1,  1}}  /* REORDER_INVERSE_NUMBERS_AS_L */
 337         },
 338         { /* TC 4: MLK1.2,3JIH */
 339             {{ 1,  1}, { 1,  1}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 340             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_LIKE_DIRECT */
 341             {{ 1,  1}, { 1,  1}}, /* REORDER_NUMBERS_SPECIAL */
 342             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 343             {{ 1,  1}, { 1,  1}}  /* REORDER_INVERSE_NUMBERS_AS_L */
 344         },
 345         { /* TC 5: FE.>12-> */
 346             {{ 1,  1}, { 1,  1}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 347             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_LIKE_DIRECT */
 348             {{ 0,  1}, { 1,  1}}, /* REORDER_NUMBERS_SPECIAL */
 349             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 350             {{ 1,  1}, { 1,  1}}  /* REORDER_INVERSE_NUMBERS_AS_L */
 351         },
 352         { /* TC 6: JIH.>12->a */
 353             {{ 1,  1}, { 1,  1}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 354             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_LIKE_DIRECT */
 355             {{ 0,  0}, { 1,  1}}, /* REORDER_NUMBERS_SPECIAL */
 356             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 357             {{ 1,  1}, { 1,  1}}  /* REORDER_INVERSE_NUMBERS_AS_L */
 358         },
 359         { /* TC 7: CBA.>67->89=a */
 360             {{ 1,  1}, { 1,  1}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 361             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_LIKE_DIRECT */
 362             {{ 0,  1}, { 1,  1}}, /* REORDER_NUMBERS_SPECIAL */
 363             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 364             {{ 0,  0}, { 1,  1}}  /* REORDER_INVERSE_NUMBERS_AS_L */
 365         },
 366         { /* TC 8: CBA.>123->xyz */
 367             {{ 1,  1}, { 1,  1}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 368             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_LIKE_DIRECT */
 369             {{ 0,  0}, { 1,  1}}, /* REORDER_NUMBERS_SPECIAL */
 370             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 371             {{ 1,  1}, { 1,  1}}  /* REORDER_INVERSE_NUMBERS_AS_L */
 372         },
 373         { /* TC 9: .>12->xyz */
 374             {{ 1,  1}, { 1,  1}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 375             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_LIKE_DIRECT */
 376             {{ 1,  0}, { 1,  1}}, /* REORDER_NUMBERS_SPECIAL */
 377             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 378             {{ 1,  1}, { 1,  1}}  /* REORDER_INVERSE_NUMBERS_AS_L */
 379         },
 380         { /* TC 10: a.>67->xyz */
 381             {{ 1,  1}, { 1,  1}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 382             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_LIKE_DIRECT */
 383             {{ 1,  1}, { 1,  1}}, /* REORDER_NUMBERS_SPECIAL */
 384             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 385             {{ 1,  0}, { 1,  1}}  /* REORDER_INVERSE_NUMBERS_AS_L */
 386         },
 387         { /* TC 11: 123JIH */
 388             {{ 1,  1}, { 1,  1}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 389             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_LIKE_DIRECT */
 390             {{ 1,  1}, { 1,  1}}, /* REORDER_NUMBERS_SPECIAL */
 391             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 392             {{ 1,  1}, { 1,  1}}  /* REORDER_INVERSE_NUMBERS_AS_L */
 393         },
 394         { /* TC 12: 123 JIH */
 395             {{ 1,  1}, { 1,  1}}, /* REORDER_GROUP_NUMBERS_WITH_R */
 396             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_LIKE_DIRECT */
 397             {{ 1,  1}, { 1,  1}}, /* REORDER_NUMBERS_SPECIAL */
 398             {{ 1,  1}, { 1,  1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
 399             {{ 1,  1}, { 1,  1}}  /* REORDER_INVERSE_NUMBERS_AS_L */
 400         }
 401     };
 402
 403     private boolean assertRoundTrip(Bidi bidi, int tc, int outIndex,
 404                                     String src, String dest,
 405                                     int mode, int option, byte level) {
 406         String descMode, descOption;
 407         String dest2;
 408
 409         switch (modes[mode]) {
 410             case Bidi.REORDER_NUMBERS_SPECIAL:
 411                 bidi.setReorderingMode(Bidi.REORDER_INVERSE_FOR_NUMBERS_SPECIAL);
 412                 break;
 413             case Bidi.REORDER_GROUP_NUMBERS_WITH_R:
 414                 bidi.setReorderingMode(Bidi.REORDER_GROUP_NUMBERS_WITH_R);
 415                 break;
 416             case Bidi.REORDER_RUNS_ONLY:
 417                 bidi.setReorderingMode(Bidi.REORDER_RUNS_ONLY);
 418                 break;
 419             case Bidi.REORDER_INVERSE_NUMBERS_AS_L:
 420                 bidi.setReorderingMode(Bidi.REORDER_DEFAULT);
 421                 break;
 422             case Bidi.REORDER_INVERSE_LIKE_DIRECT:
 423                 bidi.setReorderingMode(Bidi.REORDER_DEFAULT);
 424                 break;
 425             case Bidi.REORDER_INVERSE_FOR_NUMBERS_SPECIAL:
 426                 bidi.setReorderingMode(Bidi.REORDER_NUMBERS_SPECIAL);
 427                 break;
 428             default:
 429                 bidi.setReorderingMode(Bidi.REORDER_INVERSE_LIKE_DIRECT);
 430                 break;
 431         }
 432         bidi.setReorderingOptions(Bidi.OPTION_REMOVE_CONTROLS);
 433
 434         bidi.setPara(pseudoToU16(dest), level, null);
 435         dest2 = bidi.writeReordered(Bidi.DO_MIRRORING);
 436
 437         dest2 = u16ToPseudo(dest2);
 438         checkWhatYouCan(bidi, dest, dest2);
 439         descMode = modeToString(modes[mode]);
 440         descOption = spOptionsToString(options[option]);
 441         if (!src.equals(dest2)) {
 442             if (roundtrip[tc][mode][option][level] == 1) {
 443                 errln("\nRound trip failed for case=" + tc +
 444                       " mode=" + mode + " option=" + option +
 445                       "\nOriginal text:      " + src +
 446                       "\nRound-tripped text: " + dest2 +
 447                       "\nIntermediate text:  " + dest +
 448                       "\nReordering mode:    " + descMode +
 449                       "\nReordering option:  " + descOption +
 450                       "\nParagraph level:    " + level);
 451             } else {
 452                 logln("\nExpected round trip failure for case=" + tc +
 453                       " mode=" + mode + " option=" + option +
 454                       "\nOriginal text:      " + src +
 455                       "\nRound-tripped text: " + dest2 +
 456                       "\nIntermediate text:  " + dest +
 457                       "\nReordering mode:    " + descMode +
 458                       "\nReordering option:  " + descOption +
 459                       "\nParagraph level:    " + level);
 460             }
 461             return false;
 462         }
 463         if (!checkResultLength(bidi, dest, dest2, descMode,
 464                                "OPTION_REMOVE_CONTROLS", level)) {
 465             return false;
 466         }
 467         if ((outIndex > -1) &&
 468             !checkMaps(bidi, outIndex, src, dest, descMode,
 469                        "OPTION_REMOVE_CONTROLS", level, false)) {
 470             return false;
 471         }
 472         return true;
 473     }
 474
 475     private boolean checkResultLength(Bidi bidi, String src, String dest,
 476                                    String mode, String option, byte level) {
 477         int actualLen;
 478         if (mode.equals("REORDER_INVERSE_NUMBERS_AS_L"))
 479             actualLen = dest.length();
 480         else
 481             actualLen = bidi.getResultLength();
 482         if (actualLen != dest.length()) {
 483             errln("\nBidi.getResultLength failed." +
 484                   "\nExpected:           " + dest.length() +
 485                   "\nActual:             " + actualLen +
 486                   "\nInput:              " + src +
 487                   "\nOutput:             " + dest +
 488                   "\nReordering mode:    " + mode +
 489                   "\nReordering option:  " + option +
 490                   "\nParagraph level:    " + level);
 491             return false;
 492         }
 493         return true;
 494     }
 495
 496     static String formatMap(int[] map)
 497     {
 498         char[] buffer = new char[map.length];
 499         int i, k;
 500         char c;
 501         for (i = 0; i < map.length; i++) {
 502             k = map[i];
 503             if (k < 0)
 504                 c = '-';
 505             else if (k >= columns.length)
 506                 c = '+';
 507             else
 508                 c = columns[k];
 509             buffer[i] = c;
 510         }
 511         return new String(buffer);
 512     }
 513
 514     static final int NO = Bidi.MAP_NOWHERE;
 515
 516     static final int forwardMap[][] = {
 517     /* TC 0: 123 */
 518         { 0, 1, 2 },                                                    /* (0) */
 519     /* TC 1: .123->4.5 */
 520         { 0, 1, 2, 3, 4, 5, 6, 7, 8 },                                  /* (1) */
 521         { 8, 5, 6, 7, 4, 3, 0, 1, 2 },                                  /* (2) */
 522     /* TC 2: 678 */
 523         { 0, 1, 2 },                                                    /* (3) */
 524     /* TC 3: .678->8.9 */
 525         { 0, 6, 7, 8, 5, 4, 1, 2, 3 },                                  /* (4) */
 526         { 8, 5, 6, 7, 4, 3, 0, 1, 2 },                                  /* (5) */
 527         { 0, 1, 2, 3, 4, 5, 6, 7, 8 },                                  /* (6) */
 528     /* TC 4: MLK1.2,3JIH */
 529         { 10, 9, 8, 3, 4, 5, 6, 7, 2, 1, 0 },                           /* (7) */
 530     /* TC 5: FE.>12-> */
 531         { 5, 4, 3, 2, 0, 1, 6, 7 },                                     /* (8) */
 532         { 7, 6, 5, 4, 2, 3, 1, 0 },                                     /* (9) */
 533         { 1, 0, 2, 3, 5, 6, 7, 8 },                                     /* (10) */
 534     /* TC 6: JIH.>12->a */
 535         { 6, 5, 4, 3, 2, 0, 1, 7, 8, 9 },                               /* (11) */
 536         { 9, 8, 7, 6, 5, 3, 4, 2, 1, 0 },                               /* (12) */
 537         { 2, 1, 0, 3, 4, 6, 7, 8, 9, 10 },                              /* (13) */
 538         { 10, 9, 8, 7, 6, 4, 5, 3, 2, 0 },                              /* (14) */
 539     /* TC 7: CBA.>67->89=a */
 540         { 2, 1, 0, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13 },                  /* (15) */
 541         { 12, 11, 10, 9, 8, 6, 7, 5, 4, 2, 3, 1, 0 },                   /* (16) */
 542         { 13, 12, 11, 10, 9, 7, 8, 6, 5, 3, 4, 2, 0 },                  /* (17) */
 543         { 10, 9, 8, 7, 6, 4, 5, 3, 2, 0, 1, 11, 12 },                   /* (18) */
 544     /* TC 8: CBA.123->xyz */
 545         { 6, 5, 4, 3, 0, 1, 2, 7, 8, 9, 10, 11 },                       /* (19) */
 546         { 11, 10, 9, 8, 5, 6, 7, 4, 3, 0, 1, 2 },                       /* (20) */
 547         { 2, 1, 0, 3, 5, 6, 7, 8, 9, 10, 11, 12 },                      /* (21) */
 548         { 12, 11, 10, 9, 6, 7, 8, 5, 4, 0, 1, 2 },                      /* (22) */
 549     /* TC 9: .>12->xyz */
 550         { 0, 1, 2, 3, 4, 5, 6, 7, 8 },                                  /* (23) */
 551         { 8, 7, 5, 6, 4, 3, 0, 1, 2 },                                  /* (24) */
 552         { 9, 8, 6, 7, 5, 4, 0, 1, 2 },                                  /* (25) */
 553     /* TC 10: a.>67->xyz */
 554         { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },                               /* (26) */
 555         { 0, 1, 2, 4, 5, 7, 8, 9, 10, 11 },                             /* (27) */
 556         { 9, 8, 7, 5, 6, 4, 3, 0, 1, 2 },                               /* (28) */
 557     /* TC 11: 123JIH */
 558         { 0, 1, 2, 5, 4, 3 },                                           /* (29) */
 559         { 3, 4, 5, 2, 1, 0 },                                           /* (30) */
 560     /* TC 12: 123 JIH */
 561         { 0, 1, 2, 3, 6, 5, 4 },                                        /* (31) */
 562         { 4, 5, 6, 3, 2, 1, 0 },                                        /* (32) */
 563     };
 564     static final int inverseMap[][] = {
 565     /* TC 0: 123 */
 566         { 0, 1, 2 },                                                    /* (0) */
 567     /* TC 1: .123->4.5 */
 568         { 0, 1, 2, 3, 4, 5, 6, 7, 8 },                                  /* (1) */
 569         { 6, 7, 8, 5, 4, 1, 2, 3, 0 },                                  /* (2) */
 570     /* TC 2: 678 */
 571         { 0, 1, 2 },                                                    /* (3) */
 572     /* TC 3: .678->8.9 */
 573         { 0, 6, 7, 8, 5, 4, 1, 2, 3 },                                  /* (4) */
 574         { 6, 7, 8, 5, 4, 1, 2, 3, 0 },                                  /* (5) */
 575         { 0, 1, 2, 3, 4, 5, 6, 7, 8 },                                  /* (6) */
 576     /* TC 4: MLK1.2,3JIH */
 577         { 10, 9, 8, 3, 4, 5, 6, 7, 2, 1, 0 },                           /* (7) */
 578     /* TC 5: FE.>12-> */
 579         { 4, 5, 3, 2, 1, 0, 6, 7 },                                     /* (8) */
 580         { 7, 6, 4, 5, 3, 2, 1, 0 },                                     /* (9) */
 581         { 1, 0, 2, 3, NO, 4, 5, 6, 7 },                                 /* (10) */
 582     /* TC 6: JIH.>12->a */
 583         { 5, 6, 4, 3, 2, 1, 0, 7, 8, 9 },                               /* (11) */
 584         { 9, 8, 7, 5, 6, 4, 3, 2, 1, 0 },                               /* (12) */
 585         { 2, 1, 0, 3, 4, NO, 5, 6, 7, 8, 9 },                           /* (13) */
 586         { 9, NO, 8, 7, 5, 6, 4, 3, 2, 1, 0 },                           /* (14) */
 587     /* TC 7: CBA.>67->89=a */
 588         { 2, 1, 0, 3, 4, NO, 5, 6, 7, 8, 9, 10, 11, 12 },               /* (15) */
 589         { 12, 11, 9, 10, 8, 7, 5, 6, 4, 3, 2, 1, 0 },                   /* (16) */
 590         { 12, NO, 11, 9, 10, 8, 7, 5, 6, 4, 3, 2, 1, 0 },               /* (17) */
 591         { 9, 10, 8, 7, 5, 6, 4, 3, 2, 1, 0, 11, 12 },                   /* (18) */
 592     /* TC 8: CBA.123->xyz */
 593         { 4, 5, 6, 3, 2, 1, 0, 7, 8, 9, 10, 11 },                       /* (19) */
 594         { 9, 10, 11, 8, 7, 4, 5, 6, 3, 2, 1, 0 },                       /* (20) */
 595         { 2, 1, 0, 3, NO, 4, 5, 6, 7, 8, 9, 10, 11 },                   /* (21) */
 596         { 9, 10, 11, NO, 8, 7, 4, 5, 6, 3, 2, 1, 0 },                   /* (22) */
 597     /* TC 9: .>12->xyz */
 598         { 0, 1, 2, 3, 4, 5, 6, 7, 8 },                                  /* (23) */
 599         { 6, 7, 8, 5, 4, 2, 3, 1, 0 },                                  /* (24) */
 600         { 6, 7, 8, NO, 5, 4, 2, 3, 1, 0 },                              /* (25) */
 601     /* TC 10: a.>67->xyz */
 602         { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },                               /* (26) */
 603         { 0, 1, 2, NO, 3, 4, NO, 5, 6, 7, 8, 9 },                       /* (27) */
 604         { 7, 8, 9, 6, 5, 3, 4, 2, 1, 0 },                               /* (28) */
 605     /* TC 11: 123JIH */
 606         { 0, 1, 2, 5, 4, 3 },                                           /* (29) */
 607         { 5, 4, 3, 0, 1, 2 },                                           /* (30) */
 608     /* TC 12: 123 JIH */
 609         { 0, 1, 2, 3, 6, 5, 4 },                                        /* (31) */
 610         { 6, 5, 4, 3, 0, 1, 2 },                                        /* (32) */
 611     };
 612
 613     private boolean checkMaps(Bidi bidi, int stringIndex, String src, String dest,
 614             String mode, String option, byte level, boolean forward) {
 615
 616         int[] actualLogicalMap;
 617         int[] actualVisualMap;
 618         int[] getIndexMap;
 619         int i, srcLen, resLen, index;
 620         int[] expectedLogicalMap, expectedVisualMap;
 621         boolean testOK = true;
 622
 623         if (forward) {
 624             expectedLogicalMap = forwardMap[stringIndex];
 625             expectedVisualMap  = inverseMap[stringIndex];
 626         } else {
 627             expectedLogicalMap = inverseMap[stringIndex];
 628             expectedVisualMap  = forwardMap[stringIndex];
 629         }
 630         actualLogicalMap = bidi.getLogicalMap();
 631         srcLen = bidi.getProcessedLength();
 632         if (!Arrays.equals(expectedLogicalMap, actualLogicalMap)) {
 633             err("Bidi.getLogicalMap returned unexpected map for output " +
 634                 "string index " + stringIndex + "\n" +
 635                 "source: " + src + "\n" +
 636                 "dest  : " + dest + "\n" +
 637                 "Scale : " + columnString + "\n" +
 638                 "ExpMap: " + formatMap(expectedLogicalMap) + "\n" +
 639                 "Actual: " + formatMap(actualLogicalMap) + "\n" +
 640                 "Paragraph level  : " + level + " == " + bidi.getParaLevel() + "\n" +
 641                 "Reordering mode  : " + mode + " == " + bidi.getReorderingMode() + "\n" +
 642                 "Reordering option: " + option + " == " + bidi.getReorderingOptions() + "\n" +
 643                 "Forward flag     : " + forward + "\n");
 644             testOK = false;
 645         }
 646         resLen = bidi.getResultLength();
 647         actualVisualMap = bidi.getVisualMap();
 648         if (!Arrays.equals(expectedVisualMap, actualVisualMap)) {
 649             err("Bidi.getVisualMap returned unexpected map for output " +
 650                 "string index " + stringIndex + "\n" +
 651                 "source: " + src + "\n" +
 652                 "dest  : " + dest + "\n" +
 653                 "Scale : " + columnString + "\n" +
 654                 "ExpMap: " + formatMap(expectedVisualMap) + "\n" +
 655                 "Actual: " + formatMap(actualVisualMap) + "\n" +
 656                 "Paragraph level  : " + level + " == " + bidi.getParaLevel() + "\n" +
 657                 "Reordering mode  : " + mode + " == " + bidi.getReorderingMode() + "\n" +
 658                 "Reordering option: " + option + " == " + bidi.getReorderingOptions() + "\n" +
 659                 "Forward flag     : " + forward + "\n");
 660             testOK = false;
 661         }
 662         getIndexMap = new int[srcLen];
 663         for (i = 0; i < srcLen; i++) {
 664             index = bidi.getVisualIndex(i);
 665             getIndexMap[i] = index;
 666         }
 667         if (!Arrays.equals(actualLogicalMap, getIndexMap)) {
 668             err("Mismatch between getLogicalMap and getVisualIndex for output " +
 669                 "string index " + stringIndex + "\n" +
 670                 "source: " + src + "\n" +
 671                 "dest  : " + dest + "\n" +
 672                 "Scale : " + columnString + "\n" +
 673                 "ActMap: " + formatMap(actualLogicalMap) + "\n" +
 674                 "IdxMap: " + formatMap(getIndexMap) + "\n" +
 675                 "Paragraph level  : " + level + " == " + bidi.getParaLevel() + "\n" +
 676                 "Reordering mode  : " + mode + " == " + bidi.getReorderingMode() + "\n" +
 677                 "Reordering option: " + option + " == " + bidi.getReorderingOptions() + "\n" +
 678                 "Forward flag     : " + forward + "\n");
 679             testOK = false;
 680         }
 681         getIndexMap = new int[resLen];
 682         for (i = 0; i < resLen; i++) {
 683             index = bidi.getLogicalIndex(i);
 684             getIndexMap[i] = index;
 685         }
 686         if (!Arrays.equals(actualVisualMap, getIndexMap)) {
 687             err("Mismatch between getVisualMap and getLogicalIndex for output " +
 688                 "string index " + stringIndex + "\n" +
 689                 "source: " + src + "\n" +
 690                 "dest  : " + dest + "\n" +
 691                 "Scale : " + columnString + "\n" +
 692                 "ActMap: " + formatMap(actualVisualMap) + "\n" +
 693                 "IdxMap: " + formatMap(getIndexMap) + "\n" +
 694                 "Paragraph level  : " + level + " == " + bidi.getParaLevel() + "\n" +
 695                 "Reordering mode  : " + mode + " == " + bidi.getReorderingMode() + "\n" +
 696                 "Reordering option: " + option + " == " + bidi.getReorderingOptions() + "\n" +
 697                 "Forward flag     : " + forward + "\n");
 698             testOK = false;
 699         }
 700         return testOK;
 701     }
 702
 703
 704     public static void main(String[] args) {
 705         try {
 706             new TestReorderingMode().run(args);
 707         }
 708         catch (Exception e) {
 709             System.out.println(e);
 710         }
 711     }
 712
 713 }