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