1/*
2*******************************************************************************
3*   Copyright (C) 2001-2013, International Business Machines
4*   Corporation and others.  All Rights Reserved.
5*******************************************************************************
6*/
7
8package com.ibm.icu.dev.test.bidi;
9
10import com.ibm.icu.text.Bidi;
11
12
13/**
14 * Regression test for the UBA implementation.
15 *
16 * ported from C by Lina Kemmel, Matitiahu Allouche
17 */
18
19public class TestReorder extends BidiTest {
20
21    private static final String[] logicalOrder = {
22        "del(KC)add(K.C.&)",
23        "del(QDVT) add(BVDL)",
24        "del(PQ)add(R.S.)T)U.&",
25        "del(LV)add(L.V.) L.V.&",
26        "day  0  R  DPDHRVR dayabbr",
27        "day  1  H  DPHPDHDA dayabbr",
28        "day  2   L  DPBLENDA dayabbr",
29        "day  3  J  DPJQVM  dayabbr",
30        "day  4   I  DPIQNF    dayabbr",
31        "day  5  M  DPMEG  dayabbr",
32        "helloDPMEG",
33        "hello WXYZ"
34    };
35
36    private static final String[] visualOrder = {
37        "del(CK)add(&.C.K)",
38        "del(TVDQ) add(LDVB)",
39        "del(QP)add(S.R.)&.U(T",        /* updated for Unicode 6.3 matching brackets */
40        "del(VL)add(V.L.) &.V.L",       /* updated for Unicode 6.3 matching brackets */
41        "day  0  RVRHDPD  R dayabbr",
42        "day  1  ADHDPHPD  H dayabbr",
43        "day  2   ADNELBPD  L dayabbr",
44        "day  3  MVQJPD  J  dayabbr",
45        "day  4   FNQIPD  I    dayabbr",
46        "day  5  GEMPD  M  dayabbr",
47        "helloGEMPD",
48        "hello ZYXW"
49    };
50
51    private static final String[] visualOrder1 = {
52        ")K.C.&(dda)KC(led",
53        ")BVDL(dda )QDVT(led",
54        "T(U.&).R.S(dda)PQ(led",        /* updated for Unicode 6.3 matching brackets */
55        "L.V.& ).L.V(dda)LV(led",       /* updated for Unicode 6.3 matching brackets */
56        "rbbayad R  DPDHRVR  0  yad",
57        "rbbayad H  DPHPDHDA  1  yad",
58        "rbbayad L  DPBLENDA   2  yad",
59        "rbbayad  J  DPJQVM  3  yad",
60        "rbbayad    I  DPIQNF   4  yad",
61        "rbbayad  M  DPMEG  5  yad",
62        "DPMEGolleh",
63        "WXYZ olleh"
64    };
65
66    private static final String[] visualOrder2 = {
67        "@)@K.C.&@(dda)@KC@(led",
68        "@)@BVDL@(dda )@QDVT@(led",
69        "R.S.)T)U.&@(dda)@PQ@(led",
70        "L.V.) L.V.&@(dda)@LV@(led",
71        "rbbayad @R  DPDHRVR@  0  yad",
72        "rbbayad @H  DPHPDHDA@  1  yad",
73        "rbbayad @L  DPBLENDA@   2  yad",
74        "rbbayad  @J  DPJQVM@  3  yad",
75        "rbbayad    @I  DPIQNF@   4  yad",
76        "rbbayad  @M  DPMEG@  5  yad",
77        "DPMEGolleh",
78        "WXYZ@ olleh"
79    };
80
81    private static final String[] visualOrder3 = {
82        ")K.C.&(KC)dda(led",
83        ")BVDL(ddaQDVT) (led",
84        "R.S.)T)U.&(PQ)dda(led",
85        "L.V.) L.V.&(LV)dda(led",
86        "rbbayad DPDHRVR   R  0 yad",
87        "rbbayad DPHPDHDA   H  1 yad",
88        "rbbayad DPBLENDA     L 2 yad",
89        "rbbayad  DPJQVM   J  3 yad",
90        "rbbayad    DPIQNF     I 4 yad",
91        "rbbayad  DPMEG   M  5 yad",
92        "DPMEGolleh",
93        "WXYZ olleh"
94    };
95
96    private static final String[] visualOrder4 = {
97        "del(add(CK(.C.K)",
98        "del( (TVDQadd(LDVB)",
99        "del(add(QP(.U(T(.S.R",
100        "del(add(VL(.V.L (.V.L",
101        "day 0  R   RVRHDPD dayabbr",
102        "day 1  H   ADHDPHPD dayabbr",
103        "day 2 L     ADNELBPD dayabbr",
104        "day 3  J   MVQJPD  dayabbr",
105        "day 4 I     FNQIPD    dayabbr",
106        "day 5  M   GEMPD  dayabbr",
107        "helloGEMPD",
108        "hello ZYXW"
109    };
110
111    public void testReorder() {
112        Bidi bidi = new Bidi();
113        int testNumber;
114        int nTests = logicalOrder.length;
115        String src, srcU16, dest = "";
116
117        logln("\nEntering TestReorder\n");
118
119        for (testNumber = 0; testNumber < nTests; testNumber++) {
120            logln("Testing L2V #1 for case " + testNumber);
121            src = logicalOrder[testNumber];
122            srcU16 = pseudoToU16(src);
123            try {
124                bidi.setPara(srcU16, Bidi.LEVEL_DEFAULT_LTR, null);
125            } catch (Exception e) {
126                errln("Bidi.setPara(tests[" + testNumber + "], paraLevel " +
127                      Bidi.LEVEL_DEFAULT_LTR + " failed.");
128            }
129            try {
130                dest = u16ToPseudo(bidi.writeReordered(Bidi.DO_MIRRORING));
131            } catch (Exception e) {
132                errln("Bidi.writeReordered(tests[" + testNumber + "], paraLevel " +
133                      Bidi.LEVEL_DEFAULT_LTR + " failed.");
134            }
135            if (!visualOrder[testNumber].equals(dest)) {
136                assertEquals("Failure #1 in Bidi.writeReordered(), test number " +
137                             testNumber, visualOrder[testNumber], dest, src, null,
138                             "Bidi.DO_MIRRORING", "Bidi.LEVEL_DEFAULT_LTR");
139            }
140            checkWhatYouCan(bidi, src, dest);
141        }
142
143        for (testNumber = 0; testNumber < nTests; testNumber++) {
144            logln("Testing L2V #2 for case " + testNumber);
145            src = logicalOrder[testNumber];
146            srcU16 = pseudoToU16(src);
147            try {
148                bidi.setPara(srcU16, Bidi.LEVEL_DEFAULT_LTR, null);
149            } catch (Exception e) {
150                errln("Bidi.setPara(tests[" + testNumber + "], paraLevel " +
151                      Bidi.LEVEL_DEFAULT_LTR + " failed.");
152            }
153            try {
154                dest = u16ToPseudo(bidi.writeReordered(Bidi.DO_MIRRORING +
155                                                       Bidi.OUTPUT_REVERSE));
156            } catch (Exception e) {
157                errln("Bidi.writeReordered(test[" + testNumber + "], paraLevel "
158                        + Bidi.LEVEL_DEFAULT_LTR + " failed.");
159            }
160            assertEquals("Failure #2 in Bidi.writeReordered() at index " +
161                         testNumber, visualOrder1[testNumber], dest,
162                         logicalOrder[testNumber], null,
163                         "DO_MIRRORING + OUTPUT_REVERSE",
164                         "Bidi.LEVEL_DEFAULT_LTR");
165        }
166
167        for (testNumber = 0; testNumber < nTests; testNumber++) {
168            logln("Testing V2L #3 for case " + testNumber);
169            src = logicalOrder[testNumber];
170            srcU16 = pseudoToU16(src);
171            bidi.setInverse(true);
172            try {
173                bidi.setPara(srcU16, Bidi.LEVEL_DEFAULT_LTR, null);
174            } catch (Exception e) {
175                errln("Bidi.setPara(tests[" + testNumber + "], paraLevel " +
176                      Bidi.LEVEL_DEFAULT_LTR + " failed.");
177            }
178            try {
179                dest = u16ToPseudo(bidi.writeReordered(Bidi.OUTPUT_REVERSE |
180                                                       Bidi.INSERT_LRM_FOR_NUMERIC));
181            } catch (Exception e) {
182                errln("Bidi.writeReordered(test[" + testNumber + "], paraLevel " +
183                      Bidi.LEVEL_DEFAULT_LTR + " failed.");
184            }
185            assertEquals("Failure #3 in Bidi.writeReordered(test[" + testNumber +
186                         "])", visualOrder2[testNumber], dest,
187                         logicalOrder[testNumber], null,
188                         "INSERT_LRM_FOR_NUMERIC + OUTPUT_REVERSE",
189                         "Bidi.LEVEL_DEFAULT_LTR");
190        }
191
192        /* Max Explicit level */
193        for (testNumber = 0; testNumber < nTests; testNumber++) {
194            logln("Testing V2L #4 for case " + testNumber);
195            src = logicalOrder[testNumber];
196            srcU16 = pseudoToU16(src);
197            byte[] levels = new byte[Bidi.MAX_EXPLICIT_LEVEL];
198            for (int i = 0; i < 10; i++) {
199                levels[i] = (byte)(i + 1);
200            }
201            try {
202                bidi.setPara(srcU16, Bidi.LEVEL_DEFAULT_LTR, levels);
203            } catch (Exception e) {
204                errln("Bidi.setPara(tests[" + testNumber +
205                      "], paraLevel = MAX_EXPLICIT_LEVEL = " +
206                      Bidi.MAX_EXPLICIT_LEVEL + " failed.");
207            }
208            try {
209                dest = u16ToPseudo(bidi.writeReordered(Bidi.OUTPUT_REVERSE));
210            } catch (Exception e) {
211                errln("Bidi.writeReordered(test[" + testNumber + "], paraLevel " +
212                      Bidi.LEVEL_DEFAULT_LTR + " failed.");
213            }
214            assertEquals("Failure #4 in Bidi.writeReordered(test[" + testNumber +
215                         "])", visualOrder3[testNumber], dest,
216                         logicalOrder[testNumber], null,
217                         "OUTPUT_REVERSE", "Bidi.LEVEL_DEFAULT_LTR");
218        }
219
220        for (testNumber = 0; testNumber < nTests; testNumber++) {
221            logln("Testing V2L #5 for case " + testNumber);
222            src = logicalOrder[testNumber];
223            srcU16 = pseudoToU16(src);
224            byte[] levels = new byte[Bidi.MAX_EXPLICIT_LEVEL];
225            for (int i = 0; i < 10; i++) {
226                levels[i] = (byte)(i + 1);
227            }
228            try {
229                bidi.setPara(srcU16, Bidi.LEVEL_DEFAULT_LTR, levels);
230            } catch (Exception e) {
231                errln("Bidi.setPara(tests[" + testNumber + "], paraLevel " +
232                      Bidi.MAX_EXPLICIT_LEVEL + " failed.");
233            }
234            try {
235                dest = u16ToPseudo(bidi.writeReordered(Bidi.DO_MIRRORING |
236                                                       Bidi.REMOVE_BIDI_CONTROLS));
237            } catch (Exception e) {
238                errln("Bidi.writeReordered(test[" + testNumber + "], paraLevel "
239                        + Bidi.LEVEL_DEFAULT_LTR + " failed.");
240            }
241            assertEquals("Failure #5 in Bidi.writeReordered(test[" + testNumber +
242                         "])", visualOrder4[testNumber], dest,
243                         logicalOrder[testNumber], null,
244                         "DO_MIRRORING + REMOVE_BIDI_CONTROLS",
245                         "Bidi.LEVEL_DEFAULT_LTR");
246        }
247
248        logln("\nExiting TestReorder\n");
249    }
250
251
252    public static void main(String[] args) {
253        try {
254            new TestReorder().run(args);
255        }
256        catch (Exception e) {
257            System.out.println(e);
258        }
259    }
260
261}
262