/*
*******************************************************************************
*   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);
        }
    }

}