/* ******************************************************************************* * Copyright (C) 2001-2010, International Business Machines * Corporation and others. All Rights Reserved. ******************************************************************************* */ package com.ibm.icu.dev.test.bidi; import java.util.Arrays; import com.ibm.icu.text.Bidi; /** * Regression test for variants to the UBA. * * @author Lina Kemmel, Matitiahu Allouche */ public class TestReorderingMode extends BidiTest { static final String[] textIn = { /* (0) 123 */ "123", /* (1) .123->4.5 */ ".123->4.5", /* (2) 678 */ "678", /* (3) .678->8.9 */ ".678->8.9", /* (4) JIH1.2,3MLK */ "JIH1.2,3MLK", /* (5) FE.>12-> */ "FE.>12->", /* (6) JIH.>12->a */ "JIH.>12->a", /* (7) CBA.>67->89=a */ "CBA.>67->89=a", /* (8) CBA.123->xyz */ "CBA.123->xyz", /* (9) .>12->xyz */ ".>12->xyz", /* (10) a.>67->xyz */ "a.>67->xyz", /* (11) 123JIH */ "123JIH", /* (12) 123 JIH */ "123 JIH" }; static final String[] textOut = { /* TC 0: 123 */ "123", /* (0) */ /* TC 1: .123->4.5 */ ".123->4.5", /* (1) */ "4.5<-123.", /* (2) */ /* TC 2: 678 */ "678", /* (3) */ /* TC 3: .678->8.9 */ ".8.9<-678", /* (4) */ "8.9<-678.", /* (5) */ ".678->8.9", /* (6) */ /* TC 4: MLK1.2,3JIH */ "KLM1.2,3HIJ", /* (7) */ /* TC 5: FE.>12-> */ "12<.EF->", /* (8) */ "<-12<.EF", /* (9) */ "EF.>@12->", /* (10) */ /* TC 6: JIH.>12->a */ "12<.HIJ->a", /* (11) */ "a<-12<.HIJ", /* (12) */ "HIJ.>@12->a", /* (13) */ "a&<-12<.HIJ", /* (14) */ /* TC 7: CBA.>67->89=a */ "ABC.>@67->89=a", /* (15) */ "a=89<-67<.ABC", /* (16) */ "a&=89<-67<.ABC", /* (17) */ "89<-67<.ABC=a", /* (18) */ /* TC 8: CBA.123->xyz */ "123.ABC->xyz", /* (19) */ "xyz<-123.ABC", /* (20) */ "ABC.@123->xyz", /* (21) */ "xyz&<-123.ABC", /* (22) */ /* TC 9: .>12->xyz */ ".>12->xyz", /* (23) */ "xyz<-12<.", /* (24) */ "xyz&<-12<.", /* (25) */ /* TC 10: a.>67->xyz */ "a.>67->xyz", /* (26) */ "a.>@67@->xyz", /* (27) */ "xyz<-67<.a", /* (28) */ /* TC 11: 123JIH */ "123HIJ", /* (29) */ "HIJ123", /* (30) */ /* TC 12: 123 JIH */ "123 HIJ", /* (31) */ "HIJ 123", /* (32) */ }; static final int[][][][] outIndices = { { /* TC 0: 123 */ {{ 0, 0}, { 0, 0}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{ 0, 0}, { 0, 0}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{ 0, 0}, { 0, 0}}, /* REORDER_NUMBERS_SPECIAL */ {{ 0, 0}, { 0, 0}} /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ }, { /* TC 1: .123->4.5 */ {{ 1, 2}, { 1, 2}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{ 1, 2}, { 1, 2}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{ 1, 2}, { 1, 2}}, /* REORDER_NUMBERS_SPECIAL */ {{ 1, 2}, { 1, 2}} /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ }, { /* TC 2: 678 */ {{ 3, 3}, { 3, 3}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{ 3, 3}, { 3, 3}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{ 3, 3}, { 3, 3}}, /* REORDER_NUMBERS_SPECIAL */ {{ 3, 3}, { 3, 3}} /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ }, { /* TC 3: .678->8.9 */ {{ 6, 5}, { 6, 5}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{ 4, 5}, { 4, 5}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{ 6, 5}, { 6, 5}}, /* REORDER_NUMBERS_SPECIAL */ {{ 6, 5}, { 6, 5}} /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ }, { /* TC 4: MLK1.2,3JIH */ {{ 7, 7}, { 7, 7}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{ 7, 7}, { 7, 7}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{ 7, 7}, { 7, 7}}, /* REORDER_NUMBERS_SPECIAL */ {{ 7, 7}, { 7, 7}} /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ }, { /* TC 5: FE.>12-> */ {{ 8, 9}, { 8, 9}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{10, 9}, { 8, 9}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{ 8, 9}, { 8, 9}}, /* REORDER_NUMBERS_SPECIAL */ {{10, 9}, { 8, 9}} /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ }, { /* TC 6: JIH.>12->a */ {{11, 12}, {11, 12}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{13, 14}, {11, 12}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{11, 12}, {11, 12}}, /* REORDER_NUMBERS_SPECIAL */ {{13, 14}, {11, 12}} /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ }, { /* TC 7: CBA.>67->89=a */ {{18, 16}, {18, 16}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{18, 17}, {18, 16}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{18, 16}, {18, 16}}, /* REORDER_NUMBERS_SPECIAL */ {{15, 17}, {18, 16}} /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ }, { /* TC 8: CBA.>124->xyz */ {{19, 20}, {19, 20}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{21, 22}, {19, 20}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{19, 20}, {19, 20}}, /* REORDER_NUMBERS_SPECIAL */ {{21, 22}, {19, 20}} /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ }, { /* TC 9: .>12->xyz */ {{23, 24}, {23, 24}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{23, 25}, {23, 24}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{23, 24}, {23, 24}}, /* REORDER_NUMBERS_SPECIAL */ {{23, 25}, {23, 24}} /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ }, { /* TC 10: a.>67->xyz */ {{26, 26}, {26, 26}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{26, 27}, {26, 28}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{26, 28}, {26, 28}}, /* REORDER_NUMBERS_SPECIAL */ {{26, 27}, {26, 28}} /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ }, { /* TC 11: 124JIH */ {{30, 30}, {30, 30}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{29, 30}, {29, 30}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{30, 30}, {30, 30}}, /* REORDER_NUMBERS_SPECIAL */ {{30, 30}, {30, 30}} /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ }, { /* TC 12: 124 JIH */ {{32, 32}, {32, 32}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{31, 32}, {31, 32}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{31, 32}, {31, 32}}, /* REORDER_NUMBERS_SPECIAL */ {{31, 32}, {31, 32}} /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ } }; static final short[] modes = { Bidi.REORDER_GROUP_NUMBERS_WITH_R, Bidi.REORDER_INVERSE_LIKE_DIRECT, Bidi.REORDER_NUMBERS_SPECIAL, Bidi.REORDER_INVERSE_FOR_NUMBERS_SPECIAL, Bidi.REORDER_INVERSE_NUMBERS_AS_L }; static final int[] options = { Bidi.OPTION_INSERT_MARKS, 0 }; static final byte[] paraLevels = { Bidi.LTR, Bidi.RTL }; static final int TC_COUNT = textIn.length; static final int MODES_COUNT = modes.length; static final int OPTIONS_COUNT = options.length; static final int LEVELS_COUNT = paraLevels.length; public void testReorderingMode() { String src, dest; Bidi bidi = new Bidi(); Bidi bidi2 = new Bidi(); Bidi bidi3 = new Bidi(); int tc, mode, option, level; int modeValue, modeBack; int optionValue, optionBack; int index; String expected; boolean testOK = true; logln("\nEntering TestReorderingMode\n"); bidi2.setInverse(true); for (tc = 0; tc < TC_COUNT; tc++) { src = textIn[tc]; for (mode = 0; mode < MODES_COUNT; mode++) { modeValue = modes[mode]; bidi.setReorderingMode(modeValue); modeBack = bidi.getReorderingMode(); if (modeValue != modeBack) { errln("Error while setting reordering mode to " + modeValue + ", returned " + modeBack); } for (option = 0; option < OPTIONS_COUNT; option++) { optionValue = options[option]; bidi.setReorderingOptions(optionValue); optionBack = bidi.getReorderingOptions(); if (optionValue != optionBack) { errln("Error while setting reordering options to " + modeValue + ", returned " + modeBack); } for (level = 0; level < LEVELS_COUNT; level++) { logln("starting test " + tc + " mode=" + modeValue + " option=" + optionValue + " level=" + level); bidi.setPara(pseudoToU16(src), paraLevels[level], null); dest = bidi.writeReordered(Bidi.DO_MIRRORING); dest = u16ToPseudo(dest); if (!((modeValue == Bidi.REORDER_INVERSE_NUMBERS_AS_L) && (optionValue == Bidi.OPTION_INSERT_MARKS))) { checkWhatYouCan(bidi, src, dest); } String modeDesc = modeToString(modeValue); String optDesc = spOptionsToString(optionValue); if (modeValue == Bidi.REORDER_INVERSE_NUMBERS_AS_L) { index = -1; expected = inverseBasic(bidi2, src, optionValue, paraLevels[level]); } else { index = outIndices[tc][mode][option][level]; expected = textOut[index]; } if (!assertEquals("Actual and expected output mismatch", expected, dest, src, modeDesc, optDesc, String.valueOf(level))) { testOK = false; continue; } if ((optionValue == Bidi.OPTION_INSERT_MARKS) && !assertRoundTrip(bidi3, tc, index, src, dest, mode, option, paraLevels[level])) { testOK = false; continue; } if (!checkResultLength(bidi, src, dest, modeDesc, optDesc, paraLevels[level])) { testOK = false; continue; } if ((index > -1) && !checkMaps(bidi, index, src, dest, modeDesc, optDesc, paraLevels[level], true)) { testOK = false; } } } } } if (testOK) { logln("Reordering mode test OK"); } logln("\nExiting TestReorderingMode\n"); } String inverseBasic(Bidi bidi, String src, int option, byte level) { String dest2; if (bidi == null || src == null) { return null; } bidi.setReorderingOptions(option); bidi.setPara(pseudoToU16(src), level, null); dest2 = u16ToPseudo(bidi.writeReordered(Bidi.DO_MIRRORING)); if (!(option == Bidi.OPTION_INSERT_MARKS)) { checkWhatYouCan(bidi, src, dest2); } return dest2; } static final byte roundtrip[][][][] = { { /* TC 0: 123 */ {{ 1, 1}, { 1, 1}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{ 1, 1}, { 1, 1}}, /* REORDER_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}} /* REORDER_INVERSE_NUMBERS_AS_L */ }, { /* TC 1: .123->4.5 */ {{ 1, 1}, { 1, 1}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{ 1, 1}, { 1, 1}}, /* REORDER_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}} /* REORDER_INVERSE_NUMBERS_AS_L */ }, { /* TC 2: 678 */ {{ 1, 1}, { 1, 1}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{ 1, 1}, { 1, 1}}, /* REORDER_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}} /* REORDER_INVERSE_NUMBERS_AS_L */ }, { /* TC 3: .678->8.9 */ {{ 1, 1}, { 1, 1}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{ 1, 1}, { 1, 1}}, /* REORDER_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ {{ 0, 0}, { 1, 1}} /* REORDER_INVERSE_NUMBERS_AS_L */ }, { /* TC 4: MLK1.2,3JIH */ {{ 1, 1}, { 1, 1}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{ 1, 1}, { 1, 1}}, /* REORDER_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}} /* REORDER_INVERSE_NUMBERS_AS_L */ }, { /* TC 5: FE.>12-> */ {{ 1, 1}, { 1, 1}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{ 0, 1}, { 1, 1}}, /* REORDER_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}} /* REORDER_INVERSE_NUMBERS_AS_L */ }, { /* TC 6: JIH.>12->a */ {{ 1, 1}, { 1, 1}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{ 0, 0}, { 1, 1}}, /* REORDER_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}} /* REORDER_INVERSE_NUMBERS_AS_L */ }, { /* TC 7: CBA.>67->89=a */ {{ 1, 1}, { 1, 1}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{ 0, 1}, { 1, 1}}, /* REORDER_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ {{ 0, 0}, { 1, 1}} /* REORDER_INVERSE_NUMBERS_AS_L */ }, { /* TC 8: CBA.>123->xyz */ {{ 1, 1}, { 1, 1}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{ 0, 0}, { 1, 1}}, /* REORDER_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}} /* REORDER_INVERSE_NUMBERS_AS_L */ }, { /* TC 9: .>12->xyz */ {{ 1, 1}, { 1, 1}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{ 1, 0}, { 1, 1}}, /* REORDER_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}} /* REORDER_INVERSE_NUMBERS_AS_L */ }, { /* TC 10: a.>67->xyz */ {{ 1, 1}, { 1, 1}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{ 1, 1}, { 1, 1}}, /* REORDER_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ {{ 1, 0}, { 1, 1}} /* REORDER_INVERSE_NUMBERS_AS_L */ }, { /* TC 11: 123JIH */ {{ 1, 1}, { 1, 1}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{ 1, 1}, { 1, 1}}, /* REORDER_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}} /* REORDER_INVERSE_NUMBERS_AS_L */ }, { /* TC 12: 123 JIH */ {{ 1, 1}, { 1, 1}}, /* REORDER_GROUP_NUMBERS_WITH_R */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_LIKE_DIRECT */ {{ 1, 1}, { 1, 1}}, /* REORDER_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}}, /* REORDER_INVERSE_FOR_NUMBERS_SPECIAL */ {{ 1, 1}, { 1, 1}} /* REORDER_INVERSE_NUMBERS_AS_L */ } }; private boolean assertRoundTrip(Bidi bidi, int tc, int outIndex, String src, String dest, int mode, int option, byte level) { String descMode, descOption; String dest2; switch (modes[mode]) { case Bidi.REORDER_NUMBERS_SPECIAL: bidi.setReorderingMode(Bidi.REORDER_INVERSE_FOR_NUMBERS_SPECIAL); break; case Bidi.REORDER_GROUP_NUMBERS_WITH_R: bidi.setReorderingMode(Bidi.REORDER_GROUP_NUMBERS_WITH_R); break; case Bidi.REORDER_RUNS_ONLY: bidi.setReorderingMode(Bidi.REORDER_RUNS_ONLY); break; case Bidi.REORDER_INVERSE_NUMBERS_AS_L: bidi.setReorderingMode(Bidi.REORDER_DEFAULT); break; case Bidi.REORDER_INVERSE_LIKE_DIRECT: bidi.setReorderingMode(Bidi.REORDER_DEFAULT); break; case Bidi.REORDER_INVERSE_FOR_NUMBERS_SPECIAL: bidi.setReorderingMode(Bidi.REORDER_NUMBERS_SPECIAL); break; default: bidi.setReorderingMode(Bidi.REORDER_INVERSE_LIKE_DIRECT); break; } bidi.setReorderingOptions(Bidi.OPTION_REMOVE_CONTROLS); bidi.setPara(pseudoToU16(dest), level, null); dest2 = bidi.writeReordered(Bidi.DO_MIRRORING); dest2 = u16ToPseudo(dest2); checkWhatYouCan(bidi, dest, dest2); descMode = modeToString(modes[mode]); descOption = spOptionsToString(options[option]); if (!src.equals(dest2)) { if (roundtrip[tc][mode][option][level] == 1) { errln("\nRound trip failed for case=" + tc + " mode=" + mode + " option=" + option + "\nOriginal text: " + src + "\nRound-tripped text: " + dest2 + "\nIntermediate text: " + dest + "\nReordering mode: " + descMode + "\nReordering option: " + descOption + "\nParagraph level: " + level); } else { logln("\nExpected round trip failure for case=" + tc + " mode=" + mode + " option=" + option + "\nOriginal text: " + src + "\nRound-tripped text: " + dest2 + "\nIntermediate text: " + dest + "\nReordering mode: " + descMode + "\nReordering option: " + descOption + "\nParagraph level: " + level); } return false; } if (!checkResultLength(bidi, dest, dest2, descMode, "OPTION_REMOVE_CONTROLS", level)) { return false; } if ((outIndex > -1) && !checkMaps(bidi, outIndex, src, dest, descMode, "OPTION_REMOVE_CONTROLS", level, false)) { return false; } return true; } private boolean checkResultLength(Bidi bidi, String src, String dest, String mode, String option, byte level) { int actualLen; if (mode.equals("REORDER_INVERSE_NUMBERS_AS_L")) actualLen = dest.length(); else actualLen = bidi.getResultLength(); if (actualLen != dest.length()) { errln("\nBidi.getResultLength failed." + "\nExpected: " + dest.length() + "\nActual: " + actualLen + "\nInput: " + src + "\nOutput: " + dest + "\nReordering mode: " + mode + "\nReordering option: " + option + "\nParagraph level: " + level); return false; } return true; } static String formatMap(int[] map) { char[] buffer = new char[map.length]; int i, k; char c; for (i = 0; i < map.length; i++) { k = map[i]; if (k < 0) c = '-'; else if (k >= columns.length) c = '+'; else c = columns[k]; buffer[i] = c; } return new String(buffer); } static final int NO = Bidi.MAP_NOWHERE; static final int forwardMap[][] = { /* TC 0: 123 */ { 0, 1, 2 }, /* (0) */ /* TC 1: .123->4.5 */ { 0, 1, 2, 3, 4, 5, 6, 7, 8 }, /* (1) */ { 8, 5, 6, 7, 4, 3, 0, 1, 2 }, /* (2) */ /* TC 2: 678 */ { 0, 1, 2 }, /* (3) */ /* TC 3: .678->8.9 */ { 0, 6, 7, 8, 5, 4, 1, 2, 3 }, /* (4) */ { 8, 5, 6, 7, 4, 3, 0, 1, 2 }, /* (5) */ { 0, 1, 2, 3, 4, 5, 6, 7, 8 }, /* (6) */ /* TC 4: MLK1.2,3JIH */ { 10, 9, 8, 3, 4, 5, 6, 7, 2, 1, 0 }, /* (7) */ /* TC 5: FE.>12-> */ { 5, 4, 3, 2, 0, 1, 6, 7 }, /* (8) */ { 7, 6, 5, 4, 2, 3, 1, 0 }, /* (9) */ { 1, 0, 2, 3, 5, 6, 7, 8 }, /* (10) */ /* TC 6: JIH.>12->a */ { 6, 5, 4, 3, 2, 0, 1, 7, 8, 9 }, /* (11) */ { 9, 8, 7, 6, 5, 3, 4, 2, 1, 0 }, /* (12) */ { 2, 1, 0, 3, 4, 6, 7, 8, 9, 10 }, /* (13) */ { 10, 9, 8, 7, 6, 4, 5, 3, 2, 0 }, /* (14) */ /* TC 7: CBA.>67->89=a */ { 2, 1, 0, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13 }, /* (15) */ { 12, 11, 10, 9, 8, 6, 7, 5, 4, 2, 3, 1, 0 }, /* (16) */ { 13, 12, 11, 10, 9, 7, 8, 6, 5, 3, 4, 2, 0 }, /* (17) */ { 10, 9, 8, 7, 6, 4, 5, 3, 2, 0, 1, 11, 12 }, /* (18) */ /* TC 8: CBA.123->xyz */ { 6, 5, 4, 3, 0, 1, 2, 7, 8, 9, 10, 11 }, /* (19) */ { 11, 10, 9, 8, 5, 6, 7, 4, 3, 0, 1, 2 }, /* (20) */ { 2, 1, 0, 3, 5, 6, 7, 8, 9, 10, 11, 12 }, /* (21) */ { 12, 11, 10, 9, 6, 7, 8, 5, 4, 0, 1, 2 }, /* (22) */ /* TC 9: .>12->xyz */ { 0, 1, 2, 3, 4, 5, 6, 7, 8 }, /* (23) */ { 8, 7, 5, 6, 4, 3, 0, 1, 2 }, /* (24) */ { 9, 8, 6, 7, 5, 4, 0, 1, 2 }, /* (25) */ /* TC 10: a.>67->xyz */ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, /* (26) */ { 0, 1, 2, 4, 5, 7, 8, 9, 10, 11 }, /* (27) */ { 9, 8, 7, 5, 6, 4, 3, 0, 1, 2 }, /* (28) */ /* TC 11: 123JIH */ { 0, 1, 2, 5, 4, 3 }, /* (29) */ { 3, 4, 5, 2, 1, 0 }, /* (30) */ /* TC 12: 123 JIH */ { 0, 1, 2, 3, 6, 5, 4 }, /* (31) */ { 4, 5, 6, 3, 2, 1, 0 }, /* (32) */ }; static final int inverseMap[][] = { /* TC 0: 123 */ { 0, 1, 2 }, /* (0) */ /* TC 1: .123->4.5 */ { 0, 1, 2, 3, 4, 5, 6, 7, 8 }, /* (1) */ { 6, 7, 8, 5, 4, 1, 2, 3, 0 }, /* (2) */ /* TC 2: 678 */ { 0, 1, 2 }, /* (3) */ /* TC 3: .678->8.9 */ { 0, 6, 7, 8, 5, 4, 1, 2, 3 }, /* (4) */ { 6, 7, 8, 5, 4, 1, 2, 3, 0 }, /* (5) */ { 0, 1, 2, 3, 4, 5, 6, 7, 8 }, /* (6) */ /* TC 4: MLK1.2,3JIH */ { 10, 9, 8, 3, 4, 5, 6, 7, 2, 1, 0 }, /* (7) */ /* TC 5: FE.>12-> */ { 4, 5, 3, 2, 1, 0, 6, 7 }, /* (8) */ { 7, 6, 4, 5, 3, 2, 1, 0 }, /* (9) */ { 1, 0, 2, 3, NO, 4, 5, 6, 7 }, /* (10) */ /* TC 6: JIH.>12->a */ { 5, 6, 4, 3, 2, 1, 0, 7, 8, 9 }, /* (11) */ { 9, 8, 7, 5, 6, 4, 3, 2, 1, 0 }, /* (12) */ { 2, 1, 0, 3, 4, NO, 5, 6, 7, 8, 9 }, /* (13) */ { 9, NO, 8, 7, 5, 6, 4, 3, 2, 1, 0 }, /* (14) */ /* TC 7: CBA.>67->89=a */ { 2, 1, 0, 3, 4, NO, 5, 6, 7, 8, 9, 10, 11, 12 }, /* (15) */ { 12, 11, 9, 10, 8, 7, 5, 6, 4, 3, 2, 1, 0 }, /* (16) */ { 12, NO, 11, 9, 10, 8, 7, 5, 6, 4, 3, 2, 1, 0 }, /* (17) */ { 9, 10, 8, 7, 5, 6, 4, 3, 2, 1, 0, 11, 12 }, /* (18) */ /* TC 8: CBA.123->xyz */ { 4, 5, 6, 3, 2, 1, 0, 7, 8, 9, 10, 11 }, /* (19) */ { 9, 10, 11, 8, 7, 4, 5, 6, 3, 2, 1, 0 }, /* (20) */ { 2, 1, 0, 3, NO, 4, 5, 6, 7, 8, 9, 10, 11 }, /* (21) */ { 9, 10, 11, NO, 8, 7, 4, 5, 6, 3, 2, 1, 0 }, /* (22) */ /* TC 9: .>12->xyz */ { 0, 1, 2, 3, 4, 5, 6, 7, 8 }, /* (23) */ { 6, 7, 8, 5, 4, 2, 3, 1, 0 }, /* (24) */ { 6, 7, 8, NO, 5, 4, 2, 3, 1, 0 }, /* (25) */ /* TC 10: a.>67->xyz */ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, /* (26) */ { 0, 1, 2, NO, 3, 4, NO, 5, 6, 7, 8, 9 }, /* (27) */ { 7, 8, 9, 6, 5, 3, 4, 2, 1, 0 }, /* (28) */ /* TC 11: 123JIH */ { 0, 1, 2, 5, 4, 3 }, /* (29) */ { 5, 4, 3, 0, 1, 2 }, /* (30) */ /* TC 12: 123 JIH */ { 0, 1, 2, 3, 6, 5, 4 }, /* (31) */ { 6, 5, 4, 3, 0, 1, 2 }, /* (32) */ }; private boolean checkMaps(Bidi bidi, int stringIndex, String src, String dest, String mode, String option, byte level, boolean forward) { int[] actualLogicalMap; int[] actualVisualMap; int[] getIndexMap; int i, srcLen, resLen, index; int[] expectedLogicalMap, expectedVisualMap; boolean testOK = true; if (forward) { expectedLogicalMap = forwardMap[stringIndex]; expectedVisualMap = inverseMap[stringIndex]; } else { expectedLogicalMap = inverseMap[stringIndex]; expectedVisualMap = forwardMap[stringIndex]; } actualLogicalMap = bidi.getLogicalMap(); srcLen = bidi.getProcessedLength(); if (!Arrays.equals(expectedLogicalMap, actualLogicalMap)) { err("Bidi.getLogicalMap returned unexpected map for output " + "string index " + stringIndex + "\n" + "source: " + src + "\n" + "dest : " + dest + "\n" + "Scale : " + columnString + "\n" + "ExpMap: " + formatMap(expectedLogicalMap) + "\n" + "Actual: " + formatMap(actualLogicalMap) + "\n" + "Paragraph level : " + level + " == " + bidi.getParaLevel() + "\n" + "Reordering mode : " + mode + " == " + bidi.getReorderingMode() + "\n" + "Reordering option: " + option + " == " + bidi.getReorderingOptions() + "\n" + "Forward flag : " + forward + "\n"); testOK = false; } resLen = bidi.getResultLength(); actualVisualMap = bidi.getVisualMap(); if (!Arrays.equals(expectedVisualMap, actualVisualMap)) { err("Bidi.getVisualMap returned unexpected map for output " + "string index " + stringIndex + "\n" + "source: " + src + "\n" + "dest : " + dest + "\n" + "Scale : " + columnString + "\n" + "ExpMap: " + formatMap(expectedVisualMap) + "\n" + "Actual: " + formatMap(actualVisualMap) + "\n" + "Paragraph level : " + level + " == " + bidi.getParaLevel() + "\n" + "Reordering mode : " + mode + " == " + bidi.getReorderingMode() + "\n" + "Reordering option: " + option + " == " + bidi.getReorderingOptions() + "\n" + "Forward flag : " + forward + "\n"); testOK = false; } getIndexMap = new int[srcLen]; for (i = 0; i < srcLen; i++) { index = bidi.getVisualIndex(i); getIndexMap[i] = index; } if (!Arrays.equals(actualLogicalMap, getIndexMap)) { err("Mismatch between getLogicalMap and getVisualIndex for output " + "string index " + stringIndex + "\n" + "source: " + src + "\n" + "dest : " + dest + "\n" + "Scale : " + columnString + "\n" + "ActMap: " + formatMap(actualLogicalMap) + "\n" + "IdxMap: " + formatMap(getIndexMap) + "\n" + "Paragraph level : " + level + " == " + bidi.getParaLevel() + "\n" + "Reordering mode : " + mode + " == " + bidi.getReorderingMode() + "\n" + "Reordering option: " + option + " == " + bidi.getReorderingOptions() + "\n" + "Forward flag : " + forward + "\n"); testOK = false; } getIndexMap = new int[resLen]; for (i = 0; i < resLen; i++) { index = bidi.getLogicalIndex(i); getIndexMap[i] = index; } if (!Arrays.equals(actualVisualMap, getIndexMap)) { err("Mismatch between getVisualMap and getLogicalIndex for output " + "string index " + stringIndex + "\n" + "source: " + src + "\n" + "dest : " + dest + "\n" + "Scale : " + columnString + "\n" + "ActMap: " + formatMap(actualVisualMap) + "\n" + "IdxMap: " + formatMap(getIndexMap) + "\n" + "Paragraph level : " + level + " == " + bidi.getParaLevel() + "\n" + "Reordering mode : " + mode + " == " + bidi.getReorderingMode() + "\n" + "Reordering option: " + option + " == " + bidi.getReorderingOptions() + "\n" + "Forward flag : " + forward + "\n"); testOK = false; } return testOK; } public static void main(String[] args) { try { new TestReorderingMode().run(args); } catch (Exception e) { System.out.println(e); } } }